AWS SDK

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part/_upload_part_input.rs

@@ -156,156 +513,510 @@

         formatter.field("content_md5", &self.content_md5);
         formatter.field("checksum_algorithm", &self.checksum_algorithm);
         formatter.field("checksum_crc32", &self.checksum_crc32);
         formatter.field("checksum_crc32_c", &self.checksum_crc32_c);
         formatter.field("checksum_crc64_nvme", &self.checksum_crc64_nvme);
         formatter.field("checksum_sha1", &self.checksum_sha1);
         formatter.field("checksum_sha256", &self.checksum_sha256);
         formatter.field("key", &self.key);
         formatter.field("part_number", &self.part_number);
         formatter.field("upload_id", &self.upload_id);
         formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
         formatter.field("sse_customer_key", &"*** Sensitive Data Redacted ***");
         formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
         formatter.field("request_payer", &self.request_payer);
         formatter.field("expected_bucket_owner", &self.expected_bucket_owner);
         formatter.finish()
-172
+    }
-173
+}
 static UPLOADPARTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#UploadPartInput",

     "com.amazonaws.s3.synthetic",
     "UploadPartInput",
 );
 static UPLOADPARTINPUT_MEMBER_BODY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$Body",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "body",
     "Body",
 ,
-188
+)
 .with_http_payload();
 static UPLOADPARTINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-199
+)
 .with_http_label();
 static UPLOADPARTINPUT_MEMBER_CONTENT_LENGTH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$ContentLength",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "content_length",
     "ContentLength",
 ,
-210
+)
 .with_http_header("Content-Length");
 static UPLOADPARTINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-221
+)
 .with_http_header("Content-MD5");
 static UPLOADPARTINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-232
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static UPLOADPARTINPUT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$ChecksumCRC32",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32",
     "ChecksumCRC32",
 ,
-243
+)
 .with_http_header("x-amz-checksum-crc32");
 static UPLOADPARTINPUT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$ChecksumCRC32C",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32_c",
     "ChecksumCRC32C",
 ,
-254
+)
 .with_http_header("x-amz-checksum-crc32c");
 static UPLOADPARTINPUT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$ChecksumCRC64NVME",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc64_nvme",
     "ChecksumCRC64NVME",
 ,
-265
+)
 .with_http_header("x-amz-checksum-crc64nvme");
 static UPLOADPARTINPUT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$ChecksumSHA1",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha1",
     "ChecksumSHA1",
 ,
-276
+)
 .with_http_header("x-amz-checksum-sha1");
 static UPLOADPARTINPUT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$ChecksumSHA256",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha256",
     "ChecksumSHA256",
 ,
-287
+)
 .with_http_header("x-amz-checksum-sha256");
 static UPLOADPARTINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$Key",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
-298
+)
 .with_http_label();
 static UPLOADPARTINPUT_MEMBER_PART_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$PartNumber",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "part_number",
     "PartNumber",
 ,
-309
+)
 .with_http_query("partNumber");
 static UPLOADPARTINPUT_MEMBER_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$UploadId",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "upload_id",
     "UploadId",
 ,
-320
+)
 .with_http_query("uploadId");
 static UPLOADPARTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$SSECustomerAlgorithm",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_algorithm",
     "SSECustomerAlgorithm",
 ,
-331
+)
 .with_http_header("x-amz-server-side-encryption-customer-algorithm");
 static UPLOADPARTINPUT_MEMBER_SSE_CUSTOMER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$SSECustomerKey",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key",
     "SSECustomerKey",
 ,
-342
+)
 .with_http_header("x-amz-server-side-encryption-customer-key");
 static UPLOADPARTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$SSECustomerKeyMD5",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key_md5",
     "SSECustomerKeyMD5",
 ,
-353
+)
 .with_http_header("x-amz-server-side-encryption-customer-key-MD5");
 static UPLOADPARTINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$RequestPayer",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_payer",
     "RequestPayer",
 ,
-364
+)
 .with_http_header("x-amz-request-payer");
 static UPLOADPARTINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "UploadPartInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-375
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static UPLOADPARTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPLOADPARTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPLOADPARTINPUT_MEMBER_BODY,
         &UPLOADPARTINPUT_MEMBER_BUCKET,
         &UPLOADPARTINPUT_MEMBER_CONTENT_LENGTH,
         &UPLOADPARTINPUT_MEMBER_CONTENT_MD5,
         &UPLOADPARTINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &UPLOADPARTINPUT_MEMBER_CHECKSUM_CRC32,
         &UPLOADPARTINPUT_MEMBER_CHECKSUM_CRC32_C,
         &UPLOADPARTINPUT_MEMBER_CHECKSUM_CRC64_NVME,
         &UPLOADPARTINPUT_MEMBER_CHECKSUM_SHA1,
         &UPLOADPARTINPUT_MEMBER_CHECKSUM_SHA256,
         &UPLOADPARTINPUT_MEMBER_KEY,
         &UPLOADPARTINPUT_MEMBER_PART_NUMBER,
         &UPLOADPARTINPUT_MEMBER_UPLOAD_ID,
         &UPLOADPARTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
         &UPLOADPARTINPUT_MEMBER_SSE_CUSTOMER_KEY,
         &UPLOADPARTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
         &UPLOADPARTINPUT_MEMBER_REQUEST_PAYER,
         &UPLOADPARTINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/{Key+}?x-id=UploadPart", None));
 impl UploadPartInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPLOADPARTINPUT_SCHEMA;
-405
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UploadPartInput {
     #[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> {
--
+        {
             let val = &self.body;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         if let Some(ref val) = self.bucket {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_BUCKET, val)?;
-414
+        }
         if let Some(ref val) = self.content_length {
             ser.write_long(&UPLOADPARTINPUT_MEMBER_CONTENT_LENGTH, *val)?;
-417
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_CONTENT_MD5, val)?;
-420
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-423
+        }
         if let Some(ref val) = self.checksum_crc32 {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_CHECKSUM_CRC32, val)?;
-426
+        }
         if let Some(ref val) = self.checksum_crc32_c {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_CHECKSUM_CRC32_C, val)?;
-429
+        }
         if let Some(ref val) = self.checksum_crc64_nvme {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_CHECKSUM_CRC64_NVME, val)?;
-432
+        }
         if let Some(ref val) = self.checksum_sha1 {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_CHECKSUM_SHA1, val)?;
-435
+        }
         if let Some(ref val) = self.checksum_sha256 {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_CHECKSUM_SHA256, val)?;
-438
+        }
         if let Some(ref val) = self.key {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_KEY, val)?;
-441
+        }
         if let Some(ref val) = self.part_number {
             ser.write_integer(&UPLOADPARTINPUT_MEMBER_PART_NUMBER, *val)?;
-444
+        }
         if let Some(ref val) = self.upload_id {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_UPLOAD_ID, val)?;
-447
+        }
         if let Some(ref val) = self.sse_customer_algorithm {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM, val)?;
-450
+        }
         if let Some(ref val) = self.sse_customer_key {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_SSE_CUSTOMER_KEY, val)?;
-453
+        }
         if let Some(ref val) = self.sse_customer_key_md5 {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5, val)?;
-456
+        }
         if let Some(ref val) = self.request_payer {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
-459
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&UPLOADPARTINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-462
+        }
         Ok(())
-464
+    }
-465
+}
 impl UploadPartInput {
     /// 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(&UPLOADPARTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPLOADPARTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.body = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-487
+                }
                 Some(1) => {
                     builder.bucket = Some(deser.read_string(member)?);
-490
+                }

↧ Expand context

                 Some(2) => {
                     builder.content_length = Some(deser.read_long(member)?);
-493
+                }
                 Some(3) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-496
+                }
                 Some(4) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-499
+                }
                 Some(5) => {
                     builder.checksum_crc32 = Some(deser.read_string(member)?);
-502
+                }
                 Some(6) => {
                     builder.checksum_crc32_c = Some(deser.read_string(member)?);
-505
+                }
                 Some(7) => {
                     builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
-508
+                }
                 Some(8) => {
                     builder.checksum_sha1 = Some(deser.read_string(member)?);

@@ -516,513 +575,676 @@

↥ Expand context

                     builder.checksum_sha256 = Some(deser.read_string(member)?);
-514
+                }
                 Some(10) => {
                     builder.key = Some(deser.read_string(member)?);
-517
+                }
                 Some(11) => {
                     builder.part_number = Some(deser.read_integer(member)?);
-520
+                }
                 Some(12) => {
                     builder.upload_id = Some(deser.read_string(member)?);
-523
+                }
                 Some(13) => {
                     builder.sse_customer_algorithm = Some(deser.read_string(member)?);
-526
+                }
                 Some(14) => {
                     builder.sse_customer_key = Some(deser.read_string(member)?);
-529
+                }
                 Some(15) => {
                     builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
-532
+                }

                 Some(16) => {
                     builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
-535
+                }
                 Some(17) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-538
+                }
                 _ => {}
-540
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder.key = builder.key.or(Some(String::new()));
         builder.part_number = builder.part_number.or(Some(0i32));
         builder.upload_id = builder.upload_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl UploadPartInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("Content-Length") {
             builder.content_length = val.parse::<i64>().ok();
-+
+        }
         if let Some(val) = headers.get("Content-MD5") {
             builder.content_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-sdk-checksum-algorithm") {
             builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc32") {
             builder.checksum_crc32 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc32c") {
             builder.checksum_crc32_c = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc64nvme") {
             builder.checksum_crc64_nvme = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-sha1") {
             builder.checksum_sha1 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-sha256") {
             builder.checksum_sha256 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
             builder.sse_customer_algorithm = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key") {
             builder.sse_customer_key = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
             builder.sse_customer_key_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-request-payer") {
             builder.request_payer = Some(crate::types::RequestPayer::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UPLOADPARTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.body = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 Some(1) => {
                     builder.bucket = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => { /* read from headers above */ }
                 Some(4) => { /* read from headers above */ }
                 Some(5) => { /* read from headers above */ }
                 Some(6) => { /* read from headers above */ }
                 Some(7) => { /* read from headers above */ }
                 Some(8) => { /* read from headers above */ }
                 Some(9) => { /* read from headers above */ }
                 Some(10) => {
                     builder.key = Some(deser.read_string(member)?);
-+
+                }
                 Some(11) => {
                     builder.part_number = Some(deser.read_integer(member)?);
-+
+                }
                 Some(12) => {
                     builder.upload_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(13) => { /* read from headers above */ }
                 Some(14) => { /* read from headers above */ }
                 Some(15) => { /* read from headers above */ }
                 Some(16) => { /* read from headers above */ }
                 Some(17) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-650
+    }
-651
+}
 impl UploadPartInput {
     /// Creates a new builder-style object to manufacture [`UploadPartInput`](crate::operation::upload_part::UploadPartInput).
     pub fn builder() -> crate::operation::upload_part::builders::UploadPartInputBuilder {
         crate::operation::upload_part::builders::UploadPartInputBuilder::default()
-656
+    }

↧ Expand context

-657
+}
-658
 /// A builder for [`UploadPartInput`](crate::operation::upload_part::UploadPartInput).
 #[derive(::std::default::Default)]
 #[non_exhaustive]
 pub struct UploadPartInputBuilder {
     pub(crate) body: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) content_length: ::std::option::Option<i64>,
     pub(crate) content_md5: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) checksum_crc32: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc32_c: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc64_nvme: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_sha1: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_sha256: ::std::option::Option<::std::string::String>,
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) part_number: ::std::option::Option<i32>,
     pub(crate) upload_id: ::std::option::Option<::std::string::String>,
     pub(crate) sse_customer_algorithm: ::std::option::Option<::std::string::String>,

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part/_upload_part_output.rs

@@ -101,101 +411,476 @@

↥ Expand context

         let mut formatter = f.debug_struct("UploadPartOutput");
         formatter.field("server_side_encryption", &self.server_side_encryption);
         formatter.field("e_tag", &self.e_tag);
         formatter.field("checksum_crc32", &self.checksum_crc32);
         formatter.field("checksum_crc32_c", &self.checksum_crc32_c);
         formatter.field("checksum_crc64_nvme", &self.checksum_crc64_nvme);
         formatter.field("checksum_sha1", &self.checksum_sha1);
         formatter.field("checksum_sha256", &self.checksum_sha256);
         formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
         formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
         formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
         formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
         formatter.field("request_charged", &self.request_charged);
         formatter.field("_extended_request_id", &self._extended_request_id);
         formatter.field("_request_id", &self._request_id);
         formatter.finish()
-117
+    }
-118
+}
 static UPLOADPARTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#UploadPartOutput",

     "com.amazonaws.s3.synthetic",
     "UploadPartOutput",
 );
 static UPLOADPARTOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$ServerSideEncryption",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "server_side_encryption",
     "ServerSideEncryption",
 ,
-133
+)
 .with_http_header("x-amz-server-side-encryption");
 static UPLOADPARTOUTPUT_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$ETag",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "e_tag",
     "ETag",
 ,
-144
+)
 .with_http_header("ETag");
 static UPLOADPARTOUTPUT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$ChecksumCRC32",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32",
     "ChecksumCRC32",
 ,
-155
+)
 .with_http_header("x-amz-checksum-crc32");
 static UPLOADPARTOUTPUT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$ChecksumCRC32C",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32_c",
     "ChecksumCRC32C",
 ,
-166
+)
 .with_http_header("x-amz-checksum-crc32c");
 static UPLOADPARTOUTPUT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$ChecksumCRC64NVME",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc64_nvme",
     "ChecksumCRC64NVME",
 ,
-177
+)
 .with_http_header("x-amz-checksum-crc64nvme");
 static UPLOADPARTOUTPUT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$ChecksumSHA1",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha1",
     "ChecksumSHA1",
 ,
-188
+)
 .with_http_header("x-amz-checksum-sha1");
 static UPLOADPARTOUTPUT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$ChecksumSHA256",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha256",
     "ChecksumSHA256",
 ,
-199
+)
 .with_http_header("x-amz-checksum-sha256");
 static UPLOADPARTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$SSECustomerAlgorithm",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_algorithm",
     "SSECustomerAlgorithm",
 ,
-210
+)
 .with_http_header("x-amz-server-side-encryption-customer-algorithm");
 static UPLOADPARTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$SSECustomerKeyMD5",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key_md5",
     "SSECustomerKeyMD5",
 ,
-221
+)
 .with_http_header("x-amz-server-side-encryption-customer-key-MD5");
 static UPLOADPARTOUTPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$SSEKMSKeyId",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_key_id",
     "SSEKMSKeyId",
 ,
-232
+)
 .with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
 static UPLOADPARTOUTPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$BucketKeyEnabled",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bucket_key_enabled",
     "BucketKeyEnabled",
 ,
-243
+)
 .with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
 static UPLOADPARTOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartOutput$RequestCharged",
         "com.amazonaws.s3.synthetic",
         "UploadPartOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_charged",
     "RequestCharged",
 ,
-254
+)
 .with_http_header("x-amz-request-charged");
 static UPLOADPARTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static UPLOADPARTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPLOADPARTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPLOADPARTOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
         &UPLOADPARTOUTPUT_MEMBER_E_TAG,
         &UPLOADPARTOUTPUT_MEMBER_CHECKSUM_CRC32,
         &UPLOADPARTOUTPUT_MEMBER_CHECKSUM_CRC32_C,
         &UPLOADPARTOUTPUT_MEMBER_CHECKSUM_CRC64_NVME,
         &UPLOADPARTOUTPUT_MEMBER_CHECKSUM_SHA1,
         &UPLOADPARTOUTPUT_MEMBER_CHECKSUM_SHA256,
         &UPLOADPARTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
         &UPLOADPARTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
         &UPLOADPARTOUTPUT_MEMBER_SSEKMS_KEY_ID,
         &UPLOADPARTOUTPUT_MEMBER_BUCKET_KEY_ENABLED,
         &UPLOADPARTOUTPUT_MEMBER_REQUEST_CHARGED,
         &UPLOADPARTOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl UploadPartOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPLOADPARTOUTPUT_SCHEMA;
-285
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UploadPartOutput {
     #[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.server_side_encryption {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION, val.as_str())?;
-294
+        }
         if let Some(ref val) = self.e_tag {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_E_TAG, val)?;
-297
+        }
         if let Some(ref val) = self.checksum_crc32 {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_CHECKSUM_CRC32, val)?;
-300
+        }
         if let Some(ref val) = self.checksum_crc32_c {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_CHECKSUM_CRC32_C, val)?;
-303
+        }
         if let Some(ref val) = self.checksum_crc64_nvme {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_CHECKSUM_CRC64_NVME, val)?;
-306
+        }
         if let Some(ref val) = self.checksum_sha1 {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_CHECKSUM_SHA1, val)?;
-309
+        }
         if let Some(ref val) = self.checksum_sha256 {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_CHECKSUM_SHA256, val)?;
-312
+        }
         if let Some(ref val) = self.sse_customer_algorithm {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM, val)?;
-315
+        }
         if let Some(ref val) = self.sse_customer_key_md5 {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5, val)?;
-318
+        }
         if let Some(ref val) = self.ssekms_key_id {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_SSEKMS_KEY_ID, val)?;
-321
+        }
         if let Some(ref val) = self.bucket_key_enabled {
             ser.write_boolean(&UPLOADPARTOUTPUT_MEMBER_BUCKET_KEY_ENABLED, *val)?;
-324
+        }
         if let Some(ref val) = self.request_charged {
             ser.write_string(&UPLOADPARTOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
-327
+        }
         Ok(())
-329
+    }
-330
+}
 impl UploadPartOutput {
     /// 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(&UPLOADPARTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPLOADPARTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
-349
+                }
                 Some(1) => {
                     builder.e_tag = Some(deser.read_string(member)?);
-352
+                }
                 Some(2) => {
                     builder.checksum_crc32 = Some(deser.read_string(member)?);
-355
+                }
                 Some(3) => {
                     builder.checksum_crc32_c = Some(deser.read_string(member)?);
-358
+                }
                 Some(4) => {
                     builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
-361
+                }
                 Some(5) => {
                     builder.checksum_sha1 = Some(deser.read_string(member)?);
-364
+                }
                 Some(6) => {
                     builder.checksum_sha256 = Some(deser.read_string(member)?);
-367
+                }
                 Some(7) => {
                     builder.sse_customer_algorithm = Some(deser.read_string(member)?);
-370
+                }
                 Some(8) => {
                     builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
-373
+                }
                 Some(9) => {
                     builder.ssekms_key_id = Some(deser.read_string(member)?);
-376
+                }
                 Some(10) => {
                     builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
-379
+                }
                 Some(11) => {
                     builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
-382
+                }
                 Some(12) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-387
+            }
             Ok(())
         })?;
         Ok(builder.build())
-391
+    }
-392
+}
 impl UploadPartOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-server-side-encryption") {
             builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
-+
+        }
         if let Some(val) = headers.get("ETag") {
             builder.e_tag = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc32") {
             builder.checksum_crc32 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc32c") {
             builder.checksum_crc32_c = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc64nvme") {
             builder.checksum_crc64_nvme = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-sha1") {
             builder.checksum_sha1 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-sha256") {
             builder.checksum_sha256 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
             builder.sse_customer_algorithm = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
             builder.sse_customer_key_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
             builder.ssekms_key_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
             builder.bucket_key_enabled = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-request-charged") {
             builder.request_charged = Some(crate::types::RequestCharged::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl crate::s3_request_id::RequestIdExt for UploadPartOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-450
+    }
-451
+}
 impl ::aws_types::request_id::RequestId for UploadPartOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-455
+    }
-456
+}

↧ Expand context

 impl UploadPartOutput {
     /// Creates a new builder-style object to manufacture [`UploadPartOutput`](crate::operation::upload_part::UploadPartOutput).
     pub fn builder() -> crate::operation::upload_part::builders::UploadPartOutputBuilder {
         crate::operation::upload_part::builders::UploadPartOutputBuilder::default()
-461
+    }
-462
+}
-463
 /// A builder for [`UploadPartOutput`](crate::operation::upload_part::UploadPartOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct UploadPartOutputBuilder {
     pub(crate) server_side_encryption: ::std::option::Option<crate::types::ServerSideEncryption>,
     pub(crate) e_tag: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc32: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc32_c: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc64_nvme: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_sha1: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_sha256: ::std::option::Option<::std::string::String>,
     pub(crate) sse_customer_algorithm: ::std::option::Option<::std::string::String>,
     pub(crate) sse_customer_key_md5: ::std::option::Option<::std::string::String>,

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part_copy.rs

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

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

@@ -122,126 +184,189 @@

↥ Expand context

         &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("UploadPartCopy")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UploadPartCopyEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::upload_part_copy::UploadPartCopyError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::upload_part_copy::UploadPartCopyError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::upload_part_copy::UploadPartCopyError>::builder()
                     .transient_errors({
                         let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                         transient_errors.push("InternalError");
                         ::std::borrow::Cow::Owned(transient_errors)
                     })

                     .build(),
             );
-148
         ::std::borrow::Cow::Owned(rcb)
-150
+    }
-151
+}
-152
 #[derive(Debug)]
 struct UploadPartCopyResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UploadPartCopyResponseDeserializer {
     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;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-169
+        }

↧ Expand context

         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_upload_part_copy::de_upload_part_copy_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_upload_part_copy::de_upload_part_copy_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-177
+    }
-178
+}
 #[derive(Debug)]
 struct UploadPartCopyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UploadPartCopyRequestSerializer {
     #[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::upload_part_copy::UploadPartCopyInput>()

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part_copy/_upload_part_copy_input.rs

@@ -276,276 +562,563 @@

↥ Expand context

         formatter.field("copy_source_if_none_match", &self.copy_source_if_none_match);
         formatter.field("copy_source_if_unmodified_since", &self.copy_source_if_unmodified_since);
         formatter.field("copy_source_range", &self.copy_source_range);
         formatter.field("key", &self.key);
         formatter.field("part_number", &self.part_number);
         formatter.field("upload_id", &self.upload_id);
         formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
         formatter.field("sse_customer_key", &"*** Sensitive Data Redacted ***");
         formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
         formatter.field("copy_source_sse_customer_algorithm", &self.copy_source_sse_customer_algorithm);
         formatter.field("copy_source_sse_customer_key", &"*** Sensitive Data Redacted ***");
         formatter.field("copy_source_sse_customer_key_md5", &self.copy_source_sse_customer_key_md5);
         formatter.field("request_payer", &self.request_payer);
         formatter.field("expected_bucket_owner", &self.expected_bucket_owner);
         formatter.field("expected_source_bucket_owner", &self.expected_source_bucket_owner);
         formatter.finish()
-292
+    }
-293
+}
 static UPLOADPARTCOPYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#UploadPartCopyInput",

     "com.amazonaws.s3.synthetic",
     "UploadPartCopyInput",
 );
 static UPLOADPARTCOPYINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-308
+)
 .with_http_label();
 static UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$CopySource",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "copy_source",
     "CopySource",
 ,
-319
+)
 .with_http_header("x-amz-copy-source");
 static UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$CopySourceIfMatch",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "copy_source_if_match",
     "CopySourceIfMatch",
 ,
-330
+)
 .with_http_header("x-amz-copy-source-if-match");
 static UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_MODIFIED_SINCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$CopySourceIfModifiedSince",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "copy_source_if_modified_since",
     "CopySourceIfModifiedSince",
 ,
-341
+)
 .with_http_header("x-amz-copy-source-if-modified-since");
 static UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_NONE_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$CopySourceIfNoneMatch",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "copy_source_if_none_match",
     "CopySourceIfNoneMatch",
 ,
-352
+)
 .with_http_header("x-amz-copy-source-if-none-match");
 static UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_UNMODIFIED_SINCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$CopySourceIfUnmodifiedSince",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "copy_source_if_unmodified_since",
     "CopySourceIfUnmodifiedSince",
 ,
-363
+)
 .with_http_header("x-amz-copy-source-if-unmodified-since");
 static UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_RANGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$CopySourceRange",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "copy_source_range",
     "CopySourceRange",
 ,
-374
+)
 .with_http_header("x-amz-copy-source-range");
 static UPLOADPARTCOPYINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$Key",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
-385
+)
 .with_http_label();
 static UPLOADPARTCOPYINPUT_MEMBER_PART_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$PartNumber",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "part_number",
     "PartNumber",
 ,
-396
+)
 .with_http_query("partNumber");
 static UPLOADPARTCOPYINPUT_MEMBER_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$UploadId",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "upload_id",
     "UploadId",
 ,
-407
+)
 .with_http_query("uploadId");
 static UPLOADPARTCOPYINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$SSECustomerAlgorithm",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_algorithm",
     "SSECustomerAlgorithm",
 ,
-418
+)
 .with_http_header("x-amz-server-side-encryption-customer-algorithm");
 static UPLOADPARTCOPYINPUT_MEMBER_SSE_CUSTOMER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$SSECustomerKey",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key",
     "SSECustomerKey",
 ,
-429
+)
 .with_http_header("x-amz-server-side-encryption-customer-key");
 static UPLOADPARTCOPYINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$SSECustomerKeyMD5",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key_md5",
     "SSECustomerKeyMD5",
 ,
-440
+)
 .with_http_header("x-amz-server-side-encryption-customer-key-MD5");
 static UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$CopySourceSSECustomerAlgorithm",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "copy_source_sse_customer_algorithm",
     "CopySourceSSECustomerAlgorithm",
 ,
-451
+)
 .with_http_header("x-amz-copy-source-server-side-encryption-customer-algorithm");
 static UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$CopySourceSSECustomerKey",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "copy_source_sse_customer_key",
     "CopySourceSSECustomerKey",
 ,
-462
+)
 .with_http_header("x-amz-copy-source-server-side-encryption-customer-key");
 static UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$CopySourceSSECustomerKeyMD5",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "copy_source_sse_customer_key_md5",
     "CopySourceSSECustomerKeyMD5",
 ,
-473
+)
 .with_http_header("x-amz-copy-source-server-side-encryption-customer-key-MD5");
 static UPLOADPARTCOPYINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$RequestPayer",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_payer",
     "RequestPayer",
 ,
-484
+)
 .with_http_header("x-amz-request-payer");
 static UPLOADPARTCOPYINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-495
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static UPLOADPARTCOPYINPUT_MEMBER_EXPECTED_SOURCE_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyInput$ExpectedSourceBucketOwner",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_source_bucket_owner",
     "ExpectedSourceBucketOwner",
 ,
-506
+)
 .with_http_header("x-amz-source-expected-bucket-owner");
 static UPLOADPARTCOPYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPLOADPARTCOPYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPLOADPARTCOPYINPUT_MEMBER_BUCKET,
         &UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE,
         &UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_MATCH,
         &UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_MODIFIED_SINCE,
         &UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_NONE_MATCH,
         &UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_UNMODIFIED_SINCE,
         &UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_RANGE,
         &UPLOADPARTCOPYINPUT_MEMBER_KEY,
         &UPLOADPARTCOPYINPUT_MEMBER_PART_NUMBER,
         &UPLOADPARTCOPYINPUT_MEMBER_UPLOAD_ID,
         &UPLOADPARTCOPYINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
         &UPLOADPARTCOPYINPUT_MEMBER_SSE_CUSTOMER_KEY,
         &UPLOADPARTCOPYINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
         &UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_ALGORITHM,
         &UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_KEY,
         &UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_KEY_MD5,
         &UPLOADPARTCOPYINPUT_MEMBER_REQUEST_PAYER,
         &UPLOADPARTCOPYINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
         &UPLOADPARTCOPYINPUT_MEMBER_EXPECTED_SOURCE_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/{Key+}?x-id=UploadPartCopy", None));
 impl UploadPartCopyInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPLOADPARTCOPYINPUT_SCHEMA;
-537
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UploadPartCopyInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {

↧ Expand context

         if let Some(ref val) = self.bucket {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_BUCKET, val)?;
-546
+        }
         if let Some(ref val) = self.copy_source {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE, val)?;
-549
+        }
         if let Some(ref val) = self.copy_source_if_match {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_MATCH, val)?;
-552
+        }
         if let Some(ref val) = self.copy_source_if_modified_since {
             ser.write_timestamp(&UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_MODIFIED_SINCE, val)?;
-555
+        }
         if let Some(ref val) = self.copy_source_if_none_match {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_NONE_MATCH, val)?;
-558
+        }
         if let Some(ref val) = self.copy_source_if_unmodified_since {
             ser.write_timestamp(&UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_IF_UNMODIFIED_SINCE, val)?;
-561
+        }
         if let Some(ref val) = self.copy_source_range {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_RANGE, val)?;

@@ -575,576 +647,648 @@

↥ Expand context

-576
+        }
         if let Some(ref val) = self.sse_customer_key {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_SSE_CUSTOMER_KEY, val)?;
-579
+        }
         if let Some(ref val) = self.sse_customer_key_md5 {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5, val)?;
-582
+        }
         if let Some(ref val) = self.copy_source_sse_customer_algorithm {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_ALGORITHM, val)?;
-585
+        }
         if let Some(ref val) = self.copy_source_sse_customer_key {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_KEY, val)?;
-588
+        }
         if let Some(ref val) = self.copy_source_sse_customer_key_md5 {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_KEY_MD5, val)?;
-591
+        }
         if let Some(ref val) = self.request_payer {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
-594
+        }
         if let Some(ref val) = self.expected_bucket_owner {

             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-597
+        }
         if let Some(ref val) = self.expected_source_bucket_owner {
             ser.write_string(&UPLOADPARTCOPYINPUT_MEMBER_EXPECTED_SOURCE_BUCKET_OWNER, val)?;
-600
+        }
         Ok(())
-602
+    }
-603
+}
 impl UploadPartCopyInput {
     /// 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(&UPLOADPARTCOPYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPLOADPARTCOPYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-622
+                }
                 Some(1) => {
                     builder.copy_source = Some(deser.read_string(member)?);
-625
+                }
                 Some(2) => {
                     builder.copy_source_if_match = Some(deser.read_string(member)?);
-628
+                }

↧ Expand context

                 Some(3) => {
                     builder.copy_source_if_modified_since = Some(deser.read_timestamp(member)?);
-631
+                }
                 Some(4) => {
                     builder.copy_source_if_none_match = Some(deser.read_string(member)?);
-634
+                }
                 Some(5) => {
                     builder.copy_source_if_unmodified_since = Some(deser.read_timestamp(member)?);
-637
+                }
                 Some(6) => {
                     builder.copy_source_range = Some(deser.read_string(member)?);
-640
+                }
                 Some(7) => {
                     builder.key = Some(deser.read_string(member)?);
-643
+                }
                 Some(8) => {
                     builder.part_number = Some(deser.read_integer(member)?);
-646
+                }
                 Some(9) => {
                     builder.upload_id = Some(deser.read_string(member)?);

@@ -650,651 +709,818 @@

↥ Expand context

                     builder.sse_customer_algorithm = Some(deser.read_string(member)?);
-652
+                }
                 Some(11) => {
                     builder.sse_customer_key = Some(deser.read_string(member)?);
-655
+                }
                 Some(12) => {
                     builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
-658
+                }
                 Some(13) => {
                     builder.copy_source_sse_customer_algorithm = Some(deser.read_string(member)?);
-661
+                }
                 Some(14) => {
                     builder.copy_source_sse_customer_key = Some(deser.read_string(member)?);
-664
+                }
                 Some(15) => {
                     builder.copy_source_sse_customer_key_md5 = Some(deser.read_string(member)?);
-667
+                }
                 Some(16) => {
                     builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
-670
+                }

                 Some(17) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-673
+                }
                 Some(18) => {
                     builder.expected_source_bucket_owner = Some(deser.read_string(member)?);
-676
+                }
                 _ => {}
-678
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder.copy_source = builder.copy_source.or(Some(String::new()));
         builder.key = builder.key.or(Some(String::new()));
         builder.part_number = builder.part_number.or(Some(0i32));
         builder.upload_id = builder.upload_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl UploadPartCopyInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-copy-source") {
             builder.copy_source = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-copy-source-if-match") {
             builder.copy_source_if_match = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-copy-source-if-modified-since") {
             builder.copy_source_if_modified_since = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-copy-source-if-none-match") {
             builder.copy_source_if_none_match = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-copy-source-if-unmodified-since") {
             builder.copy_source_if_unmodified_since =
                 ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-copy-source-range") {
             builder.copy_source_range = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
             builder.sse_customer_algorithm = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key") {
             builder.sse_customer_key = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
             builder.sse_customer_key_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-copy-source-server-side-encryption-customer-algorithm") {
             builder.copy_source_sse_customer_algorithm = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-copy-source-server-side-encryption-customer-key") {
             builder.copy_source_sse_customer_key = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-copy-source-server-side-encryption-customer-key-MD5") {
             builder.copy_source_sse_customer_key_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-request-payer") {
             builder.request_payer = Some(crate::types::RequestPayer::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-source-expected-bucket-owner") {
             builder.expected_source_bucket_owner = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UPLOADPARTCOPYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => { /* read from headers above */ }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => { /* read from headers above */ }
                 Some(4) => { /* read from headers above */ }
                 Some(5) => { /* read from headers above */ }
                 Some(6) => { /* read from headers above */ }
                 Some(7) => {
                     builder.key = Some(deser.read_string(member)?);
-+
+                }
                 Some(8) => {
                     builder.part_number = Some(deser.read_integer(member)?);
-+
+                }
                 Some(9) => {
                     builder.upload_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(10) => { /* read from headers above */ }
                 Some(11) => { /* read from headers above */ }
                 Some(12) => { /* read from headers above */ }
                 Some(13) => { /* read from headers above */ }
                 Some(14) => { /* read from headers above */ }
                 Some(15) => { /* read from headers above */ }
                 Some(16) => { /* read from headers above */ }
                 Some(17) => { /* read from headers above */ }
                 Some(18) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-792
+    }
-793
+}
 impl UploadPartCopyInput {
     /// Creates a new builder-style object to manufacture [`UploadPartCopyInput`](crate::operation::upload_part_copy::UploadPartCopyInput).
     pub fn builder() -> crate::operation::upload_part_copy::builders::UploadPartCopyInputBuilder {
         crate::operation::upload_part_copy::builders::UploadPartCopyInputBuilder::default()
-798
+    }

↧ Expand context

-799
+}
-800
 /// A builder for [`UploadPartCopyInput`](crate::operation::upload_part_copy::UploadPartCopyInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct UploadPartCopyInputBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) copy_source: ::std::option::Option<::std::string::String>,
     pub(crate) copy_source_if_match: ::std::option::Option<::std::string::String>,
     pub(crate) copy_source_if_modified_since: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) copy_source_if_none_match: ::std::option::Option<::std::string::String>,
     pub(crate) copy_source_if_unmodified_since: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) copy_source_range: ::std::option::Option<::std::string::String>,
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) part_number: ::std::option::Option<i32>,
     pub(crate) upload_id: ::std::option::Option<::std::string::String>,
     pub(crate) sse_customer_algorithm: ::std::option::Option<::std::string::String>,
     pub(crate) sse_customer_key: ::std::option::Option<::std::string::String>,
     pub(crate) sse_customer_key_md5: ::std::option::Option<::std::string::String>,
     pub(crate) copy_source_sse_customer_algorithm: ::std::option::Option<::std::string::String>,

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part_copy/_upload_part_copy_output.rs

@@ -77,77 +315,368 @@

↥ Expand context

-77
+    }
-78
+}
 impl ::std::fmt::Debug for UploadPartCopyOutput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("UploadPartCopyOutput");
         formatter.field("copy_source_version_id", &self.copy_source_version_id);
         formatter.field("copy_part_result", &self.copy_part_result);
         formatter.field("server_side_encryption", &self.server_side_encryption);
         formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
         formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
         formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
         formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
         formatter.field("request_charged", &self.request_charged);
         formatter.field("_extended_request_id", &self._extended_request_id);
         formatter.field("_request_id", &self._request_id);
         formatter.finish()
-93
+    }
-94
+}
 static UPLOADPARTCOPYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#UploadPartCopyOutput",

     "com.amazonaws.s3.synthetic",
     "UploadPartCopyOutput",
 );
 static UPLOADPARTCOPYOUTPUT_MEMBER_COPY_SOURCE_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyOutput$CopySourceVersionId",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "copy_source_version_id",
     "CopySourceVersionId",
 ,
-109
+)
 .with_http_header("x-amz-copy-source-version-id");
 static UPLOADPARTCOPYOUTPUT_MEMBER_COPY_PART_RESULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyOutput$CopyPartResult",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "copy_part_result",
     "CopyPartResult",
 ,
-120
+)
 .with_http_payload();
 static UPLOADPARTCOPYOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyOutput$ServerSideEncryption",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "server_side_encryption",
     "ServerSideEncryption",
 ,
-131
+)
 .with_http_header("x-amz-server-side-encryption");
 static UPLOADPARTCOPYOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyOutput$SSECustomerAlgorithm",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_algorithm",
     "SSECustomerAlgorithm",
 ,
-142
+)
 .with_http_header("x-amz-server-side-encryption-customer-algorithm");
 static UPLOADPARTCOPYOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyOutput$SSECustomerKeyMD5",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key_md5",
     "SSECustomerKeyMD5",
 ,
-153
+)
 .with_http_header("x-amz-server-side-encryption-customer-key-MD5");
 static UPLOADPARTCOPYOUTPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyOutput$SSEKMSKeyId",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_key_id",
     "SSEKMSKeyId",
 ,
-164
+)
 .with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
 static UPLOADPARTCOPYOUTPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyOutput$BucketKeyEnabled",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bucket_key_enabled",
     "BucketKeyEnabled",
 ,
-175
+)
 .with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
 static UPLOADPARTCOPYOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#UploadPartCopyOutput$RequestCharged",
         "com.amazonaws.s3.synthetic",
         "UploadPartCopyOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_charged",
     "RequestCharged",
 ,
-186
+)
 .with_http_header("x-amz-request-charged");
 static UPLOADPARTCOPYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static UPLOADPARTCOPYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPLOADPARTCOPYOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPLOADPARTCOPYOUTPUT_MEMBER_COPY_SOURCE_VERSION_ID,
         &UPLOADPARTCOPYOUTPUT_MEMBER_COPY_PART_RESULT,
         &UPLOADPARTCOPYOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
         &UPLOADPARTCOPYOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
         &UPLOADPARTCOPYOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
         &UPLOADPARTCOPYOUTPUT_MEMBER_SSEKMS_KEY_ID,
         &UPLOADPARTCOPYOUTPUT_MEMBER_BUCKET_KEY_ENABLED,
         &UPLOADPARTCOPYOUTPUT_MEMBER_REQUEST_CHARGED,
         &UPLOADPARTCOPYOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl UploadPartCopyOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPLOADPARTCOPYOUTPUT_SCHEMA;
-213
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UploadPartCopyOutput {
     #[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.copy_source_version_id {
             ser.write_string(&UPLOADPARTCOPYOUTPUT_MEMBER_COPY_SOURCE_VERSION_ID, val)?;
-222
+        }
         if let Some(ref val) = self.copy_part_result {
             ser.write_struct(&UPLOADPARTCOPYOUTPUT_MEMBER_COPY_PART_RESULT, val)?;
-225
+        }
         if let Some(ref val) = self.server_side_encryption {
             ser.write_string(&UPLOADPARTCOPYOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION, val.as_str())?;
-228
+        }
         if let Some(ref val) = self.sse_customer_algorithm {
             ser.write_string(&UPLOADPARTCOPYOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM, val)?;
-231
+        }
         if let Some(ref val) = self.sse_customer_key_md5 {
             ser.write_string(&UPLOADPARTCOPYOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5, val)?;
-234
+        }
         if let Some(ref val) = self.ssekms_key_id {
             ser.write_string(&UPLOADPARTCOPYOUTPUT_MEMBER_SSEKMS_KEY_ID, val)?;
-237
+        }
         if let Some(ref val) = self.bucket_key_enabled {
             ser.write_boolean(&UPLOADPARTCOPYOUTPUT_MEMBER_BUCKET_KEY_ENABLED, *val)?;
-240
+        }
         if let Some(ref val) = self.request_charged {
             ser.write_string(&UPLOADPARTCOPYOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
-243
+        }
         Ok(())
-245
+    }
-246
+}
 impl UploadPartCopyOutput {
     /// 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(&UPLOADPARTCOPYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPLOADPARTCOPYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.copy_source_version_id = Some(deser.read_string(member)?);
-265
+                }
                 Some(1) => {
                     builder.copy_part_result = Some(crate::types::CopyPartResult::deserialize(deser)?);
-268
+                }
                 Some(2) => {
                     builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
-271
+                }
                 Some(3) => {
                     builder.sse_customer_algorithm = Some(deser.read_string(member)?);
-274
+                }
                 Some(4) => {
                     builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
-277
+                }
                 Some(5) => {
                     builder.ssekms_key_id = Some(deser.read_string(member)?);
-280
+                }
                 Some(6) => {
                     builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
-283
+                }
                 Some(7) => {
                     builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
-286
+                }
                 Some(8) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-291
+            }
             Ok(())
         })?;
         Ok(builder.build())
-295
+    }
-296
+}
 impl UploadPartCopyOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-copy-source-version-id") {
             builder.copy_source_version_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption") {
             builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
             builder.sse_customer_algorithm = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
             builder.sse_customer_key_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
             builder.ssekms_key_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
             builder.bucket_key_enabled = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-request-charged") {
             builder.request_charged = Some(crate::types::RequestCharged::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         if !body.is_empty() {
             builder.copy_part_result = Some(crate::types::CopyPartResult::deserialize(deserializer)?);
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl crate::s3_request_id::RequestIdExt for UploadPartCopyOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-342
+    }
-343
+}
 impl ::aws_types::request_id::RequestId for UploadPartCopyOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-347
+    }
-348
+}

↧ Expand context

 impl UploadPartCopyOutput {
     /// Creates a new builder-style object to manufacture [`UploadPartCopyOutput`](crate::operation::upload_part_copy::UploadPartCopyOutput).
     pub fn builder() -> crate::operation::upload_part_copy::builders::UploadPartCopyOutputBuilder {
         crate::operation::upload_part_copy::builders::UploadPartCopyOutputBuilder::default()
-353
+    }
-354
+}
-355
 /// A builder for [`UploadPartCopyOutput`](crate::operation::upload_part_copy::UploadPartCopyOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct UploadPartCopyOutputBuilder {
     pub(crate) copy_source_version_id: ::std::option::Option<::std::string::String>,
     pub(crate) copy_part_result: ::std::option::Option<crate::types::CopyPartResult>,
     pub(crate) server_side_encryption: ::std::option::Option<crate::types::ServerSideEncryption>,
     pub(crate) sse_customer_algorithm: ::std::option::Option<::std::string::String>,
     pub(crate) sse_customer_key_md5: ::std::option::Option<::std::string::String>,
     pub(crate) ssekms_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) bucket_key_enabled: ::std::option::Option<bool>,
     pub(crate) request_charged: ::std::option::Option<crate::types::RequestCharged>,
     _extended_request_id: Option<String>,

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/write_get_object_response.rs

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

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

@@ -127,131 +189,194 @@

↥ Expand context

         #[allow(unused_mut)]
         let mut rcb =
             ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("WriteGetObjectResponse")
                 .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
                 .with_interceptor(WriteGetObjectResponseEndpointParamsInterceptor)
                 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                     crate::operation::write_get_object_response::WriteGetObjectResponseError,
                 >::new())
                 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                     crate::operation::write_get_object_response::WriteGetObjectResponseError,
                 >::new())
                 .with_retry_classifier(
                     ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                         crate::operation::write_get_object_response::WriteGetObjectResponseError,
                     >::builder()
                     .transient_errors({
                         let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                         transient_errors.push("InternalError");
                         ::std::borrow::Cow::Owned(transient_errors)
                     })

                     .build(),
                 );
-153
         ::std::borrow::Cow::Owned(rcb)
-155
+    }
-156
+}
-157
 #[derive(Debug)]
 struct WriteGetObjectResponseResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for WriteGetObjectResponseResponseDeserializer {
     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;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-174
+        }

↧ Expand context

         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_write_get_object_response::de_write_get_object_response_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_write_get_object_response::de_write_get_object_response_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-182
+    }
-183
+}
 #[derive(Debug)]
 struct WriteGetObjectResponseRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for WriteGetObjectResponseRequestSerializer {
     #[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::write_get_object_response::WriteGetObjectResponseInput>()

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/write_get_object_response/_write_get_object_response_input.rs

@@ -371,371 +942,940 @@

↥ Expand context

         formatter.field("object_lock_mode", &self.object_lock_mode);
         formatter.field("object_lock_legal_hold_status", &self.object_lock_legal_hold_status);
         formatter.field("object_lock_retain_until_date", &self.object_lock_retain_until_date);
         formatter.field("parts_count", &self.parts_count);
         formatter.field("replication_status", &self.replication_status);
         formatter.field("request_charged", &self.request_charged);
         formatter.field("restore", &self.restore);
         formatter.field("server_side_encryption", &self.server_side_encryption);
         formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
         formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
         formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
         formatter.field("storage_class", &self.storage_class);
         formatter.field("tag_count", &self.tag_count);
         formatter.field("version_id", &self.version_id);
         formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
         formatter.finish()
-387
+    }
-388
+}
 static WRITEGETOBJECTRESPONSEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput",

     "com.amazonaws.s3.synthetic",
     "WriteGetObjectResponseInput",
 );
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_REQUEST_ROUTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$RequestRoute",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_route",
     "RequestRoute",
 ,
-403
+)
 .with_host_label()
 .with_http_header("x-amz-request-route");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_REQUEST_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$RequestToken",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_token",
     "RequestToken",
 ,
-415
+)
 .with_http_header("x-amz-request-token");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_BODY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$Body",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "body",
     "Body",
 ,
-426
+)
 .with_http_payload();
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_STATUS_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$StatusCode",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "status_code",
     "StatusCode",
 ,
-437
+)
 .with_http_header("x-amz-fwd-status");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_ERROR_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ErrorCode",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "error_code",
     "ErrorCode",
 ,
-448
+)
 .with_http_header("x-amz-fwd-error-code");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ErrorMessage",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "error_message",
     "ErrorMessage",
 ,
-459
+)
 .with_http_header("x-amz-fwd-error-message");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_ACCEPT_RANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$AcceptRanges",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "accept_ranges",
     "AcceptRanges",
 ,
-470
+)
 .with_http_header("x-amz-fwd-header-accept-ranges");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CACHE_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$CacheControl",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "cache_control",
     "CacheControl",
 ,
-481
+)
 .with_http_header("x-amz-fwd-header-Cache-Control");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_DISPOSITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ContentDisposition",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_disposition",
     "ContentDisposition",
 ,
-492
+)
 .with_http_header("x-amz-fwd-header-Content-Disposition");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ContentEncoding",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_encoding",
     "ContentEncoding",
 ,
-503
+)
 .with_http_header("x-amz-fwd-header-Content-Encoding");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ContentLanguage",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_language",
     "ContentLanguage",
 ,
-514
+)
 .with_http_header("x-amz-fwd-header-Content-Language");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_LENGTH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ContentLength",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "content_length",
     "ContentLength",
 ,
-525
+)
 .with_http_header("Content-Length");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_RANGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ContentRange",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_range",
     "ContentRange",
 ,
-536
+)
 .with_http_header("x-amz-fwd-header-Content-Range");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ContentType",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_type",
     "ContentType",
 ,
-547
+)
 .with_http_header("x-amz-fwd-header-Content-Type");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ChecksumCRC32",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32",
     "ChecksumCRC32",
 ,
-558
+)
 .with_http_header("x-amz-fwd-header-x-amz-checksum-crc32");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ChecksumCRC32C",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32_c",
     "ChecksumCRC32C",
 ,
-569
+)
 .with_http_header("x-amz-fwd-header-x-amz-checksum-crc32c");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ChecksumCRC64NVME",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc64_nvme",
     "ChecksumCRC64NVME",
 ,
-580
+)
 .with_http_header("x-amz-fwd-header-x-amz-checksum-crc64nvme");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ChecksumSHA1",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha1",
     "ChecksumSHA1",
 ,
-591
+)
 .with_http_header("x-amz-fwd-header-x-amz-checksum-sha1");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ChecksumSHA256",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha256",
     "ChecksumSHA256",
 ,
-602
+)
 .with_http_header("x-amz-fwd-header-x-amz-checksum-sha256");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_DELETE_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$DeleteMarker",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "delete_marker",
     "DeleteMarker",
 ,
-613
+)
 .with_http_header("x-amz-fwd-header-x-amz-delete-marker");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ETag",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "e_tag",
     "ETag",
 ,
-624
+)
 .with_http_header("x-amz-fwd-header-ETag");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_EXPIRES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$Expires",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "expires",
     "Expires",
 ,
-635
+)
 .with_http_header("x-amz-fwd-header-Expires");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$Expiration",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expiration",
     "Expiration",
 ,
-646
+)
 .with_http_header("x-amz-fwd-header-x-amz-expiration");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$LastModified",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "last_modified",
     "LastModified",
 ,
-657
+)
 .with_http_header("x-amz-fwd-header-Last-Modified");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_MISSING_META: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$MissingMeta",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "missing_meta",
     "MissingMeta",
 ,
-668
+)
 .with_http_header("x-amz-fwd-header-x-amz-missing-meta");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$Metadata",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "metadata",
     "Metadata",
 ,
-679
+)
 .with_http_prefix_headers("x-amz-meta-");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_OBJECT_LOCK_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ObjectLockMode",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "object_lock_mode",
     "ObjectLockMode",
 ,
-690
+)
 .with_http_header("x-amz-fwd-header-x-amz-object-lock-mode");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ObjectLockLegalHoldStatus",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "object_lock_legal_hold_status",
     "ObjectLockLegalHoldStatus",
 ,
-701
+)
 .with_http_header("x-amz-fwd-header-x-amz-object-lock-legal-hold");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ObjectLockRetainUntilDate",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "object_lock_retain_until_date",
     "ObjectLockRetainUntilDate",
 ,
-712
+)
 .with_http_header("x-amz-fwd-header-x-amz-object-lock-retain-until-date");
 .with_http_header("x-amz-fwd-header-x-amz-object-lock-retain-until-date")
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_PARTS_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$PartsCount",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "parts_count",
     "PartsCount",
 ,
-724
+)
 .with_http_header("x-amz-fwd-header-x-amz-mp-parts-count");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_REPLICATION_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ReplicationStatus",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "replication_status",
     "ReplicationStatus",
 ,
-735
+)
 .with_http_header("x-amz-fwd-header-x-amz-replication-status");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$RequestCharged",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_charged",
     "RequestCharged",
 ,
-746
+)
 .with_http_header("x-amz-fwd-header-x-amz-request-charged");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_RESTORE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$Restore",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "restore",
     "Restore",
 ,
-757
+)
 .with_http_header("x-amz-fwd-header-x-amz-restore");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$ServerSideEncryption",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "server_side_encryption",
     "ServerSideEncryption",
 ,
-768
+)
 .with_http_header("x-amz-fwd-header-x-amz-server-side-encryption");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$SSECustomerAlgorithm",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_algorithm",
     "SSECustomerAlgorithm",
 ,
-779
+)
 .with_http_header("x-amz-fwd-header-x-amz-server-side-encryption-customer-algorithm");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$SSEKMSKeyId",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_key_id",
     "SSEKMSKeyId",
 ,
-790
+)
 .with_http_header("x-amz-fwd-header-x-amz-server-side-encryption-aws-kms-key-id");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$SSECustomerKeyMD5",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key_md5",
     "SSECustomerKeyMD5",
 ,
-801
+)
 .with_http_header("x-amz-fwd-header-x-amz-server-side-encryption-customer-key-MD5");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$StorageClass",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "storage_class",
     "StorageClass",
 ,
-812
+)
 .with_http_header("x-amz-fwd-header-x-amz-storage-class");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_TAG_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$TagCount",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "tag_count",
     "TagCount",
 ,
-823
+)
 .with_http_header("x-amz-fwd-header-x-amz-tagging-count");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$VersionId",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "version_id",
     "VersionId",
 ,
-834
+)
 .with_http_header("x-amz-fwd-header-x-amz-version-id");
 static WRITEGETOBJECTRESPONSEINPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#WriteGetObjectResponseInput$BucketKeyEnabled",
         "com.amazonaws.s3.synthetic",
         "WriteGetObjectResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bucket_key_enabled",
     "BucketKeyEnabled",
 ,
-845
+)
 .with_http_header("x-amz-fwd-header-x-amz-server-side-encryption-bucket-key-enabled");
 static WRITEGETOBJECTRESPONSEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     WRITEGETOBJECTRESPONSEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_REQUEST_ROUTE,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_REQUEST_TOKEN,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_BODY,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_STATUS_CODE,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_ERROR_CODE,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_ERROR_MESSAGE,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_ACCEPT_RANGES,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CACHE_CONTROL,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_DISPOSITION,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_ENCODING,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_LANGUAGE,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_LENGTH,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_RANGE,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_TYPE,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CHECKSUM_CRC32,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CHECKSUM_CRC32_C,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CHECKSUM_CRC64_NVME,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CHECKSUM_SHA1,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_CHECKSUM_SHA256,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_DELETE_MARKER,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_E_TAG,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_EXPIRES,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_EXPIRATION,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_LAST_MODIFIED,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_MISSING_META,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_METADATA,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_OBJECT_LOCK_MODE,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_PARTS_COUNT,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_REPLICATION_STATUS,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_REQUEST_CHARGED,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_RESTORE,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_SSEKMS_KEY_ID,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_STORAGE_CLASS,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_TAG_COUNT,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_VERSION_ID,
         &WRITEGETOBJECTRESPONSEINPUT_MEMBER_BUCKET_KEY_ENABLED,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/WriteGetObjectResponse", None));
 impl WriteGetObjectResponseInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &WRITEGETOBJECTRESPONSEINPUT_SCHEMA;
-898
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for WriteGetObjectResponseInput {
     #[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.request_route {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_REQUEST_ROUTE, val)?;
-907
+        }
         if let Some(ref val) = self.request_token {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_REQUEST_TOKEN, val)?;
-910
+        }
--
+        {
             let val = &self.body;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         if let Some(ref val) = self.status_code {
             ser.write_integer(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_STATUS_CODE, *val)?;
-913
+        }
         if let Some(ref val) = self.error_code {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_ERROR_CODE, val)?;
-916
+        }
         if let Some(ref val) = self.error_message {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_ERROR_MESSAGE, val)?;
-919
+        }
         if let Some(ref val) = self.accept_ranges {

↧ Expand context

             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_ACCEPT_RANGES, val)?;
-922
+        }
         if let Some(ref val) = self.cache_control {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_CACHE_CONTROL, val)?;
-925
+        }
         if let Some(ref val) = self.content_disposition {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_DISPOSITION, val)?;
-928
+        }
         if let Some(ref val) = self.content_encoding {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_ENCODING, val)?;
-931
+        }
         if let Some(ref val) = self.content_language {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_LANGUAGE, val)?;
-934
+        }
         if let Some(ref val) = self.content_length {
             ser.write_long(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_LENGTH, *val)?;
-937
+        }
         if let Some(ref val) = self.content_range {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_CONTENT_RANGE, val)?;
-940
+        }

@@ -1011,1009 +1083,1081 @@

↥ Expand context

-1009
+        }
         if let Some(ref val) = self.server_side_encryption {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_SERVER_SIDE_ENCRYPTION, val.as_str())?;
-1012
+        }
         if let Some(ref val) = self.sse_customer_algorithm {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM, val)?;
-1015
+        }
         if let Some(ref val) = self.ssekms_key_id {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_SSEKMS_KEY_ID, val)?;
-1018
+        }
         if let Some(ref val) = self.sse_customer_key_md5 {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5, val)?;
-1021
+        }
         if let Some(ref val) = self.storage_class {
             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_STORAGE_CLASS, val.as_str())?;
-1024
+        }
         if let Some(ref val) = self.tag_count {
             ser.write_integer(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_TAG_COUNT, *val)?;
-1027
+        }
         if let Some(ref val) = self.version_id {

             ser.write_string(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_VERSION_ID, val)?;
-1030
+        }
         if let Some(ref val) = self.bucket_key_enabled {
             ser.write_boolean(&WRITEGETOBJECTRESPONSEINPUT_MEMBER_BUCKET_KEY_ENABLED, *val)?;
-1033
+        }
         Ok(())
-1035
+    }
-1036
+}
 impl WriteGetObjectResponseInput {
     /// 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(&WRITEGETOBJECTRESPONSEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&WRITEGETOBJECTRESPONSEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_route = Some(deser.read_string(member)?);
-1055
+                }
                 Some(1) => {
                     builder.request_token = Some(deser.read_string(member)?);
-1058
+                }
                 Some(2) => {
                     builder.body = Some({
                         let _ = member;

↧ Expand context

                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-1064
+                }
                 Some(3) => {
                     builder.status_code = Some(deser.read_integer(member)?);
-1067
+                }
                 Some(4) => {
                     builder.error_code = Some(deser.read_string(member)?);
-1070
+                }
                 Some(5) => {
                     builder.error_message = Some(deser.read_string(member)?);
-1073
+                }
                 Some(6) => {
                     builder.accept_ranges = Some(deser.read_string(member)?);
-1076
+                }
                 Some(7) => {
                     builder.cache_control = Some(deser.read_string(member)?);
-1079
+                }
                 Some(8) => {
                     builder.content_disposition = Some(deser.read_string(member)?);

@@ -1104,1102 +1224,1418 @@

↥ Expand context

                     builder.checksum_crc32_c = Some(deser.read_string(member)?);
-1103
+                }
                 Some(16) => {
                     builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
-1106
+                }
                 Some(17) => {
                     builder.checksum_sha1 = Some(deser.read_string(member)?);
-1109
+                }
                 Some(18) => {
                     builder.checksum_sha256 = Some(deser.read_string(member)?);
-1112
+                }
                 Some(19) => {
                     builder.delete_marker = Some(deser.read_boolean(member)?);
-1115
+                }
                 Some(20) => {
                     builder.e_tag = Some(deser.read_string(member)?);
-1118
+                }
                 Some(21) => {
                     builder.expires = Some(deser.read_timestamp(member)?);
-1121
+                }

                 Some(22) => {
                     builder.expiration = Some(deser.read_string(member)?);
-1124
+                }
                 Some(23) => {
                     builder.last_modified = Some(deser.read_timestamp(member)?);
-1127
+                }
                 Some(24) => {
                     builder.missing_meta = Some(deser.read_integer(member)?);
-1130
+                }
                 Some(25) => {
                     builder.metadata = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.metadata = Some(deser.read_string_string_map(member)?);
-1133
+                }
                 Some(26) => {
                     builder.object_lock_mode = Some(crate::types::ObjectLockMode::from(deser.read_string(member)?.as_str()));
-1136
+                }
                 Some(27) => {
                     builder.object_lock_legal_hold_status = Some(crate::types::ObjectLockLegalHoldStatus::from(deser.read_string(member)?.as_str()));
-1139
+                }
                 Some(28) => {
                     builder.object_lock_retain_until_date = Some(deser.read_timestamp(member)?);
-1142
+                }
                 Some(29) => {
                     builder.parts_count = Some(deser.read_integer(member)?);
-1145
+                }
                 Some(30) => {
                     builder.replication_status = Some(crate::types::ReplicationStatus::from(deser.read_string(member)?.as_str()));
-1148
+                }
                 Some(31) => {
                     builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
-1151
+                }
                 Some(32) => {
                     builder.restore = Some(deser.read_string(member)?);
-1154
+                }
                 Some(33) => {
                     builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
-1157
+                }
                 Some(34) => {
                     builder.sse_customer_algorithm = Some(deser.read_string(member)?);
-1160
+                }
                 Some(35) => {
                     builder.ssekms_key_id = Some(deser.read_string(member)?);
-1163
+                }
                 Some(36) => {
                     builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
-1166
+                }
                 Some(37) => {
                     builder.storage_class = Some(crate::types::StorageClass::from(deser.read_string(member)?.as_str()));
-1169
+                }
                 Some(38) => {
                     builder.tag_count = Some(deser.read_integer(member)?);
-1172
+                }
                 Some(39) => {
                     builder.version_id = Some(deser.read_string(member)?);
-1175
+                }
                 Some(40) => {
                     builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
-1178
+                }
                 _ => {}
-1180
+            }
             Ok(())
         })?;
         builder.request_route = builder.request_route.or(Some(String::new()));
         builder.request_token = builder.request_token.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl WriteGetObjectResponseInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-request-route") {
             builder.request_route = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-request-token") {
             builder.request_token = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-status") {
             builder.status_code = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-error-code") {
             builder.error_code = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-error-message") {
             builder.error_message = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-accept-ranges") {
             builder.accept_ranges = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-Cache-Control") {
             builder.cache_control = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-Content-Disposition") {
             builder.content_disposition = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-Content-Encoding") {
             builder.content_encoding = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-Content-Language") {
             builder.content_language = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Content-Length") {
             builder.content_length = val.parse::<i64>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-Content-Range") {
             builder.content_range = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-Content-Type") {
             builder.content_type = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-checksum-crc32") {
             builder.checksum_crc32 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-checksum-crc32c") {
             builder.checksum_crc32_c = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-checksum-crc64nvme") {
             builder.checksum_crc64_nvme = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-checksum-sha1") {
             builder.checksum_sha1 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-checksum-sha256") {
             builder.checksum_sha256 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-delete-marker") {
             builder.delete_marker = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-ETag") {
             builder.e_tag = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-Expires") {
             builder.expires = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-expiration") {
             builder.expiration = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-Last-Modified") {
             builder.last_modified = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-missing-meta") {
             builder.missing_meta = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-object-lock-mode") {
             builder.object_lock_mode = Some(crate::types::ObjectLockMode::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-object-lock-legal-hold") {
             builder.object_lock_legal_hold_status = Some(crate::types::ObjectLockLegalHoldStatus::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-object-lock-retain-until-date") {
             builder.object_lock_retain_until_date = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::DateTime).ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-mp-parts-count") {
             builder.parts_count = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-replication-status") {
             builder.replication_status = Some(crate::types::ReplicationStatus::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-request-charged") {
             builder.request_charged = Some(crate::types::RequestCharged::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-restore") {
             builder.restore = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-server-side-encryption") {
             builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-server-side-encryption-customer-algorithm") {
             builder.sse_customer_algorithm = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-server-side-encryption-aws-kms-key-id") {
             builder.ssekms_key_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-server-side-encryption-customer-key-MD5") {
             builder.sse_customer_key_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-storage-class") {
             builder.storage_class = Some(crate::types::StorageClass::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-tagging-count") {
             builder.tag_count = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-version-id") {
             builder.version_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-fwd-header-x-amz-server-side-encryption-bucket-key-enabled") {
             builder.bucket_key_enabled = val.parse::<bool>().ok();
-+
+        }
-+
+        {
             let mut map = ::std::collections::HashMap::new();
             for (key, val) in headers.iter() {
                 if let Some(suffix) = key.strip_prefix("x-amz-meta-") {
                     map.insert(suffix.to_string(), val.to_string());
-+
+                }
-+
+            }
             if !map.is_empty() {
                 builder.metadata = Some(map);
-+
+            }
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&WRITEGETOBJECTRESPONSEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => { /* read from headers above */ }
                 Some(2) => {
                     builder.body = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 Some(3) => { /* read from headers above */ }
                 Some(4) => { /* read from headers above */ }
                 Some(5) => { /* read from headers above */ }
                 Some(6) => { /* read from headers above */ }
                 Some(7) => { /* read from headers above */ }
                 Some(8) => { /* read from headers above */ }
                 Some(9) => { /* read from headers above */ }
                 Some(10) => { /* read from headers above */ }
                 Some(11) => { /* read from headers above */ }
                 Some(12) => { /* read from headers above */ }
                 Some(13) => { /* read from headers above */ }
                 Some(14) => { /* read from headers above */ }
                 Some(15) => { /* read from headers above */ }
                 Some(16) => { /* read from headers above */ }
                 Some(17) => { /* read from headers above */ }
                 Some(18) => { /* read from headers above */ }
                 Some(19) => { /* read from headers above */ }
                 Some(20) => { /* read from headers above */ }
                 Some(21) => { /* read from headers above */ }
                 Some(22) => { /* read from headers above */ }
                 Some(23) => { /* read from headers above */ }
                 Some(24) => { /* read from headers above */ }
                 Some(25) => { /* read from headers above */ }
                 Some(26) => { /* read from headers above */ }
                 Some(27) => { /* read from headers above */ }
                 Some(28) => { /* read from headers above */ }
                 Some(29) => { /* read from headers above */ }
                 Some(30) => { /* read from headers above */ }
                 Some(31) => { /* read from headers above */ }
                 Some(32) => { /* read from headers above */ }
                 Some(33) => { /* read from headers above */ }
                 Some(34) => { /* read from headers above */ }
                 Some(35) => { /* read from headers above */ }
                 Some(36) => { /* read from headers above */ }
                 Some(37) => { /* read from headers above */ }
                 Some(38) => { /* read from headers above */ }
                 Some(39) => { /* read from headers above */ }
                 Some(40) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-1392
+    }
-1393
+}
 impl WriteGetObjectResponseInput {
     /// Creates a new builder-style object to manufacture [`WriteGetObjectResponseInput`](crate::operation::write_get_object_response::WriteGetObjectResponseInput).
     pub fn builder() -> crate::operation::write_get_object_response::builders::WriteGetObjectResponseInputBuilder {
         crate::operation::write_get_object_response::builders::WriteGetObjectResponseInputBuilder::default()
-1398
+    }

↧ Expand context

-1399
+}
-1400
 /// A builder for [`WriteGetObjectResponseInput`](crate::operation::write_get_object_response::WriteGetObjectResponseInput).
 #[derive(::std::default::Default)]
 #[non_exhaustive]
 pub struct WriteGetObjectResponseInputBuilder {
     pub(crate) request_route: ::std::option::Option<::std::string::String>,
     pub(crate) request_token: ::std::option::Option<::std::string::String>,
     pub(crate) body: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
     pub(crate) status_code: ::std::option::Option<i32>,
     pub(crate) error_code: ::std::option::Option<::std::string::String>,
     pub(crate) error_message: ::std::option::Option<::std::string::String>,
     pub(crate) accept_ranges: ::std::option::Option<::std::string::String>,
     pub(crate) cache_control: ::std::option::Option<::std::string::String>,
     pub(crate) content_disposition: ::std::option::Option<::std::string::String>,
     pub(crate) content_encoding: ::std::option::Option<::std::string::String>,
     pub(crate) content_language: ::std::option::Option<::std::string::String>,
     pub(crate) content_length: ::std::option::Option<i64>,
     pub(crate) content_range: ::std::option::Option<::std::string::String>,
     pub(crate) content_type: ::std::option::Option<::std::string::String>,

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_analytics_and_operator.rs

@@ -1,1 +140,148 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>A conjunction (logical AND) of predicates, which is used in evaluating a metrics filter. The operator must have at least two predicates in any combination, and an object must match all of the predicates for the filter to apply.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct AnalyticsAndOperator {
     /// <p>The prefix to use when evaluating an AND predicate: The prefix that an object must have to be included in the metrics results.</p>
     pub prefix: ::std::option::Option<::std::string::String>,
     /// <p>The list of tags to use when evaluating an AND predicate.</p>
     pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-11
+}
 impl AnalyticsAndOperator {
     /// <p>The prefix to use when evaluating an AND predicate: The prefix that an object must have to be included in the metrics results.</p>
     pub fn prefix(&self) -> ::std::option::Option<&str> {
         self.prefix.as_deref()
-16
+    }
     /// <p>The list of tags to use when evaluating an AND predicate.</p>
     ///

     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-22
+    }
-23
+}
 static ANALYTICSANDOPERATOR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#AnalyticsAndOperator", "com.amazonaws.s3", "AnalyticsAndOperator");
 static ANALYTICSANDOPERATOR_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#AnalyticsAndOperator$Prefix", "com.amazonaws.s3", "AnalyticsAndOperator"),
     ::aws_smithy_schema::ShapeType::String,
     "prefix",
     "Prefix",
 ,
 );
 static ANALYTICSANDOPERATOR_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#AnalyticsAndOperator$Tags", "com.amazonaws.s3", "AnalyticsAndOperator"),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-37
+)
 .with_xml_name("Tag")
 .with_xml_flattened();
 static ANALYTICSANDOPERATOR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ANALYTICSANDOPERATOR_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ANALYTICSANDOPERATOR_MEMBER_PREFIX, &ANALYTICSANDOPERATOR_MEMBER_TAGS],
 );
 impl AnalyticsAndOperator {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ANALYTICSANDOPERATOR_SCHEMA;
-48
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for AnalyticsAndOperator {
     #[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.prefix {
             ser.write_string(&ANALYTICSANDOPERATOR_MEMBER_PREFIX, val)?;
-57
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &ANALYTICSANDOPERATOR_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-64
+                    }
                     Ok(())
                 },
             )?;
-68
+        }
         Ok(())
-70
+    }
-71
+}
 impl AnalyticsAndOperator {
     /// 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(&ANALYTICSANDOPERATOR_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ANALYTICSANDOPERATOR_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.prefix = Some(deser.read_string(member)?);
-90
+                }
                 Some(1) => {
                     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
                     });
-100
+                }
                 _ => {}
-102
+            }
             Ok(())
         })?;
         Ok(builder.build())
-106
+    }
-107
+}
 impl AnalyticsAndOperator {
     /// 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 AnalyticsAndOperator {
     /// Creates a new builder-style object to manufacture [`AnalyticsAndOperator`](crate::types::AnalyticsAndOperator).
     pub fn builder() -> crate::types::builders::AnalyticsAndOperatorBuilder {
         crate::types::builders::AnalyticsAndOperatorBuilder::default()
-123
+    }
-124
+}
-125
 /// A builder for [`AnalyticsAndOperator`](crate::types::AnalyticsAndOperator).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct AnalyticsAndOperatorBuilder {
     pub(crate) prefix: ::std::option::Option<::std::string::String>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-132
+}
 impl AnalyticsAndOperatorBuilder {
     /// <p>The prefix to use when evaluating an AND predicate: The prefix that an object must have to be included in the metrics results.</p>
     pub fn prefix(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.prefix = ::std::option::Option::Some(input.into());
         self
-138
+    }
     /// <p>The prefix to use when evaluating an AND predicate: The prefix that an object must have to be included in the metrics results.</p>
     pub fn set_prefix(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.prefix = input;
         self
-143
+    }
     /// <p>The prefix to use when evaluating an AND predicate: The prefix that an object must have to be included in the metrics results.</p>
     pub fn get_prefix(&self) -> &::std::option::Option<::std::string::String> {
         &self.prefix
-147
+    }
     /// Appends an item to `tags`.

1 1	`// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2	`#[allow(missing_docs)] // documentation missing in model`
3 3	`#[non_exhaustive]`

 impl WriteGetObjectResponseOutput {
     /// Creates a new builder-style object to manufacture [`WriteGetObjectResponseOutput`](crate::operation::write_get_object_response::WriteGetObjectResponseOutput).
     pub fn builder() -> crate::operation::write_get_object_response::builders::WriteGetObjectResponseOutputBuilder {
         crate::operation::write_get_object_response::builders::WriteGetObjectResponseOutputBuilder::default()
-97
+    }
-98
+}
-99
 /// A builder for [`WriteGetObjectResponseOutput`](crate::operation::write_get_object_response::WriteGetObjectResponseOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct WriteGetObjectResponseOutputBuilder {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-106
+}
 impl WriteGetObjectResponseOutputBuilder {
     pub(crate) fn _extended_request_id(mut self, extended_request_id: impl Into<String>) -> Self {
         self._extended_request_id = Some(extended_request_id.into());
         self
-111
+    }
-112

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The ABAC status of the general purpose bucket. When ABAC is enabled for the general purpose bucket, you can use tags to manage access to the general purpose buckets as well as for cost tracking purposes. When ABAC is disabled for the general purpose buckets, you can only use tags for cost tracking purposes. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/buckets-tagging.html">Using tags with S3 general purpose buckets</a>.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct AbacStatus {
     /// <p>The ABAC status of the general purpose bucket.</p>
     pub status: ::std::option::Option<crate::types::BucketAbacStatus>,
-9
+}
 impl AbacStatus {

 pub struct AbacStatusBuilder {
     pub(crate) status: ::std::option::Option<crate::types::BucketAbacStatus>,
-94
+}
 impl AbacStatusBuilder {
     /// <p>The ABAC status of the general purpose bucket.</p>
     pub fn status(mut self, input: crate::types::BucketAbacStatus) -> Self {
         self.status = ::std::option::Option::Some(input);
         self
-100
+    }
     /// <p>The ABAC status of the general purpose bucket.</p>
     pub fn set_status(mut self, input: ::std::option::Option<crate::types::BucketAbacStatus>) -> Self {
         self.status = input;
         self
-105
+    }
     /// <p>The ABAC status of the general purpose bucket.</p>
     pub fn get_status(&self) -> &::std::option::Option<crate::types::BucketAbacStatus> {
         &self.status
-109
+    }
     /// Consumes the builder and constructs a [`AbacStatus`](crate::types::AbacStatus).
     pub fn build(self) -> crate::types::AbacStatus {

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Specifies the days since the initiation of an incomplete multipart upload that Amazon S3 will wait before permanently removing all parts of the upload. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config"> Aborting Incomplete Multipart Uploads Using a Bucket Lifecycle Configuration</a> in the <i>Amazon S3 User Guide</i>.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct AbortIncompleteMultipartUpload {
     /// <p>Specifies the number of days after which Amazon S3 aborts an incomplete multipart upload.</p>
     pub days_after_initiation: ::std::option::Option<i32>,
-9
+}
 impl AbortIncompleteMultipartUpload {
     /// <p>Specifies the number of days after which Amazon S3 aborts an incomplete multipart upload.</p>
     pub fn days_after_initiation(&self) -> ::std::option::Option<i32> {
         self.days_after_initiation
-14
+    }
-15
+}
 static ABORTINCOMPLETEMULTIPARTUPLOAD_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3#AbortIncompleteMultipartUpload",

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part/_upload_part_input.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part/_upload_part_output.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part_copy.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part_copy/_upload_part_copy_input.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part_copy/_upload_part_copy_output.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/write_get_object_response.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/write_get_object_response/_write_get_object_response_input.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/write_get_object_response/_write_get_object_response_output.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_abac_status.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_abort_incomplete_multipart_upload.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_accelerate_configuration.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_access_control_policy.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_access_control_translation.rs

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_analytics_and_operator.rs

 pub struct AbortIncompleteMultipartUploadBuilder {
     pub(crate) days_after_initiation: ::std::option::Option<i32>,
-101
+}
 impl AbortIncompleteMultipartUploadBuilder {
     /// <p>Specifies the number of days after which Amazon S3 aborts an incomplete multipart upload.</p>
     pub fn days_after_initiation(mut self, input: i32) -> Self {
         self.days_after_initiation = ::std::option::Option::Some(input);
         self
-107
+    }
     /// <p>Specifies the number of days after which Amazon S3 aborts an incomplete multipart upload.</p>
     pub fn set_days_after_initiation(mut self, input: ::std::option::Option<i32>) -> Self {
         self.days_after_initiation = input;
         self
-112
+    }
     /// <p>Specifies the number of days after which Amazon S3 aborts an incomplete multipart upload.</p>
     pub fn get_days_after_initiation(&self) -> &::std::option::Option<i32> {
         &self.days_after_initiation
-116
+    }
     /// Consumes the builder and constructs a [`AbortIncompleteMultipartUpload`](crate::types::AbortIncompleteMultipartUpload).
     pub fn build(self) -> crate::types::AbortIncompleteMultipartUpload {

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Configures the transfer acceleration state for an Amazon S3 bucket. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html">Amazon S3 Transfer Acceleration</a> in the <i>Amazon S3 User Guide</i>.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct AccelerateConfiguration {
     /// <p>Specifies the transfer acceleration status of the bucket.</p>
     pub status: ::std::option::Option<crate::types::BucketAccelerateStatus>,
-9
+}
 impl AccelerateConfiguration {
     /// <p>Specifies the transfer acceleration status of the bucket.</p>
     pub fn status(&self) -> ::std::option::Option<&crate::types::BucketAccelerateStatus> {
         self.status.as_ref()
-14
+    }

 pub struct AccelerateConfigurationBuilder {
     pub(crate) status: ::std::option::Option<crate::types::BucketAccelerateStatus>,
-98
+}
 impl AccelerateConfigurationBuilder {
     /// <p>Specifies the transfer acceleration status of the bucket.</p>
     pub fn status(mut self, input: crate::types::BucketAccelerateStatus) -> Self {
         self.status = ::std::option::Option::Some(input);
         self
-104
+    }
     /// <p>Specifies the transfer acceleration status of the bucket.</p>
     pub fn set_status(mut self, input: ::std::option::Option<crate::types::BucketAccelerateStatus>) -> Self {
         self.status = input;
         self
-109
+    }
     /// <p>Specifies the transfer acceleration status of the bucket.</p>
     pub fn get_status(&self) -> &::std::option::Option<crate::types::BucketAccelerateStatus> {
         &self.status
-113
+    }
     /// Consumes the builder and constructs a [`AccelerateConfiguration`](crate::types::AccelerateConfiguration).
     pub fn build(self) -> crate::types::AccelerateConfiguration {

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Contains the elements that set the ACL permissions for an object per grantee.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct AccessControlPolicy {
     /// <p>A list of grants.</p>
     pub grants: ::std::option::Option<::std::vec::Vec<crate::types::Grant>>,
     /// <p>Container for the bucket owner's display name and ID.</p>
     pub owner: ::std::option::Option<crate::types::Owner>,
-11
+}
 impl AccessControlPolicy {
     /// <p>A list of grants.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.grants.is_none()`.
     pub fn grants(&self) -> &[crate::types::Grant] {
         self.grants.as_deref().unwrap_or_default()
-18
+    }

     /// <p>Container for the bucket owner's display name and ID.</p>
     pub fn owner(&self) -> ::std::option::Option<&crate::types::Owner> {
         self.owner.as_ref()
-22
+    }
-23
+}
 static ACCESSCONTROLPOLICY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#AccessControlPolicy", "com.amazonaws.s3", "AccessControlPolicy");
 static ACCESSCONTROLPOLICY_MEMBER_GRANTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#AccessControlPolicy$Grants", "com.amazonaws.s3", "AccessControlPolicy"),
     ::aws_smithy_schema::ShapeType::List,
     "grants",
     "Grants",
 ,
-31
+)
 .with_xml_name("AccessControlList");
 static ACCESSCONTROLPOLICY_MEMBER_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#AccessControlPolicy$Owner", "com.amazonaws.s3", "AccessControlPolicy"),
     ::aws_smithy_schema::ShapeType::Structure,
     "owner",
     "Owner",
 ,
 );
 static ACCESSCONTROLPOLICY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ACCESSCONTROLPOLICY_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ACCESSCONTROLPOLICY_MEMBER_GRANTS, &ACCESSCONTROLPOLICY_MEMBER_OWNER],
 );
 impl AccessControlPolicy {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ACCESSCONTROLPOLICY_SCHEMA;
-47
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for AccessControlPolicy {
     #[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.grants {
             ser.write_list(
                 &ACCESSCONTROLPOLICY_MEMBER_GRANTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Grant::SCHEMA, item)?;
-60
+                    }
                     Ok(())
                 },
             )?;
-64
+        }
         if let Some(ref val) = self.owner {
             ser.write_struct(&ACCESSCONTROLPOLICY_MEMBER_OWNER, val)?;
-67
+        }
         Ok(())
-69
+    }
-70
+}
 impl AccessControlPolicy {
     /// 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(&ACCESSCONTROLPOLICY_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ACCESSCONTROLPOLICY_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.grants = 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::Grant::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Grant::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-96
+                }
                 Some(1) => {
                     builder.owner = Some(crate::types::Owner::deserialize(deser)?);
-99
+                }
                 _ => {}
-101
+            }
             Ok(())
         })?;
         Ok(builder.build())
-105
+    }
-106
+}
 impl AccessControlPolicy {
     /// 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 AccessControlPolicy {
     /// Creates a new builder-style object to manufacture [`AccessControlPolicy`](crate::types::AccessControlPolicy).
     pub fn builder() -> crate::types::builders::AccessControlPolicyBuilder {
         crate::types::builders::AccessControlPolicyBuilder::default()
-122
+    }
-123
+}
-124
 /// A builder for [`AccessControlPolicy`](crate::types::AccessControlPolicy).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

 pub struct AccessControlPolicyBuilder {
     pub(crate) grants: ::std::option::Option<::std::vec::Vec<crate::types::Grant>>,
     pub(crate) owner: ::std::option::Option<crate::types::Owner>,
-131
+}
 impl AccessControlPolicyBuilder {
     /// Appends an item to `grants`.
     ///
     /// To override the contents of this collection use [`set_grants`](Self::set_grants).
     ///
     /// <p>A list of grants.</p>
     pub fn grants(mut self, input: crate::types::Grant) -> Self {
         let mut v = self.grants.unwrap_or_default();
         v.push(input);
         self.grants = ::std::option::Option::Some(v);
         self
-143
+    }
     /// <p>A list of grants.</p>
     pub fn set_grants(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Grant>>) -> Self {
         self.grants = input;
         self

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>A container for information about access control for replicas.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct AccessControlTranslation {
     /// <p>Specifies the replica ownership. For default and valid values, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTreplication.html">PUT bucket replication</a> in the <i>Amazon S3 API Reference</i>.</p>
     pub owner: crate::types::OwnerOverride,
-9
+}
 impl AccessControlTranslation {
     /// <p>Specifies the replica ownership. For default and valid values, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTreplication.html">PUT bucket replication</a> in the <i>Amazon S3 API Reference</i>.</p>
     pub fn owner(&self) -> &crate::types::OwnerOverride {
         &self.owner
-14
+    }
-15
+}
 static ACCESSCONTROLTRANSLATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3#AccessControlTranslation",

 pub struct AccessControlTranslationBuilder {
     pub(crate) owner: ::std::option::Option<crate::types::OwnerOverride>,
-104
+}
 impl AccessControlTranslationBuilder {
     /// <p>Specifies the replica ownership. For default and valid values, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTreplication.html">PUT bucket replication</a> in the <i>Amazon S3 API Reference</i>.</p>
     /// This field is required.
     pub fn owner(mut self, input: crate::types::OwnerOverride) -> Self {
         self.owner = ::std::option::Option::Some(input);
         self
-111
+    }
     /// <p>Specifies the replica ownership. For default and valid values, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTreplication.html">PUT bucket replication</a> in the <i>Amazon S3 API Reference</i>.</p>
     pub fn set_owner(mut self, input: ::std::option::Option<crate::types::OwnerOverride>) -> Self {
         self.owner = input;
         self
-116
+    }
     /// <p>Specifies the replica ownership. For default and valid values, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTreplication.html">PUT bucket replication</a> in the <i>Amazon S3 API Reference</i>.</p>
     pub fn get_owner(&self) -> &::std::option::Option<crate::types::OwnerOverride> {
         &self.owner
-120
+    }
     /// Consumes the builder and constructs a [`AccessControlTranslation`](crate::types::AccessControlTranslation).