Client Test

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/kitchen_sink_operation/_kitchen_sink_operation_input.rs

@@ -165,165 +477,477 @@

-165
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn string(&self) -> ::std::option::Option<&str> {
         self.string.as_deref()
-169
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn struct_with_json_name(&self) -> ::std::option::Option<&crate::types::StructWithJsonName> {
         self.struct_with_json_name.as_ref()
-173
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn timestamp(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.timestamp.as_ref()
-177
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn unix_timestamp(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.unix_timestamp.as_ref()
-181
+    }
-182
+}
 static KITCHENSINKOPERATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.json.synthetic#KitchenSinkOperationInput",

     "aws.protocoltests.json.synthetic",
     "KitchenSinkOperationInput",
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$Blob",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob",
     "Blob",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$Boolean",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "boolean",
     "Boolean",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$Double",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "double",
     "Double",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_EMPTY_STRUCT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$EmptyStruct",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "empty_struct",
     "EmptyStruct",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$Float",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "float",
     "Float",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_HTTPDATE_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$HttpdateTimestamp",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "httpdate_timestamp",
     "HttpdateTimestamp",
 ,
-247
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
 static KITCHENSINKOPERATIONINPUT_MEMBER_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$Integer",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "integer",
     "Integer",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_ISO8601_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$Iso8601Timestamp",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "iso8601_timestamp",
     "Iso8601Timestamp",
 ,
-268
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 static KITCHENSINKOPERATIONINPUT_MEMBER_JSON_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$JsonValue",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "json_value",
     "JsonValue",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_LISTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$ListOfLists",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "list_of_lists",
     "ListOfLists",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_MAPS_OF_STRINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$ListOfMapsOfStrings",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "list_of_maps_of_strings",
     "ListOfMapsOfStrings",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_STRINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$ListOfStrings",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "list_of_strings",
     "ListOfStrings",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_STRUCTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$ListOfStructs",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "list_of_structs",
     "ListOfStructs",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$Long",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "long",
     "Long",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_LISTS_OF_STRINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$MapOfListsOfStrings",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "map_of_lists_of_strings",
     "MapOfListsOfStrings",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_MAPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$MapOfMaps",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "map_of_maps",
     "MapOfMaps",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_STRINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$MapOfStrings",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "map_of_strings",
     "MapOfStrings",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_STRUCTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$MapOfStructs",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "map_of_structs",
     "MapOfStructs",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_RECURSIVE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$RecursiveList",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "recursive_list",
     "RecursiveList",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_RECURSIVE_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$RecursiveMap",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "recursive_map",
     "RecursiveMap",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_RECURSIVE_STRUCT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$RecursiveStruct",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "recursive_struct",
     "RecursiveStruct",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_SIMPLE_STRUCT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$SimpleStruct",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "simple_struct",
     "SimpleStruct",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$String",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "string",
     "String",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_STRUCT_WITH_JSON_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$StructWithJsonName",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "struct_with_json_name",
     "StructWithJsonName",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$Timestamp",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "timestamp",
     "Timestamp",
 ,
 );
 static KITCHENSINKOPERATIONINPUT_MEMBER_UNIX_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationInput$UnixTimestamp",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "unix_timestamp",
     "UnixTimestamp",
 ,
-449
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::EpochSeconds);
 static KITCHENSINKOPERATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     KITCHENSINKOPERATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &KITCHENSINKOPERATIONINPUT_MEMBER_BLOB,
         &KITCHENSINKOPERATIONINPUT_MEMBER_BOOLEAN,
         &KITCHENSINKOPERATIONINPUT_MEMBER_DOUBLE,

↧ Expand context

         &KITCHENSINKOPERATIONINPUT_MEMBER_EMPTY_STRUCT,
         &KITCHENSINKOPERATIONINPUT_MEMBER_FLOAT,
         &KITCHENSINKOPERATIONINPUT_MEMBER_HTTPDATE_TIMESTAMP,
         &KITCHENSINKOPERATIONINPUT_MEMBER_INTEGER,
         &KITCHENSINKOPERATIONINPUT_MEMBER_ISO8601_TIMESTAMP,
         &KITCHENSINKOPERATIONINPUT_MEMBER_JSON_VALUE,
         &KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_LISTS,
         &KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_MAPS_OF_STRINGS,
         &KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_STRINGS,
         &KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_STRUCTS,
         &KITCHENSINKOPERATIONINPUT_MEMBER_LONG,
         &KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_LISTS_OF_STRINGS,
         &KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_MAPS,
         &KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_STRINGS,
         &KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_STRUCTS,
         &KITCHENSINKOPERATIONINPUT_MEMBER_RECURSIVE_LIST,
         &KITCHENSINKOPERATIONINPUT_MEMBER_RECURSIVE_MAP,
         &KITCHENSINKOPERATIONINPUT_MEMBER_RECURSIVE_STRUCT,
         &KITCHENSINKOPERATIONINPUT_MEMBER_SIMPLE_STRUCT,
         &KITCHENSINKOPERATIONINPUT_MEMBER_STRING,

@@ -495,495 +615,651 @@

↥ Expand context

-495
+        }
         if let Some(ref val) = self.boolean {
             ser.write_boolean(&KITCHENSINKOPERATIONINPUT_MEMBER_BOOLEAN, *val)?;
-498
+        }
         if let Some(ref val) = self.double {
             ser.write_double(&KITCHENSINKOPERATIONINPUT_MEMBER_DOUBLE, *val)?;
-501
+        }
         if let Some(ref val) = self.empty_struct {
             ser.write_struct(&KITCHENSINKOPERATIONINPUT_MEMBER_EMPTY_STRUCT, val)?;
-504
+        }
         if let Some(ref val) = self.float {
             ser.write_float(&KITCHENSINKOPERATIONINPUT_MEMBER_FLOAT, *val)?;
-507
+        }
         if let Some(ref val) = self.httpdate_timestamp {
             ser.write_timestamp(&KITCHENSINKOPERATIONINPUT_MEMBER_HTTPDATE_TIMESTAMP, val)?;
-510
+        }
         if let Some(ref val) = self.integer {
             ser.write_integer(&KITCHENSINKOPERATIONINPUT_MEMBER_INTEGER, *val)?;
-513
+        }
         if let Some(ref val) = self.iso8601_timestamp {

             ser.write_timestamp(&KITCHENSINKOPERATIONINPUT_MEMBER_ISO8601_TIMESTAMP, val)?;
-516
+        }
         if let Some(ref val) = self.json_value {
             ser.write_string(&KITCHENSINKOPERATIONINPUT_MEMBER_JSON_VALUE, val)?;
-519
+        }
         if let Some(ref val) = self.list_of_lists {
             ser.write_list(
                 &KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_LISTS,
                 &|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(())
                             },
                         )?;
-534
+                    }
                     Ok(())
                 },
             )?;
-538
+        }
         if let Some(ref val) = self.list_of_maps_of_strings {
             ser.write_list(
                 &KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_MAPS_OF_STRINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_map(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for (key, value) in item {
                                     ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                                     ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-554
+                    }
                     Ok(())
                 },
             )?;
-558
+        }
         if let Some(ref val) = self.list_of_strings {
             ser.write_list(
                 &KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_STRINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-565
+                    }
                     Ok(())
                 },
             )?;
-569
+        }
         if let Some(ref val) = self.list_of_structs {
             ser.write_list(
                 &KITCHENSINKOPERATIONINPUT_MEMBER_LIST_OF_STRUCTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::SimpleStruct::SCHEMA, item)?;
-576
+                    }
                     Ok(())
                 },
             )?;
-580
+        }
         if let Some(ref val) = self.long {
             ser.write_long(&KITCHENSINKOPERATIONINPUT_MEMBER_LONG, *val)?;
-583
+        }
         if let Some(ref val) = self.map_of_lists_of_strings {
             ser.write_map(
                 &KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_LISTS_OF_STRINGS,
                 &|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(())
                             },
                         )?;
-600
+                    }
                     Ok(())
                 },
             )?;
-604
+        }
         if let Some(ref val) = self.map_of_maps {
             ser.write_map(
                 &KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_MAPS,
                 &|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_map(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for (key, value) in value {
                                     ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                                     ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-622
+                    }
                     Ok(())
                 },
             )?;
-626
+        }
         if let Some(ref val) = self.map_of_strings {
             ser.write_map(
                 &KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_STRINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {

↧ Expand context

                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-634
+                    }
                     Ok(())
                 },
             )?;
-638
+        }
         if let Some(ref val) = self.map_of_structs {
             ser.write_map(
                 &KITCHENSINKOPERATIONINPUT_MEMBER_MAP_OF_STRUCTS,
                 &|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::SimpleStruct::SCHEMA, value)?;
-646
+                    }
                     Ok(())
                 },
             )?;
-650
+        }
         if let Some(ref val) = self.recursive_list {

@@ -631,667 +891,924 @@

↥ Expand context

                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::KitchenSink::SCHEMA, value)?;
-669
+                    }
                     Ok(())
                 },
             )?;
-673
+        }
         if let Some(ref val) = self.recursive_struct {
             ser.write_struct(&KITCHENSINKOPERATIONINPUT_MEMBER_RECURSIVE_STRUCT, val)?;
-676
+        }
         if let Some(ref val) = self.simple_struct {
             ser.write_struct(&KITCHENSINKOPERATIONINPUT_MEMBER_SIMPLE_STRUCT, val)?;
-679
+        }
         if let Some(ref val) = self.string {
             ser.write_string(&KITCHENSINKOPERATIONINPUT_MEMBER_STRING, val)?;
-682
+        }
         if let Some(ref val) = self.struct_with_json_name {
             ser.write_struct(&KITCHENSINKOPERATIONINPUT_MEMBER_STRUCT_WITH_JSON_NAME, val)?;
-685
+        }
         if let Some(ref val) = self.timestamp {

             ser.write_timestamp(&KITCHENSINKOPERATIONINPUT_MEMBER_TIMESTAMP, val)?;
-688
+        }
         if let Some(ref val) = self.unix_timestamp {
             ser.write_timestamp(&KITCHENSINKOPERATIONINPUT_MEMBER_UNIX_TIMESTAMP, val)?;
-691
+        }
         Ok(())
-693
+    }
-694
+}
 impl KitchenSinkOperationInput {
     /// 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(&KITCHENSINKOPERATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&KITCHENSINKOPERATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.blob = Some(deser.read_blob(member)?);
-713
+                }
                 Some(1) => {
                     builder.boolean = Some(deser.read_boolean(member)?);
-716
+                }
                 Some(2) => {
                     builder.double = Some(deser.read_double(member)?);
-719
+                }
                 Some(3) => {
                     builder.empty_struct = Some(crate::types::EmptyStruct::deserialize(deser)?);
-722
+                }
                 Some(4) => {
                     builder.float = Some(deser.read_float(member)?);
-725
+                }
                 Some(5) => {
                     builder.httpdate_timestamp = Some(deser.read_timestamp(member)?);
-728
+                }
                 Some(6) => {
                     builder.integer = Some(deser.read_integer(member)?);
-731
+                }
                 Some(7) => {
                     builder.iso8601_timestamp = Some(deser.read_timestamp(member)?);
-734
+                }
                 Some(8) => {
                     builder.json_value = Some(deser.read_string(member)?);
-737
+                }
                 Some(9) => {
                     builder.list_of_lists = 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
                     });
-754
+                }
                 Some(10) => {
                     builder.list_of_maps_of_strings = 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 map = ::std::collections::HashMap::new();
                                 deser.read_map(member, &mut |key, deser| {
                                     let value = deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?;
                                     map.insert(key, value);
                                     Ok(())
                                 })?;
                                 map
                             });
                             Ok(())
                         })?;
                         container
                     });
-772
+                }
                 Some(11) => {
                     builder.list_of_strings = 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.list_of_strings = Some(deser.read_string_list(member)?);
-775
+                }
                 Some(12) => {
                     builder.list_of_structs = 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::SimpleStruct::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::SimpleStruct::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-785
+                }
                 Some(13) => {
                     builder.long = Some(deser.read_long(member)?);
-788
+                }
                 Some(14) => {
                     builder.map_of_lists_of_strings = 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
                     });
-805
+                }
                 Some(15) => {
                     builder.map_of_maps = 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 map = ::std::collections::HashMap::new();
                                 deser.read_map(member, &mut |key, deser| {
                                     let value = deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?;
                                     map.insert(key, value);
                                     Ok(())
                                 })?;
                                 map
                             });
                             Ok(())
                         })?;
                         container
                     });
-823
+                }
                 Some(16) => {
                     builder.map_of_strings = 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.map_of_strings = Some(deser.read_string_string_map(member)?);
-826
+                }
                 Some(17) => {
                     builder.map_of_structs = 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::SimpleStruct::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::SimpleStruct::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-836
+                }
                 Some(18) => {
                     builder.recursive_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::KitchenSink::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::KitchenSink::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-846
+                }
                 Some(19) => {
                     builder.recursive_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::KitchenSink::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::KitchenSink::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-856
+                }
                 Some(20) => {
                     builder.recursive_struct = Some(Box::new(crate::types::KitchenSink::deserialize(deser)?));
-859
+                }
                 Some(21) => {
                     builder.simple_struct = Some(crate::types::SimpleStruct::deserialize(deser)?);
-862
+                }
                 Some(22) => {
                     builder.string = Some(deser.read_string(member)?);
-865
+                }
                 Some(23) => {
                     builder.struct_with_json_name = Some(crate::types::StructWithJsonName::deserialize(deser)?);
-868
+                }
                 Some(24) => {
                     builder.timestamp = Some(deser.read_timestamp(member)?);
-871
+                }
                 Some(25) => {
                     builder.unix_timestamp = Some(deser.read_timestamp(member)?);
-874
+                }
                 _ => {}
-876
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-882
+    }
-883
+}
 impl KitchenSinkOperationInput {
     /// 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 KitchenSinkOperationInput {
     /// Creates a new builder-style object to manufacture [`KitchenSinkOperationInput`](crate::operation::kitchen_sink_operation::KitchenSinkOperationInput).
     pub fn builder() -> crate::operation::kitchen_sink_operation::builders::KitchenSinkOperationInputBuilder {
         crate::operation::kitchen_sink_operation::builders::KitchenSinkOperationInputBuilder::default()
-899
+    }
-900
+}
-901
 /// A builder for [`KitchenSinkOperationInput`](crate::operation::kitchen_sink_operation::KitchenSinkOperationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct KitchenSinkOperationInputBuilder {
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) boolean: ::std::option::Option<bool>,
     pub(crate) double: ::std::option::Option<f64>,
     pub(crate) empty_struct: ::std::option::Option<crate::types::EmptyStruct>,
     pub(crate) float: ::std::option::Option<f32>,
     pub(crate) httpdate_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) integer: ::std::option::Option<i32>,
     pub(crate) iso8601_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) json_value: ::std::option::Option<::std::string::String>,
     pub(crate) list_of_lists: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,
     pub(crate) list_of_maps_of_strings:
         ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::string::String>>>,
     pub(crate) list_of_strings: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) list_of_structs: ::std::option::Option<::std::vec::Vec<crate::types::SimpleStruct>>,
     pub(crate) long: ::std::option::Option<i64>,
     pub(crate) map_of_lists_of_strings:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
     pub(crate) map_of_maps: ::std::option::Option<
         ::std::collections::HashMap<::std::string::String, ::std::collections::HashMap<::std::string::String, ::std::string::String>>,

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/kitchen_sink_operation/_kitchen_sink_operation_output.rs

@@ -165,165 +477,477 @@

↥ Expand context

-165
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn string(&self) -> ::std::option::Option<&str> {
         self.string.as_deref()
-169
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn struct_with_json_name(&self) -> ::std::option::Option<&crate::types::StructWithJsonName> {
         self.struct_with_json_name.as_ref()
-173
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn timestamp(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.timestamp.as_ref()
-177
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn unix_timestamp(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.unix_timestamp.as_ref()
-181
+    }
-182
+}
 static KITCHENSINKOPERATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput",

     "aws.protocoltests.json.synthetic",
     "KitchenSinkOperationOutput",
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$Blob",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob",
     "Blob",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$Boolean",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "boolean",
     "Boolean",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$Double",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "double",
     "Double",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_EMPTY_STRUCT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$EmptyStruct",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "empty_struct",
     "EmptyStruct",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$Float",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "float",
     "Float",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_HTTPDATE_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$HttpdateTimestamp",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "httpdate_timestamp",
     "HttpdateTimestamp",
 ,
-247
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$Integer",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "integer",
     "Integer",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_ISO8601_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$Iso8601Timestamp",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "iso8601_timestamp",
     "Iso8601Timestamp",
 ,
-268
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_JSON_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$JsonValue",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "json_value",
     "JsonValue",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_LISTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$ListOfLists",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "list_of_lists",
     "ListOfLists",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_MAPS_OF_STRINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$ListOfMapsOfStrings",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "list_of_maps_of_strings",
     "ListOfMapsOfStrings",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_STRINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$ListOfStrings",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "list_of_strings",
     "ListOfStrings",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_STRUCTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$ListOfStructs",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "list_of_structs",
     "ListOfStructs",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$Long",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "long",
     "Long",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_LISTS_OF_STRINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$MapOfListsOfStrings",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "map_of_lists_of_strings",
     "MapOfListsOfStrings",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_MAPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$MapOfMaps",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "map_of_maps",
     "MapOfMaps",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_STRINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$MapOfStrings",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "map_of_strings",
     "MapOfStrings",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_STRUCTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$MapOfStructs",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "map_of_structs",
     "MapOfStructs",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_RECURSIVE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$RecursiveList",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "recursive_list",
     "RecursiveList",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_RECURSIVE_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$RecursiveMap",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "recursive_map",
     "RecursiveMap",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_RECURSIVE_STRUCT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$RecursiveStruct",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "recursive_struct",
     "RecursiveStruct",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_SIMPLE_STRUCT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$SimpleStruct",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "simple_struct",
     "SimpleStruct",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$String",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "string",
     "String",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_STRUCT_WITH_JSON_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$StructWithJsonName",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "struct_with_json_name",
     "StructWithJsonName",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$Timestamp",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "timestamp",
     "Timestamp",
 ,
 );
 static KITCHENSINKOPERATIONOUTPUT_MEMBER_UNIX_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#KitchenSinkOperationOutput$UnixTimestamp",
         "aws.protocoltests.json.synthetic",
         "KitchenSinkOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "unix_timestamp",
     "UnixTimestamp",
 ,
-449
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::EpochSeconds);
 static KITCHENSINKOPERATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     KITCHENSINKOPERATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_BLOB,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_BOOLEAN,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_DOUBLE,

↧ Expand context

         &KITCHENSINKOPERATIONOUTPUT_MEMBER_EMPTY_STRUCT,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_FLOAT,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_HTTPDATE_TIMESTAMP,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_INTEGER,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_ISO8601_TIMESTAMP,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_JSON_VALUE,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_LISTS,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_MAPS_OF_STRINGS,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_STRINGS,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_STRUCTS,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_LONG,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_LISTS_OF_STRINGS,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_MAPS,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_STRINGS,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_STRUCTS,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_RECURSIVE_LIST,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_RECURSIVE_MAP,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_RECURSIVE_STRUCT,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_SIMPLE_STRUCT,
         &KITCHENSINKOPERATIONOUTPUT_MEMBER_STRING,

@@ -495,495 +615,651 @@

↥ Expand context

-495
+        }
         if let Some(ref val) = self.boolean {
             ser.write_boolean(&KITCHENSINKOPERATIONOUTPUT_MEMBER_BOOLEAN, *val)?;
-498
+        }
         if let Some(ref val) = self.double {
             ser.write_double(&KITCHENSINKOPERATIONOUTPUT_MEMBER_DOUBLE, *val)?;
-501
+        }
         if let Some(ref val) = self.empty_struct {
             ser.write_struct(&KITCHENSINKOPERATIONOUTPUT_MEMBER_EMPTY_STRUCT, val)?;
-504
+        }
         if let Some(ref val) = self.float {
             ser.write_float(&KITCHENSINKOPERATIONOUTPUT_MEMBER_FLOAT, *val)?;
-507
+        }
         if let Some(ref val) = self.httpdate_timestamp {
             ser.write_timestamp(&KITCHENSINKOPERATIONOUTPUT_MEMBER_HTTPDATE_TIMESTAMP, val)?;
-510
+        }
         if let Some(ref val) = self.integer {
             ser.write_integer(&KITCHENSINKOPERATIONOUTPUT_MEMBER_INTEGER, *val)?;
-513
+        }
         if let Some(ref val) = self.iso8601_timestamp {

             ser.write_timestamp(&KITCHENSINKOPERATIONOUTPUT_MEMBER_ISO8601_TIMESTAMP, val)?;
-516
+        }
         if let Some(ref val) = self.json_value {
             ser.write_string(&KITCHENSINKOPERATIONOUTPUT_MEMBER_JSON_VALUE, val)?;
-519
+        }
         if let Some(ref val) = self.list_of_lists {
             ser.write_list(
                 &KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_LISTS,
                 &|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(())
                             },
                         )?;
-534
+                    }
                     Ok(())
                 },
             )?;
-538
+        }
         if let Some(ref val) = self.list_of_maps_of_strings {
             ser.write_list(
                 &KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_MAPS_OF_STRINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_map(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for (key, value) in item {
                                     ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                                     ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-554
+                    }
                     Ok(())
                 },
             )?;
-558
+        }
         if let Some(ref val) = self.list_of_strings {
             ser.write_list(
                 &KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_STRINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-565
+                    }
                     Ok(())
                 },
             )?;
-569
+        }
         if let Some(ref val) = self.list_of_structs {
             ser.write_list(
                 &KITCHENSINKOPERATIONOUTPUT_MEMBER_LIST_OF_STRUCTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::SimpleStruct::SCHEMA, item)?;
-576
+                    }
                     Ok(())
                 },
             )?;
-580
+        }
         if let Some(ref val) = self.long {
             ser.write_long(&KITCHENSINKOPERATIONOUTPUT_MEMBER_LONG, *val)?;
-583
+        }
         if let Some(ref val) = self.map_of_lists_of_strings {
             ser.write_map(
                 &KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_LISTS_OF_STRINGS,
                 &|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(())
                             },
                         )?;
-600
+                    }
                     Ok(())
                 },
             )?;
-604
+        }
         if let Some(ref val) = self.map_of_maps {
             ser.write_map(
                 &KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_MAPS,
                 &|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_map(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for (key, value) in value {
                                     ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                                     ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-622
+                    }
                     Ok(())
                 },
             )?;
-626
+        }
         if let Some(ref val) = self.map_of_strings {
             ser.write_map(
                 &KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_STRINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {

↧ Expand context

                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-634
+                    }
                     Ok(())
                 },
             )?;
-638
+        }
         if let Some(ref val) = self.map_of_structs {
             ser.write_map(
                 &KITCHENSINKOPERATIONOUTPUT_MEMBER_MAP_OF_STRUCTS,
                 &|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::SimpleStruct::SCHEMA, value)?;
-646
+                    }
                     Ok(())
                 },
             )?;
-650
+        }
         if let Some(ref val) = self.recursive_list {

@@ -631,667 +889,922 @@

↥ Expand context

                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::KitchenSink::SCHEMA, value)?;
-669
+                    }
                     Ok(())
                 },
             )?;
-673
+        }
         if let Some(ref val) = self.recursive_struct {
             ser.write_struct(&KITCHENSINKOPERATIONOUTPUT_MEMBER_RECURSIVE_STRUCT, val)?;
-676
+        }
         if let Some(ref val) = self.simple_struct {
             ser.write_struct(&KITCHENSINKOPERATIONOUTPUT_MEMBER_SIMPLE_STRUCT, val)?;
-679
+        }
         if let Some(ref val) = self.string {
             ser.write_string(&KITCHENSINKOPERATIONOUTPUT_MEMBER_STRING, val)?;
-682
+        }
         if let Some(ref val) = self.struct_with_json_name {
             ser.write_struct(&KITCHENSINKOPERATIONOUTPUT_MEMBER_STRUCT_WITH_JSON_NAME, val)?;
-685
+        }
         if let Some(ref val) = self.timestamp {

             ser.write_timestamp(&KITCHENSINKOPERATIONOUTPUT_MEMBER_TIMESTAMP, val)?;
-688
+        }
         if let Some(ref val) = self.unix_timestamp {
             ser.write_timestamp(&KITCHENSINKOPERATIONOUTPUT_MEMBER_UNIX_TIMESTAMP, val)?;
-691
+        }
         Ok(())
-693
+    }
-694
+}
 impl KitchenSinkOperationOutput {
     /// 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(&KITCHENSINKOPERATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&KITCHENSINKOPERATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.blob = Some(deser.read_blob(member)?);
-713
+                }
                 Some(1) => {
                     builder.boolean = Some(deser.read_boolean(member)?);
-716
+                }
                 Some(2) => {
                     builder.double = Some(deser.read_double(member)?);
-719
+                }
                 Some(3) => {
                     builder.empty_struct = Some(crate::types::EmptyStruct::deserialize(deser)?);
-722
+                }
                 Some(4) => {
                     builder.float = Some(deser.read_float(member)?);
-725
+                }
                 Some(5) => {
                     builder.httpdate_timestamp = Some(deser.read_timestamp(member)?);
-728
+                }
                 Some(6) => {
                     builder.integer = Some(deser.read_integer(member)?);
-731
+                }
                 Some(7) => {
                     builder.iso8601_timestamp = Some(deser.read_timestamp(member)?);
-734
+                }
                 Some(8) => {
                     builder.json_value = Some(deser.read_string(member)?);
-737
+                }
                 Some(9) => {
                     builder.list_of_lists = 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
                     });
-754
+                }
                 Some(10) => {
                     builder.list_of_maps_of_strings = 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 map = ::std::collections::HashMap::new();
                                 deser.read_map(member, &mut |key, deser| {
                                     let value = deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?;
                                     map.insert(key, value);
                                     Ok(())
                                 })?;
                                 map
                             });
                             Ok(())
                         })?;
                         container
                     });
-772
+                }
                 Some(11) => {
                     builder.list_of_strings = 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.list_of_strings = Some(deser.read_string_list(member)?);
-775
+                }
                 Some(12) => {
                     builder.list_of_structs = 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::SimpleStruct::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::SimpleStruct::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-785
+                }
                 Some(13) => {
                     builder.long = Some(deser.read_long(member)?);
-788
+                }
                 Some(14) => {
                     builder.map_of_lists_of_strings = 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
                     });
-805
+                }
                 Some(15) => {
                     builder.map_of_maps = 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 map = ::std::collections::HashMap::new();
                                 deser.read_map(member, &mut |key, deser| {
                                     let value = deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?;
                                     map.insert(key, value);
                                     Ok(())
                                 })?;
                                 map
                             });
                             Ok(())
                         })?;
                         container
                     });
-823
+                }
                 Some(16) => {
                     builder.map_of_strings = 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.map_of_strings = Some(deser.read_string_string_map(member)?);
-826
+                }
                 Some(17) => {
                     builder.map_of_structs = 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::SimpleStruct::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::SimpleStruct::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-836
+                }
                 Some(18) => {
                     builder.recursive_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::KitchenSink::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::KitchenSink::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-846
+                }
                 Some(19) => {
                     builder.recursive_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::KitchenSink::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::KitchenSink::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-856
+                }
                 Some(20) => {
                     builder.recursive_struct = Some(Box::new(crate::types::KitchenSink::deserialize(deser)?));
-859
+                }
                 Some(21) => {
                     builder.simple_struct = Some(crate::types::SimpleStruct::deserialize(deser)?);
-862
+                }
                 Some(22) => {
                     builder.string = Some(deser.read_string(member)?);
-865
+                }
                 Some(23) => {
                     builder.struct_with_json_name = Some(crate::types::StructWithJsonName::deserialize(deser)?);
-868
+                }
                 Some(24) => {
                     builder.timestamp = Some(deser.read_timestamp(member)?);
-871
+                }
                 Some(25) => {
                     builder.unix_timestamp = Some(deser.read_timestamp(member)?);
-874
+                }
                 _ => {}
-876
+            }
             Ok(())
         })?;
         Ok(builder.build())
-880
+    }
-881
+}
 impl KitchenSinkOperationOutput {
     /// 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 KitchenSinkOperationOutput {
     /// Creates a new builder-style object to manufacture [`KitchenSinkOperationOutput`](crate::operation::kitchen_sink_operation::KitchenSinkOperationOutput).
     pub fn builder() -> crate::operation::kitchen_sink_operation::builders::KitchenSinkOperationOutputBuilder {
         crate::operation::kitchen_sink_operation::builders::KitchenSinkOperationOutputBuilder::default()
-897
+    }
-898
+}
-899
 /// A builder for [`KitchenSinkOperationOutput`](crate::operation::kitchen_sink_operation::KitchenSinkOperationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct KitchenSinkOperationOutputBuilder {
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) boolean: ::std::option::Option<bool>,
     pub(crate) double: ::std::option::Option<f64>,
     pub(crate) empty_struct: ::std::option::Option<crate::types::EmptyStruct>,
     pub(crate) float: ::std::option::Option<f32>,
     pub(crate) httpdate_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) integer: ::std::option::Option<i32>,
     pub(crate) iso8601_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) json_value: ::std::option::Option<::std::string::String>,
     pub(crate) list_of_lists: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,
     pub(crate) list_of_maps_of_strings:
         ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::string::String>>>,
     pub(crate) list_of_strings: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) list_of_structs: ::std::option::Option<::std::vec::Vec<crate::types::SimpleStruct>>,
     pub(crate) long: ::std::option::Option<i64>,
     pub(crate) map_of_lists_of_strings:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
     pub(crate) map_of_maps: ::std::option::Option<
         ::std::collections::HashMap<::std::string::String, ::std::collections::HashMap<::std::string::String, ::std::string::String>>,

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/null_operation.rs

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

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

@@ -104,108 +231,231 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "NullOperation",
             "Json Protocol",
         ));
-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("NullOperation")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(NullOperationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::null_operation::NullOperationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::null_operation::NullOperationError,
             >::new());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct NullOperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for NullOperationResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_null_operation::de_null_operation_http_error(status, headers, body)
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(crate::operation::null_operation::NullOperationError::generic(
                     generic,
                 )),
             ))
         } else {
             crate::protocol_serde::shape_null_operation::de_null_operation_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, NullOperation::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::null_operation::NullOperationOutput::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 NullOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for NullOperationRequestSerializer {
     #[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::null_operation::NullOperationInput>()
             .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::null_operation::NullOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::null_operation::NullOperationInput,
                 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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonProtocol.NullOperation",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_null_operation::ser_null_operation_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, NullOperation::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-202
+    }
-203
+}
 #[derive(Debug)]
 struct NullOperationEndpointParamsInterceptor;
-206
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NullOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NullOperationEndpointParamsInterceptor"
-210
+    }
-211

↧ 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::<NullOperationInput>()
             .ok_or("failed to downcast to NullOperationInput")?;
-226
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

@@ -277,277 +337,347 @@

↥ Expand context

     /// Test ID: AwsJson11StructuresDontDeserializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_structures_dont_deserialize_null_values_response() {
         let expected_output = crate::operation::null_operation::NullOperationOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.1")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"string\": null\n}"))
                 .unwrap(),
-288
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-292
         let op = crate::operation::null_operation::NullOperation::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");
-298
         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_json_rpc::AwsJsonRpcProtocol::aws_json_1_1("JsonProtocol"),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::null_operation::NullOperationOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.string, expected_output.string, "Unexpected value for `string`");
-324
+    }
-325
+}
-326
 /// Error type for the `NullOperationError` operation.

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/null_operation/_null_operation_input.rs

@@ -23,23 +108,119 @@

↥ Expand context

         "aws.protocoltests.json.synthetic",
         "NullOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "string",
 ,
 );
 static NULLOPERATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     NULLOPERATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&NULLOPERATIONINPUT_MEMBER_STRING],
 );
 impl NullOperationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NULLOPERATIONINPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for NullOperationInput {
     #[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 {
             ser.write_string(&NULLOPERATIONINPUT_MEMBER_STRING, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl NullOperationInput {
     /// 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(&NULLOPERATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&NULLOPERATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.string = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl NullOperationInput {
     /// 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 NullOperationInput {
     /// Creates a new builder-style object to manufacture [`NullOperationInput`](crate::operation::null_operation::NullOperationInput).
     pub fn builder() -> crate::operation::null_operation::builders::NullOperationInputBuilder {
         crate::operation::null_operation::builders::NullOperationInputBuilder::default()
-94
+    }
-95
+}
-96
 /// A builder for [`NullOperationInput`](crate::operation::null_operation::NullOperationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct NullOperationInputBuilder {
     pub(crate) string: ::std::option::Option<::std::string::String>,
-102
+}
 impl NullOperationInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn string(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.string = ::std::option::Option::Some(input.into());
         self
-108
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_string(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.string = input;
         self
-113
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_string(&self) -> &::std::option::Option<::std::string::String> {
         &self.string
-117
+    }
     /// Consumes the builder and constructs a [`NullOperationInput`](crate::operation::null_operation::NullOperationInput).
     pub fn build(

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/null_operation/_null_operation_output.rs

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

↥ Expand context

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

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/operation_with_optional_input_output.rs

@@ -1,1 +40,46 @@

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

@@ -110,116 +243,241 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "OperationWithOptionalInputOutput",
             "Json Protocol",
         ));
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     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("OperationWithOptionalInputOutput")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(OperationWithOptionalInputOutputEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::operation_with_optional_input_output::OperationWithOptionalInputOutputError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::operation_with_optional_input_output::OperationWithOptionalInputOutputError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct OperationWithOptionalInputOutputResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for OperationWithOptionalInputOutputResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-162
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_operation_with_optional_input_output::de_operation_with_optional_input_output_http_error(
                 status, headers, body,
--
+            )
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::operation_with_optional_input_output::OperationWithOptionalInputOutputError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_operation_with_optional_input_output::de_operation_with_optional_input_output_http_response(
                 status, headers, body,
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, OperationWithOptionalInputOutput::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::operation_with_optional_input_output::OperationWithOptionalInputOutputOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-184
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
             .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))
-+
+        }
-190
+    }
-191
+}
 #[derive(Debug)]
 struct OperationWithOptionalInputOutputRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for OperationWithOptionalInputOutputRequestSerializer {
     #[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::operation_with_optional_input_output::OperationWithOptionalInputOutputInput>()
             .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::operation_with_optional_input_output::OperationWithOptionalInputOutputInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::operation_with_optional_input_output::OperationWithOptionalInputOutputInput,
                 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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonProtocol.OperationWithOptionalInputOutput",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_operation_with_optional_input_output::ser_operation_with_optional_input_output_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, OperationWithOptionalInputOutput::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-212
+    }
-213
+}
 #[derive(Debug)]
 struct OperationWithOptionalInputOutputEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OperationWithOptionalInputOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OperationWithOptionalInputOutputEndpointParamsInterceptor"
-220
+    }
-221

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

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/operation_with_optional_input_output/_operation_with_optional_input_output_input.rs

@@ -1,1 +108,119 @@

↥ Expand context

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

     "aws.protocoltests.json.synthetic",
     "OperationWithOptionalInputOutputInput",
 );
 static OPERATIONWITHOPTIONALINPUTOUTPUTINPUT_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#OperationWithOptionalInputOutputInput$Value",
         "aws.protocoltests.json.synthetic",
         "OperationWithOptionalInputOutputInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "value",
     "Value",
 ,
 );
 static OPERATIONWITHOPTIONALINPUTOUTPUTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     OPERATIONWITHOPTIONALINPUTOUTPUTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&OPERATIONWITHOPTIONALINPUTOUTPUTINPUT_MEMBER_VALUE],
 );
 impl OperationWithOptionalInputOutputInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OPERATIONWITHOPTIONALINPUTOUTPUTINPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for OperationWithOptionalInputOutputInput {
     #[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.value {
             ser.write_string(&OPERATIONWITHOPTIONALINPUTOUTPUTINPUT_MEMBER_VALUE, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl OperationWithOptionalInputOutputInput {
     /// 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(&OPERATIONWITHOPTIONALINPUTOUTPUTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&OPERATIONWITHOPTIONALINPUTOUTPUTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.value = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl OperationWithOptionalInputOutputInput {
     /// 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 OperationWithOptionalInputOutputInput {
     /// Creates a new builder-style object to manufacture [`OperationWithOptionalInputOutputInput`](crate::operation::operation_with_optional_input_output::OperationWithOptionalInputOutputInput).
     pub fn builder() -> crate::operation::operation_with_optional_input_output::builders::OperationWithOptionalInputOutputInputBuilder {
         crate::operation::operation_with_optional_input_output::builders::OperationWithOptionalInputOutputInputBuilder::default()
-94
+    }
-95
+}
-96
 /// A builder for [`OperationWithOptionalInputOutputInput`](crate::operation::operation_with_optional_input_output::OperationWithOptionalInputOutputInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct OperationWithOptionalInputOutputInputBuilder {
     pub(crate) value: ::std::option::Option<::std::string::String>,
-102
+}
 impl OperationWithOptionalInputOutputInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn value(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.value = ::std::option::Option::Some(input.into());
         self
-108
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_value(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.value = input;
         self
-113
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_value(&self) -> &::std::option::Option<::std::string::String> {
         &self.value
-117
+    }
     /// Consumes the builder and constructs a [`OperationWithOptionalInputOutputInput`](crate::operation::operation_with_optional_input_output::OperationWithOptionalInputOutputInput).
     pub fn build(

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/operation_with_optional_input_output/_operation_with_optional_input_output_output.rs

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

↥ Expand context

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

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

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/put_and_get_inline_documents.rs

@@ -1,1 +40,46 @@

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

@@ -110,116 +239,241 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "PutAndGetInlineDocuments",
             "Json Protocol",
         ));
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     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("PutAndGetInlineDocuments")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutAndGetInlineDocumentsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct PutAndGetInlineDocumentsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutAndGetInlineDocumentsResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-162
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_put_and_get_inline_documents::de_put_and_get_inline_documents_http_error(status, headers, body)
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_put_and_get_inline_documents::de_put_and_get_inline_documents_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, PutAndGetInlineDocuments::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::put_and_get_inline_documents::PutAndGetInlineDocumentsOutput::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))
-+
+        }
-190
+    }
-191
+}
 #[derive(Debug)]
 struct PutAndGetInlineDocumentsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutAndGetInlineDocumentsRequestSerializer {
     #[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::put_and_get_inline_documents::PutAndGetInlineDocumentsInput>()
             .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::put_and_get_inline_documents::PutAndGetInlineDocumentsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsInput,
                 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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonProtocol.PutAndGetInlineDocuments",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_put_and_get_inline_documents::ser_put_and_get_inline_documents_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, PutAndGetInlineDocuments::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-212
+    }
-213
+}
 #[derive(Debug)]
 struct PutAndGetInlineDocumentsEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutAndGetInlineDocumentsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutAndGetInlineDocumentsEndpointParamsInterceptor"
-220
+    }
-221

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

@@ -307,309 +367,379 @@

↥ Expand context

                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.1")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"inlineDocument\": {\"foo\": \"bar\"}\n}",
                 ))
                 .unwrap(),
-320
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-324
         let op = crate::operation::put_and_get_inline_documents::PutAndGetInlineDocuments::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");
-330
         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_json_rpc::AwsJsonRpcProtocol::aws_json_1_1("JsonProtocol"),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.inline_document,
             expected_output.inline_document,
             "Unexpected value for `inline_document`"
         );

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/put_and_get_inline_documents/_put_and_get_inline_documents_input.rs

@@ -1,1 +108,119 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutAndGetInlineDocumentsInput {
     #[allow(missing_docs)] // documentation missing in model
     pub inline_document: ::std::option::Option<::aws_smithy_types::Document>,
-8
+}
 impl PutAndGetInlineDocumentsInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn inline_document(&self) -> ::std::option::Option<&::aws_smithy_types::Document> {
         self.inline_document.as_ref()
-13
+    }
-14
+}
 static PUTANDGETINLINEDOCUMENTSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.json.synthetic#PutAndGetInlineDocumentsInput",

     "aws.protocoltests.json.synthetic",
     "PutAndGetInlineDocumentsInput",
 );
 static PUTANDGETINLINEDOCUMENTSINPUT_MEMBER_INLINE_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#PutAndGetInlineDocumentsInput$inlineDocument",
         "aws.protocoltests.json.synthetic",
         "PutAndGetInlineDocumentsInput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "inline_document",
     "inlineDocument",
 ,
 );
 static PUTANDGETINLINEDOCUMENTSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTANDGETINLINEDOCUMENTSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTANDGETINLINEDOCUMENTSINPUT_MEMBER_INLINE_DOCUMENT],
 );
 impl PutAndGetInlineDocumentsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTANDGETINLINEDOCUMENTSINPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutAndGetInlineDocumentsInput {
     #[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.inline_document {
             ser.write_document(&PUTANDGETINLINEDOCUMENTSINPUT_MEMBER_INLINE_DOCUMENT, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl PutAndGetInlineDocumentsInput {
     /// 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(&PUTANDGETINLINEDOCUMENTSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTANDGETINLINEDOCUMENTSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.inline_document = Some(deser.read_document(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl PutAndGetInlineDocumentsInput {
     /// 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 PutAndGetInlineDocumentsInput {
     /// Creates a new builder-style object to manufacture [`PutAndGetInlineDocumentsInput`](crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsInput).
     pub fn builder() -> crate::operation::put_and_get_inline_documents::builders::PutAndGetInlineDocumentsInputBuilder {
         crate::operation::put_and_get_inline_documents::builders::PutAndGetInlineDocumentsInputBuilder::default()
-94
+    }
-95
+}
-96
 /// A builder for [`PutAndGetInlineDocumentsInput`](crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PutAndGetInlineDocumentsInputBuilder {
     pub(crate) inline_document: ::std::option::Option<::aws_smithy_types::Document>,
-102
+}
 impl PutAndGetInlineDocumentsInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn inline_document(mut self, input: ::aws_smithy_types::Document) -> Self {
         self.inline_document = ::std::option::Option::Some(input);
         self
-108
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_inline_document(mut self, input: ::std::option::Option<::aws_smithy_types::Document>) -> Self {
         self.inline_document = input;
         self
-113
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_inline_document(&self) -> &::std::option::Option<::aws_smithy_types::Document> {
         &self.inline_document
-117
+    }
     /// Consumes the builder and constructs a [`PutAndGetInlineDocumentsInput`](crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsInput).
     pub fn build(

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/put_and_get_inline_documents/_put_and_get_inline_documents_output.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutAndGetInlineDocumentsOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub inline_document: ::std::option::Option<::aws_smithy_types::Document>,
-8
+}
 impl PutAndGetInlineDocumentsOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn inline_document(&self) -> ::std::option::Option<&::aws_smithy_types::Document> {
         self.inline_document.as_ref()
-13
+    }
-14
+}
 static PUTANDGETINLINEDOCUMENTSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.json.synthetic#PutAndGetInlineDocumentsOutput",

     "aws.protocoltests.json.synthetic",
     "PutAndGetInlineDocumentsOutput",
 );
 static PUTANDGETINLINEDOCUMENTSOUTPUT_MEMBER_INLINE_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json.synthetic#PutAndGetInlineDocumentsOutput$inlineDocument",
         "aws.protocoltests.json.synthetic",
         "PutAndGetInlineDocumentsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "inline_document",
     "inlineDocument",
 ,
 );
 static PUTANDGETINLINEDOCUMENTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTANDGETINLINEDOCUMENTSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTANDGETINLINEDOCUMENTSOUTPUT_MEMBER_INLINE_DOCUMENT],
 );
 impl PutAndGetInlineDocumentsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTANDGETINLINEDOCUMENTSOUTPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutAndGetInlineDocumentsOutput {
     #[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.inline_document {
             ser.write_document(&PUTANDGETINLINEDOCUMENTSOUTPUT_MEMBER_INLINE_DOCUMENT, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl PutAndGetInlineDocumentsOutput {
     /// 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(&PUTANDGETINLINEDOCUMENTSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTANDGETINLINEDOCUMENTSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.inline_document = Some(deser.read_document(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl PutAndGetInlineDocumentsOutput {
     /// 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 PutAndGetInlineDocumentsOutput {
     /// Creates a new builder-style object to manufacture [`PutAndGetInlineDocumentsOutput`](crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsOutput).
     pub fn builder() -> crate::operation::put_and_get_inline_documents::builders::PutAndGetInlineDocumentsOutputBuilder {
         crate::operation::put_and_get_inline_documents::builders::PutAndGetInlineDocumentsOutputBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`PutAndGetInlineDocumentsOutput`](crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PutAndGetInlineDocumentsOutputBuilder {
     pub(crate) inline_document: ::std::option::Option<::aws_smithy_types::Document>,
-100
+}
 impl PutAndGetInlineDocumentsOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn inline_document(mut self, input: ::aws_smithy_types::Document) -> Self {
         self.inline_document = ::std::option::Option::Some(input);
         self
-106
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_inline_document(mut self, input: ::std::option::Option<::aws_smithy_types::Document>) -> Self {
         self.inline_document = input;
         self
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_inline_document(&self) -> &::std::option::Option<::aws_smithy_types::Document> {
         &self.inline_document
-115
+    }
     /// Consumes the builder and constructs a [`PutAndGetInlineDocumentsOutput`](crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsOutput).
     pub fn build(self) -> crate::operation::put_and_get_inline_documents::PutAndGetInlineDocumentsOutput {

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/put_with_content_encoding.rs

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

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

@@ -110,114 +239,269 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "PutWithContentEncoding",
             "Json Protocol",
         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutWithContentEncoding")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutWithContentEncodingEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_with_content_encoding::PutWithContentEncodingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::put_with_content_encoding::PutWithContentEncodingError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct PutWithContentEncodingResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutWithContentEncodingResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-160
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_error(status, headers, body)
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::put_with_content_encoding::PutWithContentEncodingError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_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, PutWithContentEncoding::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::put_with_content_encoding::PutWithContentEncodingOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct PutWithContentEncodingRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutWithContentEncodingRequestSerializer {
     #[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::put_with_content_encoding::PutWithContentEncodingInput>()
             .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::put_with_content_encoding::PutWithContentEncodingInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, PutWithContentEncoding::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.encoding {
                     request.headers_mut().insert("Content-Encoding", val.to_string());
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-+
+                }
                 request.set_uri(uri.as_str()).expect("valid URI");
-+
+            }
-+
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, PutWithContentEncoding::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-239
+        }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_with_content_encoding::PutWithContentEncodingInput,
                 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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonProtocol.PutWithContentEncoding",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_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())
-240
+    }
-241
+}
 #[derive(Debug)]
 struct PutWithContentEncodingEndpointParamsInterceptor;
-244
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutWithContentEncodingEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutWithContentEncodingEndpointParamsInterceptor"
-248
+    }
-249

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

Client Test

Files changed: