Client Test

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/start_snapshot/_start_snapshot_input.rs

@@ -87,87 +337,347 @@

     pub fn description(&self) -> ::std::option::Option<&str> {
         self.description.as_deref()
-89
+    }
-90
+}
 impl ::std::fmt::Debug for StartSnapshotInput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("StartSnapshotInput");
         formatter.field("timeout", &self.timeout);
         formatter.field("client_token", &self.client_token);
         formatter.field("volume_size", &self.volume_size);
         formatter.field("tags", &self.tags);
         formatter.field("encrypted", &self.encrypted);
         formatter.field("kms_key_arn", &"*** Sensitive Data Redacted ***");
         formatter.field("parent_snapshot_id", &self.parent_snapshot_id);
         formatter.field("description", &self.description);
         formatter.finish()
-103
+    }
-104
+}
 static STARTSNAPSHOTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#StartSnapshotInput",

     "com.amazonaws.ebs.synthetic",
     "StartSnapshotInput",
 );
 static STARTSNAPSHOTINPUT_MEMBER_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotInput$Timeout",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "timeout",
     "Timeout",
 ,
 );
 static STARTSNAPSHOTINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotInput$ClientToken",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static STARTSNAPSHOTINPUT_MEMBER_VOLUME_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotInput$VolumeSize",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "volume_size",
     "VolumeSize",
 ,
 );
 static STARTSNAPSHOTINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotInput$Tags",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
 );
 static STARTSNAPSHOTINPUT_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotInput$Encrypted",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "encrypted",
     "Encrypted",
 ,
 );
 static STARTSNAPSHOTINPUT_MEMBER_KMS_KEY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotInput$KmsKeyArn",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_arn",
     "KmsKeyArn",
 ,
 );
 static STARTSNAPSHOTINPUT_MEMBER_PARENT_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotInput$ParentSnapshotId",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "parent_snapshot_id",
     "ParentSnapshotId",
 ,
 );
 static STARTSNAPSHOTINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotInput$Description",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "description",
     "Description",
 ,
 );
 static STARTSNAPSHOTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTSNAPSHOTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTSNAPSHOTINPUT_MEMBER_TIMEOUT,
         &STARTSNAPSHOTINPUT_MEMBER_CLIENT_TOKEN,
         &STARTSNAPSHOTINPUT_MEMBER_VOLUME_SIZE,
         &STARTSNAPSHOTINPUT_MEMBER_TAGS,
         &STARTSNAPSHOTINPUT_MEMBER_ENCRYPTED,
         &STARTSNAPSHOTINPUT_MEMBER_KMS_KEY_ARN,
         &STARTSNAPSHOTINPUT_MEMBER_PARENT_SNAPSHOT_ID,
         &STARTSNAPSHOTINPUT_MEMBER_DESCRIPTION,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/snapshots", Some(201)));
 impl StartSnapshotInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTSNAPSHOTINPUT_SCHEMA;
-208
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartSnapshotInput {
     #[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.timeout {
             ser.write_integer(&STARTSNAPSHOTINPUT_MEMBER_TIMEOUT, *val)?;
-217
+        }
         if let Some(ref val) = self.client_token {
             ser.write_string(&STARTSNAPSHOTINPUT_MEMBER_CLIENT_TOKEN, val)?;
-220
+        }
         if let Some(ref val) = self.volume_size {
             ser.write_long(&STARTSNAPSHOTINPUT_MEMBER_VOLUME_SIZE, *val)?;
-223
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &STARTSNAPSHOTINPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-230
+                    }
                     Ok(())
                 },
             )?;
-234
+        }
         if let Some(ref val) = self.encrypted {
             ser.write_boolean(&STARTSNAPSHOTINPUT_MEMBER_ENCRYPTED, *val)?;
-237
+        }
         if let Some(ref val) = self.kms_key_arn {
             ser.write_string(&STARTSNAPSHOTINPUT_MEMBER_KMS_KEY_ARN, val)?;
-240
+        }
         if let Some(ref val) = self.parent_snapshot_id {
             ser.write_string(&STARTSNAPSHOTINPUT_MEMBER_PARENT_SNAPSHOT_ID, val)?;
-243
+        }
         if let Some(ref val) = self.description {
             ser.write_string(&STARTSNAPSHOTINPUT_MEMBER_DESCRIPTION, val)?;
-246
+        }
         Ok(())
-248
+    }
-249
+}
 impl StartSnapshotInput {
     /// 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(&STARTSNAPSHOTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTSNAPSHOTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.timeout = Some(deser.read_integer(member)?);
-268
+                }
                 Some(1) => {
                     builder.client_token = Some(deser.read_string(member)?);
-271
+                }
                 Some(2) => {
                     builder.volume_size = Some(deser.read_long(member)?);
-274
+                }
                 Some(3) => {
                     builder.tags = 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::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-284
+                }
                 Some(4) => {
                     builder.encrypted = Some(deser.read_boolean(member)?);
-287
+                }
                 Some(5) => {
                     builder.kms_key_arn = Some(deser.read_string(member)?);
-290
+                }
                 Some(6) => {
                     builder.parent_snapshot_id = Some(deser.read_string(member)?);
-293
+                }
                 Some(7) => {
                     builder.description = Some(deser.read_string(member)?);
-296
+                }
                 _ => {}
-298
+            }
             Ok(())
         })?;
         builder.volume_size = builder.volume_size.or(Some(0i64));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-305
+    }
-306
+}
 impl StartSnapshotInput {
     /// 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 StartSnapshotInput {
     /// Creates a new builder-style object to manufacture [`StartSnapshotInput`](crate::operation::start_snapshot::StartSnapshotInput).
     pub fn builder() -> crate::operation::start_snapshot::builders::StartSnapshotInputBuilder {
         crate::operation::start_snapshot::builders::StartSnapshotInputBuilder::default()
-322
+    }
-323
+}
-324
 /// A builder for [`StartSnapshotInput`](crate::operation::start_snapshot::StartSnapshotInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct StartSnapshotInputBuilder {
     pub(crate) timeout: ::std::option::Option<i32>,
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) volume_size: ::std::option::Option<i64>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) encrypted: ::std::option::Option<bool>,
     pub(crate) kms_key_arn: ::std::option::Option<::std::string::String>,
     pub(crate) parent_snapshot_id: ::std::option::Option<::std::string::String>,
     pub(crate) description: ::std::option::Option<::std::string::String>,
-337
+}
 impl StartSnapshotInputBuilder {
     /// <p>The amount of time (in minutes) after which the snapshot is automatically cancelled if:</p>
     /// <ul>
     /// <li>
     /// <p>No blocks are written to the snapshot.</p></li>
     /// <li>
     /// <p>The snapshot is not completed after writing the last block of data.</p></li>
     /// </ul>
     /// <p>If no value is specified, the timeout defaults to <code>60</code> minutes.</p>
     pub fn timeout(mut self, input: i32) -> Self {

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/start_snapshot/_start_snapshot_output.rs

@@ -69,69 +219,219 @@

↥ Expand context

-69
+    }
-70
+}
 impl ::std::fmt::Debug for StartSnapshotOutput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("StartSnapshotOutput");
         formatter.field("tags", &self.tags);
         formatter.field("kms_key_arn", &"*** Sensitive Data Redacted ***");
         formatter.field("owner_id", &self.owner_id);
         formatter.field("volume_size", &self.volume_size);
         formatter.field("parent_snapshot_id", &self.parent_snapshot_id);
         formatter.field("description", &self.description);
         formatter.field("snapshot_id", &self.snapshot_id);
         formatter.field("block_size", &self.block_size);
         formatter.field("start_time", &self.start_time);
         formatter.field("status", &self.status);
         formatter.finish()
-85
+    }
-86
+}
 static STARTSNAPSHOTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#StartSnapshotOutput",

     "com.amazonaws.ebs.synthetic",
     "StartSnapshotOutput",
 );
 static STARTSNAPSHOTOUTPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotOutput$Tags",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
 );
 static STARTSNAPSHOTOUTPUT_MEMBER_KMS_KEY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotOutput$KmsKeyArn",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_arn",
     "KmsKeyArn",
 ,
 );
 static STARTSNAPSHOTOUTPUT_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotOutput$OwnerId",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "owner_id",
     "OwnerId",
 ,
 );
 static STARTSNAPSHOTOUTPUT_MEMBER_VOLUME_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotOutput$VolumeSize",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "volume_size",
     "VolumeSize",
 ,
 );
 static STARTSNAPSHOTOUTPUT_MEMBER_PARENT_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotOutput$ParentSnapshotId",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "parent_snapshot_id",
     "ParentSnapshotId",
 ,
 );
 static STARTSNAPSHOTOUTPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotOutput$Description",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "description",
     "Description",
 ,
 );
 static STARTSNAPSHOTOUTPUT_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotOutput$SnapshotId",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "snapshot_id",
     "SnapshotId",
 ,
 );
 static STARTSNAPSHOTOUTPUT_MEMBER_BLOCK_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotOutput$BlockSize",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "block_size",
     "BlockSize",
 ,
 );
 static STARTSNAPSHOTOUTPUT_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotOutput$StartTime",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "start_time",
     "StartTime",
 ,
 );
 static STARTSNAPSHOTOUTPUT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#StartSnapshotOutput$Status",
         "com.amazonaws.ebs.synthetic",
         "StartSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status",
     "Status",
 ,
 );
 static STARTSNAPSHOTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTSNAPSHOTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTSNAPSHOTOUTPUT_MEMBER_TAGS,
         &STARTSNAPSHOTOUTPUT_MEMBER_KMS_KEY_ARN,
         &STARTSNAPSHOTOUTPUT_MEMBER_OWNER_ID,
         &STARTSNAPSHOTOUTPUT_MEMBER_VOLUME_SIZE,

↧ Expand context

         &STARTSNAPSHOTOUTPUT_MEMBER_PARENT_SNAPSHOT_ID,
         &STARTSNAPSHOTOUTPUT_MEMBER_DESCRIPTION,
         &STARTSNAPSHOTOUTPUT_MEMBER_SNAPSHOT_ID,
         &STARTSNAPSHOTOUTPUT_MEMBER_BLOCK_SIZE,
         &STARTSNAPSHOTOUTPUT_MEMBER_START_TIME,
         &STARTSNAPSHOTOUTPUT_MEMBER_STATUS,
     ],
 );
 impl StartSnapshotOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTSNAPSHOTOUTPUT_SCHEMA;
-211
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartSnapshotOutput {
     #[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.tags {
             ser.write_list(

@@ -231,231 +351,359 @@

↥ Expand context

-231
+        }
         if let Some(ref val) = self.owner_id {
             ser.write_string(&STARTSNAPSHOTOUTPUT_MEMBER_OWNER_ID, val)?;
-234
+        }
         if let Some(ref val) = self.volume_size {
             ser.write_long(&STARTSNAPSHOTOUTPUT_MEMBER_VOLUME_SIZE, *val)?;
-237
+        }
         if let Some(ref val) = self.parent_snapshot_id {
             ser.write_string(&STARTSNAPSHOTOUTPUT_MEMBER_PARENT_SNAPSHOT_ID, val)?;
-240
+        }
         if let Some(ref val) = self.description {
             ser.write_string(&STARTSNAPSHOTOUTPUT_MEMBER_DESCRIPTION, val)?;
-243
+        }
         if let Some(ref val) = self.snapshot_id {
             ser.write_string(&STARTSNAPSHOTOUTPUT_MEMBER_SNAPSHOT_ID, val)?;
-246
+        }
         if let Some(ref val) = self.block_size {
             ser.write_integer(&STARTSNAPSHOTOUTPUT_MEMBER_BLOCK_SIZE, *val)?;
-249
+        }
         if let Some(ref val) = self.start_time {

             ser.write_timestamp(&STARTSNAPSHOTOUTPUT_MEMBER_START_TIME, val)?;
-252
+        }
         if let Some(ref val) = self.status {
             ser.write_string(&STARTSNAPSHOTOUTPUT_MEMBER_STATUS, val.as_str())?;
-255
+        }
         Ok(())
-257
+    }
-258
+}
 impl StartSnapshotOutput {
     /// 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(&STARTSNAPSHOTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTSNAPSHOTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.tags = 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::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-284
+                }
                 Some(1) => {
                     builder.kms_key_arn = Some(deser.read_string(member)?);
-287
+                }
                 Some(2) => {
                     builder.owner_id = Some(deser.read_string(member)?);
-290
+                }
                 Some(3) => {
                     builder.volume_size = Some(deser.read_long(member)?);
-293
+                }
                 Some(4) => {
                     builder.parent_snapshot_id = Some(deser.read_string(member)?);
-296
+                }
                 Some(5) => {
                     builder.description = Some(deser.read_string(member)?);
-299
+                }
                 Some(6) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-302
+                }
                 Some(7) => {
                     builder.block_size = Some(deser.read_integer(member)?);
-305
+                }
                 Some(8) => {
                     builder.start_time = Some(deser.read_timestamp(member)?);
-308
+                }
                 Some(9) => {
                     builder.status = Some(crate::types::Status::from(deser.read_string(member)?.as_str()));
-311
+                }
                 _ => {}
-313
+            }
             Ok(())
         })?;
         Ok(builder.build())
-317
+    }
-318
+}
 impl StartSnapshotOutput {
     /// 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 StartSnapshotOutput {
     /// Creates a new builder-style object to manufacture [`StartSnapshotOutput`](crate::operation::start_snapshot::StartSnapshotOutput).
     pub fn builder() -> crate::operation::start_snapshot::builders::StartSnapshotOutputBuilder {
         crate::operation::start_snapshot::builders::StartSnapshotOutputBuilder::default()
-334
+    }
-335
+}
-336
 /// A builder for [`StartSnapshotOutput`](crate::operation::start_snapshot::StartSnapshotOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct StartSnapshotOutputBuilder {
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) kms_key_arn: ::std::option::Option<::std::string::String>,
     pub(crate) owner_id: ::std::option::Option<::std::string::String>,
     pub(crate) volume_size: ::std::option::Option<i64>,
     pub(crate) parent_snapshot_id: ::std::option::Option<::std::string::String>,
     pub(crate) description: ::std::option::Option<::std::string::String>,
     pub(crate) snapshot_id: ::std::option::Option<::std::string::String>,
     pub(crate) block_size: ::std::option::Option<i32>,
     pub(crate) start_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) status: ::std::option::Option<crate::types::Status>,
-351
+}
 impl StartSnapshotOutputBuilder {
     /// Appends an item to `tags`.
     ///
     /// To override the contents of this collection use [`set_tags`](Self::set_tags).
     ///
     /// <p>The tags applied to the snapshot. You can specify up to 50 tags per snapshot. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html"> Tagging your Amazon EC2 resources</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
     pub fn tags(mut self, input: crate::types::Tag) -> Self {
         let mut v = self.tags.unwrap_or_default();

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

@@ -1,1 +80,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn parse_http_error_metadata(
     _response_status: u16,
     response_headers: &::aws_smithy_runtime_api::http::Headers,
     response_body: &[u8],
 ) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     crate::json_errors::parse_error_metadata(response_body, response_headers)
-+
+}
-+
 pub(crate) fn type_erase_result<O, E>(
     result: ::std::result::Result<O, E>,
 ) -> ::std::result::Result<
     ::aws_smithy_runtime_api::client::interceptors::context::Output,
     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError<::aws_smithy_runtime_api::client::interceptors::context::Error>,
-15
+>
 where
     O: ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
     E: ::std::error::Error + std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
-19
+{
     result
         .map(|output| ::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         .map_err(|error| ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(error))
         .map_err(::std::convert::Into::into)
-24
+}
-25
 pub fn parse_http_error_metadata(
     _response_status: u16,
     response_headers: &::aws_smithy_runtime_api::http::Headers,
     response_body: &[u8],
 ) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     crate::json_errors::parse_error_metadata(response_body, response_headers)
--
+}
--
 pub(crate) mod shape_complete_snapshot;
--
 pub(crate) mod shape_get_snapshot_block;
-27
 pub(crate) mod shape_list_changed_blocks;
--
 pub(crate) mod shape_list_snapshot_blocks;
--
 pub(crate) mod shape_put_snapshot_block;
--
 pub(crate) mod shape_put_snapshot_block_input;
--
 pub(crate) mod shape_start_snapshot;
--
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
--
+    }
--
+}
--
 pub(crate) mod shape_access_denied_exception;
--
 pub(crate) mod shape_concurrent_limit_exceeded_exception;
--
 pub(crate) mod shape_conflict_exception;
--
 pub(crate) mod shape_get_snapshot_block_output;
--
 pub(crate) mod shape_internal_server_exception;
--
 pub(crate) mod shape_put_snapshot_block_output;
--
 pub(crate) mod shape_request_throttled_exception;
--
 pub(crate) mod shape_resource_not_found_exception;
--
 pub(crate) mod shape_service_quota_exceeded_exception;
--
 pub(crate) mod shape_start_snapshot_input;
--
 pub(crate) mod shape_validation_exception;
--
 pub(crate) mod shape_blocks;
--
 pub(crate) mod shape_changed_blocks;
--
 pub(crate) mod shape_tag;
--
 pub(crate) mod shape_tags;
--
 pub(crate) mod shape_block;
--
 pub(crate) mod shape_changed_block;

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

@@ -1,0 +42,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_access_denied_exception_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::AccessDeniedErrorBuilder,
 ) -> ::std::result::Result<crate::types::error::builders::AccessDeniedErrorBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "Message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 "Reason" => {
                     builder = builder.set_reason(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| crate::types::AccessDeniedExceptionReason::from(u.as_ref())))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

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

@@ -1,0 +47,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_block<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
     _value: &'a [u8],
 ) -> ::std::result::Result<Option<crate::types::Block>, ::aws_smithy_json::deserialize::error::DeserializeError>
 where
     I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
--
+{
     match tokens.next().transpose()? {
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
             #[allow(unused_mut)]
             let mut builder = crate::types::builders::BlockBuilder::default();
             loop {
                 match tokens.next().transpose()? {
                     Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                     Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                         "BlockToken" => {
                             builder = builder.set_block_token(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                     .transpose()?,
                             );
--
+                        }
                         "BlockIndex" => {
                             builder = builder.set_block_index(
                                 ::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
                                     .map(i32::try_from)
                                     .transpose()?,
                             );
--
+                        }
                         _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
                     },
                     other => {
                         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                             "expected object key or end object, found: {other:?}"
                         )))
--
+                    }
--
+                }
--
+            }
             Ok(Some(builder.build()))
--
+        }
         _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "expected start object or null",
         )),
--
+    }
--
+}

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

@@ -1,0 +37,0 @@

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

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

@@ -1,0 +54,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_changed_block<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
     _value: &'a [u8],
 ) -> ::std::result::Result<Option<crate::types::ChangedBlock>, ::aws_smithy_json::deserialize::error::DeserializeError>
 where
     I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
--
+{
     match tokens.next().transpose()? {
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
             #[allow(unused_mut)]
             let mut builder = crate::types::builders::ChangedBlockBuilder::default();
             loop {
                 match tokens.next().transpose()? {
                     Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                     Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                         "FirstBlockToken" => {
                             builder = builder.set_first_block_token(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                     .transpose()?,
                             );
--
+                        }
                         "BlockIndex" => {
                             builder = builder.set_block_index(
                                 ::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
                                     .map(i32::try_from)
                                     .transpose()?,
                             );
--
+                        }
                         "SecondBlockToken" => {
                             builder = builder.set_second_block_token(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                     .transpose()?,
                             );
--
+                        }
                         _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
                     },
                     other => {
                         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                             "expected object key or end object, found: {other:?}"
                         )))
--
+                    }
--
+                }
--
+            }
             Ok(Some(builder.build()))
--
+        }
         _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "expected start object or null",
         )),
--
+    }
--
+}

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

@@ -1,0 +37,0 @@

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

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

@@ -1,0 +221,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_complete_snapshot_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::complete_snapshot::CompleteSnapshotOutput, crate::operation::complete_snapshot::CompleteSnapshotError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled(generic)),
     };
--
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "AccessDeniedException" => crate::operation::complete_snapshot::CompleteSnapshotError::AccessDeniedError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::AccessDeniedErrorBuilder::default();
                 output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
                     .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
                 let output = output.meta(generic);
                 crate::serde_util::access_denied_exception_correct_errors(output)
                     .build()
                     .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "InternalServerException" => crate::operation::complete_snapshot::CompleteSnapshotError::InternalServerError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
                 output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
                     .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "RequestThrottledException" => crate::operation::complete_snapshot::CompleteSnapshotError::RequestThrottledError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::RequestThrottledErrorBuilder::default();
                 output = crate::protocol_serde::shape_request_throttled_exception::de_request_throttled_exception_json_err(_response_body, output)
                     .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ResourceNotFoundException" => crate::operation::complete_snapshot::CompleteSnapshotError::ResourceNotFoundError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
                 output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
                     .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ServiceQuotaExceededException" => crate::operation::complete_snapshot::CompleteSnapshotError::ServiceQuotaExceededError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ServiceQuotaExceededErrorBuilder::default();
                 output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
                     _response_body,
                     output,
--
+                )
                 .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ValidationException" => crate::operation::complete_snapshot::CompleteSnapshotError::ValidationError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
                 output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
                     .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::complete_snapshot::CompleteSnapshotError::generic(generic),
     })
--
+}
--
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_complete_snapshot_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::complete_snapshot::CompleteSnapshotOutput, crate::operation::complete_snapshot::CompleteSnapshotError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::complete_snapshot::builders::CompleteSnapshotOutputBuilder::default();
         output = crate::protocol_serde::shape_complete_snapshot::de_complete_snapshot(_response_body, output)
             .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
         output.build()
     })
--
+}
--
 pub fn ser_complete_snapshot_headers(
     input: &crate::operation::complete_snapshot::CompleteSnapshotInput,
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.changed_blocks_count {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
         let formatted_2 = encoder.encode();
         let header_value = formatted_2;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "changed_blocks_count",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-ChangedBlocksCount", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_aggregation_method {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_aggregation_method",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-Checksum-Aggregation-Method", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-Checksum-Algorithm", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_7) = &input.checksum {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-Checksum", header_value);
--
+    }
     Ok(builder)
--
+}
--
 pub(crate) fn de_complete_snapshot(
     _value: &[u8],
     mut builder: crate::operation::complete_snapshot::builders::CompleteSnapshotOutputBuilder,
 ) -> ::std::result::Result<
     crate::operation::complete_snapshot::builders::CompleteSnapshotOutputBuilder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "Status" => {
                     builder = builder.set_status(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| crate::types::Status::from(u.as_ref())))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

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

@@ -1,0 +36,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_concurrent_limit_exceeded_exception_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::ConcurrentLimitExceededErrorBuilder,
 ) -> ::std::result::Result<crate::types::error::builders::ConcurrentLimitExceededErrorBuilder, ::aws_smithy_json::deserialize::error::DeserializeError>
--
+{
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "Message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

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

@@ -1,0 +35,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_conflict_exception_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::ConflictErrorBuilder,
 ) -> ::std::result::Result<crate::types::error::builders::ConflictErrorBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "Message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

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

@@ -8,8 +153,0 @@

↥ Expand context

     let _response_body = &mut _response_body;
-9
     let _response_status = response.status().as_u16();
     let _response_headers = response.headers();
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_snapshot_block::builders::GetSnapshotBlockOutputBuilder::default();
         output = output.set_block_data(Some(crate::protocol_serde::shape_get_snapshot_block_output::de_block_data_payload(
             _response_body,
         )?));
         output = output.set_checksum(
             crate::protocol_serde::shape_get_snapshot_block_output::de_checksum_header(_response_headers).map_err(|_| {
                 crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled("Failed to parse Checksum from header `x-amz-Checksum")
             })?,
         );
         output = output.set_checksum_algorithm(
             crate::protocol_serde::shape_get_snapshot_block_output::de_checksum_algorithm_header(_response_headers).map_err(|_| {
                 crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled(
                     "Failed to parse ChecksumAlgorithm from header `x-amz-Checksum-Algorithm",
-27
+                )

             })?,
         );
         output = output.set_data_length(
             crate::protocol_serde::shape_get_snapshot_block_output::de_data_length_header(_response_headers).map_err(|_| {
                 crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled("Failed to parse DataLength from header `x-amz-Data-Length")
             })?,
         );
         output.build()
     })
-37
+}
--
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_snapshot_block_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::get_snapshot_block::GetSnapshotBlockOutput, crate::operation::get_snapshot_block::GetSnapshotBlockError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled(generic)),
     };
--
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "AccessDeniedException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::AccessDeniedError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::AccessDeniedErrorBuilder::default();
                 output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
                     .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
                 let output = output.meta(generic);
                 crate::serde_util::access_denied_exception_correct_errors(output)
                     .build()
                     .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "InternalServerException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::InternalServerError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
                 output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
                     .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "RequestThrottledException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::RequestThrottledError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::RequestThrottledErrorBuilder::default();
                 output = crate::protocol_serde::shape_request_throttled_exception::de_request_throttled_exception_json_err(_response_body, output)
                     .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ResourceNotFoundException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::ResourceNotFoundError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
                 output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
                     .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ServiceQuotaExceededException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::ServiceQuotaExceededError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ServiceQuotaExceededErrorBuilder::default();
                 output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
                     _response_body,
                     output,
--
+                )
                 .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ValidationException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::ValidationError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
                 output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
                     .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::get_snapshot_block::GetSnapshotBlockError::generic(generic),
     })
--
+}

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

@@ -1,0 +35,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_internal_server_exception_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::InternalServerErrorBuilder,
 ) -> ::std::result::Result<crate::types::error::builders::InternalServerErrorBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "Message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

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

@@ -1,0 +194,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_changed_blocks_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::list_changed_blocks::ListChangedBlocksOutput, crate::operation::list_changed_blocks::ListChangedBlocksError>
--
+{
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled(generic)),
     };
--
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "AccessDeniedException" => crate::operation::list_changed_blocks::ListChangedBlocksError::AccessDeniedError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::AccessDeniedErrorBuilder::default();
                 output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
                     .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
                 let output = output.meta(generic);
                 crate::serde_util::access_denied_exception_correct_errors(output)
                     .build()
                     .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "InternalServerException" => crate::operation::list_changed_blocks::ListChangedBlocksError::InternalServerError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
                 output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
                     .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "RequestThrottledException" => crate::operation::list_changed_blocks::ListChangedBlocksError::RequestThrottledError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::RequestThrottledErrorBuilder::default();
                 output = crate::protocol_serde::shape_request_throttled_exception::de_request_throttled_exception_json_err(_response_body, output)
                     .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ResourceNotFoundException" => crate::operation::list_changed_blocks::ListChangedBlocksError::ResourceNotFoundError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
                 output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
                     .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ServiceQuotaExceededException" => crate::operation::list_changed_blocks::ListChangedBlocksError::ServiceQuotaExceededError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ServiceQuotaExceededErrorBuilder::default();
                 output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
                     _response_body,
                     output,
--
+                )
                 .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ValidationException" => crate::operation::list_changed_blocks::ListChangedBlocksError::ValidationError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
                 output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
                     .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::list_changed_blocks::ListChangedBlocksError::generic(generic),
     })
--
+}
--
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_changed_blocks_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::list_changed_blocks::ListChangedBlocksOutput, crate::operation::list_changed_blocks::ListChangedBlocksError>
--
+{
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::list_changed_blocks::builders::ListChangedBlocksOutputBuilder::default();
         output = crate::protocol_serde::shape_list_changed_blocks::de_list_changed_blocks(_response_body, output)
             .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
         output.build()
     })
--
+}
--
 pub(crate) fn de_list_changed_blocks(
     _value: &[u8],
     mut builder: crate::operation::list_changed_blocks::builders::ListChangedBlocksOutputBuilder,
 ) -> ::std::result::Result<
     crate::operation::list_changed_blocks::builders::ListChangedBlocksOutputBuilder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "BlockSize" => {
                     builder = builder.set_block_size(
                         ::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
                             .map(i32::try_from)
                             .transpose()?,
                     );
--
+                }
                 "ChangedBlocks" => {
                     builder = builder.set_changed_blocks(crate::protocol_serde::shape_changed_blocks::de_changed_blocks(tokens, _value)?);
--
+                }
                 "ExpiryTime" => {
                     builder = builder.set_expiry_time(::aws_smithy_json::deserialize::token::expect_timestamp_or_null(
                         tokens.next(),
                         ::aws_smithy_types::date_time::Format::EpochSeconds,
                     )?);
--
+                }
                 "NextToken" => {
                     builder = builder.set_next_token(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 "VolumeSize" => {
                     builder = builder.set_volume_size(
                         ::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
                             .map(i64::try_from)
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

Client Test

Files changed: