Client Test

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_lists/_xml_lists_output.rs

@@ -103,103 +299,299 @@

     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.flattened_list_with_member_namespace.is_none()`.
     pub fn flattened_list_with_member_namespace(&self) -> &[::std::string::String] {
         self.flattened_list_with_member_namespace.as_deref().unwrap_or_default()
-107
+    }
     #[allow(missing_docs)] // documentation missing in model
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.flattened_list_with_namespace.is_none()`.
     pub fn flattened_list_with_namespace(&self) -> &[::std::string::String] {
         self.flattened_list_with_namespace.as_deref().unwrap_or_default()
-113
+    }
     #[allow(missing_docs)] // documentation missing in model
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.structure_list.is_none()`.
     pub fn structure_list(&self) -> &[crate::types::StructureListMember] {
         self.structure_list.as_deref().unwrap_or_default()
-119
+    }
-120
+}
 static XMLLISTSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.ec2.synthetic#XmlListsOutput",

     "aws.protocoltests.ec2.synthetic",
     "XmlListsOutput",
 );
 static XMLLISTSOUTPUT_MEMBER_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$stringList",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_list",
     "stringList",
 ,
 );
 static XMLLISTSOUTPUT_MEMBER_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$stringSet",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_set",
     "stringSet",
 ,
 );
 static XMLLISTSOUTPUT_MEMBER_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$integerList",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "integer_list",
     "integerList",
 ,
 );
 static XMLLISTSOUTPUT_MEMBER_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$booleanList",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "boolean_list",
     "booleanList",
 ,
 );
 static XMLLISTSOUTPUT_MEMBER_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$timestampList",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "timestamp_list",
     "timestampList",
 ,
 );
 static XMLLISTSOUTPUT_MEMBER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$enumList",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "enum_list",
     "enumList",
 ,
 );
 static XMLLISTSOUTPUT_MEMBER_INT_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$intEnumList",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "int_enum_list",
     "intEnumList",
 ,
 );
 static XMLLISTSOUTPUT_MEMBER_NESTED_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$nestedStringList",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "nested_string_list",
     "nestedStringList",
 ,
 );
 static XMLLISTSOUTPUT_MEMBER_RENAMED_LIST_MEMBERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$renamedListMembers",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "renamed_list_members",
     "renamedListMembers",
 ,
-215
+)
 .with_xml_name("renamed");
 static XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$flattenedList",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "flattened_list",
     "flattenedList",
 ,
-226
+)
 .with_xml_flattened();
 static XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST2: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$flattenedList2",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "flattened_list2",
     "flattenedList2",
 ,
-237
+)
 .with_xml_name("customName")
 .with_xml_flattened();
 static XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST_WITH_MEMBER_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$flattenedListWithMemberNamespace",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "flattened_list_with_member_namespace",
     "flattenedListWithMemberNamespace",
 ,
-249
+)
 .with_xml_flattened();
 static XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST_WITH_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$flattenedListWithNamespace",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "flattened_list_with_namespace",
     "flattenedListWithNamespace",
 ,
-260
+)
 .with_xml_flattened();
 static XMLLISTSOUTPUT_MEMBER_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2.synthetic#XmlListsOutput$structureList",
         "aws.protocoltests.ec2.synthetic",
         "XmlListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "structure_list",
     "structureList",
 ,
-271
+)
 .with_xml_name("myStructureList");
 static XMLLISTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     XMLLISTSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &XMLLISTSOUTPUT_MEMBER_STRING_LIST,
         &XMLLISTSOUTPUT_MEMBER_STRING_SET,
         &XMLLISTSOUTPUT_MEMBER_INTEGER_LIST,

↧ Expand context

         &XMLLISTSOUTPUT_MEMBER_BOOLEAN_LIST,
         &XMLLISTSOUTPUT_MEMBER_TIMESTAMP_LIST,
         &XMLLISTSOUTPUT_MEMBER_ENUM_LIST,
         &XMLLISTSOUTPUT_MEMBER_INT_ENUM_LIST,
         &XMLLISTSOUTPUT_MEMBER_NESTED_STRING_LIST,
         &XMLLISTSOUTPUT_MEMBER_RENAMED_LIST_MEMBERS,
         &XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST,
         &XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST2,
         &XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST_WITH_MEMBER_NAMESPACE,
         &XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST_WITH_NAMESPACE,
         &XMLLISTSOUTPUT_MEMBER_STRUCTURE_LIST,
     ],
 );
 impl XmlListsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLLISTSOUTPUT_SCHEMA;
-296
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for XmlListsOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(

@@ -355,355 +415,423 @@

↥ Expand context

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

-375
+                    }
                     Ok(())
                 },
             )?;
-379
+        }
         if let Some(ref val) = self.nested_string_list {
             ser.write_list(
                 &XMLLISTSOUTPUT_MEMBER_NESTED_STRING_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_list(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in item {
                                     ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-394
+                    }
                     Ok(())
                 },
             )?;
-398
+        }
         if let Some(ref val) = self.renamed_list_members {
             ser.write_list(
                 &XMLLISTSOUTPUT_MEMBER_RENAMED_LIST_MEMBERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {

↧ Expand context

                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-405
+                    }
                     Ok(())
                 },
             )?;
-409
+        }
         if let Some(ref val) = self.flattened_list {
             ser.write_list(
                 &XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-416
+                    }
                     Ok(())
                 },
             )?;
-420
+        }
         if let Some(ref val) = self.flattened_list2 {
             ser.write_list(
                 &XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST2,

@@ -432,440 +694,615 @@

↥ Expand context

                 },
             )?;
-442
+        }
         if let Some(ref val) = self.flattened_list_with_namespace {
             ser.write_list(
                 &XMLLISTSOUTPUT_MEMBER_FLATTENED_LIST_WITH_NAMESPACE,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-449
+                    }
                     Ok(())
                 },
             )?;
-453
+        }
         if let Some(ref val) = self.structure_list {
             ser.write_list(
                 &XMLLISTSOUTPUT_MEMBER_STRUCTURE_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::StructureListMember::SCHEMA, item)?;

-460
+                    }
                     Ok(())
                 },
             )?;
-464
+        }
         Ok(())
-466
+    }
-467
+}
 impl XmlListsOutput {
     /// 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(&XMLLISTSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&XMLLISTSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.string_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.string_list = Some(deser.read_string_list(member)?);
-486
+                }
                 Some(1) => {
                     builder.string_set = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.string_set = Some(deser.read_string_list(member)?);
-489
+                }
                 Some(2) => {
                     builder.integer_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.integer_list = Some(deser.read_integer_list(member)?);
-492
+                }
                 Some(3) => {
                     builder.boolean_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_boolean(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_boolean(member)?);
                             Ok(())
                         })?;
                         container
                     });
-502
+                }
                 Some(4) => {
                     builder.timestamp_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_timestamp(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_timestamp(member)?);
                             Ok(())
                         })?;
                         container
                     });
-512
+                }
                 Some(5) => {
                     builder.enum_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-522
+                }
                 Some(6) => {
                     builder.int_enum_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.int_enum_list = Some(deser.read_integer_list(member)?);
-525
+                }
                 Some(7) => {
                     builder.nested_string_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push({
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-542
+                }
                 Some(8) => {
                     builder.renamed_list_members = 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.renamed_list_members = Some(deser.read_string_list(member)?);
-545
+                }
                 Some(9) => {
                     builder.flattened_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.flattened_list = Some(deser.read_string_list(member)?);
-548
+                }
                 Some(10) => {
                     builder.flattened_list2 = 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.flattened_list2 = Some(deser.read_string_list(member)?);
-551
+                }
                 Some(11) => {
                     builder.flattened_list_with_member_namespace = 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.flattened_list_with_member_namespace = Some(deser.read_string_list(member)?);
-554
+                }
                 Some(12) => {
                     builder.flattened_list_with_namespace = 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.flattened_list_with_namespace = Some(deser.read_string_list(member)?);
-557
+                }
                 Some(13) => {
                     builder.structure_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::StructureListMember::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::StructureListMember::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-567
+                }
                 _ => {}
-569
+            }
             Ok(())
         })?;
         Ok(builder.build())
-573
+    }
-574
+}
 impl XmlListsOutput {
     /// 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 XmlListsOutput {
     /// Creates a new builder-style object to manufacture [`XmlListsOutput`](crate::operation::xml_lists::XmlListsOutput).
     pub fn builder() -> crate::operation::xml_lists::builders::XmlListsOutputBuilder {
         crate::operation::xml_lists::builders::XmlListsOutputBuilder::default()
-590
+    }
-591
+}
-592
 /// A builder for [`XmlListsOutput`](crate::operation::xml_lists::XmlListsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct XmlListsOutputBuilder {
     pub(crate) string_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) string_set: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) integer_list: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) boolean_list: ::std::option::Option<::std::vec::Vec<bool>>,
     pub(crate) timestamp_list: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::DateTime>>,
     pub(crate) enum_list: ::std::option::Option<::std::vec::Vec<crate::types::FooEnum>>,
     pub(crate) int_enum_list: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) nested_string_list: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,
     pub(crate) renamed_list_members: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) flattened_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) flattened_list2: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) flattened_list_with_member_namespace: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) flattened_list_with_namespace: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) structure_list: ::std::option::Option<::std::vec::Vec<crate::types::StructureListMember>>,
-611
+}
 impl XmlListsOutputBuilder {
     /// Appends an item to `string_list`.
     ///
     /// To override the contents of this collection use [`set_string_list`](Self::set_string_list).

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_namespaces.rs

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

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

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

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "XmlNamespaces",
             "EC2 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("XmlNamespaces")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(XmlNamespacesEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::xml_namespaces::XmlNamespacesError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::xml_namespaces::XmlNamespacesError,
             >::new());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct XmlNamespacesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for XmlNamespacesResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-148
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_xml_namespaces::de_xml_namespaces_http_error(status, headers, body)
         } else {

↧ Expand context

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

@@ -244,249 +304,313 @@

↥ Expand context

             .set_nested(::std::option::Option::Some(
                 crate::types::XmlNamespaceNested::builder()
                     .set_foo(::std::option::Option::Some("Foo".to_owned()))
                     .set_values(::std::option::Option::Some(vec!["Bar".to_owned(), "Baz".to_owned()]))
                     .build(),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlNamespacesResponse xmlns=\"https://example.com/\">\n    <nested>\n        <foo xmlns:baz=\"http://baz.com\">Foo</foo>\n        <values xmlns=\"http://qux.com\">\n            <member xmlns=\"http://bux.com\">Bar</member>\n            <member xmlns=\"http://bux.com\">Baz</member>\n        </values>\n    </nested>\n    <requestId>requestid</requestId>\n</XmlNamespacesResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-264
         let op = crate::operation::xml_namespaces::XmlNamespaces::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");
-270
         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/xml"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_namespaces::XmlNamespacesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
-290
+    }
-291
+}
-292
 /// Error type for the `XmlNamespacesError` operation.

↧ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum XmlNamespacesError {
     /// 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()`:
-300
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-302
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-XmlNamespacesError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-305
+}
 impl XmlNamespacesError {
     /// Creates the `XmlNamespacesError::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/ec2_query/rust-client-codegen/src/operation/xml_namespaces/_xml_namespaces_input.rs

@@ -1,1 +69,82 @@

↥ 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 XmlNamespacesInput {}
 static XMLNAMESPACESINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.ec2.synthetic#XmlNamespacesInput",
     "aws.protocoltests.ec2.synthetic",
     "XmlNamespacesInput",
 );
 static XMLNAMESPACESINPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(XMLNAMESPACESINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl XmlNamespacesInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLNAMESPACESINPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for XmlNamespacesInput {

     #[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> {
         Ok(())
-24
+    }
-25
+}
 impl XmlNamespacesInput {
     /// 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(&XMLNAMESPACESINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&XMLNAMESPACESINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-43
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-49
+    }
-50
+}
 impl XmlNamespacesInput {
     /// 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::builder()
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl XmlNamespacesInput {
     /// Creates a new builder-style object to manufacture [`XmlNamespacesInput`](crate::operation::xml_namespaces::XmlNamespacesInput).
     pub fn builder() -> crate::operation::xml_namespaces::builders::XmlNamespacesInputBuilder {
         crate::operation::xml_namespaces::builders::XmlNamespacesInputBuilder::default()
-68
+    }
-69
+}
-70
 /// A builder for [`XmlNamespacesInput`](crate::operation::xml_namespaces::XmlNamespacesInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct XmlNamespacesInputBuilder {}
 impl XmlNamespacesInputBuilder {
     /// Consumes the builder and constructs a [`XmlNamespacesInput`](crate::operation::xml_namespaces::XmlNamespacesInput).
     pub fn build(
         self,
     ) -> ::std::result::Result<crate::operation::xml_namespaces::XmlNamespacesInput, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::operation::xml_namespaces::XmlNamespacesInput {})
-81
+    }
-82
+}

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_namespaces/_xml_namespaces_output.rs

@@ -24,24 +107,118 @@

↥ Expand context

         "XmlNamespacesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "nested",
 ,
 );
 static XMLNAMESPACESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     XMLNAMESPACESOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&XMLNAMESPACESOUTPUT_MEMBER_NESTED],
-34
+)
 .with_xml_namespace();
 impl XmlNamespacesOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLNAMESPACESOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for XmlNamespacesOutput {
     #[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.nested {
             ser.write_struct(&XMLNAMESPACESOUTPUT_MEMBER_NESTED, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl XmlNamespacesOutput {
     /// 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(&XMLNAMESPACESOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&XMLNAMESPACESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.nested = Some(crate::types::XmlNamespaceNested::deserialize(deser)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl XmlNamespacesOutput {
     /// 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 XmlNamespacesOutput {
     /// Creates a new builder-style object to manufacture [`XmlNamespacesOutput`](crate::operation::xml_namespaces::XmlNamespacesOutput).
     pub fn builder() -> crate::operation::xml_namespaces::builders::XmlNamespacesOutputBuilder {
         crate::operation::xml_namespaces::builders::XmlNamespacesOutputBuilder::default()
-93
+    }
-94
+}
-95
 /// A builder for [`XmlNamespacesOutput`](crate::operation::xml_namespaces::XmlNamespacesOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct XmlNamespacesOutputBuilder {
     pub(crate) nested: ::std::option::Option<crate::types::XmlNamespaceNested>,
-101
+}
 impl XmlNamespacesOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(mut self, input: crate::types::XmlNamespaceNested) -> Self {
         self.nested = ::std::option::Option::Some(input);
         self
-107
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_nested(mut self, input: ::std::option::Option<crate::types::XmlNamespaceNested>) -> Self {
         self.nested = input;
         self
-112
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_nested(&self) -> &::std::option::Option<crate::types::XmlNamespaceNested> {
         &self.nested
-116
+    }
     /// Consumes the builder and constructs a [`XmlNamespacesOutput`](crate::operation::xml_namespaces::XmlNamespacesOutput).
     pub fn build(self) -> crate::operation::xml_namespaces::XmlNamespacesOutput {

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_timestamps.rs

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

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

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

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "XmlTimestamps",
             "EC2 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("XmlTimestamps")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(XmlTimestampsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::xml_timestamps::XmlTimestampsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::xml_timestamps::XmlTimestampsError,
             >::new());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct XmlTimestampsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for XmlTimestampsResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-148
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_xml_timestamps::de_xml_timestamps_http_error(status, headers, body)
         } else {

↧ Expand context

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

@@ -241,246 +301,310 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_normal(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <normal>2014-04-29T18:30:38Z</normal>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-261
         let op = crate::operation::xml_timestamps::XmlTimestamps::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");
-267
         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/xml"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

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

@@ -305,314 +365,378 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_date_time_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <dateTime>2014-04-29T18:30:38Z</dateTime>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-329
         let op = crate::operation::xml_timestamps::XmlTimestamps::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");
-335
         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/xml"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

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

@@ -369,382 +429,446 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_date_time_on_target_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_date_time_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <dateTimeOnTarget>2014-04-29T18:30:38Z</dateTimeOnTarget>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-397
         let op = crate::operation::xml_timestamps::XmlTimestamps::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");
-403
         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/xml"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

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

@@ -433,450 +493,514 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_epoch_seconds_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <epochSeconds>1398796238</epochSeconds>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-465
         let op = crate::operation::xml_timestamps::XmlTimestamps::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");
-471
         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/xml"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

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

@@ -497,518 +557,582 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_epoch_seconds_on_target_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_epoch_seconds_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <epochSecondsOnTarget>1398796238</epochSecondsOnTarget>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-533
         let op = crate::operation::xml_timestamps::XmlTimestamps::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");
-539
         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/xml"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

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

@@ -561,586 +621,650 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_http_date_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <httpDate>Tue, 29 Apr 2014 18:30:38 GMT</httpDate>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-601
         let op = crate::operation::xml_timestamps::XmlTimestamps::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");
-607
         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/xml"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

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

@@ -625,654 +685,718 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_http_date_on_target_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_http_date_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <httpDateOnTarget>Tue, 29 Apr 2014 18:30:38 GMT</httpDateOnTarget>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-669
         let op = crate::operation::xml_timestamps::XmlTimestamps::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");
-675
         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/xml"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_timestamps/_xml_timestamps_input.rs

@@ -1,1 +69,82 @@

↥ 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 XmlTimestampsInput {}
 static XMLTIMESTAMPSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.ec2.synthetic#XmlTimestampsInput",
     "aws.protocoltests.ec2.synthetic",
     "XmlTimestampsInput",
 );
 static XMLTIMESTAMPSINPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(XMLTIMESTAMPSINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl XmlTimestampsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLTIMESTAMPSINPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for XmlTimestampsInput {

     #[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> {
         Ok(())
-24
+    }
-25
+}
 impl XmlTimestampsInput {
     /// 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(&XMLTIMESTAMPSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&XMLTIMESTAMPSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-43
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-49
+    }
-50
+}
 impl XmlTimestampsInput {
     /// 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::builder()
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl XmlTimestampsInput {
     /// Creates a new builder-style object to manufacture [`XmlTimestampsInput`](crate::operation::xml_timestamps::XmlTimestampsInput).
     pub fn builder() -> crate::operation::xml_timestamps::builders::XmlTimestampsInputBuilder {
         crate::operation::xml_timestamps::builders::XmlTimestampsInputBuilder::default()
-68
+    }
-69
+}
-70
 /// A builder for [`XmlTimestampsInput`](crate::operation::xml_timestamps::XmlTimestampsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct XmlTimestampsInputBuilder {}
 impl XmlTimestampsInputBuilder {
     /// Consumes the builder and constructs a [`XmlTimestampsInput`](crate::operation::xml_timestamps::XmlTimestampsInput).
     pub fn build(
         self,
     ) -> ::std::result::Result<crate::operation::xml_timestamps::XmlTimestampsInput, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::operation::xml_timestamps::XmlTimestampsInput {})
-81
+    }
-82
+}

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_timestamps/_xml_timestamps_output.rs

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

↥ Expand context

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

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

↧ Expand context

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

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

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

↥ Expand context

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

     "aws.protocoltests.ec2",
     "ComplexNestedErrorData",
 );
 static COMPLEXNESTEDERRORDATA_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2#ComplexNestedErrorData$Foo",
         "aws.protocoltests.ec2",
         "ComplexNestedErrorData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",
     "Foo",
 ,
 );
 static COMPLEXNESTEDERRORDATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COMPLEXNESTEDERRORDATA_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&COMPLEXNESTEDERRORDATA_MEMBER_FOO],
 );
 impl ComplexNestedErrorData {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COMPLEXNESTEDERRORDATA_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ComplexNestedErrorData {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.foo {
             ser.write_string(&COMPLEXNESTEDERRORDATA_MEMBER_FOO, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl ComplexNestedErrorData {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&COMPLEXNESTEDERRORDATA_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COMPLEXNESTEDERRORDATA_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl ComplexNestedErrorData {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ComplexNestedErrorData {
     /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
     pub fn builder() -> crate::types::builders::ComplexNestedErrorDataBuilder {
         crate::types::builders::ComplexNestedErrorDataBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

@@ -16,16 +99,110 @@

↥ Expand context

     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.shared#GreetingStruct", "aws.protocoltests.shared", "GreetingStruct");
 static GREETINGSTRUCT_MEMBER_HI: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.shared#GreetingStruct$hi", "aws.protocoltests.shared", "GreetingStruct"),
     ::aws_smithy_schema::ShapeType::String,
     "hi",
 ,
 );
 static GREETINGSTRUCT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GREETINGSTRUCT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GREETINGSTRUCT_MEMBER_HI],
 );
 impl GreetingStruct {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GREETINGSTRUCT_SCHEMA;
-31
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GreetingStruct {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.hi {
             ser.write_string(&GREETINGSTRUCT_MEMBER_HI, val)?;
-40
+        }
         Ok(())
-42
+    }
-43
+}
 impl GreetingStruct {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&GREETINGSTRUCT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GREETINGSTRUCT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.hi = Some(deser.read_string(member)?);
-62
+                }
                 _ => {}
-64
+            }
             Ok(())
         })?;
         Ok(builder.build())
-68
+    }
-69
+}
 impl GreetingStruct {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl GreetingStruct {
     /// Creates a new builder-style object to manufacture [`GreetingStruct`](crate::types::GreetingStruct).
     pub fn builder() -> crate::types::builders::GreetingStructBuilder {
         crate::types::builders::GreetingStructBuilder::default()
-85
+    }
-86
+}
-87
 /// A builder for [`GreetingStruct`](crate::types::GreetingStruct).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/types/_nested_struct_with_list.rs

@@ -1,1 +126,127 @@

↥ 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 NestedStructWithList {
     #[allow(missing_docs)] // documentation missing in model
     pub list_arg: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-8
+}
 impl NestedStructWithList {
     #[allow(missing_docs)] // documentation missing in model
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.list_arg.is_none()`.
     pub fn list_arg(&self) -> &[::std::string::String] {
         self.list_arg.as_deref().unwrap_or_default()
-15
+    }
-16
+}
 static NESTEDSTRUCTWITHLIST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.ec2#NestedStructWithList",

     "aws.protocoltests.ec2",
     "NestedStructWithList",
 );
 static NESTEDSTRUCTWITHLIST_MEMBER_LIST_ARG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.ec2#NestedStructWithList$ListArg",
         "aws.protocoltests.ec2",
         "NestedStructWithList",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "list_arg",
     "ListArg",
 ,
 );
 static NESTEDSTRUCTWITHLIST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     NESTEDSTRUCTWITHLIST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&NESTEDSTRUCTWITHLIST_MEMBER_LIST_ARG],
 );
 impl NestedStructWithList {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NESTEDSTRUCTWITHLIST_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for NestedStructWithList {
     #[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.list_arg {
             ser.write_list(
                 &NESTEDSTRUCTWITHLIST_MEMBER_LIST_ARG,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-53
+                    }
                     Ok(())
                 },
             )?;
-57
+        }
         Ok(())
-59
+    }
-60
+}
 impl NestedStructWithList {
     /// 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(&NESTEDSTRUCTWITHLIST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&NESTEDSTRUCTWITHLIST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.list_arg = 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_arg = Some(deser.read_string_list(member)?);
-79
+                }
                 _ => {}
-81
+            }
             Ok(())
         })?;
         Ok(builder.build())
-85
+    }
-86
+}
 impl NestedStructWithList {
     /// 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 NestedStructWithList {
     /// Creates a new builder-style object to manufacture [`NestedStructWithList`](crate::types::NestedStructWithList).
     pub fn builder() -> crate::types::builders::NestedStructWithListBuilder {
         crate::types::builders::NestedStructWithListBuilder::default()
-102
+    }
-103
+}
-104
 /// A builder for [`NestedStructWithList`](crate::types::NestedStructWithList).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct NestedStructWithListBuilder {
     pub(crate) list_arg: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-110
+}
 impl NestedStructWithListBuilder {
     /// Appends an item to `list_arg`.
     ///
     /// To override the contents of this collection use [`set_list_arg`](Self::set_list_arg).
     ///
     pub fn list_arg(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         let mut v = self.list_arg.unwrap_or_default();
         v.push(input.into());
         self.list_arg = ::std::option::Option::Some(v);
         self
-121
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_list_arg(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         self.list_arg = input;
         self
-126
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/types/_recursive_xml_shapes_output_nested1.rs

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

↥ Expand context

 );
 static RECURSIVEXMLSHAPESOUTPUTNESTED1_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RECURSIVEXMLSHAPESOUTPUTNESTED1_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RECURSIVEXMLSHAPESOUTPUTNESTED1_MEMBER_FOO,
         &RECURSIVEXMLSHAPESOUTPUTNESTED1_MEMBER_NESTED,
     ],
 );
 impl RecursiveXmlShapesOutputNested1 {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECURSIVEXMLSHAPESOUTPUTNESTED1_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RecursiveXmlShapesOutputNested1 {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.foo {

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

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/types/_recursive_xml_shapes_output_nested2.rs

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

↥ Expand context

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

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

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/types/_struct_arg.rs

@@ -2,2 +135,146 @@

↥ Expand context

 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct StructArg {
     #[allow(missing_docs)] // documentation missing in model
     pub string_arg: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub other_arg: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub recursive_arg: ::std::option::Option<::std::boxed::Box<crate::types::StructArg>>,
-12
+}
 impl StructArg {
     #[allow(missing_docs)] // documentation missing in model
     pub fn string_arg(&self) -> ::std::option::Option<&str> {
         self.string_arg.as_deref()
-17
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn other_arg(&self) -> ::std::option::Option<bool> {
         self.other_arg
-21
+    }

     #[allow(missing_docs)] // documentation missing in model
     pub fn recursive_arg(&self) -> ::std::option::Option<&crate::types::StructArg> {
         self.recursive_arg.as_deref()
-25
+    }
-26
+}
 static STRUCTARG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.ec2#StructArg", "aws.protocoltests.ec2", "StructArg");
 static STRUCTARG_MEMBER_STRING_ARG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.ec2#StructArg$StringArg", "aws.protocoltests.ec2", "StructArg"),
     ::aws_smithy_schema::ShapeType::String,
     "string_arg",
     "StringArg",
 ,
 );
 static STRUCTARG_MEMBER_OTHER_ARG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.ec2#StructArg$OtherArg", "aws.protocoltests.ec2", "StructArg"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "other_arg",
     "OtherArg",
 ,
 );
 static STRUCTARG_MEMBER_RECURSIVE_ARG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.ec2#StructArg$RecursiveArg", "aws.protocoltests.ec2", "StructArg"),
     ::aws_smithy_schema::ShapeType::Structure,
     "recursive_arg",
     "RecursiveArg",
 ,
 );
 static STRUCTARG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STRUCTARG_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STRUCTARG_MEMBER_STRING_ARG, &STRUCTARG_MEMBER_OTHER_ARG, &STRUCTARG_MEMBER_RECURSIVE_ARG],
 );
 impl StructArg {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STRUCTARG_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StructArg {
     #[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_arg {
             ser.write_string(&STRUCTARG_MEMBER_STRING_ARG, val)?;
-64
+        }
         if let Some(ref val) = self.other_arg {
             ser.write_boolean(&STRUCTARG_MEMBER_OTHER_ARG, *val)?;
-67
+        }
         if let Some(ref val) = self.recursive_arg {
             ser.write_struct(&STRUCTARG_MEMBER_RECURSIVE_ARG, val)?;
-70
+        }
         Ok(())
-72
+    }
-73
+}
 impl StructArg {
     /// 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(&STRUCTARG_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STRUCTARG_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.string_arg = Some(deser.read_string(member)?);
-92
+                }
                 Some(1) => {
                     builder.other_arg = Some(deser.read_boolean(member)?);
-95
+                }
                 Some(2) => {
                     builder.recursive_arg = Some(Box::new(crate::types::StructArg::deserialize(deser)?));
-98
+                }
                 _ => {}
-100
+            }
             Ok(())
         })?;
         Ok(builder.build())
-104
+    }
-105
+}
 impl StructArg {
     /// 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 StructArg {
     /// Creates a new builder-style object to manufacture [`StructArg`](crate::types::StructArg).
     pub fn builder() -> crate::types::builders::StructArgBuilder {
         crate::types::builders::StructArgBuilder::default()
-121
+    }
-122
+}
-123
 /// A builder for [`StructArg`](crate::types::StructArg).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StructArgBuilder {
     pub(crate) string_arg: ::std::option::Option<::std::string::String>,
     pub(crate) other_arg: ::std::option::Option<bool>,
     pub(crate) recursive_arg: ::std::option::Option<::std::boxed::Box<crate::types::StructArg>>,
-131
+}
 impl StructArgBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn string_arg(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.string_arg = ::std::option::Option::Some(input.into());
         self
-137
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_string_arg(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.string_arg = input;
         self
-142
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_string_arg(&self) -> &::std::option::Option<::std::string::String> {
         &self.string_arg
-146
+    }

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/types/_structure_list_member.rs

@@ -44,44 +130,141 @@

↥ Expand context

     "b",
 ,
-46
+)
 .with_xml_name("other");
 static STRUCTURELISTMEMBER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STRUCTURELISTMEMBER_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STRUCTURELISTMEMBER_MEMBER_A, &STRUCTURELISTMEMBER_MEMBER_B],
 );
 impl StructureListMember {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STRUCTURELISTMEMBER_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StructureListMember {
     #[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.a {

             ser.write_string(&STRUCTURELISTMEMBER_MEMBER_A, val)?;
-65
+        }
         if let Some(ref val) = self.b {
             ser.write_string(&STRUCTURELISTMEMBER_MEMBER_B, val)?;
-68
+        }
         Ok(())
-70
+    }
-71
+}
 impl StructureListMember {
     /// 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(&STRUCTURELISTMEMBER_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STRUCTURELISTMEMBER_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.a = Some(deser.read_string(member)?);
-90
+                }
                 Some(1) => {
                     builder.b = Some(deser.read_string(member)?);
-93
+                }
                 _ => {}
-95
+            }
             Ok(())
         })?;
         Ok(builder.build())
-99
+    }
-100
+}
 impl StructureListMember {
     /// 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 StructureListMember {
     /// Creates a new builder-style object to manufacture [`StructureListMember`](crate::types::StructureListMember).
     pub fn builder() -> crate::types::builders::StructureListMemberBuilder {
         crate::types::builders::StructureListMemberBuilder::default()
-116
+    }
-117
+}
-118
 /// A builder for [`StructureListMember`](crate::types::StructureListMember).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StructureListMemberBuilder {
     pub(crate) a: ::std::option::Option<::std::string::String>,
     pub(crate) b: ::std::option::Option<::std::string::String>,
-125
+}
 impl StructureListMemberBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn a(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.a = ::std::option::Option::Some(input.into());
         self
-131
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_a(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.a = input;
         self
-136
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_a(&self) -> &::std::option::Option<::std::string::String> {
         &self.a
-140
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/types/_xml_namespace_nested.rs

@@ -52,52 +148,149 @@

↥ Expand context

 .with_xml_namespace();
 impl XmlNamespaceNested {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLNAMESPACENESTED_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for XmlNamespaceNested {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.foo {
             ser.write_string(&XMLNAMESPACENESTED_MEMBER_FOO, val)?;
-65
+        }
         if let Some(ref val) = self.values {
             ser.write_list(
                 &XMLNAMESPACENESTED_MEMBER_VALUES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;

-72
+                    }
                     Ok(())
                 },
             )?;
-76
+        }
         Ok(())
-78
+    }
-79
+}
 impl XmlNamespaceNested {
     /// 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(&XMLNAMESPACENESTED_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&XMLNAMESPACENESTED_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-98
+                }
                 Some(1) => {
                     builder.values = 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.values = Some(deser.read_string_list(member)?);
-101
+                }
                 _ => {}
-103
+            }
             Ok(())
         })?;
         Ok(builder.build())
-107
+    }
-108
+}
 impl XmlNamespaceNested {
     /// 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 XmlNamespaceNested {
     /// Creates a new builder-style object to manufacture [`XmlNamespaceNested`](crate::types::XmlNamespaceNested).
     pub fn builder() -> crate::types::builders::XmlNamespaceNestedBuilder {
         crate::types::builders::XmlNamespaceNestedBuilder::default()
-124
+    }
-125
+}
-126
 /// A builder for [`XmlNamespaceNested`](crate::types::XmlNamespaceNested).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct XmlNamespaceNestedBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) values: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-133
+}
 impl XmlNamespaceNestedBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-139
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-144
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-148
+    }
     /// Appends an item to `values`.

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/types/error/_complex_error.rs

@@ -1,1 +119,130 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// This error is thrown when a request is invalid.
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ComplexError {
     #[allow(missing_docs)] // documentation missing in model
     pub top_level: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub nested: ::std::option::Option<crate::types::ComplexNestedErrorData>,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
-12
+}
 impl ComplexError {
     #[allow(missing_docs)] // documentation missing in model
     pub fn top_level(&self) -> ::std::option::Option<&str> {
         self.top_level.as_deref()
-17
+    }

     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(&self) -> ::std::option::Option<&crate::types::ComplexNestedErrorData> {
         self.nested.as_ref()
-21
+    }
-22
+}
 static COMPLEXERROR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.ec2#ComplexError", "aws.protocoltests.ec2", "ComplexError");
 static COMPLEXERROR_MEMBER_TOP_LEVEL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.ec2#ComplexError$TopLevel", "aws.protocoltests.ec2", "ComplexError"),
     ::aws_smithy_schema::ShapeType::String,
     "top_level",
     "TopLevel",
 ,
 );
 static COMPLEXERROR_MEMBER_NESTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.ec2#ComplexError$Nested", "aws.protocoltests.ec2", "ComplexError"),
     ::aws_smithy_schema::ShapeType::Structure,
     "nested",
     "Nested",
 ,
 );
 static COMPLEXERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COMPLEXERROR_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&COMPLEXERROR_MEMBER_TOP_LEVEL, &COMPLEXERROR_MEMBER_NESTED],
 );
 impl ComplexError {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COMPLEXERROR_SCHEMA;
-45
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ComplexError {
     #[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.top_level {
             ser.write_string(&COMPLEXERROR_MEMBER_TOP_LEVEL, val)?;
-54
+        }
         if let Some(ref val) = self.nested {
             ser.write_struct(&COMPLEXERROR_MEMBER_NESTED, val)?;
-57
+        }
         Ok(())
-59
+    }
-60
+}
 impl ComplexError {
     /// 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(&COMPLEXERROR_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COMPLEXERROR_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.top_level = Some(deser.read_string(member)?);
-79
+                }
                 Some(1) => {
                     builder.nested = Some(crate::types::ComplexNestedErrorData::deserialize(deser)?);
-82
+                }
                 _ => {}
-84
+            }
             Ok(())
         })?;
         Ok(builder.build())
-88
+    }
-89
+}
 impl ComplexError {
     /// 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 ComplexError {}
 impl ::std::fmt::Display for ComplexError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ComplexError")?;
         Ok(())
-106
+    }
-107
+}
 impl ::std::error::Error for ComplexError {}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for ComplexError {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {

↧ Expand context

         &self.meta
-112
+    }
-113
+}
 impl ComplexError {
     /// Creates a new builder-style object to manufacture [`ComplexError`](crate::types::error::ComplexError).
     pub fn builder() -> crate::types::error::builders::ComplexErrorBuilder {
         crate::types::error::builders::ComplexErrorBuilder::default()
-118
+    }
-119
+}
-120
 /// A builder for [`ComplexError`](crate::types::error::ComplexError).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ComplexErrorBuilder {
     pub(crate) top_level: ::std::option::Option<::std::string::String>,
     pub(crate) nested: ::std::option::Option<crate::types::ComplexNestedErrorData>,
     meta: std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
-128
+}
 impl ComplexErrorBuilder {
     #[allow(missing_docs)] // documentation missing in model

Client Test

Files changed: