Client Test

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

@@ -157,157 +224,224 @@

-157
+}
 #[derive(Debug)]
 struct MalformedStringRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedStringRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_string::MalformedStringInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_string::MalformedStringInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedString").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_string::MalformedStringInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_malformed_string::ser_malformed_string_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-193
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-198
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-200
+    }
-201
+}
 #[derive(Debug)]
 struct MalformedStringEndpointParamsInterceptor;
-204

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedStringEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedStringEndpointParamsInterceptor"
-208
+    }
-209
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedStringInput>()
             .ok_or("failed to downcast to MalformedStringInput")?;
-224

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

@@ -159,159 +234,234 @@

↥ Expand context

-159
+}
 #[derive(Debug)]
 struct MalformedTimestampBodyDateTimeRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedTimestampBodyDateTimeRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_timestamp_body_date_time::MalformedTimestampBodyDateTimeInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_timestamp_body_date_time::MalformedTimestampBodyDateTimeInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedTimestampBodyDateTime").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-185
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_body_date_time::MalformedTimestampBodyDateTimeInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-194
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_malformed_timestamp_body_date_time::ser_malformed_timestamp_body_date_time_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-205
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-207
+    }
-208
+}
 #[derive(Debug)]
 struct MalformedTimestampBodyDateTimeEndpointParamsInterceptor;
-211
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampBodyDateTimeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampBodyDateTimeEndpointParamsInterceptor"

↧ Expand context

-215
+    }
-216
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampBodyDateTimeInput>()
             .ok_or("failed to downcast to MalformedTimestampBodyDateTimeInput")?;
-231
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;

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

@@ -157,157 +232,232 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct MalformedTimestampBodyDefaultRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedTimestampBodyDefaultRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_timestamp_body_default::MalformedTimestampBodyDefaultInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_timestamp_body_default::MalformedTimestampBodyDefaultInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedTimestampBodyDefault").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_body_default::MalformedTimestampBodyDefaultInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-192
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_malformed_timestamp_body_default::ser_malformed_timestamp_body_default_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-203
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-205
+    }
-206
+}
 #[derive(Debug)]
 struct MalformedTimestampBodyDefaultEndpointParamsInterceptor;
-209
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampBodyDefaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampBodyDefaultEndpointParamsInterceptor"

↧ Expand context

-213
+    }
-214
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampBodyDefaultInput>()
             .ok_or("failed to downcast to MalformedTimestampBodyDefaultInput")?;
-229
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;

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

@@ -159,159 +234,234 @@

↥ Expand context

-159
+}
 #[derive(Debug)]
 struct MalformedTimestampBodyHttpDateRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedTimestampBodyHttpDateRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_timestamp_body_http_date::MalformedTimestampBodyHttpDateInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_timestamp_body_http_date::MalformedTimestampBodyHttpDateInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedTimestampBodyHttpDate").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-185
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_body_http_date::MalformedTimestampBodyHttpDateInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-194
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_malformed_timestamp_body_http_date::ser_malformed_timestamp_body_http_date_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-205
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-207
+    }
-208
+}
 #[derive(Debug)]
 struct MalformedTimestampBodyHttpDateEndpointParamsInterceptor;
-211
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampBodyHttpDateEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampBodyHttpDateEndpointParamsInterceptor"

↧ Expand context

-215
+    }
-216
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampBodyHttpDateInput>()
             .ok_or("failed to downcast to MalformedTimestampBodyHttpDateInput")?;
-231
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;

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

@@ -161,161 +230,230 @@

↥ Expand context

-161
+}
 #[derive(Debug)]
 struct MalformedTimestampHeaderDateTimeRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedTimestampHeaderDateTimeRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_timestamp_header_date_time::MalformedTimestampHeaderDateTimeInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_timestamp_header_date_time::MalformedTimestampHeaderDateTimeInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedTimestampHeaderDateTime").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-187
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_header_date_time::MalformedTimestampHeaderDateTimeInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_malformed_timestamp_header_date_time::ser_malformed_timestamp_header_date_time_headers(
                     input, builder,
                 )?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-199
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-204
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-206
+    }
-207
+}
 #[derive(Debug)]
 struct MalformedTimestampHeaderDateTimeEndpointParamsInterceptor;
-210

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampHeaderDateTimeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampHeaderDateTimeEndpointParamsInterceptor"
-214
+    }
-215
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampHeaderDateTimeInput>()
             .ok_or("failed to downcast to MalformedTimestampHeaderDateTimeInput")?;
-230

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

@@ -159,159 +227,227 @@

↥ Expand context

-159
+}
 #[derive(Debug)]
 struct MalformedTimestampHeaderDefaultRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedTimestampHeaderDefaultRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_timestamp_header_default::MalformedTimestampHeaderDefaultInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_timestamp_header_default::MalformedTimestampHeaderDefaultInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedTimestampHeaderDefault").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-185
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_header_default::MalformedTimestampHeaderDefaultInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder =
                     crate::protocol_serde::shape_malformed_timestamp_header_default::ser_malformed_timestamp_header_default_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-196
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-201
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-203
+    }
-204
+}
 #[derive(Debug)]
 struct MalformedTimestampHeaderDefaultEndpointParamsInterceptor;
-207

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampHeaderDefaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampHeaderDefaultEndpointParamsInterceptor"
-211
+    }
-212
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampHeaderDefaultInput>()
             .ok_or("failed to downcast to MalformedTimestampHeaderDefaultInput")?;
-227

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

@@ -157,157 +225,225 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct MalformedTimestampHeaderEpochRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedTimestampHeaderEpochRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_timestamp_header_epoch::MalformedTimestampHeaderEpochInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_timestamp_header_epoch::MalformedTimestampHeaderEpochInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedTimestampHeaderEpoch").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_header_epoch::MalformedTimestampHeaderEpochInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder =
                     crate::protocol_serde::shape_malformed_timestamp_header_epoch::ser_malformed_timestamp_header_epoch_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-194
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-199
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-201
+    }
-202
+}
 #[derive(Debug)]
 struct MalformedTimestampHeaderEpochEndpointParamsInterceptor;
-205

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampHeaderEpochEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampHeaderEpochEndpointParamsInterceptor"
-209
+    }
-210
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampHeaderEpochInput>()
             .ok_or("failed to downcast to MalformedTimestampHeaderEpochInput")?;
-225

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

@@ -168,168 +234,234 @@

↥ Expand context

             .downcast::<crate::operation::malformed_timestamp_path_default::MalformedTimestampPathDefaultInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::malformed_timestamp_path_default::MalformedTimestampPathDefaultInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.timestamp;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("timestamp", "cannot be empty or unset"))?;
                 let timestamp = ::aws_smithy_http::label::fmt_timestamp(input_1, ::aws_smithy_types::date_time::Format::DateTime)?;
                 if timestamp.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "timestamp",
                         "cannot be empty or unset",
                     ));
-191
+                }
                 ::std::write!(output, "/MalformedTimestampPathDefault/{timestamp}", timestamp = timestamp).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-194
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_path_default::MalformedTimestampPathDefaultInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-203
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-208
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-210
+    }
-211
+}
 #[derive(Debug)]
 struct MalformedTimestampPathDefaultEndpointParamsInterceptor;
-214

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampPathDefaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampPathDefaultEndpointParamsInterceptor"
-218
+    }
-219
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampPathDefaultInput>()
             .ok_or("failed to downcast to MalformedTimestampPathDefaultInput")?;
-234

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

@@ -168,168 +234,234 @@

