Client Test

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

@@ -204,204 +265,267 @@

-204
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-206
+    }
-207
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithPayloadEndpointParamsInterceptor;
-210
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedContentTypeWithPayloadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedContentTypeWithPayloadEndpointParamsInterceptor"
-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::<MalformedContentTypeWithPayloadInput>()
             .ok_or("failed to downcast to MalformedContentTypeWithPayloadInput")?;
-230
         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(())
-239
+    }
-240
+}
-241
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-244
 /// Error type for the `MalformedContentTypeWithPayloadError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedContentTypeWithPayloadError {
     /// 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()`:
-252
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-254
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedContentTypeWithPayloadError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-257
+}
 impl MalformedContentTypeWithPayloadError {
     /// Creates the `MalformedContentTypeWithPayloadError::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(),
         })
-267
+    }

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/malformed_content_type_without_body.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 MalformedContentTypeWithoutBodyEndpointParamsInterceptor;
-204
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedContentTypeWithoutBodyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedContentTypeWithoutBodyEndpointParamsInterceptor"
-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::<MalformedContentTypeWithoutBodyInput>()
             .ok_or("failed to downcast to MalformedContentTypeWithoutBodyInput")?;
-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 `MalformedContentTypeWithoutBodyError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedContentTypeWithoutBodyError {
     /// 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-MalformedContentTypeWithoutBodyError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-251
+}
 impl MalformedContentTypeWithoutBodyError {
     /// Creates the `MalformedContentTypeWithoutBodyError::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_content_type_without_body_empty_input.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 MalformedContentTypeWithoutBodyEmptyInputEndpointParamsInterceptor;
-204
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedContentTypeWithoutBodyEmptyInputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedContentTypeWithoutBodyEmptyInputEndpointParamsInterceptor"
-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::<MalformedContentTypeWithoutBodyEmptyInputInput>()
             .ok_or("failed to downcast to MalformedContentTypeWithoutBodyEmptyInputInput")?;
-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 `MalformedContentTypeWithoutBodyEmptyInputError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedContentTypeWithoutBodyEmptyInputError {
     /// 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-MalformedContentTypeWithoutBodyEmptyInputError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-251
+}
 impl MalformedContentTypeWithoutBodyEmptyInputError {
     /// Creates the `MalformedContentTypeWithoutBodyEmptyInputError::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_double.rs

@@ -226,226 +287,289 @@

↥ Expand context

-226
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-228
+    }
-229
+}
 #[derive(Debug)]
 struct MalformedDoubleEndpointParamsInterceptor;
-232
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedDoubleEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedDoubleEndpointParamsInterceptor"
-236
+    }
-237
     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::<MalformedDoubleInput>()
             .ok_or("failed to downcast to MalformedDoubleInput")?;
-252
         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(())
-261
+    }
-262
+}
-263
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-266
 /// Error type for the `MalformedDoubleError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedDoubleError {
     /// 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()`:
-274
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-276
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedDoubleError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-279
+}
 impl MalformedDoubleError {
     /// Creates the `MalformedDoubleError::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(),
         })
-289
+    }

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

@@ -220,220 +281,283 @@

↥ Expand context

-220
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-222
+    }
-223
+}
 #[derive(Debug)]
 struct MalformedFloatEndpointParamsInterceptor;
-226
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedFloatEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedFloatEndpointParamsInterceptor"
-230
+    }
-231
     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::<MalformedFloatInput>()
             .ok_or("failed to downcast to MalformedFloatInput")?;
-246
         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(())
-255
+    }
-256
+}
-257
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-260
 /// Error type for the `MalformedFloatError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedFloatError {
     /// 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()`:
-268
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-270
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedFloatError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-273
+}
 impl MalformedFloatError {
     /// Creates the `MalformedFloatError::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(),
         })
-283
+    }

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

@@ -226,226 +287,289 @@

↥ Expand context

-226
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-228
+    }
-229
+}
 #[derive(Debug)]
 struct MalformedIntegerEndpointParamsInterceptor;
-232
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedIntegerEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedIntegerEndpointParamsInterceptor"
-236
+    }
-237
     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::<MalformedIntegerInput>()
             .ok_or("failed to downcast to MalformedIntegerInput")?;
-252
         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(())
-261
+    }
-262
+}
-263
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-266
 /// Error type for the `MalformedIntegerError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedIntegerError {
     /// 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()`:
-274
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-276
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedIntegerError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-279
+}
 impl MalformedIntegerError {
     /// Creates the `MalformedIntegerError::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(),
         })
-289
+    }

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/malformed_list.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 MalformedListEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedListEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedListEndpointParamsInterceptor"
-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::<MalformedListInput>()
             .ok_or("failed to downcast to MalformedListInput")?;
-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 `MalformedListError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedListError {
     /// 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-MalformedListError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-247
+}
 impl MalformedListError {
     /// Creates the `MalformedListError::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/malformed_long.rs

@@ -220,220 +281,283 @@

↥ Expand context

-220
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-222
+    }
-223
+}
 #[derive(Debug)]
 struct MalformedLongEndpointParamsInterceptor;
-226
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedLongEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedLongEndpointParamsInterceptor"
-230
+    }
-231
     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::<MalformedLongInput>()
             .ok_or("failed to downcast to MalformedLongInput")?;
-246
         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(())
-255
+    }
-256
+}
-257
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-260
 /// Error type for the `MalformedLongError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedLongError {
     /// 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()`:
-268
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-270
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedLongError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-273
+}
 impl MalformedLongError {
     /// Creates the `MalformedLongError::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(),
         })
-283
+    }

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/malformed_map.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 MalformedMapEndpointParamsInterceptor;
-200
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedMapEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedMapEndpointParamsInterceptor"
-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::<MalformedMapInput>()
             .ok_or("failed to downcast to MalformedMapInput")?;
-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 `MalformedMapError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedMapError {
     /// 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-MalformedMapError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-247
+}
 impl MalformedMapError {
     /// Creates the `MalformedMapError::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/malformed_request_body.rs

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct MalformedRequestBodyEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedRequestBodyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedRequestBodyEndpointParamsInterceptor"
-212
+    }
-213
     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::<MalformedRequestBodyInput>()
             .ok_or("failed to downcast to MalformedRequestBodyInput")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 /// Error type for the `MalformedRequestBodyError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedRequestBodyError {
     /// 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()`:
-250
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-252
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedRequestBodyError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-255
+}
 impl MalformedRequestBodyError {
     /// Creates the `MalformedRequestBodyError::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(),
         })
-265
+    }

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

@@ -220,220 +281,283 @@

↥ Expand context

-220
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-222
+    }
-223
+}
 #[derive(Debug)]
 struct MalformedShortEndpointParamsInterceptor;
-226
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedShortEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedShortEndpointParamsInterceptor"
-230
+    }
-231
     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::<MalformedShortInput>()
             .ok_or("failed to downcast to MalformedShortInput")?;
-246
         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(())
-255
+    }
-256
+}
-257
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-260
 /// Error type for the `MalformedShortError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedShortError {
     /// 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()`:
-268
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-270
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedShortError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-273
+}
 impl MalformedShortError {
     /// Creates the `MalformedShortError::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(),
         })
-283
+    }

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/malformed_string.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 MalformedStringEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedStringEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedStringEndpointParamsInterceptor"
-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::<MalformedStringInput>()
             .ok_or("failed to downcast to MalformedStringInput")?;
-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 `MalformedStringError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedStringError {
     /// 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-MalformedStringError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-250
+}
 impl MalformedStringError {
     /// Creates the `MalformedStringError::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/malformed_timestamp_body_date_time.rs

@@ -204,204 +265,267 @@

↥ Expand context

-204
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-206
+    }
-207
+}
 #[derive(Debug)]
 struct MalformedTimestampBodyDateTimeEndpointParamsInterceptor;
-210
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampBodyDateTimeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampBodyDateTimeEndpointParamsInterceptor"
-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::<MalformedTimestampBodyDateTimeInput>()
             .ok_or("failed to downcast to MalformedTimestampBodyDateTimeInput")?;
-230
         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(())
-239
+    }
-240
+}
-241
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-244
 /// Error type for the `MalformedTimestampBodyDateTimeError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampBodyDateTimeError {
     /// 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()`:
-252
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-254
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampBodyDateTimeError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-257
+}
 impl MalformedTimestampBodyDateTimeError {
     /// Creates the `MalformedTimestampBodyDateTimeError::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(),
         })
-267
+    }

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

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct MalformedTimestampBodyDefaultEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampBodyDefaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampBodyDefaultEndpointParamsInterceptor"
-212
+    }
-213
     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")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 /// Error type for the `MalformedTimestampBodyDefaultError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampBodyDefaultError {
     /// 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()`:
-250
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-252
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampBodyDefaultError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-255
+}
 impl MalformedTimestampBodyDefaultError {
     /// Creates the `MalformedTimestampBodyDefaultError::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(),
         })
-265
+    }

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

@@ -204,204 +265,267 @@

↥ Expand context

-204
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-206
+    }
-207
+}
 #[derive(Debug)]
 struct MalformedTimestampBodyHttpDateEndpointParamsInterceptor;
-210
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedTimestampBodyHttpDateEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedTimestampBodyHttpDateEndpointParamsInterceptor"
-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::<MalformedTimestampBodyHttpDateInput>()
             .ok_or("failed to downcast to MalformedTimestampBodyHttpDateInput")?;
-230
         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(())
-239
+    }
-240
+}
-241
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-244
 /// Error type for the `MalformedTimestampBodyHttpDateError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

↧ Expand context

 pub enum MalformedTimestampBodyHttpDateError {
     /// 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()`:
-252
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-254
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampBodyHttpDateError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-257
+}
 impl MalformedTimestampBodyHttpDateError {
     /// Creates the `MalformedTimestampBodyHttpDateError::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(),
         })
-267
+    }

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

@@ -203,203 +264,266 @@

↥ Expand context

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

↧ Expand context

 pub enum MalformedTimestampHeaderDateTimeError {
     /// 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()`:
-251
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-253
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MalformedTimestampHeaderDateTimeError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-256
+}
 impl MalformedTimestampHeaderDateTimeError {
     /// Creates the `MalformedTimestampHeaderDateTimeError::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(),
         })
-266
+    }

Client Test

Files changed: