Client Test

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/types/error/_invalid_greeting.rs

@@ -1,1 +99,110 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// This error is thrown when an invalid greeting value is provided.
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct InvalidGreeting {
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::option::Option<::std::string::String>,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,

-10
+}
 static INVALIDGREETING_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.query#InvalidGreeting", "aws.protocoltests.query", "InvalidGreeting");
 static INVALIDGREETING_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.query#InvalidGreeting$Message",
         "aws.protocoltests.query",
         "InvalidGreeting",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static INVALIDGREETING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INVALIDGREETING_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&INVALIDGREETING_MEMBER_MESSAGE],
 );
 impl InvalidGreeting {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVALIDGREETING_SCHEMA;
-31
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for InvalidGreeting {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.message {
             ser.write_string(&INVALIDGREETING_MEMBER_MESSAGE, val)?;
-40
+        }
         Ok(())
-42
+    }
-43
+}
 impl InvalidGreeting {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&INVALIDGREETING_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INVALIDGREETING_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-62
+                }
                 _ => {}
-64
+            }
             Ok(())
         })?;
         Ok(builder.build())
-68
+    }
-69
+}
 impl InvalidGreeting {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl InvalidGreeting {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-85
+    }
-86
+}
 impl ::std::fmt::Display for InvalidGreeting {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "InvalidGreeting")?;
         if let ::std::option::Option::Some(inner_1) = &self.message {

↧ Expand context

-91
+            {
                 ::std::write!(f, ": {inner_1}")?;
-93
+            }
-94
+        }
         Ok(())
-96
+    }
-97
+}
 impl ::std::error::Error for InvalidGreeting {}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for InvalidGreeting {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-102
+    }
-103
+}
 impl InvalidGreeting {
     /// Creates a new builder-style object to manufacture [`InvalidGreeting`](crate::types::error::InvalidGreeting).
     pub fn builder() -> crate::types::error::builders::InvalidGreetingBuilder {
         crate::types::error::builders::InvalidGreetingBuilder::default()
-108
+    }
-109
+}
-110

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/config.rs

@@ -10,10 +69,73 @@

↥ Expand context

     pub(crate) config: crate::config::FrozenLayer,
     cloneable: ::aws_smithy_types::config_bag::CloneableLayer,
     pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-15
+}
 impl Config {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>
     ///
     pub fn builder() -> Builder {
         Builder::default()
-26
+    }
     /// Converts this config back into a builder so that it can be tweaked.
     pub fn to_builder(&self) -> Builder {
         Builder {

             config: self.cloneable.clone(),
             runtime_components: self.runtime_components.clone(),
             runtime_plugins: self.runtime_plugins.clone(),
             behavior_version: self.behavior_version,
-34
+        }
-35
+    }
     /// Return a reference to the stalled stream protection configuration contained in this config, if any.
     pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
         self.config.load::<crate::config::StalledStreamProtectionConfig>()
-39
+    }
     /// Returns the client protocol used for serialization and deserialization.
     pub fn protocol(&self) -> ::std::option::Option<&::aws_smithy_schema::protocol::SharedClientProtocol> {
         self.config.load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
-+
+    }
     /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
     pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
         self.runtime_components.http_client()
-47
+    }
     /// Return the auth schemes configured on this service config
     pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
         self.runtime_components.auth_schemes()
-51
+    }
-52
     /// Return the auth scheme resolver configured on this service config

↧ Expand context

     pub fn auth_scheme_resolver(&self) -> ::std::option::Option<::aws_smithy_runtime_api::client::auth::SharedAuthSchemeOptionResolver> {
         self.runtime_components.auth_scheme_option_resolver()
-56
+    }
     /// Returns the configured auth scheme preference
     pub fn auth_scheme_preference(&self) -> ::std::option::Option<&::aws_smithy_runtime_api::client::auth::AuthSchemePreference> {
         self.config.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>()
-60
+    }
     /// Returns the endpoint resolver.
     pub fn endpoint_resolver(&self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver {
         self.runtime_components.endpoint_resolver().expect("resolver defaulted if not set")
-64
+    }
     /// Return a reference to the retry configuration contained in this config, if any.
     pub fn retry_config(&self) -> ::std::option::Option<&::aws_smithy_types::retry::RetryConfig> {
         self.config.load::<::aws_smithy_types::retry::RetryConfig>()
-68
+    }
-69
     /// Return a cloned shared async sleep implementation from this config, if any.
     pub fn sleep_impl(&self) -> ::std::option::Option<crate::config::SharedAsyncSleep> {
         self.runtime_components.sleep_impl()
-73
+    }

@@ -105,109 +185,208 @@

↥ Expand context

     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-111
+}
 impl ::std::default::Default for Builder {
     fn default() -> Self {
         Self {
             config: ::std::default::Default::default(),
             runtime_components: crate::config::RuntimeComponentsBuilder::new("service config"),
             runtime_plugins: ::std::default::Default::default(),
             behavior_version: ::std::default::Default::default(),
-119
+        }
-120
+    }
-121
+}
 impl Builder {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>

     ///
     pub fn new() -> Self {
         Self::default()
-132
+    }
     /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
     /// but not those in runtime components.
     #[allow(unused)]
     pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
         let mut builder = Self::new();
         builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         if let ::std::option::Option::Some(protocol) = config_bag.load::<::aws_smithy_schema::protocol::SharedClientProtocol>().cloned() {
             builder.set_protocol(::std::option::Option::Some(protocol));
-+
+        }
         builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
         builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
         builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
         builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
         builder
-147
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
         self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
         self
-153
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn set_stalled_stream_protection(
         &mut self,
         stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
     ) -> &mut Self {
         self.config.store_or_unset(stalled_stream_protection_config);
         self
-162
+    }
     /// Sets the client protocol to use for serialization and deserialization.
     ///
     /// This overrides the default protocol determined by the service model,
     /// enabling runtime protocol selection.
     pub fn protocol(mut self, protocol: impl ::aws_smithy_schema::protocol::ClientProtocol + 'static) -> Self {
         self.set_protocol(::std::option::Option::Some(::aws_smithy_schema::protocol::SharedClientProtocol::new(
             protocol,
         )));
         self
-+
+    }
-+
     /// Sets the client protocol to use for serialization and deserialization.
     pub fn set_protocol(&mut self, protocol: ::std::option::Option<::aws_smithy_schema::protocol::SharedClientProtocol>) -> &mut Self {
         self.config.store_or_unset(protocol);
         self
-+
+    }
     /// Sets the HTTP client to use when making requests.
     ///
     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use std::time::Duration;
     /// use big_numbers::config::Config;

↧ Expand context

     /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
     ///
     /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
     ///     .with_webpki_roots()
     ///     .https_only()
     ///     .enable_http1()
     ///     .enable_http2()
     ///     .build();
     /// let hyper_client = HyperClientBuilder::new().build(https_connector);
     ///
     /// // This connector can then be given to a generated service Config
     /// let config = my_service_client::Config::builder()
     ///     .endpoint_url("https://example.com")
     ///     .http_client(hyper_client)
     ///     .build();
     /// let client = my_service_client::Client::from_conf(config);
     /// # }
     /// # }
     /// ```
     pub fn http_client(mut self, http_client: impl crate::config::HttpClient + 'static) -> Self {

@@ -1116,1139 +1175,1203 @@

↥ Expand context

-1139
+    }
     /// Builds a [`Config`].
     #[allow(unused_mut)]
     pub fn build(mut self) -> Config {
         let mut layer = self.config;
         if self.runtime_components.time_source().is_none() {
             self.runtime_components
                 .set_time_source(::std::option::Option::Some(::std::default::Default::default()));
-1147
+        }
         Config {
             config: crate::config::Layer::from(layer.clone())
                 .with_name("big_numbers::config::Config")
                 .freeze(),
             cloneable: layer,
             runtime_components: self.runtime_components,
             runtime_plugins: self.runtime_plugins,
             behavior_version: self.behavior_version,
-1156
+        }
-1157
+    }
-1158
+}

 #[derive(::std::fmt::Debug)]
 pub(crate) struct ServiceRuntimePlugin {
     config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
     runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1163
+}
-1164
 impl ServiceRuntimePlugin {
     pub fn new(_service_config: crate::config::Config) -> Self {
         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("BigNumberService");
             if _service_config.protocol().is_none() {
                 cfg.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
-+
+            }
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
             use crate::config::auth::ResolveAuthScheme;
             crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
         }));
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());

↧ Expand context

         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-1186
+    }
-1187
+}
-1188
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-1192
+    }
-1193
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults
-1196
+    }
-1197
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-1203
+    }

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/lib.rs

@@ -76,76 +110,108 @@

↥ Expand context

 ///     .build();
 /// let client = big_numbers::Client::from_conf(config);
 /// ```
 ///
 /// _Note:_ Client construction is expensive due to connection thread pool initialization, and should be done
 /// once at application start-up. Cloning a client is cheap (it's just an [`Arc`](std::sync::Arc) under the hood),
 /// so creating it once at start-up and cloning it around the application as needed is recommended.
 pub mod client;
-84
 /// Configuration for the service.
 pub mod config;
-87
 /// Common errors and error handling utilities.
 pub mod error;
-90
 mod error_meta;
-92
 /// Information about this crate.
 pub mod meta;
-95

 /// Primitives such as `Blob` or `DateTime` used by other types.
 pub mod primitives;
-98
 /// All operations that this crate can perform.
 pub mod operation;
-101
 pub(crate) mod protocol_serde;
-103
 mod sdk_feature_tracker;
-105
 mod serialization_settings;
--
 mod json_errors;
-107
 pub use client::Client;

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_big_numbers.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `ProcessBigNumbers`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ProcessBigNumbers;
 impl ProcessBigNumbers {
     /// Creates a new `ProcessBigNumbers`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::process_big_numbers::ProcessBigNumbersInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::process_big_numbers::ProcessBigNumbersOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::process_big_numbers::ProcessBigNumbersInput,
     ) -> ::std::result::Result<
         crate::operation::process_big_numbers::ProcessBigNumbersOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::process_big_numbers::ProcessBigNumbersError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::process_big_numbers::ProcessBigNumbersError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::process_big_numbers::ProcessBigNumbersOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -113,117 +232,239 @@

↥ Expand context

         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ProcessBigNumbers")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ProcessBigNumbersEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::process_big_numbers::ProcessBigNumbersError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::process_big_numbers::ProcessBigNumbersError,
             >::new());
-136

         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct ProcessBigNumbersResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ProcessBigNumbersResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-160
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_process_big_numbers::de_process_big_numbers_http_error(status, headers, body)
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::process_big_numbers::ProcessBigNumbersError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_process_big_numbers::de_process_big_numbers_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, ProcessBigNumbers::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::process_big_numbers::ProcessBigNumbersOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct ProcessBigNumbersRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ProcessBigNumbersRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::process_big_numbers::ProcessBigNumbersInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::process_big_numbers::ProcessBigNumbersInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/process").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::process_big_numbers::ProcessBigNumbersInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_process_big_numbers::ser_process_big_numbers_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, ProcessBigNumbers::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-210
+    }
-211
+}
 #[derive(Debug)]
 struct ProcessBigNumbersEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ProcessBigNumbersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ProcessBigNumbersEndpointParamsInterceptor"
-218
+    }
-219

↧ Expand context

     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::<ProcessBigNumbersInput>()
             .ok_or("failed to downcast to ProcessBigNumbersInput")?;
-234
         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));

@@ -473,480 +806,883 @@

↥ Expand context

             ))
             .set_ratio(::std::option::Option::Some(
                 <::aws_smithy_types::BigDecimal as ::std::str::FromStr>::from_str("0.123456789").expect("invalid string for BigDecimal"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\"result\":999999999,\"ratio\":0.123456789}"))
                 .unwrap(),
-491
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-495
         let op = crate::operation::process_big_numbers::ProcessBigNumbers::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

             .expect("the config must have a deserializer");
-501
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::process_big_numbers::ProcessBigNumbersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.result, expected_output.result, "Unexpected value for `result`");
         ::pretty_assertions::assert_eq!(parsed.ratio, expected_output.ratio, "Unexpected value for `ratio`");
-528
+    }
     /// Test ID: NegativeBigNumbersInJsonResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn negative_big_numbers_in_json_response_response() {
         let expected_output = crate::operation::process_big_numbers::ProcessBigNumbersOutput::builder()
             .set_result(::std::option::Option::Some(
                 <::aws_smithy_types::BigInteger as ::std::str::FromStr>::from_str("-123456789").expect("Invalid string for BigInteger"),
             ))
             .set_ratio(::std::option::Option::Some(
                 <::aws_smithy_types::BigDecimal as ::std::str::FromStr>::from_str("-999.999").expect("invalid string for BigDecimal"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\"result\":-123456789,\"ratio\":-999.999}"))
                 .unwrap(),
-547
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-551
         let op = crate::operation::process_big_numbers::ProcessBigNumbers::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-557
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::process_big_numbers::ProcessBigNumbersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.result, expected_output.result, "Unexpected value for `result`");
         ::pretty_assertions::assert_eq!(parsed.ratio, expected_output.ratio, "Unexpected value for `ratio`");
-584
+    }
     /// Test ID: VeryLargeBigNumbersInJsonResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn very_large_big_numbers_in_json_response_response() {
         let expected_output = crate::operation::process_big_numbers::ProcessBigNumbersOutput::builder()
             .set_result(::std::option::Option::Some(
                 <::aws_smithy_types::BigInteger as ::std::str::FromStr>::from_str("18446744073709551616").expect("Invalid string for BigInteger"),
             ))
             .set_ratio(::std::option::Option::Some(
                 <::aws_smithy_types::BigDecimal as ::std::str::FromStr>::from_str("123456.789").expect("invalid string for BigDecimal"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\"result\":18446744073709551616,\"ratio\":123456.789}",
                 ))
                 .unwrap(),
-605
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-609
         let op = crate::operation::process_big_numbers::ProcessBigNumbers::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-615
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::process_big_numbers::ProcessBigNumbersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.result, expected_output.result, "Unexpected value for `result`");
         ::pretty_assertions::assert_eq!(parsed.ratio, expected_output.ratio, "Unexpected value for `ratio`");
-642
+    }
     /// Test ID: ZeroBigNumbersInJsonResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn zero_big_numbers_in_json_response_response() {
         let expected_output = crate::operation::process_big_numbers::ProcessBigNumbersOutput::builder()
             .set_result(::std::option::Option::Some(
                 <::aws_smithy_types::BigInteger as ::std::str::FromStr>::from_str("0").expect("Invalid string for BigInteger"),
             ))
             .set_ratio(::std::option::Option::Some(
                 <::aws_smithy_types::BigDecimal as ::std::str::FromStr>::from_str("0.0").expect("invalid string for BigDecimal"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\"result\":0,\"ratio\":0.0}"))
                 .unwrap(),
-661
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-665
         let op = crate::operation::process_big_numbers::ProcessBigNumbers::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-671
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::process_big_numbers::ProcessBigNumbersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.result, expected_output.result, "Unexpected value for `result`");
         ::pretty_assertions::assert_eq!(parsed.ratio, expected_output.ratio, "Unexpected value for `ratio`");
-698
+    }
     /// Test ID: NullBigNumbersInJsonResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn null_big_numbers_in_json_response_response() {
         let expected_output = crate::operation::process_big_numbers::ProcessBigNumbersOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\"result\":null,\"ratio\":null}"))
                 .unwrap(),
-710
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-714
         let op = crate::operation::process_big_numbers::ProcessBigNumbers::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-720
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::process_big_numbers::ProcessBigNumbersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.result, expected_output.result, "Unexpected value for `result`");
         ::pretty_assertions::assert_eq!(parsed.ratio, expected_output.ratio, "Unexpected value for `ratio`");
-747
+    }
     /// Test ID: ScientificNotationBigNumbersInJsonResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn scientific_notation_big_numbers_in_json_response_response() {
         let expected_output = crate::operation::process_big_numbers::ProcessBigNumbersOutput::builder()
             .set_result(::std::option::Option::Some(
                 <::aws_smithy_types::BigInteger as ::std::str::FromStr>::from_str("1500000000000").expect("Invalid string for BigInteger"),
             ))
             .set_ratio(::std::option::Option::Some(
                 <::aws_smithy_types::BigDecimal as ::std::str::FromStr>::from_str("2.5E-8").expect("invalid string for BigDecimal"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\"result\":1500000000000,\"ratio\":2.5E-8}"))
                 .unwrap(),
-766
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-770
         let op = crate::operation::process_big_numbers::ProcessBigNumbers::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-776
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::process_big_numbers::ProcessBigNumbersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.result, expected_output.result, "Unexpected value for `result`");
         ::pretty_assertions::assert_eq!(parsed.ratio, expected_output.ratio, "Unexpected value for `ratio`");
-803
+    }
     /// Test ID: UppercaseScientificNotationBigNumbersInJsonResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn uppercase_scientific_notation_big_numbers_in_json_response_response() {
         let expected_output = crate::operation::process_big_numbers::ProcessBigNumbersOutput::builder()
             .set_result(::std::option::Option::Some(
                 <::aws_smithy_types::BigInteger as ::std::str::FromStr>::from_str("789000000000000000000").expect("Invalid string for BigInteger"),
             ))
             .set_ratio(::std::option::Option::Some(
                 <::aws_smithy_types::BigDecimal as ::std::str::FromStr>::from_str("1.23E-15").expect("invalid string for BigDecimal"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\"result\":789000000000000000000,\"ratio\":1.23E-15}",
                 ))
                 .unwrap(),
-824
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-828
         let op = crate::operation::process_big_numbers::ProcessBigNumbers::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-834
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::process_big_numbers::ProcessBigNumbersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.result, expected_output.result, "Unexpected value for `result`");
         ::pretty_assertions::assert_eq!(parsed.ratio, expected_output.ratio, "Unexpected value for `ratio`");
-861
+    }
-862
+}
-863

↧ Expand context

 /// Error type for the `ProcessBigNumbersError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum ProcessBigNumbersError {
     /// 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()`:
-871
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-873
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-ProcessBigNumbersError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-876
+}
 impl ProcessBigNumbersError {
     /// Creates the `ProcessBigNumbersError::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(),

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_big_numbers/_process_big_numbers_input.rs

@@ -3,3 +130,142 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ProcessBigNumbersInput {
     #[allow(missing_docs)] // documentation missing in model
     pub big_int: ::std::option::Option<::aws_smithy_types::BigInteger>,
     #[allow(missing_docs)] // documentation missing in model
     pub big_dec: ::std::option::Option<::aws_smithy_types::BigDecimal>,
-10
+}
 impl ProcessBigNumbersInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn big_int(&self) -> ::std::option::Option<&::aws_smithy_types::BigInteger> {
         self.big_int.as_ref()
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn big_dec(&self) -> ::std::option::Option<&::aws_smithy_types::BigDecimal> {
         self.big_dec.as_ref()
-19
+    }
-20
+}
 static PROCESSBIGNUMBERSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.bignumbers.synthetic#ProcessBigNumbersInput",

     "com.amazonaws.bignumbers.synthetic",
     "ProcessBigNumbersInput",
 );
 static PROCESSBIGNUMBERSINPUT_MEMBER_BIG_INT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bignumbers.synthetic#ProcessBigNumbersInput$bigInt",
         "com.amazonaws.bignumbers.synthetic",
         "ProcessBigNumbersInput",
     ),
     ::aws_smithy_schema::ShapeType::BigInteger,
     "big_int",
     "bigInt",
 ,
 );
 static PROCESSBIGNUMBERSINPUT_MEMBER_BIG_DEC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bignumbers.synthetic#ProcessBigNumbersInput$bigDec",
         "com.amazonaws.bignumbers.synthetic",
         "ProcessBigNumbersInput",
     ),
     ::aws_smithy_schema::ShapeType::BigDecimal,
     "big_dec",
     "bigDec",
 ,
 );
 static PROCESSBIGNUMBERSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PROCESSBIGNUMBERSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PROCESSBIGNUMBERSINPUT_MEMBER_BIG_INT, &PROCESSBIGNUMBERSINPUT_MEMBER_BIG_DEC],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/process", None));
 impl ProcessBigNumbersInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PROCESSBIGNUMBERSINPUT_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ProcessBigNumbersInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.big_int {
             ser.write_big_integer(&PROCESSBIGNUMBERSINPUT_MEMBER_BIG_INT, val)?;
-64
+        }
         if let Some(ref val) = self.big_dec {
             ser.write_big_decimal(&PROCESSBIGNUMBERSINPUT_MEMBER_BIG_DEC, val)?;
-67
+        }
         Ok(())
-69
+    }
-70
+}
 impl ProcessBigNumbersInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PROCESSBIGNUMBERSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PROCESSBIGNUMBERSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.big_int = Some(deser.read_big_integer(member)?);
-89
+                }
                 Some(1) => {
                     builder.big_dec = Some(deser.read_big_decimal(member)?);
-92
+                }
                 _ => {}
-94
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-100
+    }
-101
+}
 impl ProcessBigNumbersInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ProcessBigNumbersInput {
     /// Creates a new builder-style object to manufacture [`ProcessBigNumbersInput`](crate::operation::process_big_numbers::ProcessBigNumbersInput).
     pub fn builder() -> crate::operation::process_big_numbers::builders::ProcessBigNumbersInputBuilder {
         crate::operation::process_big_numbers::builders::ProcessBigNumbersInputBuilder::default()
-117
+    }
-118
+}
-119
 /// A builder for [`ProcessBigNumbersInput`](crate::operation::process_big_numbers::ProcessBigNumbersInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ProcessBigNumbersInputBuilder {
     pub(crate) big_int: ::std::option::Option<::aws_smithy_types::BigInteger>,
     pub(crate) big_dec: ::std::option::Option<::aws_smithy_types::BigDecimal>,
-126
+}
 impl ProcessBigNumbersInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn big_int(mut self, input: ::aws_smithy_types::BigInteger) -> Self {
         self.big_int = ::std::option::Option::Some(input);
         self
-132
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_big_int(mut self, input: ::std::option::Option<::aws_smithy_types::BigInteger>) -> Self {
         self.big_int = input;
         self
-137
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_big_int(&self) -> &::std::option::Option<::aws_smithy_types::BigInteger> {
         &self.big_int
-141
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_big_numbers/_process_big_numbers_output.rs

@@ -42,42 +128,139 @@

↥ Expand context

     ::aws_smithy_schema::ShapeType::BigDecimal,
     "ratio",
 ,
 );
 static PROCESSBIGNUMBERSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PROCESSBIGNUMBERSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PROCESSBIGNUMBERSOUTPUT_MEMBER_RESULT, &PROCESSBIGNUMBERSOUTPUT_MEMBER_RATIO],
 );
 impl ProcessBigNumbersOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PROCESSBIGNUMBERSOUTPUT_SCHEMA;
-54
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ProcessBigNumbersOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.result {

             ser.write_big_integer(&PROCESSBIGNUMBERSOUTPUT_MEMBER_RESULT, val)?;
-63
+        }
         if let Some(ref val) = self.ratio {
             ser.write_big_decimal(&PROCESSBIGNUMBERSOUTPUT_MEMBER_RATIO, val)?;
-66
+        }
         Ok(())
-68
+    }
-69
+}
 impl ProcessBigNumbersOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PROCESSBIGNUMBERSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PROCESSBIGNUMBERSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.result = Some(deser.read_big_integer(member)?);
-88
+                }
                 Some(1) => {
                     builder.ratio = Some(deser.read_big_decimal(member)?);
-91
+                }
                 _ => {}
-93
+            }
             Ok(())
         })?;
         Ok(builder.build())
-97
+    }
-98
+}
 impl ProcessBigNumbersOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ProcessBigNumbersOutput {
     /// Creates a new builder-style object to manufacture [`ProcessBigNumbersOutput`](crate::operation::process_big_numbers::ProcessBigNumbersOutput).
     pub fn builder() -> crate::operation::process_big_numbers::builders::ProcessBigNumbersOutputBuilder {
         crate::operation::process_big_numbers::builders::ProcessBigNumbersOutputBuilder::default()
-114
+    }
-115
+}
-116
 /// A builder for [`ProcessBigNumbersOutput`](crate::operation::process_big_numbers::ProcessBigNumbersOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ProcessBigNumbersOutputBuilder {
     pub(crate) result: ::std::option::Option<::aws_smithy_types::BigInteger>,
     pub(crate) ratio: ::std::option::Option<::aws_smithy_types::BigDecimal>,
-123
+}
 impl ProcessBigNumbersOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn result(mut self, input: ::aws_smithy_types::BigInteger) -> Self {
         self.result = ::std::option::Option::Some(input);
         self
-129
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_result(mut self, input: ::std::option::Option<::aws_smithy_types::BigInteger>) -> Self {
         self.result = input;
         self
-134
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_result(&self) -> &::std::option::Option<::aws_smithy_types::BigInteger> {
         &self.result
-138
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_nested_big_numbers.rs

@@ -1,1 +40,45 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `ProcessNestedBigNumbers`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ProcessNestedBigNumbers;
 impl ProcessNestedBigNumbers {
     /// Creates a new `ProcessNestedBigNumbers`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersInput,
     ) -> ::std::result::Result<
         crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersOutput>()
                 .expect("correct output type"),
-43
+        )
-44
+    }
-45

@@ -113,118 +234,240 @@

↥ Expand context

         ));
-119
         ::std::option::Option::Some(cfg.freeze())
-121
+    }
-122
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ProcessNestedBigNumbers")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ProcessNestedBigNumbersEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersError,
             >::new());
-137

         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct ProcessNestedBigNumbersResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ProcessNestedBigNumbersResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-161
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_process_nested_big_numbers::de_process_nested_big_numbers_http_error(status, headers, body)
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_process_nested_big_numbers::de_process_nested_big_numbers_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, ProcessNestedBigNumbers::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-189
+    }
-190
+}
 #[derive(Debug)]
 struct ProcessNestedBigNumbersRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ProcessNestedBigNumbersRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/nested").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_process_nested_big_numbers::ser_process_nested_big_numbers_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, ProcessNestedBigNumbers::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-211
+    }
-212
+}
 #[derive(Debug)]
 struct ProcessNestedBigNumbersEndpointParamsInterceptor;
-215
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ProcessNestedBigNumbersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ProcessNestedBigNumbersEndpointParamsInterceptor"
-219
+    }
-220

↧ Expand context

     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::<ProcessNestedBigNumbersInput>()
             .ok_or("failed to downcast to ProcessNestedBigNumbersInput")?;
-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));

@@ -391,397 +451,467 @@

↥ Expand context

                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\"numbers\":[10,20,30],\"ratios\":[0.1,0.2,0.3],\"intMap\":{\"x\":1000},\"decMap\":{\"y\":99.99}}",
                 ))
                 .unwrap(),
-408
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-412
         let op = crate::operation::process_nested_big_numbers::ProcessNestedBigNumbers::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

             .expect("the config must have a deserializer");
-418
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.numbers, expected_output.numbers, "Unexpected value for `numbers`");
         ::pretty_assertions::assert_eq!(parsed.ratios, expected_output.ratios, "Unexpected value for `ratios`");
         ::pretty_assertions::assert_eq!(parsed.int_map, expected_output.int_map, "Unexpected value for `int_map`");
         ::pretty_assertions::assert_eq!(parsed.dec_map, expected_output.dec_map, "Unexpected value for `dec_map`");
-447
+    }

↧ Expand context

-448
+}
-449
 /// Error type for the `ProcessNestedBigNumbersError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum ProcessNestedBigNumbersError {
     /// 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()`:
-457
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-459
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-ProcessNestedBigNumbersError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-462
+}
 impl ProcessNestedBigNumbersError {
     /// Creates the `ProcessNestedBigNumbersError::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 {

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_nested_big_numbers/_process_nested_big_numbers_input.rs

@@ -39,39 +121,122 @@

↥ Expand context

     "com.amazonaws.bignumbers.synthetic",
     "ProcessNestedBigNumbersInput",
 );
 static PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_NUMBERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bignumbers.synthetic#ProcessNestedBigNumbersInput$numbers",
         "com.amazonaws.bignumbers.synthetic",
         "ProcessNestedBigNumbersInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "numbers",
 ,
 );
 static PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_RATIOS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bignumbers.synthetic#ProcessNestedBigNumbersInput$ratios",
         "com.amazonaws.bignumbers.synthetic",
         "ProcessNestedBigNumbersInput",
     ),
     ::aws_smithy_schema::ShapeType::List,

     "ratios",
 ,
 );
 static PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_INT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bignumbers.synthetic#ProcessNestedBigNumbersInput$intMap",
         "com.amazonaws.bignumbers.synthetic",
         "ProcessNestedBigNumbersInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "int_map",
     "intMap",
 ,
 );
 static PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_DEC_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bignumbers.synthetic#ProcessNestedBigNumbersInput$decMap",
         "com.amazonaws.bignumbers.synthetic",
         "ProcessNestedBigNumbersInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dec_map",
     "decMap",
 ,
 );
 static PROCESSNESTEDBIGNUMBERSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PROCESSNESTEDBIGNUMBERSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_NUMBERS,
         &PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_RATIOS,
         &PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_INT_MAP,
         &PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_DEC_MAP,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/nested", None));
 impl ProcessNestedBigNumbersInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PROCESSNESTEDBIGNUMBERSINPUT_SCHEMA;
-96
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ProcessNestedBigNumbersInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {

↧ Expand context

         if let Some(ref val) = self.numbers {
             ser.write_list(
                 &PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_NUMBERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_big_integer(&aws_smithy_schema::prelude::BIG_INTEGER, item)?;
-109
+                    }
                     Ok(())
                 },
             )?;
-113
+        }
         if let Some(ref val) = self.ratios {
             ser.write_list(
                 &PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_RATIOS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_big_decimal(&aws_smithy_schema::prelude::BIG_DECIMAL, item)?;
-120
+                    }
                     Ok(())
                 },

@@ -123,124 +257,257 @@

↥ Expand context

-124
+        }
         if let Some(ref val) = self.int_map {
             ser.write_map(
                 &PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_INT_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_big_integer(&::aws_smithy_schema::prelude::BIG_INTEGER, value)?;
-132
+                    }
                     Ok(())
                 },
             )?;
-136
+        }
         if let Some(ref val) = self.dec_map {
             ser.write_map(
                 &PROCESSNESTEDBIGNUMBERSINPUT_MEMBER_DEC_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_big_decimal(&::aws_smithy_schema::prelude::BIG_DECIMAL, value)?;

-144
+                    }
                     Ok(())
                 },
             )?;
-148
+        }
         Ok(())
-150
+    }
-151
+}
 impl ProcessNestedBigNumbersInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PROCESSNESTEDBIGNUMBERSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PROCESSNESTEDBIGNUMBERSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.numbers = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_big_integer(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_big_integer(member)?);
                             Ok(())
                         })?;
                         container
                     });
-177
+                }
                 Some(1) => {
                     builder.ratios = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_big_decimal(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_big_decimal(member)?);
                             Ok(())
                         })?;
                         container
                     });
-187
+                }
                 Some(2) => {
                     builder.int_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_big_integer(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_big_integer(member)?);
                             Ok(())
                         })?;
                         container
                     });
-197
+                }
                 Some(3) => {
                     builder.dec_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_big_decimal(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_big_decimal(member)?);
                             Ok(())
                         })?;
                         container
                     });
-207
+                }
                 _ => {}
-209
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-215
+    }
-216
+}
 impl ProcessNestedBigNumbersInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ProcessNestedBigNumbersInput {
     /// Creates a new builder-style object to manufacture [`ProcessNestedBigNumbersInput`](crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersInput).
     pub fn builder() -> crate::operation::process_nested_big_numbers::builders::ProcessNestedBigNumbersInputBuilder {
         crate::operation::process_nested_big_numbers::builders::ProcessNestedBigNumbersInputBuilder::default()
-232
+    }
-233
+}
-234
 /// A builder for [`ProcessNestedBigNumbersInput`](crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ProcessNestedBigNumbersInputBuilder {
     pub(crate) numbers: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::BigInteger>>,
     pub(crate) ratios: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::BigDecimal>>,
     pub(crate) int_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::aws_smithy_types::BigInteger>>,
     pub(crate) dec_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::aws_smithy_types::BigDecimal>>,
-243
+}
 impl ProcessNestedBigNumbersInputBuilder {
     /// Appends an item to `numbers`.
     ///
     /// To override the contents of this collection use [`set_numbers`](Self::set_numbers).
     ///
     pub fn numbers(mut self, input: ::aws_smithy_types::BigInteger) -> Self {
         let mut v = self.numbers.unwrap_or_default();
         v.push(input);
         self.numbers = ::std::option::Option::Some(v);
         self
-254
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_numbers(mut self, input: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::BigInteger>>) -> Self {
         self.numbers = input;

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_nested_big_numbers/_process_nested_big_numbers_output.rs

@@ -39,39 +109,109 @@

↥ Expand context

     "com.amazonaws.bignumbers.synthetic",
     "ProcessNestedBigNumbersOutput",
 );
 static PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_NUMBERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bignumbers.synthetic#ProcessNestedBigNumbersOutput$numbers",
         "com.amazonaws.bignumbers.synthetic",
         "ProcessNestedBigNumbersOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "numbers",
 ,
 );
 static PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_RATIOS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bignumbers.synthetic#ProcessNestedBigNumbersOutput$ratios",
         "com.amazonaws.bignumbers.synthetic",
         "ProcessNestedBigNumbersOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,

     "ratios",
 ,
 );
 static PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_INT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bignumbers.synthetic#ProcessNestedBigNumbersOutput$intMap",
         "com.amazonaws.bignumbers.synthetic",
         "ProcessNestedBigNumbersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "int_map",
     "intMap",
 ,
 );
 static PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_DEC_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bignumbers.synthetic#ProcessNestedBigNumbersOutput$decMap",
         "com.amazonaws.bignumbers.synthetic",
         "ProcessNestedBigNumbersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dec_map",
     "decMap",
 ,
 );
 static PROCESSNESTEDBIGNUMBERSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PROCESSNESTEDBIGNUMBERSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_NUMBERS,
         &PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_RATIOS,
         &PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_INT_MAP,
         &PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_DEC_MAP,

↧ Expand context

     ],
 );
 impl ProcessNestedBigNumbersOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PROCESSNESTEDBIGNUMBERSOUTPUT_SCHEMA;
-95
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ProcessNestedBigNumbersOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.numbers {
             ser.write_list(
                 &PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_NUMBERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_big_integer(&aws_smithy_schema::prelude::BIG_INTEGER, item)?;
-108
+                    }
                     Ok(())

@@ -123,123 +255,254 @@

↥ Expand context

-123
+        }
         if let Some(ref val) = self.int_map {
             ser.write_map(
                 &PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_INT_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_big_integer(&::aws_smithy_schema::prelude::BIG_INTEGER, value)?;
-131
+                    }
                     Ok(())
                 },
             )?;
-135
+        }
         if let Some(ref val) = self.dec_map {
             ser.write_map(
                 &PROCESSNESTEDBIGNUMBERSOUTPUT_MEMBER_DEC_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_big_decimal(&::aws_smithy_schema::prelude::BIG_DECIMAL, value)?;

-143
+                    }
                     Ok(())
                 },
             )?;
-147
+        }
         Ok(())
-149
+    }
-150
+}
 impl ProcessNestedBigNumbersOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PROCESSNESTEDBIGNUMBERSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PROCESSNESTEDBIGNUMBERSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.numbers = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_big_integer(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_big_integer(member)?);
                             Ok(())
                         })?;
                         container
                     });
-176
+                }
                 Some(1) => {
                     builder.ratios = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_big_decimal(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_big_decimal(member)?);
                             Ok(())
                         })?;
                         container
                     });
-186
+                }
                 Some(2) => {
                     builder.int_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_big_integer(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_big_integer(member)?);
                             Ok(())
                         })?;
                         container
                     });
-196
+                }
                 Some(3) => {
                     builder.dec_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_big_decimal(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_big_decimal(member)?);
                             Ok(())
                         })?;
                         container
                     });
-206
+                }
                 _ => {}
-208
+            }
             Ok(())
         })?;
         Ok(builder.build())
-212
+    }
-213
+}
 impl ProcessNestedBigNumbersOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ProcessNestedBigNumbersOutput {
     /// Creates a new builder-style object to manufacture [`ProcessNestedBigNumbersOutput`](crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersOutput).
     pub fn builder() -> crate::operation::process_nested_big_numbers::builders::ProcessNestedBigNumbersOutputBuilder {
         crate::operation::process_nested_big_numbers::builders::ProcessNestedBigNumbersOutputBuilder::default()
-229
+    }
-230
+}
-231
 /// A builder for [`ProcessNestedBigNumbersOutput`](crate::operation::process_nested_big_numbers::ProcessNestedBigNumbersOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ProcessNestedBigNumbersOutputBuilder {
     pub(crate) numbers: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::BigInteger>>,
     pub(crate) ratios: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::BigDecimal>>,
     pub(crate) int_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::aws_smithy_types::BigInteger>>,
     pub(crate) dec_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::aws_smithy_types::BigDecimal>>,
-240
+}
 impl ProcessNestedBigNumbersOutputBuilder {
     /// Appends an item to `numbers`.
     ///
     /// To override the contents of this collection use [`set_numbers`](Self::set_numbers).
     ///
     pub fn numbers(mut self, input: ::aws_smithy_types::BigInteger) -> Self {
         let mut v = self.numbers.unwrap_or_default();
         v.push(input);
         self.numbers = ::std::option::Option::Some(v);
         self
-251
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_numbers(mut self, input: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::BigInteger>>) -> Self {
         self.numbers = input;

1 1	`# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2	`[package]`
3 3	`name = "big_numbers"`

 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 protocol = "aws.protocols#restJson1"
 [dependencies.aws-smithy-async]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client"]
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-1x"]
 [dependencies.aws-smithy-schema]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-schema"

 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 features = ["http-body-1-x"]
 [dependencies.bytes]
 version = "1.4.0"
 [dependencies.fastrand]
 version = "2.0.0"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.http-1x]
 version = "1"
 package = "http"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-smithy-http-client]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-client"
 features = ["test-util"]
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
 [dev-dependencies.pretty_assertions]

Client Test

Files changed:

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/types/error/_invalid_greeting.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/Cargo.toml

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/config.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/lib.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_big_numbers.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_big_numbers/_process_big_numbers_input.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_big_numbers/_process_big_numbers_output.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_nested_big_numbers.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_nested_big_numbers/_process_nested_big_numbers_input.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/operation/process_nested_big_numbers/_process_nested_big_numbers_output.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/protocol_serde.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/protocol_serde/shape_big_decimal_list.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/protocol_serde/shape_big_integer_list.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/protocol_serde/shape_process_big_numbers.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/protocol_serde/shape_process_big_numbers_input.rs

tmp-codegen-diff/codegen-client-test/big_numbers/rust-client-codegen/src/protocol_serde/shape_process_nested_big_numbers.rs

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn type_erase_result<O, E>(
     result: ::std::result::Result<O, E>,
 ) -> ::std::result::Result<
     ::aws_smithy_runtime_api::client::interceptors::context::Output,
     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError<::aws_smithy_runtime_api::client::interceptors::context::Error>,
--
+>
 where
     O: ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
     E: ::std::error::Error + std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
--
+{
     result
         .map(|output| ::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         .map_err(|error| ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(error))
         .map_err(::std::convert::Into::into)
--
+}
--
 pub fn parse_http_error_metadata(
     _response_status: u16,
     response_headers: &::aws_smithy_runtime_api::http::Headers,
     response_body: &[u8],
 ) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     crate::json_errors::parse_error_metadata(response_body, response_headers)
-8
+}
--
 pub(crate) mod shape_process_big_numbers;
--
 pub(crate) mod shape_process_nested_big_numbers;
--
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
--
+    }
--
+}
--
 pub(crate) mod shape_process_big_numbers_input;
--
 pub(crate) mod shape_process_nested_big_numbers_input;
--
 pub(crate) mod shape_big_decimal_list;
--
 pub(crate) mod shape_big_integer_list;
--
 pub(crate) mod shape_string_to_big_decimal_map;
--
 pub(crate) mod shape_string_to_big_integer_map;

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_big_decimal_list<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
     _value: &'a [u8],
 ) -> ::std::result::Result<Option<::std::vec::Vec<::aws_smithy_types::BigDecimal>>, ::aws_smithy_json::deserialize::error::DeserializeError>
 where
     I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
--
+{
     match tokens.next().transpose()? {
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             let mut items = Vec::new();
             loop {
                 match tokens.peek() {
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         tokens.next().transpose().unwrap();
                         break;
--
+                    }
                     _ => {
                         let value = ::aws_smithy_json::deserialize::token::expect_number_as_string_or_null(tokens.next(), _value)?
                             .map(<::aws_smithy_types::BigDecimal as ::std::str::FromStr>::from_str)
                             .transpose()
                             .map_err(|e| ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!("invalid BigDecimal: {e}")))?;
                         if let Some(value) = value {
                             items.push(value);
                         } else {
                             return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                 "dense list cannot contain null values",
                             ));
--
+                        }
--
+                    }
--
+                }
--
+            }
             Ok(Some(items))
--
+        }
         _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "expected start array or null",
         )),
--
+    }
--
+}

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_process_big_numbers_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::process_big_numbers::ProcessBigNumbersOutput, crate::operation::process_big_numbers::ProcessBigNumbersError>
--
+{
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::process_big_numbers::ProcessBigNumbersError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::process_big_numbers::ProcessBigNumbersError::generic(generic))
--
+}
--
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_process_big_numbers_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::process_big_numbers::ProcessBigNumbersOutput, crate::operation::process_big_numbers::ProcessBigNumbersError>
--
+{
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::process_big_numbers::builders::ProcessBigNumbersOutputBuilder::default();
         output = crate::protocol_serde::shape_process_big_numbers::de_process_big_numbers(_response_body, output)
             .map_err(crate::operation::process_big_numbers::ProcessBigNumbersError::unhandled)?;
         output.build()
     })
--
+}
--
 pub fn ser_process_big_numbers_input(
     input: &crate::operation::process_big_numbers::ProcessBigNumbersInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_process_big_numbers_input::ser_process_big_numbers_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
--
+}
--
 pub(crate) fn de_process_big_numbers(
     _value: &[u8],
     mut builder: crate::operation::process_big_numbers::builders::ProcessBigNumbersOutputBuilder,
 ) -> ::std::result::Result<
     crate::operation::process_big_numbers::builders::ProcessBigNumbersOutputBuilder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "ratio" => {
                     builder = builder.set_ratio(
                         ::aws_smithy_json::deserialize::token::expect_number_as_string_or_null(tokens.next(), _value)?
                             .map(<::aws_smithy_types::BigDecimal as ::std::str::FromStr>::from_str)
                             .transpose()
                             .map_err(|e| ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!("invalid BigDecimal: {e}")))?,
                     );
--
+                }
                 "result" => {
                     builder = builder.set_result(
                         ::aws_smithy_json::deserialize::token::expect_number_as_string_or_null(tokens.next(), _value)?
                             .map(<::aws_smithy_types::BigInteger as ::std::str::FromStr>::from_str)
                             .transpose()
                             .map_err(|e| ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!("invalid BigInteger: {e}")))?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn ser_process_big_numbers_input_input(
     object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::operation::process_big_numbers::ProcessBigNumbersInput,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     if let Some(var_1) = &input.big_dec {
         object.key("bigDec").write_raw_value(var_1.as_ref());
--
+    }
     if let Some(var_2) = &input.big_int {
         object.key("bigInt").write_raw_value(var_2.as_ref());
--
+    }
     Ok(())
--
+}