↥ Expand context

             .downcast::<crate::operation::malformed_timestamp_path_epoch::MalformedTimestampPathEpochInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::malformed_timestamp_path_epoch::MalformedTimestampPathEpochInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.timestamp;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("timestamp", "cannot be empty or unset"))?;
                 let timestamp = ::aws_smithy_http::label::fmt_timestamp(input_1, ::aws_smithy_types::date_time::Format::EpochSeconds)?;
                 if timestamp.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "timestamp",
                         "cannot be empty or unset",
                     ));
-191
+                }
                 ::std::write!(output, "/MalformedTimestampPathEpoch/{timestamp}", timestamp = timestamp).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-194
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_path_epoch::MalformedTimestampPathEpochInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-203
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-208
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-210
+    }
-211
+}
 #[derive(Debug)]
 struct MalformedTimestampPathEpochEndpointParamsInterceptor;
-214

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampPathEpochEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampPathEpochEndpointParamsInterceptor"
-218
+    }
-219
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampPathEpochInput>()
             .ok_or("failed to downcast to MalformedTimestampPathEpochInput")?;
-234

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

@@ -170,170 +236,236 @@

↥ Expand context

             .downcast::<crate::operation::malformed_timestamp_path_http_date::MalformedTimestampPathHttpDateInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::malformed_timestamp_path_http_date::MalformedTimestampPathHttpDateInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.timestamp;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("timestamp", "cannot be empty or unset"))?;
                 let timestamp = ::aws_smithy_http::label::fmt_timestamp(input_1, ::aws_smithy_types::date_time::Format::HttpDate)?;
                 if timestamp.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "timestamp",
                         "cannot be empty or unset",
                     ));
-193
+                }
                 ::std::write!(output, "/MalformedTimestampPathHttpDate/{timestamp}", timestamp = timestamp).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-196
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_path_http_date::MalformedTimestampPathHttpDateInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-205
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-210
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-212
+    }
-213
+}
 #[derive(Debug)]
 struct MalformedTimestampPathHttpDateEndpointParamsInterceptor;
-216

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampPathHttpDateEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampPathHttpDateEndpointParamsInterceptor"
-220
+    }
-221
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampPathHttpDateInput>()
             .ok_or("failed to downcast to MalformedTimestampPathHttpDateInput")?;
-236

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

@@ -172,172 +239,239 @@

↥ Expand context

             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::malformed_timestamp_query_default::MalformedTimestampQueryDefaultInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedTimestampQueryDefault").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             fn uri_query(
                 _input: &crate::operation::malformed_timestamp_query_default::MalformedTimestampQueryDefaultInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 let inner_1 = &_input.timestamp;
                 let inner_1 = inner_1
                     .as_ref()

                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("timestamp", "cannot be empty or unset"))?;
                 query.push_kv(
                     "timestamp",
                     &::aws_smithy_http::query::fmt_timestamp(inner_1, ::aws_smithy_types::date_time::Format::DateTime)?,
                 );
                 ::std::result::Result::Ok(())
-198
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_query_default::MalformedTimestampQueryDefaultInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-208
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-213
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-215
+    }
-216
+}
 #[derive(Debug)]
 struct MalformedTimestampQueryDefaultEndpointParamsInterceptor;
-219

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampQueryDefaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampQueryDefaultEndpointParamsInterceptor"
-223
+    }
-224
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampQueryDefaultInput>()
             .ok_or("failed to downcast to MalformedTimestampQueryDefaultInput")?;
-239

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

@@ -172,172 +239,239 @@

↥ Expand context

             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::malformed_timestamp_query_epoch::MalformedTimestampQueryEpochInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedTimestampQueryEpoch").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             fn uri_query(
                 _input: &crate::operation::malformed_timestamp_query_epoch::MalformedTimestampQueryEpochInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 let inner_1 = &_input.timestamp;
                 let inner_1 = inner_1
                     .as_ref()

                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("timestamp", "cannot be empty or unset"))?;
                 query.push_kv(
                     "timestamp",
                     &::aws_smithy_http::query::fmt_timestamp(inner_1, ::aws_smithy_types::date_time::Format::EpochSeconds)?,
                 );
                 ::std::result::Result::Ok(())
-198
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_query_epoch::MalformedTimestampQueryEpochInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-208
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-213
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-215
+    }
-216
+}
 #[derive(Debug)]
 struct MalformedTimestampQueryEpochEndpointParamsInterceptor;
-219

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampQueryEpochEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampQueryEpochEndpointParamsInterceptor"
-223
+    }
-224
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampQueryEpochInput>()
             .ok_or("failed to downcast to MalformedTimestampQueryEpochInput")?;
-239

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

@@ -174,174 +241,241 @@

↥ Expand context

             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::malformed_timestamp_query_http_date::MalformedTimestampQueryHttpDateInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedTimestampQueryHttpDate").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-185
+            }
             fn uri_query(
                 _input: &crate::operation::malformed_timestamp_query_http_date::MalformedTimestampQueryHttpDateInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 let inner_1 = &_input.timestamp;
                 let inner_1 = inner_1
                     .as_ref()

                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("timestamp", "cannot be empty or unset"))?;
                 query.push_kv(
                     "timestamp",
                     &::aws_smithy_http::query::fmt_timestamp(inner_1, ::aws_smithy_types::date_time::Format::HttpDate)?,
                 );
                 ::std::result::Result::Ok(())
-200
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_timestamp_query_http_date::MalformedTimestampQueryHttpDateInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-210
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-215
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-217
+    }
-218
+}
 #[derive(Debug)]
 struct MalformedTimestampQueryHttpDateEndpointParamsInterceptor;
-221

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampQueryHttpDateEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampQueryHttpDateEndpointParamsInterceptor"
-225
+    }
-226
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedTimestampQueryHttpDateInput>()
             .ok_or("failed to downcast to MalformedTimestampQueryHttpDateInput")?;
-241

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

@@ -151,151 +224,224 @@

↥ Expand context

-151
+}
 #[derive(Debug)]
 struct MalformedUnionRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedUnionRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_union::MalformedUnionInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_union::MalformedUnionInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedUnion").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-177
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_union::MalformedUnionInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-186
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_union::ser_malformed_union_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-195
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-197
+    }
-198
+}
 #[derive(Debug)]
 struct MalformedUnionEndpointParamsInterceptor;
-201
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedUnionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedUnionEndpointParamsInterceptor"

↧ Expand context

-205
+    }
-206
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MalformedUnionInput>()
             .ok_or("failed to downcast to MalformedUnionInput")?;
-221
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;

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

@@ -157,157 +224,224 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct MediaTypeHeaderRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MediaTypeHeaderRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::media_type_header::MediaTypeHeaderInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::media_type_header::MediaTypeHeaderInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MediaTypeHeader").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::media_type_header::MediaTypeHeaderInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_media_type_header::ser_media_type_header_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-193
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-198
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-200
+    }
-201
+}
 #[derive(Debug)]
 struct MediaTypeHeaderEndpointParamsInterceptor;
-204

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MediaTypeHeaderEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MediaTypeHeaderEndpointParamsInterceptor"
-208
+    }
-209
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<MediaTypeHeaderInput>()
             .ok_or("failed to downcast to MediaTypeHeaderInput")?;
-224

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

@@ -157,157 +223,223 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct NoInputAndNoOutputRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for NoInputAndNoOutputRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::no_input_and_no_output::NoInputAndNoOutputInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::no_input_and_no_output::NoInputAndNoOutputInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/NoInputAndNoOutput").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::no_input_and_no_output::NoInputAndNoOutputInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-192
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-197
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct NoInputAndNoOutputEndpointParamsInterceptor;
-203

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NoInputAndNoOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NoInputAndNoOutputEndpointParamsInterceptor"
-207
+    }
-208
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<NoInputAndNoOutputInput>()
             .ok_or("failed to downcast to NoInputAndNoOutputInput")?;
-223

Client Test

Files changed: