Client Test

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_lists/_rpc_v2_cbor_lists_output.rs

@@ -71,71 +221,221 @@

     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.nested_string_list.is_none()`.
     pub fn nested_string_list(&self) -> &[::std::vec::Vec<::std::string::String>] {
         self.nested_string_list.as_deref().unwrap_or_default()
-75
+    }
     #[allow(missing_docs)] // documentation missing in model
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.structure_list.is_none()`.
     pub fn structure_list(&self) -> &[crate::types::StructureListMember] {
         self.structure_list.as_deref().unwrap_or_default()
-81
+    }
     #[allow(missing_docs)] // documentation missing in model
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.blob_list.is_none()`.
     pub fn blob_list(&self) -> &[::aws_smithy_types::Blob] {
         self.blob_list.as_deref().unwrap_or_default()
-87
+    }
-88
+}
 static RPCV2CBORLISTSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "RpcV2CborListsOutput",
 );
 static RPCV2CBORLISTSOUTPUT_MEMBER_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$stringList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_list",
     "stringList",
 ,
 );
 static RPCV2CBORLISTSOUTPUT_MEMBER_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$stringSet",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_set",
     "stringSet",
 ,
 );
 static RPCV2CBORLISTSOUTPUT_MEMBER_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$integerList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "integer_list",
     "integerList",
 ,
 );
 static RPCV2CBORLISTSOUTPUT_MEMBER_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$booleanList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "boolean_list",
     "booleanList",
 ,
 );
 static RPCV2CBORLISTSOUTPUT_MEMBER_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$timestampList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "timestamp_list",
     "timestampList",
 ,
 );
 static RPCV2CBORLISTSOUTPUT_MEMBER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$enumList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "enum_list",
     "enumList",
 ,
 );
 static RPCV2CBORLISTSOUTPUT_MEMBER_INT_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$intEnumList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "int_enum_list",
     "intEnumList",
 ,
 );
 static RPCV2CBORLISTSOUTPUT_MEMBER_NESTED_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$nestedStringList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "nested_string_list",
     "nestedStringList",
 ,
 );
 static RPCV2CBORLISTSOUTPUT_MEMBER_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$structureList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "structure_list",
     "structureList",
 ,
 );
 static RPCV2CBORLISTSOUTPUT_MEMBER_BLOB_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$blobList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "blob_list",
     "blobList",
 ,
 );
 static RPCV2CBORLISTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RPCV2CBORLISTSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RPCV2CBORLISTSOUTPUT_MEMBER_STRING_LIST,
         &RPCV2CBORLISTSOUTPUT_MEMBER_STRING_SET,
         &RPCV2CBORLISTSOUTPUT_MEMBER_INTEGER_LIST,
         &RPCV2CBORLISTSOUTPUT_MEMBER_BOOLEAN_LIST,

↧ Expand context

         &RPCV2CBORLISTSOUTPUT_MEMBER_TIMESTAMP_LIST,
         &RPCV2CBORLISTSOUTPUT_MEMBER_ENUM_LIST,
         &RPCV2CBORLISTSOUTPUT_MEMBER_INT_ENUM_LIST,
         &RPCV2CBORLISTSOUTPUT_MEMBER_NESTED_STRING_LIST,
         &RPCV2CBORLISTSOUTPUT_MEMBER_STRUCTURE_LIST,
         &RPCV2CBORLISTSOUTPUT_MEMBER_BLOB_LIST,
     ],
 );
 impl RpcV2CborListsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RPCV2CBORLISTSOUTPUT_SCHEMA;
-213
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RpcV2CborListsOutput {
     #[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.string_list {
             ser.write_list(

@@ -272,272 +515,476 @@

↥ Expand context

                 },
             )?;
-274
+        }
         if let Some(ref val) = self.enum_list {
             ser.write_list(
                 &RPCV2CBORLISTSOUTPUT_MEMBER_ENUM_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-281
+                    }
                     Ok(())
                 },
             )?;
-285
+        }
         if let Some(ref val) = self.int_enum_list {
             ser.write_list(
                 &RPCV2CBORLISTSOUTPUT_MEMBER_INT_ENUM_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_integer(&aws_smithy_schema::prelude::INTEGER, *item)?;

-292
+                    }
                     Ok(())
                 },
             )?;
-296
+        }
         if let Some(ref val) = self.nested_string_list {
             ser.write_list(
                 &RPCV2CBORLISTSOUTPUT_MEMBER_NESTED_STRING_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_list(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in item {
                                     ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-311
+                    }
                     Ok(())
                 },
             )?;
-315
+        }
         if let Some(ref val) = self.structure_list {
             ser.write_list(
                 &RPCV2CBORLISTSOUTPUT_MEMBER_STRUCTURE_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::StructureListMember::SCHEMA, item)?;
-322
+                    }
                     Ok(())
                 },
             )?;
-326
+        }
         if let Some(ref val) = self.blob_list {
             ser.write_list(
                 &RPCV2CBORLISTSOUTPUT_MEMBER_BLOB_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_blob(&aws_smithy_schema::prelude::BLOB, item)?;
-333
+                    }
                     Ok(())
                 },
             )?;
-337
+        }
         Ok(())
-339
+    }
-340
+}
 impl RpcV2CborListsOutput {
     /// 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(&RPCV2CBORLISTSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RPCV2CBORLISTSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.string_list = 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_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.string_list = Some(deser.read_string_list(member)?);
-359
+                }
                 Some(1) => {
                     builder.string_set = 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_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.string_set = Some(deser.read_string_list(member)?);
-362
+                }
                 Some(2) => {
                     builder.integer_list = 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_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.integer_list = Some(deser.read_integer_list(member)?);
-365
+                }
                 Some(3) => {
                     builder.boolean_list = 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_boolean(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_boolean(member)?);
                             Ok(())
                         })?;
                         container
                     });
-375
+                }
                 Some(4) => {
                     builder.timestamp_list = 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_timestamp(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_timestamp(member)?);
                             Ok(())
                         })?;
                         container
                     });
-385
+                }
                 Some(5) => {
                     builder.enum_list = 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(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-395
+                }
                 Some(6) => {
                     builder.int_enum_list = 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_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.int_enum_list = Some(deser.read_integer_list(member)?);
-398
+                }
                 Some(7) => {
                     builder.nested_string_list = 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(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push({
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-415
+                }
                 Some(8) => {
                     builder.structure_list = 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(crate::types::StructureListMember::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::StructureListMember::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-425
+                }
                 Some(9) => {
                     builder.blob_list = 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_blob(member)?);
                             Ok(list)
                         })?
                     });
                     builder.blob_list = Some(deser.read_blob_list(member)?);
-428
+                }
                 _ => {}
-430
+            }
             Ok(())
         })?;
         Ok(builder.build())
-434
+    }
-435
+}
 impl RpcV2CborListsOutput {
     /// 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 RpcV2CborListsOutput {
     /// Creates a new builder-style object to manufacture [`RpcV2CborListsOutput`](crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput).
     pub fn builder() -> crate::operation::rpc_v2_cbor_lists::builders::RpcV2CborListsOutputBuilder {
         crate::operation::rpc_v2_cbor_lists::builders::RpcV2CborListsOutputBuilder::default()
-451
+    }
-452
+}
-453
 /// A builder for [`RpcV2CborListsOutput`](crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RpcV2CborListsOutputBuilder {
     pub(crate) string_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) string_set: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) integer_list: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) boolean_list: ::std::option::Option<::std::vec::Vec<bool>>,
     pub(crate) timestamp_list: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::DateTime>>,
     pub(crate) enum_list: ::std::option::Option<::std::vec::Vec<crate::types::FooEnum>>,
     pub(crate) int_enum_list: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) nested_string_list: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,
     pub(crate) structure_list: ::std::option::Option<::std::vec::Vec<crate::types::StructureListMember>>,
     pub(crate) blob_list: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::Blob>>,
-468
+}
 impl RpcV2CborListsOutputBuilder {
     /// Appends an item to `string_list`.
     ///
     /// To override the contents of this collection use [`set_string_list`](Self::set_string_list).
     ///
     pub fn string_list(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         let mut v = self.string_list.unwrap_or_default();
         v.push(input.into());

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_sparse_maps.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `RpcV2CborSparseMaps`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct RpcV2CborSparseMaps;
 impl RpcV2CborSparseMaps {
     /// Creates a new `RpcV2CborSparseMaps`
     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::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput,
     ) -> ::std::result::Result<
         crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsError,
             ::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::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsError>()
                     .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::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -104,108 +166,171 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "RpcV2CborSparseMaps",
             "RpcV2Protocol",
         ));
-112
         ::std::option::Option::Some(cfg.freeze())
-114
+    }
-115
     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("RpcV2CborSparseMaps")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(RpcV2CborSparseMapsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsError,
             >::new());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct RpcV2CborSparseMapsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RpcV2CborSparseMapsResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &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());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-148
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_rpc_v2_cbor_sparse_maps::de_rpc_v2_cbor_sparse_maps_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_rpc_v2_cbor_sparse_maps::de_rpc_v2_cbor_sparse_maps_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-155
+    }
-156
+}
 #[derive(Debug)]
 struct RpcV2CborSparseMapsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RpcV2CborSparseMapsRequestSerializer {
     #[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::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

@@ -530,535 +590,599 @@

↥ Expand context

             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "v29zcGFyc2VTdHJ1Y3RNYXC/Y2Zvb79iaGlldGhlcmX/Y2Jher9iaGljYnll////",
                 ))
                 .unwrap(),
-546
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-550
         let op = crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMaps::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");
-556
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.sparse_struct_map,
             expected_output.sparse_struct_map,
             "Unexpected value for `sparse_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.sparse_number_map,
             expected_output.sparse_number_map,
             "Unexpected value for `sparse_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_boolean_map,
             expected_output.sparse_boolean_map,
             "Unexpected value for `sparse_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_string_map,
             expected_output.sparse_string_map,
             "Unexpected value for `sparse_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_set_map,
             expected_output.sparse_set_map,
             "Unexpected value for `sparse_set_map`"
         );

@@ -618,627 +678,691 @@

↥ Expand context

             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "v3BzcGFyc2VCb29sZWFuTWFwv2F49v9vc3BhcnNlTnVtYmVyTWFwv2F49v9vc3BhcnNlU3RyaW5nTWFwv2F49v9vc3BhcnNlU3RydWN0TWFwv2F49v//",
                 ))
                 .unwrap(),
-638
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-642
         let op = crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMaps::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");
-648
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.sparse_struct_map,
             expected_output.sparse_struct_map,
             "Unexpected value for `sparse_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.sparse_number_map,
             expected_output.sparse_number_map,
             "Unexpected value for `sparse_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_boolean_map,
             expected_output.sparse_boolean_map,
             "Unexpected value for `sparse_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_string_map,
             expected_output.sparse_string_map,
             "Unexpected value for `sparse_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_set_map,
             expected_output.sparse_set_map,
             "Unexpected value for `sparse_set_map`"
         );

@@ -690,703 +750,767 @@

↥ Expand context

                 ret.insert("y".to_owned(), ::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned()]));
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v2xzcGFyc2VTZXRNYXC/YXmfYWFhYv9heJ////8="))
                 .unwrap(),
-714
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-718
         let op = crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMaps::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");
-724
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.sparse_struct_map,
             expected_output.sparse_struct_map,
             "Unexpected value for `sparse_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.sparse_number_map,
             expected_output.sparse_number_map,
             "Unexpected value for `sparse_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_boolean_map,
             expected_output.sparse_boolean_map,
             "Unexpected value for `sparse_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_string_map,
             expected_output.sparse_string_map,
             "Unexpected value for `sparse_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_set_map,
             expected_output.sparse_set_map,
             "Unexpected value for `sparse_set_map`"
         );

@@ -763,780 +823,844 @@

↥ Expand context

                 ret.insert("z".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v2xzcGFyc2VTZXRNYXC/YXif/2F5n2FhYWL/YXr2//8="))
                 .unwrap(),
-791
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-795
         let op = crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMaps::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");
-801
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.sparse_struct_map,
             expected_output.sparse_struct_map,
             "Unexpected value for `sparse_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.sparse_number_map,
             expected_output.sparse_number_map,
             "Unexpected value for `sparse_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_boolean_map,
             expected_output.sparse_boolean_map,
             "Unexpected value for `sparse_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_string_map,
             expected_output.sparse_string_map,
             "Unexpected value for `sparse_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_set_map,
             expected_output.sparse_set_map,
             "Unexpected value for `sparse_set_map`"
         );

@@ -841,862 +901,926 @@

↥ Expand context

             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "v29zcGFyc2VOdW1iZXJNYXC/YXgA/3BzcGFyc2VCb29sZWFuTWFwv2F49P//",
                 ))
                 .unwrap(),
-873
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-877
         let op = crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMaps::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");
-883
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.sparse_struct_map,
             expected_output.sparse_struct_map,
             "Unexpected value for `sparse_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.sparse_number_map,
             expected_output.sparse_number_map,
             "Unexpected value for `sparse_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_boolean_map,
             expected_output.sparse_boolean_map,
             "Unexpected value for `sparse_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_string_map,
             expected_output.sparse_string_map,
             "Unexpected value for `sparse_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_set_map,
             expected_output.sparse_set_map,
             "Unexpected value for `sparse_set_map`"
         );

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_sparse_maps/_rpc_v2_cbor_sparse_maps_input.rs

@@ -30,30 +130,130 @@

↥ Expand context

     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_boolean_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<bool>>> {
         self.sparse_boolean_map.as_ref()
-33
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_string_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>> {
         self.sparse_string_map.as_ref()
-39
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_set_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::vec::Vec<::std::string::String>>>>
-44
+    {
         self.sparse_set_map.as_ref()
-46
+    }
-47
+}
 static RPCV2CBORSPARSEMAPSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "RpcV2CborSparseMapsInput",
 );
 static RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput$sparseStructMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborSparseMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_struct_map",
     "sparseStructMap",
 ,
 );
 static RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput$sparseNumberMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborSparseMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_number_map",
     "sparseNumberMap",
 ,
 );
 static RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput$sparseBooleanMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborSparseMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_boolean_map",
     "sparseBooleanMap",
 ,
 );
 static RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput$sparseStringMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborSparseMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_string_map",
     "sparseStringMap",
 ,
 );
 static RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput$sparseSetMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborSparseMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_set_map",
     "sparseSetMap",
 ,
 );
 static RPCV2CBORSPARSEMAPSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RPCV2CBORSPARSEMAPSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_STRUCT_MAP,
         &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_NUMBER_MAP,
         &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_BOOLEAN_MAP,
         &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_STRING_MAP,

↧ Expand context

         &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_SET_MAP,
     ],
 );
 impl RpcV2CborSparseMapsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RPCV2CBORSPARSEMAPSINPUT_SCHEMA;
-117
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RpcV2CborSparseMapsInput {
     #[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.sparse_struct_map {
             ser.write_map(
                 &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_STRUCT_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {

@@ -178,178 +381,392 @@

↥ Expand context

                 },
             )?;
-180
+        }
         if let Some(ref val) = self.sparse_string_map {
             ser.write_map(
                 &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_STRING_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {
                             Some(value) => {
                                 ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-190
+                            }
                             None => {
                                 ser.write_null(&::aws_smithy_schema::prelude::STRING)?;
-193
+                            }
-194
+                        }
-195
+                    }
                     Ok(())
                 },

             )?;
-199
+        }
         if let Some(ref val) = self.sparse_set_map {
             ser.write_map(
                 &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_SET_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {
                             Some(value) => {
                                 todo!("schema: unsupported map value type");
                                 ser.write_list(
                                     &::aws_smithy_schema::prelude::DOCUMENT,
                                     &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                         for item in value {
                                             ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                        }
                                         Ok(())
                                     },
                                 )?;
-217
+                            }
                             None => {
                                 ser.write_null(&::aws_smithy_schema::prelude::STRING)?;
-220
+                            }
-221
+                        }
-222
+                    }
                     Ok(())
                 },
             )?;
-226
+        }
         Ok(())
-228
+    }
-229
+}
 impl RpcV2CborSparseMapsInput {
     /// 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(&RPCV2CBORSPARSEMAPSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RPCV2CBORSPARSEMAPSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.sparse_struct_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(crate::types::GreetingStruct::deserialize(deser)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-263
+                }
                 Some(1) => {
                     builder.sparse_number_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_integer(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-281
+                }
                 Some(2) => {
                     builder.sparse_boolean_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_boolean(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-299
+                }
                 Some(3) => {
                     builder.sparse_string_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_string(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-317
+                }
                 Some(4) => {
                     builder.sparse_set_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(todo!("deserialize nested aggregate"))
                                     Some({
                                         let mut list = Vec::new();
                                         deser.read_list(member, &mut |deser| {
                                             list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
                                             Ok(())
                                         })?;
                                         list
                                     })
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-342
+                }
                 _ => {}
-344
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-350
+    }
-351
+}
 impl RpcV2CborSparseMapsInput {
     /// 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 RpcV2CborSparseMapsInput {
     /// Creates a new builder-style object to manufacture [`RpcV2CborSparseMapsInput`](crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput).
     pub fn builder() -> crate::operation::rpc_v2_cbor_sparse_maps::builders::RpcV2CborSparseMapsInputBuilder {
         crate::operation::rpc_v2_cbor_sparse_maps::builders::RpcV2CborSparseMapsInputBuilder::default()
-367
+    }
-368
+}
-369
 /// A builder for [`RpcV2CborSparseMapsInput`](crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RpcV2CborSparseMapsInputBuilder {
     pub(crate) sparse_struct_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<crate::types::GreetingStruct>>>,
     pub(crate) sparse_number_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<i32>>>,
     pub(crate) sparse_boolean_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<bool>>>,
     pub(crate) sparse_string_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>>,
     pub(crate) sparse_set_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::vec::Vec<::std::string::String>>>>,
-382
+}
 impl RpcV2CborSparseMapsInputBuilder {
     /// Adds a key-value pair to `sparse_struct_map`.
     ///
     /// To override the contents of this collection use [`set_sparse_struct_map`](Self::set_sparse_struct_map).
     ///
     pub fn sparse_struct_map(
         mut self,
         k: impl ::std::convert::Into<::std::string::String>,
         v: ::std::option::Option<crate::types::GreetingStruct>,
     ) -> Self {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_sparse_maps/_rpc_v2_cbor_sparse_maps_output.rs

@@ -30,30 +130,130 @@

↥ Expand context

     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_boolean_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<bool>>> {
         self.sparse_boolean_map.as_ref()
-33
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_string_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>> {
         self.sparse_string_map.as_ref()
-39
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_set_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::vec::Vec<::std::string::String>>>>
-44
+    {
         self.sparse_set_map.as_ref()
-46
+    }
-47
+}
 static RPCV2CBORSPARSEMAPSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "RpcV2CborSparseMapsOutput",
 );
 static RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput$sparseStructMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborSparseMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_struct_map",
     "sparseStructMap",
 ,
 );
 static RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput$sparseNumberMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborSparseMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_number_map",
     "sparseNumberMap",
 ,
 );
 static RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput$sparseBooleanMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborSparseMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_boolean_map",
     "sparseBooleanMap",
 ,
 );
 static RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput$sparseStringMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborSparseMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_string_map",
     "sparseStringMap",
 ,
 );
 static RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput$sparseSetMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "RpcV2CborSparseMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_set_map",
     "sparseSetMap",
 ,
 );
 static RPCV2CBORSPARSEMAPSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RPCV2CBORSPARSEMAPSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_STRUCT_MAP,
         &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_NUMBER_MAP,
         &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_BOOLEAN_MAP,
         &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_STRING_MAP,

↧ Expand context

         &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_SET_MAP,
     ],
 );
 impl RpcV2CborSparseMapsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RPCV2CBORSPARSEMAPSOUTPUT_SCHEMA;
-117
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RpcV2CborSparseMapsOutput {
     #[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.sparse_struct_map {
             ser.write_map(
                 &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_STRUCT_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {

@@ -178,178 +379,390 @@

↥ Expand context

                 },
             )?;
-180
+        }
         if let Some(ref val) = self.sparse_string_map {
             ser.write_map(
                 &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_STRING_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {
                             Some(value) => {
                                 ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-190
+                            }
                             None => {
                                 ser.write_null(&::aws_smithy_schema::prelude::STRING)?;
-193
+                            }
-194
+                        }
-195
+                    }
                     Ok(())
                 },

             )?;
-199
+        }
         if let Some(ref val) = self.sparse_set_map {
             ser.write_map(
                 &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_SET_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {
                             Some(value) => {
                                 todo!("schema: unsupported map value type");
                                 ser.write_list(
                                     &::aws_smithy_schema::prelude::DOCUMENT,
                                     &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                         for item in value {
                                             ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                        }
                                         Ok(())
                                     },
                                 )?;
-217
+                            }
                             None => {
                                 ser.write_null(&::aws_smithy_schema::prelude::STRING)?;
-220
+                            }
-221
+                        }
-222
+                    }
                     Ok(())
                 },
             )?;
-226
+        }
         Ok(())
-228
+    }
-229
+}
 impl RpcV2CborSparseMapsOutput {
     /// 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(&RPCV2CBORSPARSEMAPSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RPCV2CBORSPARSEMAPSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.sparse_struct_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(crate::types::GreetingStruct::deserialize(deser)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-263
+                }
                 Some(1) => {
                     builder.sparse_number_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_integer(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-281
+                }
                 Some(2) => {
                     builder.sparse_boolean_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_boolean(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-299
+                }
                 Some(3) => {
                     builder.sparse_string_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_string(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-317
+                }
                 Some(4) => {
                     builder.sparse_set_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(todo!("deserialize nested aggregate"))
                                     Some({
                                         let mut list = Vec::new();
                                         deser.read_list(member, &mut |deser| {
                                             list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
                                             Ok(())
                                         })?;
                                         list
                                     })
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-342
+                }
                 _ => {}
-344
+            }
             Ok(())
         })?;
         Ok(builder.build())
-348
+    }
-349
+}
 impl RpcV2CborSparseMapsOutput {
     /// 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 RpcV2CborSparseMapsOutput {
     /// Creates a new builder-style object to manufacture [`RpcV2CborSparseMapsOutput`](crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput).
     pub fn builder() -> crate::operation::rpc_v2_cbor_sparse_maps::builders::RpcV2CborSparseMapsOutputBuilder {
         crate::operation::rpc_v2_cbor_sparse_maps::builders::RpcV2CborSparseMapsOutputBuilder::default()
-365
+    }
-366
+}
-367
 /// A builder for [`RpcV2CborSparseMapsOutput`](crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RpcV2CborSparseMapsOutputBuilder {
     pub(crate) sparse_struct_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<crate::types::GreetingStruct>>>,
     pub(crate) sparse_number_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<i32>>>,
     pub(crate) sparse_boolean_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<bool>>>,
     pub(crate) sparse_string_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>>,
     pub(crate) sparse_set_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::vec::Vec<::std::string::String>>>>,
-380
+}
 impl RpcV2CborSparseMapsOutputBuilder {
     /// Adds a key-value pair to `sparse_struct_map`.
     ///
     /// To override the contents of this collection use [`set_sparse_struct_map`](Self::set_sparse_struct_map).
     ///
     pub fn sparse_struct_map(
         mut self,
         k: impl ::std::convert::Into<::std::string::String>,
         v: ::std::option::Option<crate::types::GreetingStruct>,
     ) -> Self {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/simple_scalar_properties.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `SimpleScalarProperties`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct SimpleScalarProperties;
 impl SimpleScalarProperties {
     /// Creates a new `SimpleScalarProperties`
     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::simple_scalar_properties::SimpleScalarPropertiesInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput,
     ) -> ::std::result::Result<
         crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::simple_scalar_properties::SimpleScalarPropertiesError,
             ::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::simple_scalar_properties::SimpleScalarPropertiesError>()
                     .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::simple_scalar_properties::SimpleScalarPropertiesOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -110,114 +172,177 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "SimpleScalarProperties",
             "RpcV2Protocol",
         ));
-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("SimpleScalarProperties")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(SimpleScalarPropertiesEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::simple_scalar_properties::SimpleScalarPropertiesError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::simple_scalar_properties::SimpleScalarPropertiesError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct SimpleScalarPropertiesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for SimpleScalarPropertiesResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &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());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-161
+    }
-162
+}
 #[derive(Debug)]
 struct SimpleScalarPropertiesRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for SimpleScalarPropertiesRequestSerializer {
     #[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::simple_scalar_properties::SimpleScalarPropertiesInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

@@ -506,511 +566,575 @@

↥ Expand context

             .set_float_value(::std::option::Option::Some(7.625_f32))
             .set_integer_value(::std::option::Option::Some(256))
             .set_short_value(::std::option::Option::Some(9898))
             .set_string_value(::std::option::Option::Some("simple".to_owned()))
             .set_blob_value(::std::option::Option::Some(::aws_smithy_types::Blob::new("foo")))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "application/cbor")
         .header("smithy-protocol", "rpc-v2-cbor")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("v3B0cnVlQm9vbGVhblZhbHVl9XFmYWxzZUJvb2xlYW5WYWx1ZfRpYnl0ZVZhbHVlBWtkb3VibGVWYWx1Zfs//jlYEGJN02pmbG9hdFZhbHVl+kD0AABsaW50ZWdlclZhbHVlGQEAanNob3J0VmFsdWUZJqprc3RyaW5nVmFsdWVmc2ltcGxlaWJsb2JWYWx1ZUNmb2//"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-526
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-532
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.true_boolean_value,
             expected_output.true_boolean_value,
             "Unexpected value for `true_boolean_value`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.false_boolean_value,
             expected_output.false_boolean_value,
             "Unexpected value for `false_boolean_value`"
         );
         ::pretty_assertions::assert_eq!(parsed.byte_value, expected_output.byte_value, "Unexpected value for `byte_value`");
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value
         );
         ::pretty_assertions::assert_eq!(
             parsed.integer_value,

@@ -586,595 +646,659 @@

↥ Expand context

             .set_float_value(::std::option::Option::Some(7.625_f32))
             .set_integer_value(::std::option::Option::Some(256))
             .set_short_value(::std::option::Option::Some(9898))
             .set_string_value(::std::option::Option::Some("simple".to_owned()))
             .set_blob_value(::std::option::Option::Some(::aws_smithy_types::Blob::new("foo")))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "application/cbor")
         .header("smithy-protocol", "rpc-v2-cbor")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("qXB0cnVlQm9vbGVhblZhbHVl9XFmYWxzZUJvb2xlYW5WYWx1ZfRpYnl0ZVZhbHVlBWtkb3VibGVWYWx1Zfs//jlYEGJN02pmbG9hdFZhbHVl+kD0AABsaW50ZWdlclZhbHVlGQEAanNob3J0VmFsdWUZJqprc3RyaW5nVmFsdWVmc2ltcGxlaWJsb2JWYWx1ZUNmb28="))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-610
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-616
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.true_boolean_value,
             expected_output.true_boolean_value,
             "Unexpected value for `true_boolean_value`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.false_boolean_value,
             expected_output.false_boolean_value,
             "Unexpected value for `false_boolean_value`"
         );
         ::pretty_assertions::assert_eq!(parsed.byte_value, expected_output.byte_value, "Unexpected value for `byte_value`");
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value
         );
         ::pretty_assertions::assert_eq!(
             parsed.integer_value,

@@ -658,671 +718,735 @@

↥ Expand context

     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_client_doesnt_deserialize_null_structure_values_response() {
         let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v2tzdHJpbmdWYWx1Zfb/"))
                 .unwrap(),
-682
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-686
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-692
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.true_boolean_value,
             expected_output.true_boolean_value,
             "Unexpected value for `true_boolean_value`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.false_boolean_value,
             expected_output.false_boolean_value,
             "Unexpected value for `false_boolean_value`"
         );
         ::pretty_assertions::assert_eq!(parsed.byte_value, expected_output.byte_value, "Unexpected value for `byte_value`");
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value
         );
         ::pretty_assertions::assert_eq!(
             parsed.integer_value,

@@ -739,756 +799,820 @@

↥ Expand context

             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "v2tkb3VibGVWYWx1Zft/+AAAAAAAAGpmbG9hdFZhbHVl+n/AAAD/",
                 ))
                 .unwrap(),
-767
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-771
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-777
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.true_boolean_value,
             expected_output.true_boolean_value,
             "Unexpected value for `true_boolean_value`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.false_boolean_value,
             expected_output.false_boolean_value,
             "Unexpected value for `false_boolean_value`"
         );
         ::pretty_assertions::assert_eq!(parsed.byte_value, expected_output.byte_value, "Unexpected value for `byte_value`");
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value
         );
         ::pretty_assertions::assert_eq!(
             parsed.integer_value,

@@ -820,841 +880,905 @@

↥ Expand context

             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "v2tkb3VibGVWYWx1Zft/8AAAAAAAAGpmbG9hdFZhbHVl+n+AAAD/",
                 ))
                 .unwrap(),
-852
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-856
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-862
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.true_boolean_value,
             expected_output.true_boolean_value,
             "Unexpected value for `true_boolean_value`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.false_boolean_value,
             expected_output.false_boolean_value,
             "Unexpected value for `false_boolean_value`"
         );
         ::pretty_assertions::assert_eq!(parsed.byte_value, expected_output.byte_value, "Unexpected value for `byte_value`");
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value
         );
         ::pretty_assertions::assert_eq!(
             parsed.integer_value,

@@ -901,926 +961,990 @@

↥ Expand context

             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "v2tkb3VibGVWYWx1Zfv/8AAAAAAAAGpmbG9hdFZhbHVl+v+AAAD/",
                 ))
                 .unwrap(),
-937
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-941
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-947
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.true_boolean_value,
             expected_output.true_boolean_value,
             "Unexpected value for `true_boolean_value`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.false_boolean_value,
             expected_output.false_boolean_value,
             "Unexpected value for `false_boolean_value`"
         );
         ::pretty_assertions::assert_eq!(parsed.byte_value, expected_output.byte_value, "Unexpected value for `byte_value`");
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value
         );
         ::pretty_assertions::assert_eq!(
             parsed.integer_value,

@@ -981,1010 +1041,1074 @@

↥ Expand context

             .set_short_value(::std::option::Option::Some(10))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "v2tkb3VibGVWYWx1Zfk+AGpmbG9hdFZhbHVl+UegbGludGVnZXJWYWx1ZRg4aWxvbmdWYWx1ZRkBAGpzaG9ydFZhbHVlCv8=",
                 ))
                 .unwrap(),
-1021
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1025
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-1031
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.true_boolean_value,
             expected_output.true_boolean_value,
             "Unexpected value for `true_boolean_value`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.false_boolean_value,
             expected_output.false_boolean_value,
             "Unexpected value for `false_boolean_value`"
         );
         ::pretty_assertions::assert_eq!(parsed.byte_value, expected_output.byte_value, "Unexpected value for `byte_value`");
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value
         );
         ::pretty_assertions::assert_eq!(
             parsed.integer_value,

@@ -1064,1097 +1124,1161 @@

↥ Expand context

             .set_long_value(::std::option::Option::Some(9873))
             .set_short_value(::std::option::Option::Some(9898))
             .set_string_value(::std::option::Option::Some("simple".to_owned()))
             .set_true_boolean_value(::std::option::Option::Some(true))
             .set_blob_value(::std::option::Option::Some(::aws_smithy_types::Blob::new("foo")))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "application/cbor")
         .header("smithy-protocol", "rpc-v2-cbor")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("v2lieXRlVmFsdWUFa2RvdWJsZVZhbHVl+z/+OVgQYk3TcWZhbHNlQm9vbGVhblZhbHVl9GpmbG9hdFZhbHVl+kD0AABrZXh0cmFPYmplY3S/c2luZGVmaW5pdGVMZW5ndGhNYXC/a3dpdGhBbkFycmF5nwECA///cWRlZmluaXRlTGVuZ3RoTWFwo3J3aXRoQURlZmluaXRlQXJyYXmDAQIDeB1hbmRTb21lSW5kZWZpbml0ZUxlbmd0aFN0cmluZ3gfdGhhdCBoYXMsIGJlZW4gY2h1bmtlZCBvbiBjb21tYWxub3JtYWxTdHJpbmdjZm9vanNob3J0VmFsdWUZJw9uc29tZU90aGVyRmllbGR2dGhpcyBzaG91bGQgYmUgc2tpcHBlZP9saW50ZWdlclZhbHVlGQEAaWxvbmdWYWx1ZRkmkWpzaG9ydFZhbHVlGSaqa3N0cmluZ1ZhbHVlZnNpbXBsZXB0cnVlQm9vbGVhblZhbHVl9WlibG9iVmFsdWVDZm9v/w=="))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1112
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-1118
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.true_boolean_value,
             expected_output.true_boolean_value,
             "Unexpected value for `true_boolean_value`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.false_boolean_value,
             expected_output.false_boolean_value,
             "Unexpected value for `false_boolean_value`"
         );
         ::pretty_assertions::assert_eq!(parsed.byte_value, expected_output.byte_value, "Unexpected value for `byte_value`");
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value
         );
         ::pretty_assertions::assert_eq!(
             parsed.integer_value,

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/simple_scalar_properties/_simple_scalar_properties_input.rs

@@ -51,51 +201,201 @@

↥ Expand context

-51
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn long_value(&self) -> ::std::option::Option<i64> {
         self.long_value
-55
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn short_value(&self) -> ::std::option::Option<i16> {
         self.short_value
-59
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn string_value(&self) -> ::std::option::Option<&str> {
         self.string_value.as_deref()
-63
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn blob_value(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
         self.blob_value.as_ref()
-67
+    }
-68
+}
 static SIMPLESCALARPROPERTIESINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "SimpleScalarPropertiesInput",
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_TRUE_BOOLEAN_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput$trueBooleanValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "true_boolean_value",
     "trueBooleanValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_FALSE_BOOLEAN_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput$falseBooleanValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "false_boolean_value",
     "falseBooleanValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_BYTE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput$byteValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "byte_value",
     "byteValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_DOUBLE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput$doubleValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "double_value",
     "doubleValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_FLOAT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput$floatValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "float_value",
     "floatValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_INTEGER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput$integerValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "integer_value",
     "integerValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_LONG_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput$longValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "long_value",
     "longValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_SHORT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput$shortValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "short_value",
     "shortValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_STRING_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput$stringValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "string_value",
     "stringValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_BLOB_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesInput$blobValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob_value",
     "blobValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SIMPLESCALARPROPERTIESINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_TRUE_BOOLEAN_VALUE,
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_FALSE_BOOLEAN_VALUE,
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_BYTE_VALUE,
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_DOUBLE_VALUE,

↧ Expand context

         &SIMPLESCALARPROPERTIESINPUT_MEMBER_FLOAT_VALUE,
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_INTEGER_VALUE,
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_LONG_VALUE,
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_SHORT_VALUE,
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_STRING_VALUE,
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_BLOB_VALUE,
     ],
 );
 impl SimpleScalarPropertiesInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SIMPLESCALARPROPERTIESINPUT_SCHEMA;
-193
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SimpleScalarPropertiesInput {
     #[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.true_boolean_value {
             ser.write_boolean(&SIMPLESCALARPROPERTIESINPUT_MEMBER_TRUE_BOOLEAN_VALUE, *val)?;

@@ -205,205 +317,328 @@

↥ Expand context

-205
+        }
         if let Some(ref val) = self.byte_value {
             ser.write_byte(&SIMPLESCALARPROPERTIESINPUT_MEMBER_BYTE_VALUE, *val)?;
-208
+        }
         if let Some(ref val) = self.double_value {
             ser.write_double(&SIMPLESCALARPROPERTIESINPUT_MEMBER_DOUBLE_VALUE, *val)?;
-211
+        }
         if let Some(ref val) = self.float_value {
             ser.write_float(&SIMPLESCALARPROPERTIESINPUT_MEMBER_FLOAT_VALUE, *val)?;
-214
+        }
         if let Some(ref val) = self.integer_value {
             ser.write_integer(&SIMPLESCALARPROPERTIESINPUT_MEMBER_INTEGER_VALUE, *val)?;
-217
+        }
         if let Some(ref val) = self.long_value {
             ser.write_long(&SIMPLESCALARPROPERTIESINPUT_MEMBER_LONG_VALUE, *val)?;
-220
+        }
         if let Some(ref val) = self.short_value {
             ser.write_short(&SIMPLESCALARPROPERTIESINPUT_MEMBER_SHORT_VALUE, *val)?;
-223
+        }
         if let Some(ref val) = self.string_value {

             ser.write_string(&SIMPLESCALARPROPERTIESINPUT_MEMBER_STRING_VALUE, val)?;
-226
+        }
         if let Some(ref val) = self.blob_value {
             ser.write_blob(&SIMPLESCALARPROPERTIESINPUT_MEMBER_BLOB_VALUE, val)?;
-229
+        }
         Ok(())
-231
+    }
-232
+}
 impl SimpleScalarPropertiesInput {
     /// 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(&SIMPLESCALARPROPERTIESINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SIMPLESCALARPROPERTIESINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.true_boolean_value = Some(deser.read_boolean(member)?);
-251
+                }
                 Some(1) => {
                     builder.false_boolean_value = Some(deser.read_boolean(member)?);
-254
+                }
                 Some(2) => {
                     builder.byte_value = Some(deser.read_byte(member)?);
-257
+                }
                 Some(3) => {
                     builder.double_value = Some(deser.read_double(member)?);
-260
+                }
                 Some(4) => {
                     builder.float_value = Some(deser.read_float(member)?);
-263
+                }
                 Some(5) => {
                     builder.integer_value = Some(deser.read_integer(member)?);
-266
+                }
                 Some(6) => {
                     builder.long_value = Some(deser.read_long(member)?);
-269
+                }
                 Some(7) => {
                     builder.short_value = Some(deser.read_short(member)?);
-272
+                }
                 Some(8) => {
                     builder.string_value = Some(deser.read_string(member)?);
-275
+                }
                 Some(9) => {
                     builder.blob_value = Some(deser.read_blob(member)?);
-278
+                }
                 _ => {}
-280
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-286
+    }
-287
+}
 impl SimpleScalarPropertiesInput {
     /// 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 SimpleScalarPropertiesInput {
     /// Creates a new builder-style object to manufacture [`SimpleScalarPropertiesInput`](crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput).
     pub fn builder() -> crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesInputBuilder {
         crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesInputBuilder::default()
-303
+    }
-304
+}
-305
 /// A builder for [`SimpleScalarPropertiesInput`](crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SimpleScalarPropertiesInputBuilder {
     pub(crate) true_boolean_value: ::std::option::Option<bool>,
     pub(crate) false_boolean_value: ::std::option::Option<bool>,
     pub(crate) byte_value: ::std::option::Option<i8>,
     pub(crate) double_value: ::std::option::Option<f64>,
     pub(crate) float_value: ::std::option::Option<f32>,
     pub(crate) integer_value: ::std::option::Option<i32>,
     pub(crate) long_value: ::std::option::Option<i64>,
     pub(crate) short_value: ::std::option::Option<i16>,
     pub(crate) string_value: ::std::option::Option<::std::string::String>,
     pub(crate) blob_value: ::std::option::Option<::aws_smithy_types::Blob>,
-320
+}
 impl SimpleScalarPropertiesInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn true_boolean_value(mut self, input: bool) -> Self {
         self.true_boolean_value = ::std::option::Option::Some(input);
         self
-326
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_true_boolean_value(mut self, input: ::std::option::Option<bool>) -> Self {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/simple_scalar_properties/_simple_scalar_properties_output.rs

@@ -51,51 +201,201 @@

↥ Expand context

-51
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn long_value(&self) -> ::std::option::Option<i64> {
         self.long_value
-55
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn short_value(&self) -> ::std::option::Option<i16> {
         self.short_value
-59
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn string_value(&self) -> ::std::option::Option<&str> {
         self.string_value.as_deref()
-63
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn blob_value(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
         self.blob_value.as_ref()
-67
+    }
-68
+}
 static SIMPLESCALARPROPERTIESOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "SimpleScalarPropertiesOutput",
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_TRUE_BOOLEAN_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput$trueBooleanValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "true_boolean_value",
     "trueBooleanValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_FALSE_BOOLEAN_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput$falseBooleanValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "false_boolean_value",
     "falseBooleanValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_BYTE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput$byteValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "byte_value",
     "byteValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_DOUBLE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput$doubleValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "double_value",
     "doubleValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_FLOAT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput$floatValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "float_value",
     "floatValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_INTEGER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput$integerValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "integer_value",
     "integerValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_LONG_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput$longValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "long_value",
     "longValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_SHORT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput$shortValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "short_value",
     "shortValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_STRING_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput$stringValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "string_value",
     "stringValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_BLOB_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleScalarPropertiesOutput$blobValue",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob_value",
     "blobValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SIMPLESCALARPROPERTIESOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_TRUE_BOOLEAN_VALUE,
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_FALSE_BOOLEAN_VALUE,
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_BYTE_VALUE,
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_DOUBLE_VALUE,

↧ Expand context

         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_FLOAT_VALUE,
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_INTEGER_VALUE,
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_LONG_VALUE,
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_SHORT_VALUE,
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_STRING_VALUE,
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_BLOB_VALUE,
     ],
 );
 impl SimpleScalarPropertiesOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SIMPLESCALARPROPERTIESOUTPUT_SCHEMA;
-193
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SimpleScalarPropertiesOutput {
     #[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.true_boolean_value {
             ser.write_boolean(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_TRUE_BOOLEAN_VALUE, *val)?;

@@ -205,205 +315,326 @@

↥ Expand context

-205
+        }
         if let Some(ref val) = self.byte_value {
             ser.write_byte(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_BYTE_VALUE, *val)?;
-208
+        }
         if let Some(ref val) = self.double_value {
             ser.write_double(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_DOUBLE_VALUE, *val)?;
-211
+        }
         if let Some(ref val) = self.float_value {
             ser.write_float(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_FLOAT_VALUE, *val)?;
-214
+        }
         if let Some(ref val) = self.integer_value {
             ser.write_integer(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_INTEGER_VALUE, *val)?;
-217
+        }
         if let Some(ref val) = self.long_value {
             ser.write_long(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_LONG_VALUE, *val)?;
-220
+        }
         if let Some(ref val) = self.short_value {
             ser.write_short(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_SHORT_VALUE, *val)?;
-223
+        }
         if let Some(ref val) = self.string_value {

             ser.write_string(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_STRING_VALUE, val)?;
-226
+        }
         if let Some(ref val) = self.blob_value {
             ser.write_blob(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_BLOB_VALUE, val)?;
-229
+        }
         Ok(())
-231
+    }
-232
+}
 impl SimpleScalarPropertiesOutput {
     /// 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(&SIMPLESCALARPROPERTIESOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SIMPLESCALARPROPERTIESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.true_boolean_value = Some(deser.read_boolean(member)?);
-251
+                }
                 Some(1) => {
                     builder.false_boolean_value = Some(deser.read_boolean(member)?);
-254
+                }
                 Some(2) => {
                     builder.byte_value = Some(deser.read_byte(member)?);
-257
+                }
                 Some(3) => {
                     builder.double_value = Some(deser.read_double(member)?);
-260
+                }
                 Some(4) => {
                     builder.float_value = Some(deser.read_float(member)?);
-263
+                }
                 Some(5) => {
                     builder.integer_value = Some(deser.read_integer(member)?);
-266
+                }
                 Some(6) => {
                     builder.long_value = Some(deser.read_long(member)?);
-269
+                }
                 Some(7) => {
                     builder.short_value = Some(deser.read_short(member)?);
-272
+                }
                 Some(8) => {
                     builder.string_value = Some(deser.read_string(member)?);
-275
+                }
                 Some(9) => {
                     builder.blob_value = Some(deser.read_blob(member)?);
-278
+                }
                 _ => {}
-280
+            }
             Ok(())
         })?;
         Ok(builder.build())
-284
+    }
-285
+}
 impl SimpleScalarPropertiesOutput {
     /// 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 SimpleScalarPropertiesOutput {
     /// Creates a new builder-style object to manufacture [`SimpleScalarPropertiesOutput`](crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput).
     pub fn builder() -> crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesOutputBuilder {
         crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesOutputBuilder::default()
-301
+    }
-302
+}
-303
 /// A builder for [`SimpleScalarPropertiesOutput`](crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SimpleScalarPropertiesOutputBuilder {
     pub(crate) true_boolean_value: ::std::option::Option<bool>,
     pub(crate) false_boolean_value: ::std::option::Option<bool>,
     pub(crate) byte_value: ::std::option::Option<i8>,
     pub(crate) double_value: ::std::option::Option<f64>,
     pub(crate) float_value: ::std::option::Option<f32>,
     pub(crate) integer_value: ::std::option::Option<i32>,
     pub(crate) long_value: ::std::option::Option<i64>,
     pub(crate) short_value: ::std::option::Option<i16>,
     pub(crate) string_value: ::std::option::Option<::std::string::String>,
     pub(crate) blob_value: ::std::option::Option<::aws_smithy_types::Blob>,
-318
+}
 impl SimpleScalarPropertiesOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn true_boolean_value(mut self, input: bool) -> Self {
         self.true_boolean_value = ::std::option::Option::Some(input);
         self
-324
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_true_boolean_value(mut self, input: ::std::option::Option<bool>) -> Self {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/sparse_nulls_operation.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `SparseNullsOperation`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct SparseNullsOperation;
 impl SparseNullsOperation {
     /// Creates a new `SparseNullsOperation`
     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::sparse_nulls_operation::SparseNullsOperationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::sparse_nulls_operation::SparseNullsOperationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::sparse_nulls_operation::SparseNullsOperationInput,
     ) -> ::std::result::Result<
         crate::operation::sparse_nulls_operation::SparseNullsOperationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::sparse_nulls_operation::SparseNullsOperationError,
             ::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::sparse_nulls_operation::SparseNullsOperationError>()
                     .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::sparse_nulls_operation::SparseNullsOperationOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -110,114 +172,177 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "SparseNullsOperation",
             "RpcV2Protocol",
         ));
-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("SparseNullsOperation")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(SparseNullsOperationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::sparse_nulls_operation::SparseNullsOperationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::sparse_nulls_operation::SparseNullsOperationError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct SparseNullsOperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for SparseNullsOperationResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &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());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_sparse_nulls_operation::de_sparse_nulls_operation_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_sparse_nulls_operation::de_sparse_nulls_operation_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-161
+    }
-162
+}
 #[derive(Debug)]
 struct SparseNullsOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for SparseNullsOperationRequestSerializer {
     #[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::sparse_nulls_operation::SparseNullsOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

@@ -345,350 +457,470 @@

↥ Expand context

                 ret.insert("foo".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v29zcGFyc2VTdHJpbmdNYXC/Y2Zvb/b//w=="))
                 .unwrap(),
-361
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-365
         let op = crate::operation::sparse_nulls_operation::SparseNullsOperation::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");
-371
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::sparse_nulls_operation::SparseNullsOperationOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.sparse_string_list,
             expected_output.sparse_string_list,
             "Unexpected value for `sparse_string_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.sparse_string_map,
             expected_output.sparse_string_map,
             "Unexpected value for `sparse_string_map`"
         );
-400
+    }
-401
     /// Deserializes null values in lists
     /// Test ID: RpcV2CborSparseListsDeserializeNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_sparse_lists_deserialize_null_response() {
         let expected_output = crate::operation::sparse_nulls_operation::SparseNullsOperationOutput::builder()
             .set_sparse_string_list(::std::option::Option::Some(vec![::std::option::Option::None]))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v3BzcGFyc2VTdHJpbmdMaXN0n/b//w=="))
                 .unwrap(),
-417
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-421
         let op = crate::operation::sparse_nulls_operation::SparseNullsOperation::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");
-427
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::sparse_nulls_operation::SparseNullsOperationOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.sparse_string_list,
             expected_output.sparse_string_list,
             "Unexpected value for `sparse_string_list`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.sparse_string_map,
             expected_output.sparse_string_map,
             "Unexpected value for `sparse_string_map`"
         );
-456
+    }
-457
+}
-458
 /// Error type for the `SparseNullsOperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum SparseNullsOperationError {
     /// 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()`:
-466
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-468
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-SparseNullsOperationError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/sparse_nulls_operation/_sparse_nulls_operation_input.rs

@@ -7,7 +77,77 @@

↥ Expand context

     pub sparse_string_list: ::std::option::Option<::std::vec::Vec<::std::option::Option<::std::string::String>>>,
     #[allow(missing_docs)] // documentation missing in model
     pub sparse_string_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>>,
-10
+}
 impl SparseNullsOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.sparse_string_list.is_none()`.
     pub fn sparse_string_list(&self) -> &[::std::option::Option<::std::string::String>] {
         self.sparse_string_list.as_deref().unwrap_or_default()
-17
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_string_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>> {
         self.sparse_string_map.as_ref()
-23
+    }
-24
+}
 static SPARSENULLSOPERATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#SparseNullsOperationInput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "SparseNullsOperationInput",
 );
 static SPARSENULLSOPERATIONINPUT_MEMBER_SPARSE_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SparseNullsOperationInput$sparseStringList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SparseNullsOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "sparse_string_list",
     "sparseStringList",
 ,
 );
 static SPARSENULLSOPERATIONINPUT_MEMBER_SPARSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SparseNullsOperationInput$sparseStringMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SparseNullsOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_string_map",
     "sparseStringMap",
 ,
 );
 static SPARSENULLSOPERATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPARSENULLSOPERATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPARSENULLSOPERATIONINPUT_MEMBER_SPARSE_STRING_LIST,
         &SPARSENULLSOPERATIONINPUT_MEMBER_SPARSE_STRING_MAP,
     ],
 );

↧ Expand context

 impl SparseNullsOperationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPARSENULLSOPERATIONINPUT_SCHEMA;
-61
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SparseNullsOperationInput {
     #[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.sparse_string_list {
             ser.write_list(
                 &SPARSENULLSOPERATIONINPUT_MEMBER_SPARSE_STRING_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         match item {
                             Some(item) => {
                                 ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-76
+                            }
                             None => {

@@ -80,80 +201,206 @@

↥ Expand context

-80
+                        }
-81
+                    }
                     Ok(())
                 },
             )?;
-85
+        }
         if let Some(ref val) = self.sparse_string_map {
             ser.write_map(
                 &SPARSENULLSOPERATIONINPUT_MEMBER_SPARSE_STRING_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {
                             Some(value) => {
                                 ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-95
+                            }
                             None => {
                                 ser.write_null(&::aws_smithy_schema::prelude::STRING)?;
-98
+                            }
-99
+                        }

-100
+                    }
                     Ok(())
                 },
             )?;
-104
+        }
         Ok(())
-106
+    }
-107
+}
 impl SparseNullsOperationInput {
     /// 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(&SPARSENULLSOPERATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPARSENULLSOPERATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.sparse_string_list = 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(if deser.is_null() {
                                 deser.read_string(member).ok();
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(if deser.is_null() {
                                 deser.read_null()?;
                                 None
                             } else {
                                 Some(deser.read_string(member)?)
                             });
                             Ok(list)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-138
+                }
                 Some(1) => {
                     builder.sparse_string_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_string(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-156
+                }
                 _ => {}
-158
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-164
+    }
-165
+}
 impl SparseNullsOperationInput {
     /// 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 SparseNullsOperationInput {
     /// Creates a new builder-style object to manufacture [`SparseNullsOperationInput`](crate::operation::sparse_nulls_operation::SparseNullsOperationInput).
     pub fn builder() -> crate::operation::sparse_nulls_operation::builders::SparseNullsOperationInputBuilder {
         crate::operation::sparse_nulls_operation::builders::SparseNullsOperationInputBuilder::default()
-181
+    }
-182
+}
-183
 /// A builder for [`SparseNullsOperationInput`](crate::operation::sparse_nulls_operation::SparseNullsOperationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SparseNullsOperationInputBuilder {
     pub(crate) sparse_string_list: ::std::option::Option<::std::vec::Vec<::std::option::Option<::std::string::String>>>,
     pub(crate) sparse_string_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>>,
-191
+}
 impl SparseNullsOperationInputBuilder {
     /// Appends an item to `sparse_string_list`.
     ///
     /// To override the contents of this collection use [`set_sparse_string_list`](Self::set_sparse_string_list).
     ///
     pub fn sparse_string_list(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         let mut v = self.sparse_string_list.unwrap_or_default();
         v.push(input);
         self.sparse_string_list = ::std::option::Option::Some(v);
         self
-202
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_sparse_string_list(mut self, input: ::std::option::Option<::std::vec::Vec<::std::option::Option<::std::string::String>>>) -> Self {
         self.sparse_string_list = input;
         self

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/sparse_nulls_operation/_sparse_nulls_operation_output.rs

@@ -7,7 +77,77 @@

↥ Expand context

     pub sparse_string_list: ::std::option::Option<::std::vec::Vec<::std::option::Option<::std::string::String>>>,
     #[allow(missing_docs)] // documentation missing in model
     pub sparse_string_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>>,
-10
+}
 impl SparseNullsOperationOutput {
     #[allow(missing_docs)] // documentation missing in model
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.sparse_string_list.is_none()`.
     pub fn sparse_string_list(&self) -> &[::std::option::Option<::std::string::String>] {
         self.sparse_string_list.as_deref().unwrap_or_default()
-17
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_string_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>> {
         self.sparse_string_map.as_ref()
-23
+    }
-24
+}
 static SPARSENULLSOPERATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#SparseNullsOperationOutput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "SparseNullsOperationOutput",
 );
 static SPARSENULLSOPERATIONOUTPUT_MEMBER_SPARSE_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SparseNullsOperationOutput$sparseStringList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SparseNullsOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "sparse_string_list",
     "sparseStringList",
 ,
 );
 static SPARSENULLSOPERATIONOUTPUT_MEMBER_SPARSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SparseNullsOperationOutput$sparseStringMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SparseNullsOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_string_map",
     "sparseStringMap",
 ,
 );
 static SPARSENULLSOPERATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPARSENULLSOPERATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPARSENULLSOPERATIONOUTPUT_MEMBER_SPARSE_STRING_LIST,
         &SPARSENULLSOPERATIONOUTPUT_MEMBER_SPARSE_STRING_MAP,
     ],
 );

↧ Expand context

 impl SparseNullsOperationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPARSENULLSOPERATIONOUTPUT_SCHEMA;
-61
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SparseNullsOperationOutput {
     #[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.sparse_string_list {
             ser.write_list(
                 &SPARSENULLSOPERATIONOUTPUT_MEMBER_SPARSE_STRING_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         match item {
                             Some(item) => {
                                 ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-76
+                            }
                             None => {

@@ -80,80 +199,204 @@

↥ Expand context

-80
+                        }
-81
+                    }
                     Ok(())
                 },
             )?;
-85
+        }
         if let Some(ref val) = self.sparse_string_map {
             ser.write_map(
                 &SPARSENULLSOPERATIONOUTPUT_MEMBER_SPARSE_STRING_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {
                             Some(value) => {
                                 ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-95
+                            }
                             None => {
                                 ser.write_null(&::aws_smithy_schema::prelude::STRING)?;
-98
+                            }
-99
+                        }

-100
+                    }
                     Ok(())
                 },
             )?;
-104
+        }
         Ok(())
-106
+    }
-107
+}
 impl SparseNullsOperationOutput {
     /// 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(&SPARSENULLSOPERATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPARSENULLSOPERATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.sparse_string_list = 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(if deser.is_null() {
                                 deser.read_string(member).ok();
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(if deser.is_null() {
                                 deser.read_null()?;
                                 None
                             } else {
                                 Some(deser.read_string(member)?)
                             });
                             Ok(list)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-138
+                }
                 Some(1) => {
                     builder.sparse_string_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(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_string(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-156
+                }
                 _ => {}
-158
+            }
             Ok(())
         })?;
         Ok(builder.build())
-162
+    }
-163
+}
 impl SparseNullsOperationOutput {
     /// 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 SparseNullsOperationOutput {
     /// Creates a new builder-style object to manufacture [`SparseNullsOperationOutput`](crate::operation::sparse_nulls_operation::SparseNullsOperationOutput).
     pub fn builder() -> crate::operation::sparse_nulls_operation::builders::SparseNullsOperationOutputBuilder {
         crate::operation::sparse_nulls_operation::builders::SparseNullsOperationOutputBuilder::default()
-179
+    }
-180
+}
-181
 /// A builder for [`SparseNullsOperationOutput`](crate::operation::sparse_nulls_operation::SparseNullsOperationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SparseNullsOperationOutputBuilder {
     pub(crate) sparse_string_list: ::std::option::Option<::std::vec::Vec<::std::option::Option<::std::string::String>>>,
     pub(crate) sparse_string_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>>,
-189
+}
 impl SparseNullsOperationOutputBuilder {
     /// Appends an item to `sparse_string_list`.
     ///
     /// To override the contents of this collection use [`set_sparse_string_list`](Self::set_sparse_string_list).
     ///
     pub fn sparse_string_list(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         let mut v = self.sparse_string_list.unwrap_or_default();
         v.push(input);
         self.sparse_string_list = ::std::option::Option::Some(v);
         self
-200
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_sparse_string_list(mut self, input: ::std::option::Option<::std::vec::Vec<::std::option::Option<::std::string::String>>>) -> Self {
         self.sparse_string_list = input;
         self

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/types/_client_optional_defaults.rs

@@ -23,23 +106,117 @@

↥ Expand context

         "smithy.protocoltests.rpcv2Cbor",
         "ClientOptionalDefaults",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "member",
 ,
 );
 static CLIENTOPTIONALDEFAULTS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CLIENTOPTIONALDEFAULTS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CLIENTOPTIONALDEFAULTS_MEMBER_MEMBER],
 );
 impl ClientOptionalDefaults {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CLIENTOPTIONALDEFAULTS_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ClientOptionalDefaults {
     #[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.member {
             ser.write_integer(&CLIENTOPTIONALDEFAULTS_MEMBER_MEMBER, *val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl ClientOptionalDefaults {
     /// 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(&CLIENTOPTIONALDEFAULTS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CLIENTOPTIONALDEFAULTS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.member = Some(deser.read_integer(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl ClientOptionalDefaults {
     /// 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 ClientOptionalDefaults {
     /// Creates a new builder-style object to manufacture [`ClientOptionalDefaults`](crate::types::ClientOptionalDefaults).
     pub fn builder() -> crate::types::builders::ClientOptionalDefaultsBuilder {
         crate::types::builders::ClientOptionalDefaultsBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`ClientOptionalDefaults`](crate::types::ClientOptionalDefaults).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ClientOptionalDefaultsBuilder {
     pub(crate) member: ::std::option::Option<i32>,
-100
+}
 impl ClientOptionalDefaultsBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn member(mut self, input: i32) -> Self {
         self.member = ::std::option::Option::Some(input);
         self
-106
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_member(mut self, input: ::std::option::Option<i32>) -> Self {
         self.member = input;
         self
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_member(&self) -> &::std::option::Option<i32> {
         &self.member
-115
+    }
     /// Consumes the builder and constructs a [`ClientOptionalDefaults`](crate::types::ClientOptionalDefaults).
     pub fn build(self) -> crate::types::ClientOptionalDefaults {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/types/_complex_nested_error_data.rs

@@ -1,1 +106,117 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ComplexNestedErrorData {
     #[allow(missing_docs)] // documentation missing in model
     pub foo: ::std::option::Option<::std::string::String>,
-8
+}
 impl ComplexNestedErrorData {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(&self) -> ::std::option::Option<&str> {
         self.foo.as_deref()
-13
+    }
-14
+}
 static COMPLEXNESTEDERRORDATA_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor#ComplexNestedErrorData",

     "smithy.protocoltests.rpcv2Cbor",
     "ComplexNestedErrorData",
 );
 static COMPLEXNESTEDERRORDATA_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#ComplexNestedErrorData$Foo",
         "smithy.protocoltests.rpcv2Cbor",
         "ComplexNestedErrorData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",
     "Foo",
 ,
 );
 static COMPLEXNESTEDERRORDATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COMPLEXNESTEDERRORDATA_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&COMPLEXNESTEDERRORDATA_MEMBER_FOO],
 );
 impl ComplexNestedErrorData {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COMPLEXNESTEDERRORDATA_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ComplexNestedErrorData {
     #[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.foo {
             ser.write_string(&COMPLEXNESTEDERRORDATA_MEMBER_FOO, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl ComplexNestedErrorData {
     /// 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(&COMPLEXNESTEDERRORDATA_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COMPLEXNESTEDERRORDATA_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl ComplexNestedErrorData {
     /// 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 ComplexNestedErrorData {
     /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
     pub fn builder() -> crate::types::builders::ComplexNestedErrorDataBuilder {
         crate::types::builders::ComplexNestedErrorDataBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ComplexNestedErrorDataBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
-100
+}
 impl ComplexNestedErrorDataBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-106
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-115
+    }
     /// Consumes the builder and constructs a [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
     pub fn build(self) -> crate::types::ComplexNestedErrorData {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/types/_defaults.rs

@@ -129,129 +409,409 @@

↥ Expand context

     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_short(&self) -> i16 {
         self.zero_short
-132
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_integer(&self) -> i32 {
         self.zero_integer
-136
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_long(&self) -> i64 {
         self.zero_long
-140
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_float(&self) -> f32 {
         self.zero_float
-144
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_double(&self) -> f64 {
         self.zero_double
-148
+    }

-149
+}
 static DEFAULTS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("smithy.protocoltests.rpcv2Cbor#Defaults", "smithy.protocoltests.rpcv2Cbor", "Defaults");
 static DEFAULTS_MEMBER_DEFAULT_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultString",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "default_string",
     "defaultString",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultBoolean",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "default_boolean",
     "defaultBoolean",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultList",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "default_list",
     "defaultList",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultTimestamp",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "default_timestamp",
     "defaultTimestamp",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultBlob",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "default_blob",
     "defaultBlob",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_BYTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultByte",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "default_byte",
     "defaultByte",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_SHORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultShort",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "default_short",
     "defaultShort",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultInteger",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "default_integer",
     "defaultInteger",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultLong",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "default_long",
     "defaultLong",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultFloat",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "default_float",
     "defaultFloat",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultDouble",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "default_double",
     "defaultDouble",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultMap",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "default_map",
     "defaultMap",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultEnum",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "default_enum",
     "defaultEnum",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_INT_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$defaultIntEnum",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "default_int_enum",
     "defaultIntEnum",
 ,
 );
 static DEFAULTS_MEMBER_EMPTY_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$emptyString",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "empty_string",
     "emptyString",
 ,
 );
 static DEFAULTS_MEMBER_FALSE_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$falseBoolean",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "false_boolean",
     "falseBoolean",
 ,
 );
 static DEFAULTS_MEMBER_EMPTY_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$emptyBlob",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "empty_blob",
     "emptyBlob",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_BYTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$zeroByte",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "zero_byte",
     "zeroByte",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_SHORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$zeroShort",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "zero_short",
     "zeroShort",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$zeroInteger",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "zero_integer",
     "zeroInteger",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$zeroLong",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "zero_long",
     "zeroLong",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$zeroFloat",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "zero_float",
     "zeroFloat",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#Defaults$zeroDouble",
         "smithy.protocoltests.rpcv2Cbor",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "zero_double",
     "zeroDouble",
 ,
 );
 static DEFAULTS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DEFAULTS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DEFAULTS_MEMBER_DEFAULT_STRING,
         &DEFAULTS_MEMBER_DEFAULT_BOOLEAN,
         &DEFAULTS_MEMBER_DEFAULT_LIST,
         &DEFAULTS_MEMBER_DEFAULT_TIMESTAMP,

↧ Expand context

         &DEFAULTS_MEMBER_DEFAULT_BLOB,
         &DEFAULTS_MEMBER_DEFAULT_BYTE,
         &DEFAULTS_MEMBER_DEFAULT_SHORT,
         &DEFAULTS_MEMBER_DEFAULT_INTEGER,
         &DEFAULTS_MEMBER_DEFAULT_LONG,
         &DEFAULTS_MEMBER_DEFAULT_FLOAT,
         &DEFAULTS_MEMBER_DEFAULT_DOUBLE,
         &DEFAULTS_MEMBER_DEFAULT_MAP,
         &DEFAULTS_MEMBER_DEFAULT_ENUM,
         &DEFAULTS_MEMBER_DEFAULT_INT_ENUM,
         &DEFAULTS_MEMBER_EMPTY_STRING,
         &DEFAULTS_MEMBER_FALSE_BOOLEAN,
         &DEFAULTS_MEMBER_EMPTY_BLOB,
         &DEFAULTS_MEMBER_ZERO_BYTE,
         &DEFAULTS_MEMBER_ZERO_SHORT,
         &DEFAULTS_MEMBER_ZERO_INTEGER,
         &DEFAULTS_MEMBER_ZERO_LONG,
         &DEFAULTS_MEMBER_ZERO_FLOAT,
         &DEFAULTS_MEMBER_ZERO_DOUBLE,
     ],

@@ -507,507 +676,667 @@

↥ Expand context

-507
+        }
-508
+        {
             let val = &self.zero_byte;
             ser.write_byte(&DEFAULTS_MEMBER_ZERO_BYTE, *val)?;
-511
+        }
-512
+        {
             let val = &self.zero_short;
             ser.write_short(&DEFAULTS_MEMBER_ZERO_SHORT, *val)?;
-515
+        }
-516
+        {
             let val = &self.zero_integer;
             ser.write_integer(&DEFAULTS_MEMBER_ZERO_INTEGER, *val)?;
-519
+        }
-520
+        {
             let val = &self.zero_long;
             ser.write_long(&DEFAULTS_MEMBER_ZERO_LONG, *val)?;
-523
+        }
-524
+        {
             let val = &self.zero_float;
             ser.write_float(&DEFAULTS_MEMBER_ZERO_FLOAT, *val)?;

-527
+        }
-528
+        {
             let val = &self.zero_double;
             ser.write_double(&DEFAULTS_MEMBER_ZERO_DOUBLE, *val)?;
-531
+        }
         Ok(())
-533
+    }
-534
+}
 impl Defaults {
     /// 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(&DEFAULTS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DEFAULTS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.default_string = Some(deser.read_string(member)?);
-553
+                }
                 Some(1) => {
                     builder.default_boolean = Some(deser.read_boolean(member)?);
-556
+                }
                 Some(2) => {
                     builder.default_list = 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_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.default_list = Some(deser.read_string_list(member)?);
-559
+                }
                 Some(3) => {
                     builder.default_timestamp = Some(deser.read_timestamp(member)?);
-562
+                }
                 Some(4) => {
                     builder.default_blob = Some(deser.read_blob(member)?);
-565
+                }
                 Some(5) => {
                     builder.default_byte = Some(deser.read_byte(member)?);
-568
+                }
                 Some(6) => {
                     builder.default_short = Some(deser.read_short(member)?);
-571
+                }
                 Some(7) => {
                     builder.default_integer = Some(deser.read_integer(member)?);
-574
+                }
                 Some(8) => {
                     builder.default_long = Some(deser.read_long(member)?);
-577
+                }
                 Some(9) => {
                     builder.default_float = Some(deser.read_float(member)?);
-580
+                }
                 Some(10) => {
                     builder.default_double = Some(deser.read_double(member)?);
-583
+                }
                 Some(11) => {
                     builder.default_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_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.default_map = Some(deser.read_string_string_map(member)?);
-586
+                }
                 Some(12) => {
                     builder.default_enum = Some(crate::types::TestEnum::from(deser.read_string(member)?.as_str()));
-589
+                }
                 Some(13) => {
                     builder.default_int_enum = Some(deser.read_integer(member)?);
-592
+                }
                 Some(14) => {
                     builder.empty_string = Some(deser.read_string(member)?);
-595
+                }
                 Some(15) => {
                     builder.false_boolean = Some(deser.read_boolean(member)?);
-598
+                }
                 Some(16) => {
                     builder.empty_blob = Some(deser.read_blob(member)?);
-601
+                }
                 Some(17) => {
                     builder.zero_byte = Some(deser.read_byte(member)?);
-604
+                }
                 Some(18) => {
                     builder.zero_short = Some(deser.read_short(member)?);
-607
+                }
                 Some(19) => {
                     builder.zero_integer = Some(deser.read_integer(member)?);
-610
+                }
                 Some(20) => {
                     builder.zero_long = Some(deser.read_long(member)?);
-613
+                }
                 Some(21) => {
                     builder.zero_float = Some(deser.read_float(member)?);
-616
+                }
                 Some(22) => {
                     builder.zero_double = Some(deser.read_double(member)?);
-619
+                }
                 _ => {}
-621
+            }
             Ok(())
         })?;
         Ok(builder.build())
-625
+    }
-626
+}
 impl Defaults {
     /// 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 Defaults {
     /// Creates a new builder-style object to manufacture [`Defaults`](crate::types::Defaults).
     pub fn builder() -> crate::types::builders::DefaultsBuilder {
         crate::types::builders::DefaultsBuilder::default()
-642
+    }
-643
+}
-644
 /// A builder for [`Defaults`](crate::types::Defaults).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DefaultsBuilder {
     pub(crate) default_string: ::std::option::Option<::std::string::String>,
     pub(crate) default_boolean: ::std::option::Option<bool>,
     pub(crate) default_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) default_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) default_blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) default_byte: ::std::option::Option<i8>,
     pub(crate) default_short: ::std::option::Option<i16>,
     pub(crate) default_integer: ::std::option::Option<i32>,
     pub(crate) default_long: ::std::option::Option<i64>,
     pub(crate) default_float: ::std::option::Option<f32>,
     pub(crate) default_double: ::std::option::Option<f64>,
     pub(crate) default_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) default_enum: ::std::option::Option<crate::types::TestEnum>,
     pub(crate) default_int_enum: ::std::option::Option<i32>,
     pub(crate) empty_string: ::std::option::Option<::std::string::String>,
     pub(crate) false_boolean: ::std::option::Option<bool>,
     pub(crate) empty_blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) zero_byte: ::std::option::Option<i8>,
     pub(crate) zero_short: ::std::option::Option<i16>,

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/types/_greeting_struct.rs

@@ -23,23 +106,117 @@

↥ Expand context

         "smithy.protocoltests.shared",
         "GreetingStruct",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "hi",
 ,
 );
 static GREETINGSTRUCT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GREETINGSTRUCT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GREETINGSTRUCT_MEMBER_HI],
 );
 impl GreetingStruct {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GREETINGSTRUCT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GreetingStruct {
     #[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.hi {
             ser.write_string(&GREETINGSTRUCT_MEMBER_HI, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl GreetingStruct {
     /// 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(&GREETINGSTRUCT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GREETINGSTRUCT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.hi = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl GreetingStruct {
     /// 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 GreetingStruct {
     /// Creates a new builder-style object to manufacture [`GreetingStruct`](crate::types::GreetingStruct).
     pub fn builder() -> crate::types::builders::GreetingStructBuilder {
         crate::types::builders::GreetingStructBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`GreetingStruct`](crate::types::GreetingStruct).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GreetingStructBuilder {
     pub(crate) hi: ::std::option::Option<::std::string::String>,
-100
+}
 impl GreetingStructBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn hi(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.hi = ::std::option::Option::Some(input.into());
         self
-106
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_hi(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.hi = input;
         self
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_hi(&self) -> &::std::option::Option<::std::string::String> {
         &self.hi
-115
+    }
     /// Consumes the builder and constructs a [`GreetingStruct`](crate::types::GreetingStruct).
     pub fn build(self) -> crate::types::GreetingStruct {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/types/_recursive_shapes_input_output_nested1.rs

@@ -45,45 +131,142 @@

↥ Expand context

 );
 static RECURSIVESHAPESINPUTOUTPUTNESTED1_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RECURSIVESHAPESINPUTOUTPUTNESTED1_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RECURSIVESHAPESINPUTOUTPUTNESTED1_MEMBER_FOO,
         &RECURSIVESHAPESINPUTOUTPUTNESTED1_MEMBER_NESTED,
     ],
 );
 impl RecursiveShapesInputOutputNested1 {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECURSIVESHAPESINPUTOUTPUTNESTED1_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RecursiveShapesInputOutputNested1 {
     #[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.foo {

             ser.write_string(&RECURSIVESHAPESINPUTOUTPUTNESTED1_MEMBER_FOO, val)?;
-66
+        }
         if let Some(ref val) = self.nested {
             ser.write_struct(&RECURSIVESHAPESINPUTOUTPUTNESTED1_MEMBER_NESTED, val)?;
-69
+        }
         Ok(())
-71
+    }
-72
+}
 impl RecursiveShapesInputOutputNested1 {
     /// 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(&RECURSIVESHAPESINPUTOUTPUTNESTED1_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RECURSIVESHAPESINPUTOUTPUTNESTED1_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-91
+                }
                 Some(1) => {
                     builder.nested = Some(Box::new(crate::types::RecursiveShapesInputOutputNested2::deserialize(deser)?));
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         Ok(builder.build())
-100
+    }
-101
+}
 impl RecursiveShapesInputOutputNested1 {
     /// 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 RecursiveShapesInputOutputNested1 {
     /// Creates a new builder-style object to manufacture [`RecursiveShapesInputOutputNested1`](crate::types::RecursiveShapesInputOutputNested1).
     pub fn builder() -> crate::types::builders::RecursiveShapesInputOutputNested1Builder {
         crate::types::builders::RecursiveShapesInputOutputNested1Builder::default()
-117
+    }
-118
+}
-119
 /// A builder for [`RecursiveShapesInputOutputNested1`](crate::types::RecursiveShapesInputOutputNested1).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RecursiveShapesInputOutputNested1Builder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) nested: ::std::option::Option<::std::boxed::Box<crate::types::RecursiveShapesInputOutputNested2>>,
-126
+}
 impl RecursiveShapesInputOutputNested1Builder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-132
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-137
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-141
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/types/_recursive_shapes_input_output_nested2.rs

@@ -13,13 +131,142 @@

↥ Expand context

     pub fn bar(&self) -> ::std::option::Option<&str> {
         self.bar.as_deref()
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn recursive_member(&self) -> ::std::option::Option<&crate::types::RecursiveShapesInputOutputNested1> {
         self.recursive_member.as_ref()
-19
+    }
-20
+}
 static RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor#RecursiveShapesInputOutputNested2",
     "smithy.protocoltests.rpcv2Cbor",
     "RecursiveShapesInputOutputNested2",
 );
 static RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_BAR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#RecursiveShapesInputOutputNested2$bar",
         "smithy.protocoltests.rpcv2Cbor",
         "RecursiveShapesInputOutputNested2",
     ),
     ::aws_smithy_schema::ShapeType::String,

     "bar",
 ,
 );
 static RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_RECURSIVE_MEMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor#RecursiveShapesInputOutputNested2$recursiveMember",
         "smithy.protocoltests.rpcv2Cbor",
         "RecursiveShapesInputOutputNested2",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "recursive_member",
     "recursiveMember",
 ,
 );
 static RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_BAR,
         &RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_RECURSIVE_MEMBER,
     ],
 );
 impl RecursiveShapesInputOutputNested2 {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RecursiveShapesInputOutputNested2 {
     #[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.bar {
             ser.write_string(&RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_BAR, val)?;
-66
+        }
         if let Some(ref val) = self.recursive_member {
             ser.write_struct(&RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_RECURSIVE_MEMBER, val)?;
-69
+        }
         Ok(())
-71
+    }
-72
+}
 impl RecursiveShapesInputOutputNested2 {
     /// 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(&RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bar = Some(deser.read_string(member)?);
-91
+                }
                 Some(1) => {
                     builder.recursive_member = Some(crate::types::RecursiveShapesInputOutputNested1::deserialize(deser)?);
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         Ok(builder.build())
-100
+    }
-101
+}
 impl RecursiveShapesInputOutputNested2 {
     /// 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 RecursiveShapesInputOutputNested2 {
     /// Creates a new builder-style object to manufacture [`RecursiveShapesInputOutputNested2`](crate::types::RecursiveShapesInputOutputNested2).
     pub fn builder() -> crate::types::builders::RecursiveShapesInputOutputNested2Builder {
         crate::types::builders::RecursiveShapesInputOutputNested2Builder::default()
-117
+    }
-118
+}
-119
 /// A builder for [`RecursiveShapesInputOutputNested2`](crate::types::RecursiveShapesInputOutputNested2).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RecursiveShapesInputOutputNested2Builder {
     pub(crate) bar: ::std::option::Option<::std::string::String>,
     pub(crate) recursive_member: ::std::option::Option<crate::types::RecursiveShapesInputOutputNested1>,
-126
+}
 impl RecursiveShapesInputOutputNested2Builder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn bar(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.bar = ::std::option::Option::Some(input.into());
         self
-132
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_bar(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.bar = input;
         self
-137
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_bar(&self) -> &::std::option::Option<::std::string::String> {
         &self.bar
-141
+    }
     #[allow(missing_docs)] // documentation missing in model

Client Test

Files changed: