Client Test

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

@@ -63,63 +221,222 @@

     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.int_enum_list.is_none()`.
     pub fn int_enum_list(&self) -> &[i32] {
         self.int_enum_list.as_deref().unwrap_or_default()
-67
+    }
     /// A list of lists of strings.
     ///
     /// 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()
-73
+    }
     #[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()
-79
+    }
-80
+}
 static JSONLISTSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#JsonListsInput",

     "aws.protocoltests.restjson.synthetic",
     "JsonListsInput",
 );
 static JSONLISTSINPUT_MEMBER_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$stringList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_list",
     "stringList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$stringSet",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_set",
     "stringSet",
 ,
 );
 static JSONLISTSINPUT_MEMBER_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$integerList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "integer_list",
     "integerList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$booleanList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "boolean_list",
     "booleanList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$timestampList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "timestamp_list",
     "timestampList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$enumList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "enum_list",
     "enumList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_INT_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$intEnumList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "int_enum_list",
     "intEnumList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_NESTED_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$nestedStringList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "nested_string_list",
     "nestedStringList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$structureList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "structure_list",
     "structureList",
 ,
-175
+)
 .with_json_name("myStructureList");
 static JSONLISTSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     JSONLISTSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &JSONLISTSINPUT_MEMBER_STRING_LIST,
         &JSONLISTSINPUT_MEMBER_STRING_SET,
         &JSONLISTSINPUT_MEMBER_INTEGER_LIST,
         &JSONLISTSINPUT_MEMBER_BOOLEAN_LIST,
         &JSONLISTSINPUT_MEMBER_TIMESTAMP_LIST,
         &JSONLISTSINPUT_MEMBER_ENUM_LIST,
         &JSONLISTSINPUT_MEMBER_INT_ENUM_LIST,
         &JSONLISTSINPUT_MEMBER_NESTED_STRING_LIST,
         &JSONLISTSINPUT_MEMBER_STRUCTURE_LIST,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/JsonLists", None));
 impl JsonListsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONLISTSINPUT_SCHEMA;
-196
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonListsInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {

↧ Expand context

         if let Some(ref val) = self.string_list {
             ser.write_list(
                 &JSONLISTSINPUT_MEMBER_STRING_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-209
+                    }
                     Ok(())
                 },
             )?;
-213
+        }
         if let Some(ref val) = self.string_set {
             ser.write_list(
                 &JSONLISTSINPUT_MEMBER_STRING_SET,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-220
+                    }
                     Ok(())
                 },

@@ -254,255 +475,447 @@

↥ Expand context

                 },
             )?;
-257
+        }
         if let Some(ref val) = self.enum_list {
             ser.write_list(
                 &JSONLISTSINPUT_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())?;
-264
+                    }
                     Ok(())
                 },
             )?;
-268
+        }
         if let Some(ref val) = self.int_enum_list {
             ser.write_list(
                 &JSONLISTSINPUT_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)?;

-275
+                    }
                     Ok(())
                 },
             )?;
-279
+        }
         if let Some(ref val) = self.nested_string_list {
             ser.write_list(
                 &JSONLISTSINPUT_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(())
                             },
                         )?;
-294
+                    }
                     Ok(())
                 },
             )?;
-298
+        }
         if let Some(ref val) = self.structure_list {
             ser.write_list(
                 &JSONLISTSINPUT_MEMBER_STRUCTURE_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::StructureListMember::SCHEMA, item)?;
-305
+                    }
                     Ok(())
                 },
             )?;
-309
+        }
         Ok(())
-311
+    }
-312
+}
 impl JsonListsInput {
     /// 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(&JSONLISTSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&JSONLISTSINPUT_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)?);
-331
+                }
                 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)?);
-334
+                }
                 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)?);
-337
+                }
                 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
                     });
-347
+                }
                 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
                     });
-357
+                }
                 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
                     });
-367
+                }
                 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)?);
-370
+                }
                 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
                     });
-387
+                }
                 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
                     });
-397
+                }
                 _ => {}
-399
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-405
+    }
-406
+}
 impl JsonListsInput {
     /// 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 JsonListsInput {
     /// Creates a new builder-style object to manufacture [`JsonListsInput`](crate::operation::json_lists::JsonListsInput).
     pub fn builder() -> crate::operation::json_lists::builders::JsonListsInputBuilder {
         crate::operation::json_lists::builders::JsonListsInputBuilder::default()
-422
+    }
-423
+}
-424
 /// A builder for [`JsonListsInput`](crate::operation::json_lists::JsonListsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonListsInputBuilder {
     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>>,
-438
+}
 impl JsonListsInputBuilder {
     /// 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());
         self.string_list = ::std::option::Option::Some(v);

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

@@ -63,63 +203,203 @@

↥ Expand context

     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.int_enum_list.is_none()`.
     pub fn int_enum_list(&self) -> &[i32] {
         self.int_enum_list.as_deref().unwrap_or_default()
-67
+    }
     /// A list of lists of strings.
     ///
     /// 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()
-73
+    }
     #[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()
-79
+    }
-80
+}
 static JSONLISTSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#JsonListsOutput",

     "aws.protocoltests.restjson.synthetic",
     "JsonListsOutput",
 );
 static JSONLISTSOUTPUT_MEMBER_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$stringList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_list",
     "stringList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$stringSet",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_set",
     "stringSet",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$integerList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "integer_list",
     "integerList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$booleanList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "boolean_list",
     "booleanList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$timestampList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "timestamp_list",
     "timestampList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$enumList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "enum_list",
     "enumList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_INT_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$intEnumList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "int_enum_list",
     "intEnumList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_NESTED_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$nestedStringList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "nested_string_list",
     "nestedStringList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$structureList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "structure_list",
     "structureList",
 ,
-175
+)
 .with_json_name("myStructureList");
 static JSONLISTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     JSONLISTSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &JSONLISTSOUTPUT_MEMBER_STRING_LIST,
         &JSONLISTSOUTPUT_MEMBER_STRING_SET,
         &JSONLISTSOUTPUT_MEMBER_INTEGER_LIST,

↧ Expand context

         &JSONLISTSOUTPUT_MEMBER_BOOLEAN_LIST,
         &JSONLISTSOUTPUT_MEMBER_TIMESTAMP_LIST,
         &JSONLISTSOUTPUT_MEMBER_ENUM_LIST,
         &JSONLISTSOUTPUT_MEMBER_INT_ENUM_LIST,
         &JSONLISTSOUTPUT_MEMBER_NESTED_STRING_LIST,
         &JSONLISTSOUTPUT_MEMBER_STRUCTURE_LIST,
     ],
 );
 impl JsonListsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONLISTSOUTPUT_SCHEMA;
-195
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonListsOutput {
     #[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(

@@ -254,254 +473,444 @@

↥ Expand context

                 },
             )?;
-256
+        }
         if let Some(ref val) = self.enum_list {
             ser.write_list(
                 &JSONLISTSOUTPUT_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())?;
-263
+                    }
                     Ok(())
                 },
             )?;
-267
+        }
         if let Some(ref val) = self.int_enum_list {
             ser.write_list(
                 &JSONLISTSOUTPUT_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)?;

-274
+                    }
                     Ok(())
                 },
             )?;
-278
+        }
         if let Some(ref val) = self.nested_string_list {
             ser.write_list(
                 &JSONLISTSOUTPUT_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(())
                             },
                         )?;
-293
+                    }
                     Ok(())
                 },
             )?;
-297
+        }
         if let Some(ref val) = self.structure_list {
             ser.write_list(
                 &JSONLISTSOUTPUT_MEMBER_STRUCTURE_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::StructureListMember::SCHEMA, item)?;
-304
+                    }
                     Ok(())
                 },
             )?;
-308
+        }
         Ok(())
-310
+    }
-311
+}
 impl JsonListsOutput {
     /// 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(&JSONLISTSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&JSONLISTSOUTPUT_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)?);
-330
+                }
                 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)?);
-333
+                }
                 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)?);
-336
+                }
                 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
                     });
-346
+                }
                 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
                     });
-356
+                }
                 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
                     });
-366
+                }
                 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)?);
-369
+                }
                 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
                     });
-386
+                }
                 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
                     });
-396
+                }
                 _ => {}
-398
+            }
             Ok(())
         })?;
         Ok(builder.build())
-402
+    }
-403
+}
 impl JsonListsOutput {
     /// 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 JsonListsOutput {
     /// Creates a new builder-style object to manufacture [`JsonListsOutput`](crate::operation::json_lists::JsonListsOutput).
     pub fn builder() -> crate::operation::json_lists::builders::JsonListsOutputBuilder {
         crate::operation::json_lists::builders::JsonListsOutputBuilder::default()
-419
+    }
-420
+}
-421
 /// A builder for [`JsonListsOutput`](crate::operation::json_lists::JsonListsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonListsOutputBuilder {
     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>>,
-435
+}
 impl JsonListsOutputBuilder {
     /// 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());
         self.string_list = ::std::option::Option::Some(v);

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/json_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 `JsonMaps`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct JsonMaps;
 impl JsonMaps {
     /// Creates a new `JsonMaps`
     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::json_maps::JsonMapsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::json_maps::JsonMapsOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::json_maps::JsonMapsInput,
     ) -> ::std::result::Result<
         crate::operation::json_maps::JsonMapsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::json_maps::JsonMapsError,
             ::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::json_maps::JsonMapsError>().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::json_maps::JsonMapsOutput>()
                 .expect("correct output type"),
-38
+        )
-39
+    }
-40
     pub(crate) async fn orchestrate_with_stop_point(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::json_maps::JsonMapsInput,
         stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,

@@ -103,107 +220,223 @@

↥ Expand context

         ));
-108
         ::std::option::Option::Some(cfg.freeze())
-110
+    }
-111
     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("JsonMaps")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(JsonMapsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::json_maps::JsonMapsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::json_maps::JsonMapsError,
             >::new());
-126

         ::std::borrow::Cow::Owned(rcb)
-128
+    }
-129
+}
-130
 #[derive(Debug)]
 struct JsonMapsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for JsonMapsResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-142
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_json_maps::de_json_maps_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(crate::operation::json_maps::JsonMapsError::generic(generic)),
             ))
         } else {
             crate::protocol_serde::shape_json_maps::de_json_maps_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, JsonMaps::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::json_maps::JsonMapsOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-174
+    }
-175
+}
 #[derive(Debug)]
 struct JsonMapsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for JsonMapsRequestSerializer {
     #[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::json_maps::JsonMapsInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::json_maps::JsonMapsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/JsonMaps").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::json_maps::JsonMapsInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_json_maps::ser_json_maps_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, JsonMaps::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-194
+    }
-195
+}
 #[derive(Debug)]
 struct JsonMapsEndpointParamsInterceptor;
-198
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonMapsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonMapsEndpointParamsInterceptor"
-202
+    }
-203

↧ Expand context

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

@@ -377,380 +437,450 @@

↥ Expand context

                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("bye".to_owned()))
                         .build(),
                 );
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "application/json")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"denseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-395
         let op = crate::operation::json_maps::JsonMaps::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");
-401
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_maps::JsonMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );

@@ -454,467 +514,537 @@

↥ Expand context

                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"denseNumberMap\": {\n        \"x\": 0\n    },\n    \"denseBooleanMap\": {\n        \"x\": false\n    }\n}",
                 ))
                 .unwrap(),
-478
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-482
         let op = crate::operation::json_maps::JsonMaps::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");
-488
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_maps::JsonMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );

@@ -527,550 +587,620 @@

↥ Expand context

                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}",
                 ))
                 .unwrap(),
-561
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-565
         let op = crate::operation::json_maps::JsonMaps::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");
-571
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_maps::JsonMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );

@@ -602,635 +662,705 @@

↥ Expand context

                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"],\n        \"z\": null\n    }\n}",
                 ))
                 .unwrap(),
-646
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-650
         let op = crate::operation::json_maps::JsonMaps::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");
-656
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_maps::JsonMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );

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

@@ -23,23 +136,137 @@

↥ Expand context

     pub fn dense_number_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, i32>> {
         self.dense_number_map.as_ref()
-25
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_boolean_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, bool>> {
         self.dense_boolean_map.as_ref()
-29
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_string_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.dense_string_map.as_ref()
-33
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_set_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         self.dense_set_map.as_ref()
-39
+    }
-40
+}
 static JSONMAPSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#JsonMapsInput",

     "aws.protocoltests.restjson.synthetic",
     "JsonMapsInput",
 );
 static JSONMAPSINPUT_MEMBER_DENSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsInput$denseStructMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_struct_map",
     "denseStructMap",
 ,
 );
 static JSONMAPSINPUT_MEMBER_DENSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsInput$denseNumberMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_number_map",
     "denseNumberMap",
 ,
 );
 static JSONMAPSINPUT_MEMBER_DENSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsInput$denseBooleanMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_boolean_map",
     "denseBooleanMap",
 ,
 );
 static JSONMAPSINPUT_MEMBER_DENSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsInput$denseStringMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_string_map",
     "denseStringMap",
 ,
 );
 static JSONMAPSINPUT_MEMBER_DENSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsInput$denseSetMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_set_map",
     "denseSetMap",
 ,
 );
 static JSONMAPSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     JSONMAPSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &JSONMAPSINPUT_MEMBER_DENSE_STRUCT_MAP,
         &JSONMAPSINPUT_MEMBER_DENSE_NUMBER_MAP,
         &JSONMAPSINPUT_MEMBER_DENSE_BOOLEAN_MAP,
         &JSONMAPSINPUT_MEMBER_DENSE_STRING_MAP,
         &JSONMAPSINPUT_MEMBER_DENSE_SET_MAP,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/JsonMaps", None));
 impl JsonMapsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONMAPSINPUT_SCHEMA;
-111
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonMapsInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {

↧ Expand context

         if let Some(ref val) = self.dense_struct_map {
             ser.write_map(
                 &JSONMAPSINPUT_MEMBER_DENSE_STRUCT_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::GreetingStruct::SCHEMA, value)?;
-125
+                    }
                     Ok(())
                 },
             )?;
-129
+        }
         if let Some(ref val) = self.dense_number_map {
             ser.write_map(
                 &JSONMAPSINPUT_MEMBER_DENSE_NUMBER_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_integer(&::aws_smithy_schema::prelude::INTEGER, *value)?;
-137
+                    }

@@ -141,142 +299,305 @@

↥ Expand context

         if let Some(ref val) = self.dense_boolean_map {
             ser.write_map(
                 &JSONMAPSINPUT_MEMBER_DENSE_BOOLEAN_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_boolean(&::aws_smithy_schema::prelude::BOOLEAN, *value)?;
-149
+                    }
                     Ok(())
                 },
             )?;
-153
+        }
         if let Some(ref val) = self.dense_string_map {
             ser.write_map(
                 &JSONMAPSINPUT_MEMBER_DENSE_STRING_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-161
+                    }

                     Ok(())
                 },
             )?;
-165
+        }
         if let Some(ref val) = self.dense_set_map {
             ser.write_map(
                 &JSONMAPSINPUT_MEMBER_DENSE_SET_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         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(())
                             },
                         )?;
-182
+                    }
                     Ok(())
                 },
             )?;
-186
+        }
         Ok(())
-188
+    }
-189
+}
 impl JsonMapsInput {
     /// 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(&JSONMAPSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&JSONMAPSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dense_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(key, crate::types::GreetingStruct::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-215
+                }
                 Some(1) => {
                     builder.dense_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(key, deser.read_integer(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_integer(member)?);
                             Ok(())
                         })?;
                         container
                     });
-225
+                }
                 Some(2) => {
                     builder.dense_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(key, deser.read_boolean(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_boolean(member)?);
                             Ok(())
                         })?;
                         container
                     });
-235
+                }
                 Some(3) => {
                     builder.dense_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(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.dense_string_map = Some(deser.read_string_string_map(member)?);
-238
+                }
                 Some(4) => {
                     builder.dense_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(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 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
                     });
-255
+                }
                 _ => {}
-257
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-263
+    }
-264
+}
 impl JsonMapsInput {
     /// 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 JsonMapsInput {
     /// Creates a new builder-style object to manufacture [`JsonMapsInput`](crate::operation::json_maps::JsonMapsInput).
     pub fn builder() -> crate::operation::json_maps::builders::JsonMapsInputBuilder {
         crate::operation::json_maps::builders::JsonMapsInputBuilder::default()
-280
+    }
-281
+}
-282
 /// A builder for [`JsonMapsInput`](crate::operation::json_maps::JsonMapsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonMapsInputBuilder {
     pub(crate) dense_struct_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::GreetingStruct>>,
     pub(crate) dense_number_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
     pub(crate) dense_boolean_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, bool>>,
     pub(crate) dense_string_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) dense_set_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
-292
+}
 impl JsonMapsInputBuilder {
     /// Adds a key-value pair to `dense_struct_map`.
     ///
     /// To override the contents of this collection use [`set_dense_struct_map`](Self::set_dense_struct_map).
     ///
     pub fn dense_struct_map(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::GreetingStruct) -> Self {
         let mut hash_map = self.dense_struct_map.unwrap_or_default();
         hash_map.insert(k.into(), v);
         self.dense_struct_map = ::std::option::Option::Some(hash_map);
         self
-303
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_dense_struct_map(

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

@@ -23,23 +123,123 @@

↥ Expand context

     pub fn dense_number_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, i32>> {
         self.dense_number_map.as_ref()
-25
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_boolean_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, bool>> {
         self.dense_boolean_map.as_ref()
-29
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_string_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.dense_string_map.as_ref()
-33
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_set_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         self.dense_set_map.as_ref()
-39
+    }
-40
+}
 static JSONMAPSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#JsonMapsOutput",

     "aws.protocoltests.restjson.synthetic",
     "JsonMapsOutput",
 );
 static JSONMAPSOUTPUT_MEMBER_DENSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsOutput$denseStructMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_struct_map",
     "denseStructMap",
 ,
 );
 static JSONMAPSOUTPUT_MEMBER_DENSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsOutput$denseNumberMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_number_map",
     "denseNumberMap",
 ,
 );
 static JSONMAPSOUTPUT_MEMBER_DENSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsOutput$denseBooleanMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_boolean_map",
     "denseBooleanMap",
 ,
 );
 static JSONMAPSOUTPUT_MEMBER_DENSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsOutput$denseStringMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_string_map",
     "denseStringMap",
 ,
 );
 static JSONMAPSOUTPUT_MEMBER_DENSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsOutput$denseSetMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_set_map",
     "denseSetMap",
 ,
 );
 static JSONMAPSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     JSONMAPSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &JSONMAPSOUTPUT_MEMBER_DENSE_STRUCT_MAP,
         &JSONMAPSOUTPUT_MEMBER_DENSE_NUMBER_MAP,
         &JSONMAPSOUTPUT_MEMBER_DENSE_BOOLEAN_MAP,
         &JSONMAPSOUTPUT_MEMBER_DENSE_STRING_MAP,

↧ Expand context

         &JSONMAPSOUTPUT_MEMBER_DENSE_SET_MAP,
     ],
 );
 impl JsonMapsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONMAPSOUTPUT_SCHEMA;
-110
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonMapsOutput {
     #[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.dense_struct_map {
             ser.write_map(
                 &JSONMAPSOUTPUT_MEMBER_DENSE_STRUCT_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::GreetingStruct::SCHEMA, value)?;

@@ -141,141 +297,302 @@

↥ Expand context

         if let Some(ref val) = self.dense_boolean_map {
             ser.write_map(
                 &JSONMAPSOUTPUT_MEMBER_DENSE_BOOLEAN_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_boolean(&::aws_smithy_schema::prelude::BOOLEAN, *value)?;
-148
+                    }
                     Ok(())
                 },
             )?;
-152
+        }
         if let Some(ref val) = self.dense_string_map {
             ser.write_map(
                 &JSONMAPSOUTPUT_MEMBER_DENSE_STRING_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-160
+                    }

                     Ok(())
                 },
             )?;
-164
+        }
         if let Some(ref val) = self.dense_set_map {
             ser.write_map(
                 &JSONMAPSOUTPUT_MEMBER_DENSE_SET_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         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(())
                             },
                         )?;
-181
+                    }
                     Ok(())
                 },
             )?;
-185
+        }
         Ok(())
-187
+    }
-188
+}
 impl JsonMapsOutput {
     /// 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(&JSONMAPSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&JSONMAPSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dense_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(key, crate::types::GreetingStruct::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-214
+                }
                 Some(1) => {
                     builder.dense_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(key, deser.read_integer(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_integer(member)?);
                             Ok(())
                         })?;
                         container
                     });
-224
+                }
                 Some(2) => {
                     builder.dense_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(key, deser.read_boolean(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_boolean(member)?);
                             Ok(())
                         })?;
                         container
                     });
-234
+                }
                 Some(3) => {
                     builder.dense_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(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.dense_string_map = Some(deser.read_string_string_map(member)?);
-237
+                }
                 Some(4) => {
                     builder.dense_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(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 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
                     });
-254
+                }
                 _ => {}
-256
+            }
             Ok(())
         })?;
         Ok(builder.build())
-260
+    }
-261
+}
 impl JsonMapsOutput {
     /// 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 JsonMapsOutput {
     /// Creates a new builder-style object to manufacture [`JsonMapsOutput`](crate::operation::json_maps::JsonMapsOutput).
     pub fn builder() -> crate::operation::json_maps::builders::JsonMapsOutputBuilder {
         crate::operation::json_maps::builders::JsonMapsOutputBuilder::default()
-277
+    }
-278
+}
-279
 /// A builder for [`JsonMapsOutput`](crate::operation::json_maps::JsonMapsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonMapsOutputBuilder {
     pub(crate) dense_struct_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::GreetingStruct>>,
     pub(crate) dense_number_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
     pub(crate) dense_boolean_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, bool>>,
     pub(crate) dense_string_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) dense_set_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
-289
+}
 impl JsonMapsOutputBuilder {
     /// Adds a key-value pair to `dense_struct_map`.
     ///
     /// To override the contents of this collection use [`set_dense_struct_map`](Self::set_dense_struct_map).
     ///
     pub fn dense_struct_map(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::GreetingStruct) -> Self {
         let mut hash_map = self.dense_struct_map.unwrap_or_default();
         hash_map.insert(k.into(), v);
         self.dense_struct_map = ::std::option::Option::Some(hash_map);
         self
-300
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_dense_struct_map(

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

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

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

@@ -107,111 +226,233 @@

↥ Expand context

         ));
-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("JsonTimestamps")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(JsonTimestampsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::json_timestamps::JsonTimestampsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::json_timestamps::JsonTimestampsError,
             >::new());
-130

         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct JsonTimestampsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for JsonTimestampsResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-146
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_json_timestamps::de_json_timestamps_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::json_timestamps::JsonTimestampsError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_json_timestamps::de_json_timestamps_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, JsonTimestamps::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::json_timestamps::JsonTimestampsOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-182
+    }
-183
+}
 #[derive(Debug)]
 struct JsonTimestampsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for JsonTimestampsRequestSerializer {
     #[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::json_timestamps::JsonTimestampsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::json_timestamps::JsonTimestampsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/JsonTimestamps").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::json_timestamps::JsonTimestampsInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_json_timestamps::ser_json_timestamps_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, JsonTimestamps::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-204
+    }
-205
+}
 #[derive(Debug)]
 struct JsonTimestampsEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonTimestampsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonTimestampsEndpointParamsInterceptor"
-212
+    }
-213

↧ Expand context

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

@@ -495,502 +555,572 @@

↥ Expand context

         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_normal(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"normal\": 1398796238\n}"))
                 .unwrap(),
-513
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-517
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-523
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-571
+    }
-572

@@ -563,580 +623,650 @@

↥ Expand context

                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"dateTime\": \"2014-04-29T18:30:38Z\"\n}",
                 ))
                 .unwrap(),
-591
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-595
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-601
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-649
+    }
-650

@@ -631,658 +691,728 @@

↥ Expand context

                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\n}",
                 ))
                 .unwrap(),
-669
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-673
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-679
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-727
+    }
-728

@@ -697,734 +757,804 @@

↥ Expand context

         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"epochSeconds\": 1398796238\n}"))
                 .unwrap(),
-745
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-749
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-755
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-803
+    }
-804

@@ -763,810 +823,880 @@

↥ Expand context

         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_epoch_seconds_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"epochSecondsOnTarget\": 1398796238\n}"))
                 .unwrap(),
-821
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-825
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-831
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-879
+    }
-880

@@ -831,888 +891,958 @@

↥ Expand context

                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
                 ))
                 .unwrap(),
-899
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-903
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-909
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-957
+    }
-958

@@ -899,966 +959,1036 @@

↥ Expand context

                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
                 ))
                 .unwrap(),
-977
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-981
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-987
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-1035
+    }
-1036
+}

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

@@ -43,43 +251,266 @@

↥ Expand context

     pub fn http_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.http_date.as_ref()
-45
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn http_date_on_target(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.http_date_on_target.as_ref()
-49
+    }
-50
+}
 static JSONTIMESTAMPSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#JsonTimestampsInput",
     "aws.protocoltests.restjson.synthetic",
     "JsonTimestampsInput",
 );
 static JSONTIMESTAMPSINPUT_MEMBER_NORMAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsInput$normal",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,

     "normal",
 ,
 );
 static JSONTIMESTAMPSINPUT_MEMBER_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsInput$dateTime",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "date_time",
     "dateTime",
 ,
-75
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 static JSONTIMESTAMPSINPUT_MEMBER_DATE_TIME_ON_TARGET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsInput$dateTimeOnTarget",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "date_time_on_target",
     "dateTimeOnTarget",
 ,
 );
-+
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 static JSONTIMESTAMPSINPUT_MEMBER_EPOCH_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsInput$epochSeconds",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "epoch_seconds",
     "epochSeconds",
 ,
-97
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::EpochSeconds);
 static JSONTIMESTAMPSINPUT_MEMBER_EPOCH_SECONDS_ON_TARGET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsInput$epochSecondsOnTarget",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "epoch_seconds_on_target",
     "epochSecondsOnTarget",
 ,
 );
-+
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::EpochSeconds);
 static JSONTIMESTAMPSINPUT_MEMBER_HTTP_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsInput$httpDate",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "http_date",
     "httpDate",
 ,
-119
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
 static JSONTIMESTAMPSINPUT_MEMBER_HTTP_DATE_ON_TARGET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsInput$httpDateOnTarget",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "http_date_on_target",
     "httpDateOnTarget",
 ,
 );
-+
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
 static JSONTIMESTAMPSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     JSONTIMESTAMPSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &JSONTIMESTAMPSINPUT_MEMBER_NORMAL,
         &JSONTIMESTAMPSINPUT_MEMBER_DATE_TIME,
         &JSONTIMESTAMPSINPUT_MEMBER_DATE_TIME_ON_TARGET,
         &JSONTIMESTAMPSINPUT_MEMBER_EPOCH_SECONDS,
         &JSONTIMESTAMPSINPUT_MEMBER_EPOCH_SECONDS_ON_TARGET,
         &JSONTIMESTAMPSINPUT_MEMBER_HTTP_DATE,
         &JSONTIMESTAMPSINPUT_MEMBER_HTTP_DATE_ON_TARGET,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/JsonTimestamps", None));
 impl JsonTimestampsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONTIMESTAMPSINPUT_SCHEMA;
-149
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonTimestampsInput {
     #[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.normal {
             ser.write_timestamp(&JSONTIMESTAMPSINPUT_MEMBER_NORMAL, val)?;
-158
+        }
         if let Some(ref val) = self.date_time {
             ser.write_timestamp(&JSONTIMESTAMPSINPUT_MEMBER_DATE_TIME, val)?;
-161
+        }
         if let Some(ref val) = self.date_time_on_target {
             ser.write_timestamp(&JSONTIMESTAMPSINPUT_MEMBER_DATE_TIME_ON_TARGET, val)?;
-164
+        }
         if let Some(ref val) = self.epoch_seconds {
             ser.write_timestamp(&JSONTIMESTAMPSINPUT_MEMBER_EPOCH_SECONDS, val)?;
-167
+        }
         if let Some(ref val) = self.epoch_seconds_on_target {
             ser.write_timestamp(&JSONTIMESTAMPSINPUT_MEMBER_EPOCH_SECONDS_ON_TARGET, val)?;
-170
+        }
         if let Some(ref val) = self.http_date {
             ser.write_timestamp(&JSONTIMESTAMPSINPUT_MEMBER_HTTP_DATE, val)?;
-173
+        }
         if let Some(ref val) = self.http_date_on_target {
             ser.write_timestamp(&JSONTIMESTAMPSINPUT_MEMBER_HTTP_DATE_ON_TARGET, val)?;
-176
+        }
         Ok(())
-178
+    }
-179
+}
 impl JsonTimestampsInput {
     /// 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(&JSONTIMESTAMPSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&JSONTIMESTAMPSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.normal = Some(deser.read_timestamp(member)?);
-198
+                }
                 Some(1) => {
                     builder.date_time = Some(deser.read_timestamp(member)?);
-201
+                }
                 Some(2) => {
                     builder.date_time_on_target = Some(deser.read_timestamp(member)?);
-204
+                }
                 Some(3) => {
                     builder.epoch_seconds = Some(deser.read_timestamp(member)?);
-207
+                }
                 Some(4) => {
                     builder.epoch_seconds_on_target = Some(deser.read_timestamp(member)?);
-210
+                }
                 Some(5) => {
                     builder.http_date = Some(deser.read_timestamp(member)?);
-213
+                }
                 Some(6) => {
                     builder.http_date_on_target = Some(deser.read_timestamp(member)?);
-216
+                }
                 _ => {}
-218
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-224
+    }
-225
+}
 impl JsonTimestampsInput {
     /// 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 JsonTimestampsInput {
     /// Creates a new builder-style object to manufacture [`JsonTimestampsInput`](crate::operation::json_timestamps::JsonTimestampsInput).
     pub fn builder() -> crate::operation::json_timestamps::builders::JsonTimestampsInputBuilder {
         crate::operation::json_timestamps::builders::JsonTimestampsInputBuilder::default()
-241
+    }
-242
+}
-243
 /// A builder for [`JsonTimestampsInput`](crate::operation::json_timestamps::JsonTimestampsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonTimestampsInputBuilder {
     pub(crate) normal: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) date_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) date_time_on_target: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) epoch_seconds: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) epoch_seconds_on_target: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) http_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) http_date_on_target: ::std::option::Option<::aws_smithy_types::DateTime>,
-255
+}
 impl JsonTimestampsInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn normal(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         self.normal = ::std::option::Option::Some(input);
         self
-261
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_normal(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         self.normal = input;
         self
-266
+    }

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

@@ -43,43 +249,263 @@

↥ Expand context

     pub fn http_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.http_date.as_ref()
-45
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn http_date_on_target(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.http_date_on_target.as_ref()
-49
+    }
-50
+}
 static JSONTIMESTAMPSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#JsonTimestampsOutput",
     "aws.protocoltests.restjson.synthetic",
     "JsonTimestampsOutput",
 );
 static JSONTIMESTAMPSOUTPUT_MEMBER_NORMAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsOutput$normal",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,

     "normal",
 ,
 );
 static JSONTIMESTAMPSOUTPUT_MEMBER_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsOutput$dateTime",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "date_time",
     "dateTime",
 ,
-75
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 static JSONTIMESTAMPSOUTPUT_MEMBER_DATE_TIME_ON_TARGET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsOutput$dateTimeOnTarget",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "date_time_on_target",
     "dateTimeOnTarget",
 ,
 );
-+
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 static JSONTIMESTAMPSOUTPUT_MEMBER_EPOCH_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsOutput$epochSeconds",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "epoch_seconds",
     "epochSeconds",
 ,
-97
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::EpochSeconds);
 static JSONTIMESTAMPSOUTPUT_MEMBER_EPOCH_SECONDS_ON_TARGET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsOutput$epochSecondsOnTarget",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "epoch_seconds_on_target",
     "epochSecondsOnTarget",
 ,
 );
-+
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::EpochSeconds);
 static JSONTIMESTAMPSOUTPUT_MEMBER_HTTP_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsOutput$httpDate",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "http_date",
     "httpDate",
 ,
-119
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
 static JSONTIMESTAMPSOUTPUT_MEMBER_HTTP_DATE_ON_TARGET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonTimestampsOutput$httpDateOnTarget",
         "aws.protocoltests.restjson.synthetic",
         "JsonTimestampsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "http_date_on_target",
     "httpDateOnTarget",
 ,
 );
-+
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
 static JSONTIMESTAMPSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     JSONTIMESTAMPSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &JSONTIMESTAMPSOUTPUT_MEMBER_NORMAL,
         &JSONTIMESTAMPSOUTPUT_MEMBER_DATE_TIME,
         &JSONTIMESTAMPSOUTPUT_MEMBER_DATE_TIME_ON_TARGET,
         &JSONTIMESTAMPSOUTPUT_MEMBER_EPOCH_SECONDS,
         &JSONTIMESTAMPSOUTPUT_MEMBER_EPOCH_SECONDS_ON_TARGET,
         &JSONTIMESTAMPSOUTPUT_MEMBER_HTTP_DATE,
         &JSONTIMESTAMPSOUTPUT_MEMBER_HTTP_DATE_ON_TARGET,
     ],
 );
 impl JsonTimestampsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONTIMESTAMPSOUTPUT_SCHEMA;
-148
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonTimestampsOutput {
     #[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.normal {
             ser.write_timestamp(&JSONTIMESTAMPSOUTPUT_MEMBER_NORMAL, val)?;
-157
+        }
         if let Some(ref val) = self.date_time {
             ser.write_timestamp(&JSONTIMESTAMPSOUTPUT_MEMBER_DATE_TIME, val)?;
-160
+        }
         if let Some(ref val) = self.date_time_on_target {
             ser.write_timestamp(&JSONTIMESTAMPSOUTPUT_MEMBER_DATE_TIME_ON_TARGET, val)?;
-163
+        }
         if let Some(ref val) = self.epoch_seconds {
             ser.write_timestamp(&JSONTIMESTAMPSOUTPUT_MEMBER_EPOCH_SECONDS, val)?;
-166
+        }
         if let Some(ref val) = self.epoch_seconds_on_target {
             ser.write_timestamp(&JSONTIMESTAMPSOUTPUT_MEMBER_EPOCH_SECONDS_ON_TARGET, val)?;
-169
+        }
         if let Some(ref val) = self.http_date {
             ser.write_timestamp(&JSONTIMESTAMPSOUTPUT_MEMBER_HTTP_DATE, val)?;
-172
+        }
         if let Some(ref val) = self.http_date_on_target {
             ser.write_timestamp(&JSONTIMESTAMPSOUTPUT_MEMBER_HTTP_DATE_ON_TARGET, val)?;
-175
+        }
         Ok(())
-177
+    }
-178
+}
 impl JsonTimestampsOutput {
     /// 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(&JSONTIMESTAMPSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&JSONTIMESTAMPSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.normal = Some(deser.read_timestamp(member)?);
-197
+                }
                 Some(1) => {
                     builder.date_time = Some(deser.read_timestamp(member)?);
-200
+                }
                 Some(2) => {
                     builder.date_time_on_target = Some(deser.read_timestamp(member)?);
-203
+                }
                 Some(3) => {
                     builder.epoch_seconds = Some(deser.read_timestamp(member)?);
-206
+                }
                 Some(4) => {
                     builder.epoch_seconds_on_target = Some(deser.read_timestamp(member)?);
-209
+                }
                 Some(5) => {
                     builder.http_date = Some(deser.read_timestamp(member)?);
-212
+                }
                 Some(6) => {
                     builder.http_date_on_target = Some(deser.read_timestamp(member)?);
-215
+                }
                 _ => {}
-217
+            }
             Ok(())
         })?;
         Ok(builder.build())
-221
+    }
-222
+}
 impl JsonTimestampsOutput {
     /// 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 JsonTimestampsOutput {
     /// Creates a new builder-style object to manufacture [`JsonTimestampsOutput`](crate::operation::json_timestamps::JsonTimestampsOutput).
     pub fn builder() -> crate::operation::json_timestamps::builders::JsonTimestampsOutputBuilder {
         crate::operation::json_timestamps::builders::JsonTimestampsOutputBuilder::default()
-238
+    }
-239
+}
-240
 /// A builder for [`JsonTimestampsOutput`](crate::operation::json_timestamps::JsonTimestampsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonTimestampsOutputBuilder {
     pub(crate) normal: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) date_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) date_time_on_target: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) epoch_seconds: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) epoch_seconds_on_target: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) http_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) http_date_on_target: ::std::option::Option<::aws_smithy_types::DateTime>,
-252
+}
 impl JsonTimestampsOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn normal(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         self.normal = ::std::option::Option::Some(input);
         self
-258
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_normal(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         self.normal = input;
         self
-263
+    }

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

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

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

@@ -107,111 +224,229 @@

↥ Expand context

         ));
-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("JsonUnions")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(JsonUnionsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::json_unions::JsonUnionsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::json_unions::JsonUnionsError,
             >::new());
-130

         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct JsonUnionsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for JsonUnionsResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-146
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_json_unions::de_json_unions_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(crate::operation::json_unions::JsonUnionsError::generic(
                     generic,
                 )),
             ))
         } else {
             crate::protocol_serde::shape_json_unions::de_json_unions_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, JsonUnions::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::json_unions::JsonUnionsOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-180
+    }
-181
+}
 #[derive(Debug)]
 struct JsonUnionsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for JsonUnionsRequestSerializer {
     #[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::json_unions::JsonUnionsInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::json_unions::JsonUnionsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/JsonUnions").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::json_unions::JsonUnionsInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_json_unions::ser_json_unions_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, JsonUnions::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-200
+    }
-201
+}
 #[derive(Debug)]
 struct JsonUnionsEndpointParamsInterceptor;
-204
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonUnionsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonUnionsEndpointParamsInterceptor"
-208
+    }
-209

↧ Expand context

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

@@ -603,608 +1073,1178 @@

↥ Expand context

         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StringValue("foo".to_owned())))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\n    }\n}",
                 ))
                 .unwrap(),
-619
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-623
         let op = crate::operation::json_unions::JsonUnions::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");
-629
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-655
+    }
-656
     /// Deserializes a boolean union value
     /// Test ID: RestJsonDeserializeBooleanUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_boolean_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::BooleanValue(true)))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"booleanValue\": true\n    }\n}",
                 ))
                 .unwrap(),
-673
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-677
         let op = crate::operation::json_unions::JsonUnions::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");
-683
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-709
+    }
-710
     /// Deserializes a number union value
     /// Test ID: RestJsonDeserializeNumberUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_number_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::NumberValue(1)))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"numberValue\": 1\n    }\n}",
                 ))
                 .unwrap(),
-727
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-731
         let op = crate::operation::json_unions::JsonUnions::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");
-737
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-763
+    }
-764
     /// Deserializes a blob union value
     /// Test ID: RestJsonDeserializeBlobUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_blob_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::BlobValue(
                 ::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/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"blobValue\": \"Zm9v\"\n    }\n}",
                 ))
                 .unwrap(),
-783
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-787
         let op = crate::operation::json_unions::JsonUnions::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");
-793
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-819
+    }
-820
     /// Deserializes a timestamp union value
     /// Test ID: RestJsonDeserializeTimestampUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_timestamp_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::TimestampValue(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"timestampValue\": 1398796238\n    }\n}",
                 ))
                 .unwrap(),
-839
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-843
         let op = crate::operation::json_unions::JsonUnions::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");
-849
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-875
+    }
-876
     /// Deserializes an enum union value
     /// Test ID: RestJsonDeserializeEnumUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_enum_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::EnumValue(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"enumValue\": \"Foo\"\n    }\n}",
                 ))
                 .unwrap(),
-895
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-899
         let op = crate::operation::json_unions::JsonUnions::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");
-905
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-931
+    }
-932
     /// Deserializes a list union value
     /// Test ID: RestJsonDeserializeListUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_list_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::ListValue(vec![
                 "foo".to_owned(),
                 "bar".to_owned(),
             ])))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"listValue\": [\"foo\", \"bar\"]\n    }\n}",
                 ))
                 .unwrap(),
-952
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-956
         let op = crate::operation::json_unions::JsonUnions::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");
-962
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-988
+    }
-989
     /// Deserializes a map union value
     /// Test ID: RestJsonDeserializeMapUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_map_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::MapValue({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), "bar".to_owned());
                 ret.insert("spam".to_owned(), "eggs".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/json")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1011
         let op = crate::operation::json_unions::JsonUnions::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");
-1017
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-1043
+    }
-1044
     /// Deserializes a structure union value
     /// Test ID: RestJsonDeserializeStructureUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_structure_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".to_owned()))
                     .build(),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}",
                 ))
                 .unwrap(),
-1065
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1069
         let op = crate::operation::json_unions::JsonUnions::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");
-1075
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-1101
+    }
-1102
     /// Ignores an unrecognized __type property
     /// Test ID: RestJsonDeserializeIgnoreType
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_ignore_type_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".to_owned()))
                     .build(),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "application/json")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"contents\": {\n        \"__type\": \"aws.protocoltests.json10#MyUnion\",\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1123
         let op = crate::operation::json_unions::JsonUnions::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");
-1129
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-1155
+    }
-1156
+}
-1157
 /// Error type for the `JsonUnionsError` operation.

↧ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum JsonUnionsError {
     /// 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()`:
-1165
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-1167
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-JsonUnionsError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-1170
+}
 impl JsonUnionsError {
     /// Creates the `JsonUnionsError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),

Client Test

Files changed: