Client Test

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

@@ -200,200 +261,263 @@

-200
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-202
+    }
-203
+}
 #[derive(Debug)]
 struct MalformedTimestampHeaderDefaultEndpointParamsInterceptor;
-206
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampHeaderDefaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampHeaderDefaultEndpointParamsInterceptor"
-210
+    }
-211
     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")?;
-226
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-235
+    }
-236
+}
-237
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-240
 /// Error type for the `MalformedTimestampHeaderDefaultError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampHeaderDefaultError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-248
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-250
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampHeaderDefaultError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-253
+}
 impl MalformedTimestampHeaderDefaultError {
     /// Creates the `MalformedTimestampHeaderDefaultError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-263
+    }

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

@@ -198,198 +259,261 @@

↥ Expand context

-198
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-200
+    }
-201
+}
 #[derive(Debug)]
 struct MalformedTimestampHeaderEpochEndpointParamsInterceptor;
-204
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampHeaderEpochEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampHeaderEpochEndpointParamsInterceptor"
-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::<MalformedTimestampHeaderEpochInput>()
             .ok_or("failed to downcast to MalformedTimestampHeaderEpochInput")?;
-224
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-233
+    }
-234
+}
-235
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-238
 /// Error type for the `MalformedTimestampHeaderEpochError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampHeaderEpochError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-246
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-248
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampHeaderEpochError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-251
+}
 impl MalformedTimestampHeaderEpochError {
     /// Creates the `MalformedTimestampHeaderEpochError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-261
+    }

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

@@ -207,207 +268,270 @@

↥ Expand context

-207
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-209
+    }
-210
+}
 #[derive(Debug)]
 struct MalformedTimestampPathDefaultEndpointParamsInterceptor;
-213
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampPathDefaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampPathDefaultEndpointParamsInterceptor"
-217
+    }
-218
     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")?;
-233
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-242
+    }
-243
+}
-244
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-247
 /// Error type for the `MalformedTimestampPathDefaultError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampPathDefaultError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-255
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-257
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampPathDefaultError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-260
+}
 impl MalformedTimestampPathDefaultError {
     /// Creates the `MalformedTimestampPathDefaultError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-270
+    }

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

@@ -207,207 +268,270 @@

↥ Expand context

-207
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-209
+    }
-210
+}
 #[derive(Debug)]
 struct MalformedTimestampPathEpochEndpointParamsInterceptor;
-213
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampPathEpochEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampPathEpochEndpointParamsInterceptor"
-217
+    }
-218
     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")?;
-233
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-242
+    }
-243
+}
-244
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-247
 /// Error type for the `MalformedTimestampPathEpochError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampPathEpochError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-255
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-257
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampPathEpochError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-260
+}
 impl MalformedTimestampPathEpochError {
     /// Creates the `MalformedTimestampPathEpochError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-270
+    }

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

@@ -209,209 +270,272 @@

↥ Expand context

-209
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-211
+    }
-212
+}
 #[derive(Debug)]
 struct MalformedTimestampPathHttpDateEndpointParamsInterceptor;
-215
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampPathHttpDateEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampPathHttpDateEndpointParamsInterceptor"
-219
+    }
-220
     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")?;
-235
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-244
+    }
-245
+}
-246
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-249
 /// Error type for the `MalformedTimestampPathHttpDateError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampPathHttpDateError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-257
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-259
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampPathHttpDateError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-262
+}
 impl MalformedTimestampPathHttpDateError {
     /// Creates the `MalformedTimestampPathHttpDateError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-272
+    }

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

@@ -212,212 +273,275 @@

↥ Expand context

-212
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-214
+    }
-215
+}
 #[derive(Debug)]
 struct MalformedTimestampQueryDefaultEndpointParamsInterceptor;
-218
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampQueryDefaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampQueryDefaultEndpointParamsInterceptor"
-222
+    }
-223
     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")?;
-238
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-247
+    }
-248
+}
-249
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-252
 /// Error type for the `MalformedTimestampQueryDefaultError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampQueryDefaultError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-260
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-262
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampQueryDefaultError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-265
+}
 impl MalformedTimestampQueryDefaultError {
     /// Creates the `MalformedTimestampQueryDefaultError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-275
+    }

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

@@ -212,212 +273,275 @@

↥ Expand context

-212
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-214
+    }
-215
+}
 #[derive(Debug)]
 struct MalformedTimestampQueryEpochEndpointParamsInterceptor;
-218
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampQueryEpochEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampQueryEpochEndpointParamsInterceptor"
-222
+    }
-223
     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")?;
-238
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-247
+    }
-248
+}
-249
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-252
 /// Error type for the `MalformedTimestampQueryEpochError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampQueryEpochError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-260
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-262
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampQueryEpochError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-265
+}
 impl MalformedTimestampQueryEpochError {
     /// Creates the `MalformedTimestampQueryEpochError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-275
+    }

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

@@ -214,214 +275,277 @@

↥ Expand context

-214
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-216
+    }
-217
+}
 #[derive(Debug)]
 struct MalformedTimestampQueryHttpDateEndpointParamsInterceptor;
-220
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampQueryHttpDateEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampQueryHttpDateEndpointParamsInterceptor"
-224
+    }
-225
     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")?;
-240
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-249
+    }
-250
+}
-251
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-254
 /// Error type for the `MalformedTimestampQueryHttpDateError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampQueryHttpDateError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-262
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-264
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampQueryHttpDateError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-267
+}
 impl MalformedTimestampQueryHttpDateError {
     /// Creates the `MalformedTimestampQueryHttpDateError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-277
+    }

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

@@ -194,194 +255,257 @@

↥ Expand context

-194
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-196
+    }
-197
+}
 #[derive(Debug)]
 struct MalformedUnionEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedUnionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedUnionEndpointParamsInterceptor"
-204
+    }
-205
     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")?;
-220
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-229
+    }
-230
+}
-231
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-234
 /// Error type for the `MalformedUnionError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedUnionError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-242
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-244
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedUnionError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-247
+}
 impl MalformedUnionError {
     /// Creates the `MalformedUnionError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-257
+    }

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

@@ -197,197 +258,260 @@

↥ Expand context

-197
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct MediaTypeHeaderEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MediaTypeHeaderEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MediaTypeHeaderEndpointParamsInterceptor"
-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::<MediaTypeHeaderInput>()
             .ok_or("failed to downcast to MediaTypeHeaderInput")?;
-223
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-232
+    }
-233
+}
-234
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-237
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod media_type_header_test {

↧ Expand context

-241
     /// 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() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-252
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .media_type_header()
             .set_json(::std::option::Option::Some("true".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

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

@@ -196,196 +257,259 @@

↥ Expand context

-196
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-198
+    }
-199
+}
 #[derive(Debug)]
 struct NoInputAndNoOutputEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NoInputAndNoOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NoInputAndNoOutputEndpointParamsInterceptor"
-206
+    }
-207
     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")?;
-222
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-231
+    }
-232
+}
-233
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-236
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod no_input_and_no_output_test {

↧ Expand context

-240
     /// 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() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-253
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.no_input_and_no_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.

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

@@ -196,196 +257,259 @@

↥ Expand context

-196
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-198
+    }
-199
+}
 #[derive(Debug)]
 struct NoInputAndOutputEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NoInputAndOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NoInputAndOutputEndpointParamsInterceptor"
-206
+    }
-207
     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::<NoInputAndOutputInput>()
             .ok_or("failed to downcast to NoInputAndOutputInput")?;
-222
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-231
+    }
-232
+}
-233
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-236
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod no_input_and_output_test {

↧ Expand context

-240
     /// 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() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-253
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.no_input_and_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.

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

@@ -197,197 +258,260 @@

↥ Expand context

-197
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct NullAndEmptyHeadersClientEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NullAndEmptyHeadersClientEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NullAndEmptyHeadersClientEndpointParamsInterceptor"
-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::<NullAndEmptyHeadersClientInput>()
             .ok_or("failed to downcast to NullAndEmptyHeadersClientInput")?;
-223
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-232
+    }
-233
+}
-234
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-237
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod null_and_empty_headers_client_test {

↧ Expand context

-241
     /// Do not send null values, but do send empty strings and empty lists over the wire in headers
     /// Test ID: RestJsonNullAndEmptyHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_null_and_empty_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-252
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .null_and_empty_headers_client()
             .set_a(::std::option::Option::None)
             .set_b(::std::option::Option::Some("".to_owned()))
             .set_c(::std::option::Option::Some(vec![]))
             .send()
             .await;

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

@@ -197,197 +258,260 @@

↥ Expand context

-197
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct NullAndEmptyHeadersServerEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NullAndEmptyHeadersServerEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NullAndEmptyHeadersServerEndpointParamsInterceptor"
-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::<NullAndEmptyHeadersServerInput>()
             .ok_or("failed to downcast to NullAndEmptyHeadersServerInput")?;
-223
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-232
+    }
-233
+}
-234
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-237
 /// Error type for the `NullAndEmptyHeadersServerError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum NullAndEmptyHeadersServerError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-245
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-247
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-NullAndEmptyHeadersServerError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-250
+}
 impl NullAndEmptyHeadersServerError {
     /// Creates the `NullAndEmptyHeadersServerError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-260
+    }

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

@@ -216,216 +277,279 @@

↥ Expand context

-216
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-218
+    }
-219
+}
 #[derive(Debug)]
 struct OmitsNullSerializesEmptyStringEndpointParamsInterceptor;
-222
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OmitsNullSerializesEmptyStringEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OmitsNullSerializesEmptyStringEndpointParamsInterceptor"
-226
+    }
-227
     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::<OmitsNullSerializesEmptyStringInput>()
             .ok_or("failed to downcast to OmitsNullSerializesEmptyStringInput")?;
-242
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-251
+    }
-252
+}
-253
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-256
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod omits_null_serializes_empty_string_test {

↧ Expand context

-260
     /// Omits null query values
     /// Test ID: RestJsonOmitsNullQuery
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_omits_null_query_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-271
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .omits_null_serializes_empty_string()
             .set_null_value(::std::option::Option::None)
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

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

@@ -256,256 +317,319 @@

↥ Expand context

-256
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-258
+    }
-259
+}
 #[derive(Debug)]
 struct OmitsSerializingEmptyListsEndpointParamsInterceptor;
-262
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OmitsSerializingEmptyListsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OmitsSerializingEmptyListsEndpointParamsInterceptor"
-266
+    }
-267
     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::<OmitsSerializingEmptyListsInput>()
             .ok_or("failed to downcast to OmitsSerializingEmptyListsInput")?;
-282
         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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-291
+    }
-292
+}
-293
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-296
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod omits_serializing_empty_lists_test {

↧ Expand context

-300
     /// Supports omitting empty lists.
     /// Test ID: RestJsonOmitsEmptyListQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_omits_empty_list_query_values_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-311
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .omits_serializing_empty_lists()
             .set_query_string_list(::std::option::Option::Some(vec![]))
             .set_query_integer_list(::std::option::Option::Some(vec![]))
             .set_query_double_list(::std::option::Option::Some(vec![]))
             .set_query_boolean_list(::std::option::Option::Some(vec![]))
             .set_query_timestamp_list(::std::option::Option::Some(vec![]))

Client Test

Files changed: