AWS SDK

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

@@ -101,101 +445,498 @@

-101
+    }
     /// <p>Confirms that the requester knows that they will be charged for the request. Bucket owners need not specify this parameter in their requests. If either the source or destination S3 bucket has Requester Pays enabled, the requester will pay for corresponding charges to copy the object. For information about downloading objects from Requester Pays buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html">Downloading Objects in Requester Pays Buckets</a> in the <i>Amazon S3 User Guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn request_payer(&self) -> ::std::option::Option<&crate::types::RequestPayer> {
         self.request_payer.as_ref()
-107
+    }
     /// <p>Version ID used to reference a specific version of the object.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn version_id(&self) -> ::std::option::Option<&str> {
         self.version_id.as_deref()
-113
+    }
     /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
     pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
         self.expected_bucket_owner.as_deref()
-117
+    }
-118
+}
 static PUTOBJECTACLINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectAclInput",

     "com.amazonaws.s3.synthetic",
     "PutObjectAclInput",
 );
 static PUTOBJECTACLINPUT_MEMBER_ACL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$ACL",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "acl",
     "ACL",
 ,
-133
+)
 .with_http_header("x-amz-acl");
 static PUTOBJECTACLINPUT_MEMBER_ACCESS_CONTROL_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$AccessControlPolicy",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "access_control_policy",
     "AccessControlPolicy",
 ,
-144
+)
 .with_xml_name("AccessControlPolicy")
 .with_http_payload();
 static PUTOBJECTACLINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-156
+)
 .with_http_label();
 static PUTOBJECTACLINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-167
+)
 .with_http_header("Content-MD5");
 static PUTOBJECTACLINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-178
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTOBJECTACLINPUT_MEMBER_GRANT_FULL_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$GrantFullControl",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_full_control",
     "GrantFullControl",
 ,
-189
+)
 .with_http_header("x-amz-grant-full-control");
 static PUTOBJECTACLINPUT_MEMBER_GRANT_READ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$GrantRead",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read",
     "GrantRead",
 ,
-200
+)
 .with_http_header("x-amz-grant-read");
 static PUTOBJECTACLINPUT_MEMBER_GRANT_READ_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$GrantReadACP",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read_acp",
     "GrantReadACP",
 ,
-211
+)
 .with_http_header("x-amz-grant-read-acp");
 static PUTOBJECTACLINPUT_MEMBER_GRANT_WRITE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$GrantWrite",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_write",
     "GrantWrite",
 ,
-222
+)
 .with_http_header("x-amz-grant-write");
 static PUTOBJECTACLINPUT_MEMBER_GRANT_WRITE_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$GrantWriteACP",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_write_acp",
     "GrantWriteACP",
 ,
-233
+)
 .with_http_header("x-amz-grant-write-acp");
 static PUTOBJECTACLINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$Key",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
-244
+)
 .with_http_label();
 static PUTOBJECTACLINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$RequestPayer",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_payer",
     "RequestPayer",
 ,
-255
+)
 .with_http_header("x-amz-request-payer");
 static PUTOBJECTACLINPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$VersionId",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "version_id",
     "VersionId",
 ,
-266
+)
 .with_http_query("versionId");
 static PUTOBJECTACLINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-277
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTOBJECTACLINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTACLINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTOBJECTACLINPUT_MEMBER_ACL,
         &PUTOBJECTACLINPUT_MEMBER_ACCESS_CONTROL_POLICY,
         &PUTOBJECTACLINPUT_MEMBER_BUCKET,
         &PUTOBJECTACLINPUT_MEMBER_CONTENT_MD5,
         &PUTOBJECTACLINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTOBJECTACLINPUT_MEMBER_GRANT_FULL_CONTROL,
         &PUTOBJECTACLINPUT_MEMBER_GRANT_READ,
         &PUTOBJECTACLINPUT_MEMBER_GRANT_READ_ACP,
         &PUTOBJECTACLINPUT_MEMBER_GRANT_WRITE,
         &PUTOBJECTACLINPUT_MEMBER_GRANT_WRITE_ACP,
         &PUTOBJECTACLINPUT_MEMBER_KEY,
         &PUTOBJECTACLINPUT_MEMBER_REQUEST_PAYER,
         &PUTOBJECTACLINPUT_MEMBER_VERSION_ID,
         &PUTOBJECTACLINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/{Key+}?acl", None));
 impl PutObjectAclInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTACLINPUT_SCHEMA;
-303
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectAclInput {
     #[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.acl {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_ACL, val.as_str())?;
-312
+        }
         if let Some(ref val) = self.access_control_policy {
             ser.write_struct(&PUTOBJECTACLINPUT_MEMBER_ACCESS_CONTROL_POLICY, val)?;
-315
+        }
         if let Some(ref val) = self.bucket {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_BUCKET, val)?;
-318
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_CONTENT_MD5, val)?;
-321
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-324
+        }
         if let Some(ref val) = self.grant_full_control {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_GRANT_FULL_CONTROL, val)?;
-327
+        }
         if let Some(ref val) = self.grant_read {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_GRANT_READ, val)?;
-330
+        }
         if let Some(ref val) = self.grant_read_acp {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_GRANT_READ_ACP, val)?;
-333
+        }
         if let Some(ref val) = self.grant_write {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_GRANT_WRITE, val)?;
-336
+        }
         if let Some(ref val) = self.grant_write_acp {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_GRANT_WRITE_ACP, val)?;
-339
+        }
         if let Some(ref val) = self.key {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_KEY, val)?;
-342
+        }
         if let Some(ref val) = self.request_payer {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
-345
+        }
         if let Some(ref val) = self.version_id {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_VERSION_ID, val)?;
-348
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTOBJECTACLINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-351
+        }
         Ok(())
-353
+    }
-354
+}
 impl PutObjectAclInput {
     /// 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(&PUTOBJECTACLINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTACLINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.acl = Some(crate::types::ObjectCannedAcl::from(deser.read_string(member)?.as_str()));
-373
+                }
                 Some(1) => {
                     builder.access_control_policy = Some(crate::types::AccessControlPolicy::deserialize(deser)?);
-376
+                }
                 Some(2) => {
                     builder.bucket = Some(deser.read_string(member)?);
-379
+                }
                 Some(3) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-382
+                }
                 Some(4) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-385
+                }
                 Some(5) => {
                     builder.grant_full_control = Some(deser.read_string(member)?);
-388
+                }
                 Some(6) => {
                     builder.grant_read = Some(deser.read_string(member)?);
-391
+                }
                 Some(7) => {
                     builder.grant_read_acp = Some(deser.read_string(member)?);
-394
+                }
                 Some(8) => {
                     builder.grant_write = Some(deser.read_string(member)?);
-397
+                }
                 Some(9) => {
                     builder.grant_write_acp = Some(deser.read_string(member)?);
-400
+                }
                 Some(10) => {
                     builder.key = Some(deser.read_string(member)?);
-403
+                }
                 Some(11) => {
                     builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
-406
+                }
                 Some(12) => {
                     builder.version_id = Some(deser.read_string(member)?);
-409
+                }
                 Some(13) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-412
+                }
                 _ => {}
-414
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder.key = builder.key.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutObjectAclInput {
     /// 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-acl") {
             builder.acl = Some(crate::types::ObjectCannedAcl::from(val));
-+
+        }
         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-grant-full-control") {
             builder.grant_full_control = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-grant-read") {
             builder.grant_read = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-grant-read-acp") {
             builder.grant_read_acp = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-grant-write") {
             builder.grant_write = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-grant-write-acp") {
             builder.grant_write_acp = 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 !body.is_empty() {
             builder.access_control_policy = Some(crate::types::AccessControlPolicy::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-472
+    }
-473
+}
 impl PutObjectAclInput {
     /// Creates a new builder-style object to manufacture [`PutObjectAclInput`](crate::operation::put_object_acl::PutObjectAclInput).
     pub fn builder() -> crate::operation::put_object_acl::builders::PutObjectAclInputBuilder {
         crate::operation::put_object_acl::builders::PutObjectAclInputBuilder::default()
-478
+    }

↧ Expand context

-479
+}
-480
 /// A builder for [`PutObjectAclInput`](crate::operation::put_object_acl::PutObjectAclInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectAclInputBuilder {
     pub(crate) acl: ::std::option::Option<crate::types::ObjectCannedAcl>,
     pub(crate) access_control_policy: ::std::option::Option<crate::types::AccessControlPolicy>,
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) content_md5: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) grant_full_control: ::std::option::Option<::std::string::String>,
     pub(crate) grant_read: ::std::option::Option<::std::string::String>,
     pub(crate) grant_read_acp: ::std::option::Option<::std::string::String>,
     pub(crate) grant_write: ::std::option::Option<::std::string::String>,
     pub(crate) grant_write_acp: ::std::option::Option<::std::string::String>,
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) request_payer: ::std::option::Option<crate::types::RequestPayer>,
     pub(crate) version_id: ::std::option::Option<::std::string::String>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,

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

@@ -3,3 +113,144 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutObjectAclOutput {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub request_charged: ::std::option::Option<crate::types::RequestCharged>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-12
+}
 impl PutObjectAclOutput {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn request_charged(&self) -> ::std::option::Option<&crate::types::RequestCharged> {
         self.request_charged.as_ref()
-19
+    }
-20
+}
 static PUTOBJECTACLOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectAclOutput",

     "com.amazonaws.s3.synthetic",
     "PutObjectAclOutput",
 );
 static PUTOBJECTACLOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectAclOutput$RequestCharged",
         "com.amazonaws.s3.synthetic",
         "PutObjectAclOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_charged",
     "RequestCharged",
 ,
-35
+)
 .with_http_header("x-amz-request-charged");
 static PUTOBJECTACLOUTPUT_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 PUTOBJECTACLOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTACLOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTOBJECTACLOUTPUT_MEMBER_REQUEST_CHARGED],
     &[&PUTOBJECTACLOUTPUT_MEMBER_REQUEST_CHARGED, &PUTOBJECTACLOUTPUT_MEMBER__REQUEST_ID],
 );
 impl PutObjectAclOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTACLOUTPUT_SCHEMA;
-52
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectAclOutput {
     #[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_charged {
             ser.write_string(&PUTOBJECTACLOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
-61
+        }
         Ok(())
-63
+    }
-64
+}
 impl PutObjectAclOutput {
     /// 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(&PUTOBJECTACLOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTACLOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
-83
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-88
+            }
             Ok(())
         })?;
         Ok(builder.build())
-92
+    }
-93
+}
 impl PutObjectAclOutput {
     /// 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-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 PutObjectAclOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-118
+    }
-119
+}
 impl ::aws_types::request_id::RequestId for PutObjectAclOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-123
+    }
-124
+}

↧ Expand context

 impl PutObjectAclOutput {
     /// Creates a new builder-style object to manufacture [`PutObjectAclOutput`](crate::operation::put_object_acl::PutObjectAclOutput).
     pub fn builder() -> crate::operation::put_object_acl::builders::PutObjectAclOutputBuilder {
         crate::operation::put_object_acl::builders::PutObjectAclOutputBuilder::default()
-129
+    }
-130
+}
-131
 /// A builder for [`PutObjectAclOutput`](crate::operation::put_object_acl::PutObjectAclOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectAclOutputBuilder {
     pub(crate) request_charged: ::std::option::Option<crate::types::RequestCharged>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-139
+}
 impl PutObjectAclOutputBuilder {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn request_charged(mut self, input: crate::types::RequestCharged) -> Self {

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `PutObjectLegalHold`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectLegalHold;
 impl PutObjectLegalHold {
     /// Creates a new `PutObjectLegalHold`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_object_legal_hold::PutObjectLegalHoldInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_object_legal_hold::PutObjectLegalHoldOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::put_object_legal_hold::PutObjectLegalHoldInput,
     ) -> ::std::result::Result<
         crate::operation::put_object_legal_hold::PutObjectLegalHoldOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_object_legal_hold::PutObjectLegalHoldError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::put_object_legal_hold::PutObjectLegalHoldError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::put_object_legal_hold::PutObjectLegalHoldOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -176,180 +238,243 @@

↥ Expand context

                                         is_presigned_req,
                                     ) {
                                         (_, _, _, _, true) => {}
                                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)
                                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-186
+                                        }
                                         _ => {},
-188
+                                    }
-189
                                     // We return a bool indicating if the user did set the checksum value, if they did
                                     // we can short circuit and exit the interceptor early.
                                     Ok(user_set_checksum_value)
-193
+                                }
                                 ))
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_object_legal_hold::PutObjectLegalHoldError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_object_legal_hold::PutObjectLegalHoldError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_legal_hold::PutObjectLegalHoldError>::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());
-202
         ::std::borrow::Cow::Owned(rcb)
-204
+    }
-205
+}
-206
 #[derive(Debug)]
 struct PutObjectLegalHoldResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectLegalHoldResponseDeserializer {
     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;
-223
+        }

↧ 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_put_object_legal_hold::de_put_object_legal_hold_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_object_legal_hold::de_put_object_legal_hold_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-231
+    }
-232
+}
 #[derive(Debug)]
 struct PutObjectLegalHoldRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutObjectLegalHoldRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::put_object_legal_hold::PutObjectLegalHoldInput>()

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

@@ -49,49 +285,320 @@

↥ Expand context

     pub fn version_id(&self) -> ::std::option::Option<&str> {
         self.version_id.as_deref()
-51
+    }
     /// <p>The MD5 hash for the request body.</p>
     /// <p>For requests made using the Amazon Web Services Command Line Interface (CLI) or Amazon Web Services SDKs, this field is calculated automatically.</p>
     pub fn content_md5(&self) -> ::std::option::Option<&str> {
         self.content_md5.as_deref()
-56
+    }
     /// <p>Indicates the algorithm used to create the checksum for the object when you use the SDK. This header will not provide any additional functionality if you don't use the SDK. When you send this header, there must be a corresponding <code>x-amz-checksum</code> or <code>x-amz-trailer</code> header sent. Otherwise, Amazon S3 fails the request with the HTTP status code <code>400 Bad Request</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
     /// <p>If you provide an individual checksum, Amazon S3 ignores any provided <code>ChecksumAlgorithm</code> parameter.</p>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-61
+    }
     /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
     pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
         self.expected_bucket_owner.as_deref()
-65
+    }
-66
+}
 static PUTOBJECTLEGALHOLDINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectLegalHoldInput",

     "com.amazonaws.s3.synthetic",
     "PutObjectLegalHoldInput",
 );
 static PUTOBJECTLEGALHOLDINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLegalHoldInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutObjectLegalHoldInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-81
+)
 .with_http_label();
 static PUTOBJECTLEGALHOLDINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLegalHoldInput$Key",
         "com.amazonaws.s3.synthetic",
         "PutObjectLegalHoldInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
-92
+)
 .with_http_label();
 static PUTOBJECTLEGALHOLDINPUT_MEMBER_LEGAL_HOLD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLegalHoldInput$LegalHold",
         "com.amazonaws.s3.synthetic",
         "PutObjectLegalHoldInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "legal_hold",
     "LegalHold",
 ,
-103
+)
 .with_xml_name("LegalHold")
 .with_http_payload();
 static PUTOBJECTLEGALHOLDINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLegalHoldInput$RequestPayer",
         "com.amazonaws.s3.synthetic",
         "PutObjectLegalHoldInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_payer",
     "RequestPayer",
 ,
-115
+)
 .with_http_header("x-amz-request-payer");
 static PUTOBJECTLEGALHOLDINPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLegalHoldInput$VersionId",
         "com.amazonaws.s3.synthetic",
         "PutObjectLegalHoldInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "version_id",
     "VersionId",
 ,
-126
+)
 .with_http_query("versionId");
 static PUTOBJECTLEGALHOLDINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLegalHoldInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutObjectLegalHoldInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-137
+)
 .with_http_header("Content-MD5");
 static PUTOBJECTLEGALHOLDINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLegalHoldInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutObjectLegalHoldInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-148
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTOBJECTLEGALHOLDINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLegalHoldInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutObjectLegalHoldInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-159
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTOBJECTLEGALHOLDINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTLEGALHOLDINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTOBJECTLEGALHOLDINPUT_MEMBER_BUCKET,
         &PUTOBJECTLEGALHOLDINPUT_MEMBER_KEY,
         &PUTOBJECTLEGALHOLDINPUT_MEMBER_LEGAL_HOLD,
         &PUTOBJECTLEGALHOLDINPUT_MEMBER_REQUEST_PAYER,
         &PUTOBJECTLEGALHOLDINPUT_MEMBER_VERSION_ID,
         &PUTOBJECTLEGALHOLDINPUT_MEMBER_CONTENT_MD5,
         &PUTOBJECTLEGALHOLDINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTOBJECTLEGALHOLDINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/{Key+}?legal-hold", None));
 impl PutObjectLegalHoldInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTLEGALHOLDINPUT_SCHEMA;
-179
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectLegalHoldInput {
     #[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.bucket {
             ser.write_string(&PUTOBJECTLEGALHOLDINPUT_MEMBER_BUCKET, val)?;
-188
+        }
         if let Some(ref val) = self.key {
             ser.write_string(&PUTOBJECTLEGALHOLDINPUT_MEMBER_KEY, val)?;
-191
+        }
         if let Some(ref val) = self.legal_hold {
             ser.write_struct(&PUTOBJECTLEGALHOLDINPUT_MEMBER_LEGAL_HOLD, val)?;
-194
+        }
         if let Some(ref val) = self.request_payer {
             ser.write_string(&PUTOBJECTLEGALHOLDINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
-197
+        }
         if let Some(ref val) = self.version_id {
             ser.write_string(&PUTOBJECTLEGALHOLDINPUT_MEMBER_VERSION_ID, val)?;
-200
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTOBJECTLEGALHOLDINPUT_MEMBER_CONTENT_MD5, val)?;
-203
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTOBJECTLEGALHOLDINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-206
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTOBJECTLEGALHOLDINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-209
+        }
         Ok(())
-211
+    }
-212
+}
 impl PutObjectLegalHoldInput {
     /// 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(&PUTOBJECTLEGALHOLDINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTLEGALHOLDINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-231
+                }
                 Some(1) => {
                     builder.key = Some(deser.read_string(member)?);
-234
+                }
                 Some(2) => {
                     builder.legal_hold = Some(crate::types::ObjectLockLegalHold::deserialize(deser)?);
-237
+                }
                 Some(3) => {
                     builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
-240
+                }
                 Some(4) => {
                     builder.version_id = Some(deser.read_string(member)?);
-243
+                }
                 Some(5) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-246
+                }
                 Some(6) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-249
+                }
                 Some(7) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-252
+                }
                 _ => {}
-254
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder.key = builder.key.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutObjectLegalHoldInput {
     /// 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-payer") {
             builder.request_payer = Some(crate::types::RequestPayer::from(val));
-+
+        }
         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-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         if !body.is_empty() {
             builder.legal_hold = Some(crate::types::ObjectLockLegalHold::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-294
+    }
-295
+}
 impl PutObjectLegalHoldInput {
     /// Creates a new builder-style object to manufacture [`PutObjectLegalHoldInput`](crate::operation::put_object_legal_hold::PutObjectLegalHoldInput).
     pub fn builder() -> crate::operation::put_object_legal_hold::builders::PutObjectLegalHoldInputBuilder {
         crate::operation::put_object_legal_hold::builders::PutObjectLegalHoldInputBuilder::default()
-300
+    }

↧ Expand context

-301
+}
-302
 /// A builder for [`PutObjectLegalHoldInput`](crate::operation::put_object_legal_hold::PutObjectLegalHoldInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectLegalHoldInputBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) legal_hold: ::std::option::Option<crate::types::ObjectLockLegalHold>,
     pub(crate) request_payer: ::std::option::Option<crate::types::RequestPayer>,
     pub(crate) version_id: ::std::option::Option<::std::string::String>,
     pub(crate) content_md5: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-315
+}
 impl PutObjectLegalHoldInputBuilder {
     /// <p>The bucket name containing the object that you want to place a legal hold on.</p>
     /// <p><b>Access points</b> - When you use this action with an access point for general purpose buckets, you must provide the alias of the access point in place of the bucket name or specify the access point ARN. When you use this action with an access point for directory buckets, you must provide the access point name in place of the bucket name. When using the access point ARN, you must direct requests to the access point hostname. The access point hostname takes the form <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com. When using this action with an access point through the Amazon Web Services SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using access points</a> in the <i>Amazon S3 User Guide</i>.</p>
     /// This field is required.
     pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

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

@@ -3,3 +113,147 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutObjectLegalHoldOutput {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub request_charged: ::std::option::Option<crate::types::RequestCharged>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-12
+}
 impl PutObjectLegalHoldOutput {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn request_charged(&self) -> ::std::option::Option<&crate::types::RequestCharged> {
         self.request_charged.as_ref()
-19
+    }
-20
+}
 static PUTOBJECTLEGALHOLDOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectLegalHoldOutput",

     "com.amazonaws.s3.synthetic",
     "PutObjectLegalHoldOutput",
 );
 static PUTOBJECTLEGALHOLDOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLegalHoldOutput$RequestCharged",
         "com.amazonaws.s3.synthetic",
         "PutObjectLegalHoldOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_charged",
     "RequestCharged",
 ,
-35
+)
 .with_http_header("x-amz-request-charged");
 static PUTOBJECTLEGALHOLDOUTPUT_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 PUTOBJECTLEGALHOLDOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTLEGALHOLDOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTOBJECTLEGALHOLDOUTPUT_MEMBER_REQUEST_CHARGED],
     &[
         &PUTOBJECTLEGALHOLDOUTPUT_MEMBER_REQUEST_CHARGED,
         &PUTOBJECTLEGALHOLDOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl PutObjectLegalHoldOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTLEGALHOLDOUTPUT_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectLegalHoldOutput {
     #[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_charged {
             ser.write_string(&PUTOBJECTLEGALHOLDOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
-64
+        }
         Ok(())
-66
+    }
-67
+}
 impl PutObjectLegalHoldOutput {
     /// 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(&PUTOBJECTLEGALHOLDOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTLEGALHOLDOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
-86
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-91
+            }
             Ok(())
         })?;
         Ok(builder.build())
-95
+    }
-96
+}
 impl PutObjectLegalHoldOutput {
     /// 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-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 PutObjectLegalHoldOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-121
+    }
-122
+}
 impl ::aws_types::request_id::RequestId for PutObjectLegalHoldOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-126
+    }
-127
+}

↧ Expand context

 impl PutObjectLegalHoldOutput {
     /// Creates a new builder-style object to manufacture [`PutObjectLegalHoldOutput`](crate::operation::put_object_legal_hold::PutObjectLegalHoldOutput).
     pub fn builder() -> crate::operation::put_object_legal_hold::builders::PutObjectLegalHoldOutputBuilder {
         crate::operation::put_object_legal_hold::builders::PutObjectLegalHoldOutputBuilder::default()
-132
+    }
-133
+}
-134
 /// A builder for [`PutObjectLegalHoldOutput`](crate::operation::put_object_legal_hold::PutObjectLegalHoldOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectLegalHoldOutputBuilder {
     pub(crate) request_charged: ::std::option::Option<crate::types::RequestCharged>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-142
+}
 impl PutObjectLegalHoldOutputBuilder {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn request_charged(mut self, input: crate::types::RequestCharged) -> Self {

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `PutObjectLockConfiguration`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectLockConfiguration;
 impl PutObjectLockConfiguration {
     /// Creates a new `PutObjectLockConfiguration`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::put_object_lock_configuration::PutObjectLockConfigurationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::put_object_lock_configuration::PutObjectLockConfigurationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::put_object_lock_configuration::PutObjectLockConfigurationInput,
     ) -> ::std::result::Result<
         crate::operation::put_object_lock_configuration::PutObjectLockConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::put_object_lock_configuration::PutObjectLockConfigurationOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -186,192 +248,255 @@

↥ Expand context

                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
                 >::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(),
             );
-214
         ::std::borrow::Cow::Owned(rcb)
-216
+    }
-217
+}
-218
 #[derive(Debug)]
 struct PutObjectLockConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectLockConfigurationResponseDeserializer {
     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;
-235
+        }

↧ 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_put_object_lock_configuration::de_put_object_lock_configuration_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_object_lock_configuration::de_put_object_lock_configuration_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-243
+    }
-244
+}
 #[derive(Debug)]
 struct PutObjectLockConfigurationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutObjectLockConfigurationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::put_object_lock_configuration::PutObjectLockConfigurationInput>()

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

@@ -41,41 +259,296 @@

↥ Expand context

     pub fn token(&self) -> ::std::option::Option<&str> {
         self.token.as_deref()
-43
+    }
     /// <p>The MD5 hash for the request body.</p>
     /// <p>For requests made using the Amazon Web Services Command Line Interface (CLI) or Amazon Web Services SDKs, this field is calculated automatically.</p>
     pub fn content_md5(&self) -> ::std::option::Option<&str> {
         self.content_md5.as_deref()
-48
+    }
     /// <p>Indicates the algorithm used to create the checksum for the object when you use the SDK. This header will not provide any additional functionality if you don't use the SDK. When you send this header, there must be a corresponding <code>x-amz-checksum</code> or <code>x-amz-trailer</code> header sent. Otherwise, Amazon S3 fails the request with the HTTP status code <code>400 Bad Request</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
     /// <p>If you provide an individual checksum, Amazon S3 ignores any provided <code>ChecksumAlgorithm</code> parameter.</p>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-53
+    }
     /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
     pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
         self.expected_bucket_owner.as_deref()
-57
+    }
-58
+}
 static PUTOBJECTLOCKCONFIGURATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectLockConfigurationInput",

     "com.amazonaws.s3.synthetic",
     "PutObjectLockConfigurationInput",
 );
 static PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLockConfigurationInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutObjectLockConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-73
+)
 .with_http_label();
 static PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_OBJECT_LOCK_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLockConfigurationInput$ObjectLockConfiguration",
         "com.amazonaws.s3.synthetic",
         "PutObjectLockConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "object_lock_configuration",
     "ObjectLockConfiguration",
 ,
-84
+)
 .with_xml_name("ObjectLockConfiguration")
 .with_http_payload();
 static PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLockConfigurationInput$RequestPayer",
         "com.amazonaws.s3.synthetic",
         "PutObjectLockConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_payer",
     "RequestPayer",
 ,
-96
+)
 .with_http_header("x-amz-request-payer");
 static PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLockConfigurationInput$Token",
         "com.amazonaws.s3.synthetic",
         "PutObjectLockConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "token",
     "Token",
 ,
-107
+)
 .with_http_header("x-amz-bucket-object-lock-token");
 static PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLockConfigurationInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutObjectLockConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-118
+)
 .with_http_header("Content-MD5");
 static PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLockConfigurationInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutObjectLockConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-129
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLockConfigurationInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutObjectLockConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-140
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTOBJECTLOCKCONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTLOCKCONFIGURATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_BUCKET,
         &PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_OBJECT_LOCK_CONFIGURATION,
         &PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_REQUEST_PAYER,
         &PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_TOKEN,
         &PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_CONTENT_MD5,
         &PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?object-lock", None));
 impl PutObjectLockConfigurationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTLOCKCONFIGURATIONINPUT_SCHEMA;
-159
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectLockConfigurationInput {
     #[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.bucket {
             ser.write_string(&PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_BUCKET, val)?;
-168
+        }
         if let Some(ref val) = self.object_lock_configuration {
             ser.write_struct(&PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_OBJECT_LOCK_CONFIGURATION, val)?;
-171
+        }
         if let Some(ref val) = self.request_payer {
             ser.write_string(&PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
-174
+        }
         if let Some(ref val) = self.token {
             ser.write_string(&PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_TOKEN, val)?;
-177
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_CONTENT_MD5, val)?;
-180
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-183
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTOBJECTLOCKCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-186
+        }
         Ok(())
-188
+    }
-189
+}
 impl PutObjectLockConfigurationInput {
     /// 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(&PUTOBJECTLOCKCONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTLOCKCONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-208
+                }
                 Some(1) => {
                     builder.object_lock_configuration = Some(crate::types::ObjectLockConfiguration::deserialize(deser)?);
-211
+                }
                 Some(2) => {
                     builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
-214
+                }
                 Some(3) => {
                     builder.token = Some(deser.read_string(member)?);
-217
+                }
                 Some(4) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-220
+                }
                 Some(5) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-223
+                }
                 Some(6) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-226
+                }
                 _ => {}
-228
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutObjectLockConfigurationInput {
     /// 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-payer") {
             builder.request_payer = Some(crate::types::RequestPayer::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-bucket-object-lock-token") {
             builder.token = Some(val.to_string());
-+
+        }
         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-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         if !body.is_empty() {
             builder.object_lock_configuration = Some(crate::types::ObjectLockConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-270
+    }
-271
+}
 impl PutObjectLockConfigurationInput {
     /// Creates a new builder-style object to manufacture [`PutObjectLockConfigurationInput`](crate::operation::put_object_lock_configuration::PutObjectLockConfigurationInput).
     pub fn builder() -> crate::operation::put_object_lock_configuration::builders::PutObjectLockConfigurationInputBuilder {
         crate::operation::put_object_lock_configuration::builders::PutObjectLockConfigurationInputBuilder::default()
-276
+    }

↧ Expand context

-277
+}
-278
 /// A builder for [`PutObjectLockConfigurationInput`](crate::operation::put_object_lock_configuration::PutObjectLockConfigurationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectLockConfigurationInputBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) object_lock_configuration: ::std::option::Option<crate::types::ObjectLockConfiguration>,
     pub(crate) request_payer: ::std::option::Option<crate::types::RequestPayer>,
     pub(crate) token: ::std::option::Option<::std::string::String>,
     pub(crate) content_md5: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-290
+}
 impl PutObjectLockConfigurationInputBuilder {
     /// <p>The bucket whose Object Lock configuration you want to create or replace.</p>
     /// This field is required.
     pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.bucket = ::std::option::Option::Some(input.into());
         self

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

@@ -3,3 +113,147 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutObjectLockConfigurationOutput {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub request_charged: ::std::option::Option<crate::types::RequestCharged>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-12
+}
 impl PutObjectLockConfigurationOutput {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn request_charged(&self) -> ::std::option::Option<&crate::types::RequestCharged> {
         self.request_charged.as_ref()
-19
+    }
-20
+}
 static PUTOBJECTLOCKCONFIGURATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectLockConfigurationOutput",

     "com.amazonaws.s3.synthetic",
     "PutObjectLockConfigurationOutput",
 );
 static PUTOBJECTLOCKCONFIGURATIONOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectLockConfigurationOutput$RequestCharged",
         "com.amazonaws.s3.synthetic",
         "PutObjectLockConfigurationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_charged",
     "RequestCharged",
 ,
-35
+)
 .with_http_header("x-amz-request-charged");
 static PUTOBJECTLOCKCONFIGURATIONOUTPUT_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 PUTOBJECTLOCKCONFIGURATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTLOCKCONFIGURATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTOBJECTLOCKCONFIGURATIONOUTPUT_MEMBER_REQUEST_CHARGED],
     &[
         &PUTOBJECTLOCKCONFIGURATIONOUTPUT_MEMBER_REQUEST_CHARGED,
         &PUTOBJECTLOCKCONFIGURATIONOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl PutObjectLockConfigurationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTLOCKCONFIGURATIONOUTPUT_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectLockConfigurationOutput {
     #[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_charged {
             ser.write_string(&PUTOBJECTLOCKCONFIGURATIONOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
-64
+        }
         Ok(())
-66
+    }
-67
+}
 impl PutObjectLockConfigurationOutput {
     /// 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(&PUTOBJECTLOCKCONFIGURATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTLOCKCONFIGURATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
-86
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-91
+            }
             Ok(())
         })?;
         Ok(builder.build())
-95
+    }
-96
+}
 impl PutObjectLockConfigurationOutput {
     /// 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-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 PutObjectLockConfigurationOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-121
+    }
-122
+}
 impl ::aws_types::request_id::RequestId for PutObjectLockConfigurationOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-126
+    }
-127
+}

↧ Expand context

 impl PutObjectLockConfigurationOutput {
     /// Creates a new builder-style object to manufacture [`PutObjectLockConfigurationOutput`](crate::operation::put_object_lock_configuration::PutObjectLockConfigurationOutput).
     pub fn builder() -> crate::operation::put_object_lock_configuration::builders::PutObjectLockConfigurationOutputBuilder {
         crate::operation::put_object_lock_configuration::builders::PutObjectLockConfigurationOutputBuilder::default()
-132
+    }
-133
+}
-134
 /// A builder for [`PutObjectLockConfigurationOutput`](crate::operation::put_object_lock_configuration::PutObjectLockConfigurationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectLockConfigurationOutputBuilder {
     pub(crate) request_charged: ::std::option::Option<crate::types::RequestCharged>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-142
+}
 impl PutObjectLockConfigurationOutputBuilder {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn request_charged(mut self, input: crate::types::RequestCharged) -> Self {

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `PutObjectRetention`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectRetention;
 impl PutObjectRetention {
     /// Creates a new `PutObjectRetention`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_object_retention::PutObjectRetentionInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_object_retention::PutObjectRetentionOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::put_object_retention::PutObjectRetentionInput,
     ) -> ::std::result::Result<
         crate::operation::put_object_retention::PutObjectRetentionOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_object_retention::PutObjectRetentionError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::put_object_retention::PutObjectRetentionError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::put_object_retention::PutObjectRetentionOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -176,180 +238,243 @@

↥ Expand context

                                         is_presigned_req,
                                     ) {
                                         (_, _, _, _, true) => {}
                                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)
                                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-186
+                                        }
                                         _ => {},
-188
+                                    }
-189
                                     // We return a bool indicating if the user did set the checksum value, if they did
                                     // we can short circuit and exit the interceptor early.
                                     Ok(user_set_checksum_value)
-193
+                                }
                                 ))
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_object_retention::PutObjectRetentionError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_object_retention::PutObjectRetentionError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_retention::PutObjectRetentionError>::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());
-202
         ::std::borrow::Cow::Owned(rcb)
-204
+    }
-205
+}
-206
 #[derive(Debug)]
 struct PutObjectRetentionResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectRetentionResponseDeserializer {
     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;
-223
+        }

↧ 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_put_object_retention::de_put_object_retention_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_object_retention::de_put_object_retention_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-231
+    }
-232
+}
 #[derive(Debug)]
 struct PutObjectRetentionRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutObjectRetentionRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::put_object_retention::PutObjectRetentionInput>()

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

@@ -55,55 +309,347 @@

↥ Expand context

     pub fn bypass_governance_retention(&self) -> ::std::option::Option<bool> {
         self.bypass_governance_retention
-57
+    }
     /// <p>The MD5 hash for the request body.</p>
     /// <p>For requests made using the Amazon Web Services Command Line Interface (CLI) or Amazon Web Services SDKs, this field is calculated automatically.</p>
     pub fn content_md5(&self) -> ::std::option::Option<&str> {
         self.content_md5.as_deref()
-62
+    }
     /// <p>Indicates the algorithm used to create the checksum for the object when you use the SDK. This header will not provide any additional functionality if you don't use the SDK. When you send this header, there must be a corresponding <code>x-amz-checksum</code> or <code>x-amz-trailer</code> header sent. Otherwise, Amazon S3 fails the request with the HTTP status code <code>400 Bad Request</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
     /// <p>If you provide an individual checksum, Amazon S3 ignores any provided <code>ChecksumAlgorithm</code> parameter.</p>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-67
+    }
     /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
     pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
         self.expected_bucket_owner.as_deref()
-71
+    }
-72
+}
 static PUTOBJECTRETENTIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectRetentionInput",

     "com.amazonaws.s3.synthetic",
     "PutObjectRetentionInput",
 );
 static PUTOBJECTRETENTIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectRetentionInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutObjectRetentionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-87
+)
 .with_http_label();
 static PUTOBJECTRETENTIONINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectRetentionInput$Key",
         "com.amazonaws.s3.synthetic",
         "PutObjectRetentionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
-98
+)
 .with_http_label();
 static PUTOBJECTRETENTIONINPUT_MEMBER_RETENTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectRetentionInput$Retention",
         "com.amazonaws.s3.synthetic",
         "PutObjectRetentionInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "retention",
     "Retention",
 ,
-109
+)
 .with_xml_name("Retention")
 .with_http_payload();
 static PUTOBJECTRETENTIONINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectRetentionInput$RequestPayer",
         "com.amazonaws.s3.synthetic",
         "PutObjectRetentionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_payer",
     "RequestPayer",
 ,
-121
+)
 .with_http_header("x-amz-request-payer");
 static PUTOBJECTRETENTIONINPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectRetentionInput$VersionId",
         "com.amazonaws.s3.synthetic",
         "PutObjectRetentionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "version_id",
     "VersionId",
 ,
-132
+)
 .with_http_query("versionId");
 static PUTOBJECTRETENTIONINPUT_MEMBER_BYPASS_GOVERNANCE_RETENTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectRetentionInput$BypassGovernanceRetention",
         "com.amazonaws.s3.synthetic",
         "PutObjectRetentionInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bypass_governance_retention",
     "BypassGovernanceRetention",
 ,
-143
+)
 .with_http_header("x-amz-bypass-governance-retention");
 static PUTOBJECTRETENTIONINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectRetentionInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutObjectRetentionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-154
+)
 .with_http_header("Content-MD5");
 static PUTOBJECTRETENTIONINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectRetentionInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutObjectRetentionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-165
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTOBJECTRETENTIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectRetentionInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutObjectRetentionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-176
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTOBJECTRETENTIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTRETENTIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTOBJECTRETENTIONINPUT_MEMBER_BUCKET,
         &PUTOBJECTRETENTIONINPUT_MEMBER_KEY,
         &PUTOBJECTRETENTIONINPUT_MEMBER_RETENTION,
         &PUTOBJECTRETENTIONINPUT_MEMBER_REQUEST_PAYER,
         &PUTOBJECTRETENTIONINPUT_MEMBER_VERSION_ID,
         &PUTOBJECTRETENTIONINPUT_MEMBER_BYPASS_GOVERNANCE_RETENTION,
         &PUTOBJECTRETENTIONINPUT_MEMBER_CONTENT_MD5,
         &PUTOBJECTRETENTIONINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTOBJECTRETENTIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/{Key+}?retention", None));
 impl PutObjectRetentionInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTRETENTIONINPUT_SCHEMA;
-197
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectRetentionInput {
     #[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.bucket {
             ser.write_string(&PUTOBJECTRETENTIONINPUT_MEMBER_BUCKET, val)?;
-206
+        }
         if let Some(ref val) = self.key {
             ser.write_string(&PUTOBJECTRETENTIONINPUT_MEMBER_KEY, val)?;
-209
+        }
         if let Some(ref val) = self.retention {
             ser.write_struct(&PUTOBJECTRETENTIONINPUT_MEMBER_RETENTION, val)?;
-212
+        }
         if let Some(ref val) = self.request_payer {
             ser.write_string(&PUTOBJECTRETENTIONINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
-215
+        }
         if let Some(ref val) = self.version_id {
             ser.write_string(&PUTOBJECTRETENTIONINPUT_MEMBER_VERSION_ID, val)?;
-218
+        }
         if let Some(ref val) = self.bypass_governance_retention {
             ser.write_boolean(&PUTOBJECTRETENTIONINPUT_MEMBER_BYPASS_GOVERNANCE_RETENTION, *val)?;
-221
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTOBJECTRETENTIONINPUT_MEMBER_CONTENT_MD5, val)?;
-224
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTOBJECTRETENTIONINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-227
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTOBJECTRETENTIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-230
+        }
         Ok(())
-232
+    }
-233
+}
 impl PutObjectRetentionInput {
     /// 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(&PUTOBJECTRETENTIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTRETENTIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-252
+                }
                 Some(1) => {
                     builder.key = Some(deser.read_string(member)?);
-255
+                }
                 Some(2) => {
                     builder.retention = Some(crate::types::ObjectLockRetention::deserialize(deser)?);
-258
+                }
                 Some(3) => {
                     builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
-261
+                }
                 Some(4) => {
                     builder.version_id = Some(deser.read_string(member)?);
-264
+                }
                 Some(5) => {
                     builder.bypass_governance_retention = Some(deser.read_boolean(member)?);
-267
+                }
                 Some(6) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-270
+                }
                 Some(7) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-273
+                }
                 Some(8) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-276
+                }
                 _ => {}
-278
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder.key = builder.key.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutObjectRetentionInput {
     /// 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-payer") {
             builder.request_payer = Some(crate::types::RequestPayer::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-bypass-governance-retention") {
             builder.bypass_governance_retention = val.parse::<bool>().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-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         if !body.is_empty() {
             builder.retention = Some(crate::types::ObjectLockRetention::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-321
+    }
-322
+}
 impl PutObjectRetentionInput {
     /// Creates a new builder-style object to manufacture [`PutObjectRetentionInput`](crate::operation::put_object_retention::PutObjectRetentionInput).
     pub fn builder() -> crate::operation::put_object_retention::builders::PutObjectRetentionInputBuilder {
         crate::operation::put_object_retention::builders::PutObjectRetentionInputBuilder::default()
-327
+    }

↧ Expand context

-328
+}
-329
 /// A builder for [`PutObjectRetentionInput`](crate::operation::put_object_retention::PutObjectRetentionInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectRetentionInputBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) retention: ::std::option::Option<crate::types::ObjectLockRetention>,
     pub(crate) request_payer: ::std::option::Option<crate::types::RequestPayer>,
     pub(crate) version_id: ::std::option::Option<::std::string::String>,
     pub(crate) bypass_governance_retention: ::std::option::Option<bool>,
     pub(crate) content_md5: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-343
+}
 impl PutObjectRetentionInputBuilder {
     /// <p>The bucket name that contains the object you want to apply this Object Retention configuration to.</p>
     /// <p><b>Access points</b> - When you use this action with an access point for general purpose buckets, you must provide the alias of the access point in place of the bucket name or specify the access point ARN. When you use this action with an access point for directory buckets, you must provide the access point name in place of the bucket name. When using the access point ARN, you must direct requests to the access point hostname. The access point hostname takes the form <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com. When using this action with an access point through the Amazon Web Services SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using access points</a> in the <i>Amazon S3 User Guide</i>.</p>
     /// This field is required.

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

@@ -3,3 +113,147 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutObjectRetentionOutput {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub request_charged: ::std::option::Option<crate::types::RequestCharged>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-12
+}
 impl PutObjectRetentionOutput {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn request_charged(&self) -> ::std::option::Option<&crate::types::RequestCharged> {
         self.request_charged.as_ref()
-19
+    }
-20
+}
 static PUTOBJECTRETENTIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectRetentionOutput",

     "com.amazonaws.s3.synthetic",
     "PutObjectRetentionOutput",
 );
 static PUTOBJECTRETENTIONOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectRetentionOutput$RequestCharged",
         "com.amazonaws.s3.synthetic",
         "PutObjectRetentionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_charged",
     "RequestCharged",
 ,
-35
+)
 .with_http_header("x-amz-request-charged");
 static PUTOBJECTRETENTIONOUTPUT_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 PUTOBJECTRETENTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTRETENTIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTOBJECTRETENTIONOUTPUT_MEMBER_REQUEST_CHARGED],
     &[
         &PUTOBJECTRETENTIONOUTPUT_MEMBER_REQUEST_CHARGED,
         &PUTOBJECTRETENTIONOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl PutObjectRetentionOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTRETENTIONOUTPUT_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectRetentionOutput {
     #[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_charged {
             ser.write_string(&PUTOBJECTRETENTIONOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
-64
+        }
         Ok(())
-66
+    }
-67
+}
 impl PutObjectRetentionOutput {
     /// 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(&PUTOBJECTRETENTIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTRETENTIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
-86
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-91
+            }
             Ok(())
         })?;
         Ok(builder.build())
-95
+    }
-96
+}
 impl PutObjectRetentionOutput {
     /// 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-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 PutObjectRetentionOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-121
+    }
-122
+}
 impl ::aws_types::request_id::RequestId for PutObjectRetentionOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-126
+    }
-127
+}

↧ Expand context

 impl PutObjectRetentionOutput {
     /// Creates a new builder-style object to manufacture [`PutObjectRetentionOutput`](crate::operation::put_object_retention::PutObjectRetentionOutput).
     pub fn builder() -> crate::operation::put_object_retention::builders::PutObjectRetentionOutputBuilder {
         crate::operation::put_object_retention::builders::PutObjectRetentionOutputBuilder::default()
-132
+    }
-133
+}
-134
 /// A builder for [`PutObjectRetentionOutput`](crate::operation::put_object_retention::PutObjectRetentionOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectRetentionOutputBuilder {
     pub(crate) request_charged: ::std::option::Option<crate::types::RequestCharged>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-142
+}
 impl PutObjectRetentionOutputBuilder {
     /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn request_charged(mut self, input: crate::types::RequestCharged) -> Self {

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `PutObjectTagging`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectTagging;
 impl PutObjectTagging {
     /// Creates a new `PutObjectTagging`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_object_tagging::PutObjectTaggingInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_object_tagging::PutObjectTaggingOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::put_object_tagging::PutObjectTaggingInput,
     ) -> ::std::result::Result<
         crate::operation::put_object_tagging::PutObjectTaggingOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_object_tagging::PutObjectTaggingError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::put_object_tagging::PutObjectTaggingError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::put_object_tagging::PutObjectTaggingOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -180,184 +242,247 @@

↥ Expand context

-184
+                    }
-185
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_object_tagging::PutObjectTaggingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_object_tagging::PutObjectTaggingError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_tagging::PutObjectTaggingError>::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(),
             );
-206
         ::std::borrow::Cow::Owned(rcb)
-208
+    }
-209
+}
-210
 #[derive(Debug)]
 struct PutObjectTaggingResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectTaggingResponseDeserializer {
     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;
-227
+        }

↧ 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_put_object_tagging::de_put_object_tagging_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_object_tagging::de_put_object_tagging_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-235
+    }
-236
+}
 #[derive(Debug)]
 struct PutObjectTaggingRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutObjectTaggingRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::put_object_tagging::PutObjectTaggingInput>()

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

@@ -47,47 +283,318 @@

↥ Expand context

     /// <p>Indicates the algorithm used to create the checksum for the object when you use the SDK. This header will not provide any additional functionality if you don't use the SDK. When you send this header, there must be a corresponding <code>x-amz-checksum</code> or <code>x-amz-trailer</code> header sent. Otherwise, Amazon S3 fails the request with the HTTP status code <code>400 Bad Request</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
     /// <p>If you provide an individual checksum, Amazon S3 ignores any provided <code>ChecksumAlgorithm</code> parameter.</p>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-51
+    }
     /// <p>Container for the <code>TagSet</code> and <code>Tag</code> elements</p>
     pub fn tagging(&self) -> ::std::option::Option<&crate::types::Tagging> {
         self.tagging.as_ref()
-55
+    }
     /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
     pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
         self.expected_bucket_owner.as_deref()
-59
+    }
     /// <p>Confirms that the requester knows that she or he will be charged for the tagging object request. Bucket owners need not specify this parameter in their requests.</p>
     pub fn request_payer(&self) -> ::std::option::Option<&crate::types::RequestPayer> {
         self.request_payer.as_ref()
-63
+    }
-64
+}
 static PUTOBJECTTAGGINGINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectTaggingInput",

     "com.amazonaws.s3.synthetic",
     "PutObjectTaggingInput",
 );
 static PUTOBJECTTAGGINGINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectTaggingInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutObjectTaggingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-79
+)
 .with_http_label();
 static PUTOBJECTTAGGINGINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectTaggingInput$Key",
         "com.amazonaws.s3.synthetic",
         "PutObjectTaggingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
-90
+)
 .with_http_label();
 static PUTOBJECTTAGGINGINPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectTaggingInput$VersionId",
         "com.amazonaws.s3.synthetic",
         "PutObjectTaggingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "version_id",
     "VersionId",
 ,
-101
+)
 .with_http_query("versionId");
 static PUTOBJECTTAGGINGINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectTaggingInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutObjectTaggingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-112
+)
 .with_http_header("Content-MD5");
 static PUTOBJECTTAGGINGINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectTaggingInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutObjectTaggingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-123
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTOBJECTTAGGINGINPUT_MEMBER_TAGGING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectTaggingInput$Tagging",
         "com.amazonaws.s3.synthetic",
         "PutObjectTaggingInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "tagging",
     "Tagging",
 ,
-134
+)
 .with_xml_name("Tagging")
 .with_http_payload();
 static PUTOBJECTTAGGINGINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectTaggingInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutObjectTaggingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-146
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTOBJECTTAGGINGINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectTaggingInput$RequestPayer",
         "com.amazonaws.s3.synthetic",
         "PutObjectTaggingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_payer",
     "RequestPayer",
 ,
-157
+)
 .with_http_header("x-amz-request-payer");
 static PUTOBJECTTAGGINGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTTAGGINGINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTOBJECTTAGGINGINPUT_MEMBER_BUCKET,
         &PUTOBJECTTAGGINGINPUT_MEMBER_KEY,
         &PUTOBJECTTAGGINGINPUT_MEMBER_VERSION_ID,
         &PUTOBJECTTAGGINGINPUT_MEMBER_CONTENT_MD5,
         &PUTOBJECTTAGGINGINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTOBJECTTAGGINGINPUT_MEMBER_TAGGING,
         &PUTOBJECTTAGGINGINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
         &PUTOBJECTTAGGINGINPUT_MEMBER_REQUEST_PAYER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/{Key+}?tagging", None));
 impl PutObjectTaggingInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTTAGGINGINPUT_SCHEMA;
-177
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectTaggingInput {
     #[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.bucket {
             ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_BUCKET, val)?;
-186
+        }
         if let Some(ref val) = self.key {
             ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_KEY, val)?;
-189
+        }
         if let Some(ref val) = self.version_id {
             ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_VERSION_ID, val)?;
-192
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_CONTENT_MD5, val)?;
-195
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-198
+        }
         if let Some(ref val) = self.tagging {
             ser.write_struct(&PUTOBJECTTAGGINGINPUT_MEMBER_TAGGING, val)?;
-201
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-204
+        }
         if let Some(ref val) = self.request_payer {
             ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
-207
+        }
         Ok(())
-209
+    }
-210
+}
 impl PutObjectTaggingInput {
     /// 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(&PUTOBJECTTAGGINGINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTTAGGINGINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-229
+                }
                 Some(1) => {
                     builder.key = Some(deser.read_string(member)?);
-232
+                }
                 Some(2) => {
                     builder.version_id = Some(deser.read_string(member)?);
-235
+                }
                 Some(3) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-238
+                }
                 Some(4) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-241
+                }
                 Some(5) => {
                     builder.tagging = Some(crate::types::Tagging::deserialize(deser)?);
-244
+                }
                 Some(6) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-247
+                }
                 Some(7) => {
                     builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
-250
+                }
                 _ => {}
-252
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder.key = builder.key.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutObjectTaggingInput {
     /// 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-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-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-request-payer") {
             builder.request_payer = Some(crate::types::RequestPayer::from(val));
-+
+        }
         if !body.is_empty() {
             builder.tagging = Some(crate::types::Tagging::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-292
+    }
-293
+}
 impl PutObjectTaggingInput {
     /// Creates a new builder-style object to manufacture [`PutObjectTaggingInput`](crate::operation::put_object_tagging::PutObjectTaggingInput).
     pub fn builder() -> crate::operation::put_object_tagging::builders::PutObjectTaggingInputBuilder {
         crate::operation::put_object_tagging::builders::PutObjectTaggingInputBuilder::default()
-298
+    }

↧ Expand context

-299
+}
-300
 /// A builder for [`PutObjectTaggingInput`](crate::operation::put_object_tagging::PutObjectTaggingInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectTaggingInputBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) version_id: ::std::option::Option<::std::string::String>,
     pub(crate) content_md5: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) tagging: ::std::option::Option<crate::types::Tagging>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
     pub(crate) request_payer: ::std::option::Option<crate::types::RequestPayer>,
-313
+}
 impl PutObjectTaggingInputBuilder {
     /// <p>The bucket name containing the object.</p>
     /// <p><b>Access points</b> - When you use this action with an access point for general purpose buckets, you must provide the alias of the access point in place of the bucket name or specify the access point ARN. When you use this action with an access point for directory buckets, you must provide the access point name in place of the bucket name. When using the access point ARN, you must direct requests to the access point hostname. The access point hostname takes the form <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com. When using this action with an access point through the Amazon Web Services SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using access points</a> in the <i>Amazon S3 User Guide</i>.</p>
     /// <p><b>S3 on Outposts</b> - When you use this action with S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form <code> <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>. When you use this action with S3 on Outposts, the destination bucket must be the Outposts access point ARN or the access point alias. For more information about S3 on Outposts, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
     /// This field is required.

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

@@ -1,1 +109,140 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutObjectTaggingOutput {
     /// <p>The versionId of the object the tag-set was added to.</p>
     pub version_id: ::std::option::Option<::std::string::String>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-10
+}
 impl PutObjectTaggingOutput {
     /// <p>The versionId of the object the tag-set was added to.</p>
     pub fn version_id(&self) -> ::std::option::Option<&str> {
         self.version_id.as_deref()
-15
+    }
-16
+}
 static PUTOBJECTTAGGINGOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectTaggingOutput",

     "com.amazonaws.s3.synthetic",
     "PutObjectTaggingOutput",
 );
 static PUTOBJECTTAGGINGOUTPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectTaggingOutput$VersionId",
         "com.amazonaws.s3.synthetic",
         "PutObjectTaggingOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "version_id",
     "VersionId",
 ,
-31
+)
 .with_http_header("x-amz-version-id");
 static PUTOBJECTTAGGINGOUTPUT_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 PUTOBJECTTAGGINGOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTTAGGINGOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTOBJECTTAGGINGOUTPUT_MEMBER_VERSION_ID],
     &[&PUTOBJECTTAGGINGOUTPUT_MEMBER_VERSION_ID, &PUTOBJECTTAGGINGOUTPUT_MEMBER__REQUEST_ID],
 );
 impl PutObjectTaggingOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTTAGGINGOUTPUT_SCHEMA;
-48
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectTaggingOutput {
     #[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.version_id {
             ser.write_string(&PUTOBJECTTAGGINGOUTPUT_MEMBER_VERSION_ID, val)?;
-57
+        }
         Ok(())
-59
+    }
-60
+}
 impl PutObjectTaggingOutput {
     /// 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(&PUTOBJECTTAGGINGOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTTAGGINGOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.version_id = Some(deser.read_string(member)?);
-79
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-84
+            }
             Ok(())
         })?;
         Ok(builder.build())
-88
+    }
-89
+}
 impl PutObjectTaggingOutput {
     /// 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-version-id") {
             builder.version_id = Some(val.to_string());
-+
+        }
         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 PutObjectTaggingOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-114
+    }
-115
+}
 impl ::aws_types::request_id::RequestId for PutObjectTaggingOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-119
+    }
-120
+}

↧ Expand context

 impl PutObjectTaggingOutput {
     /// Creates a new builder-style object to manufacture [`PutObjectTaggingOutput`](crate::operation::put_object_tagging::PutObjectTaggingOutput).
     pub fn builder() -> crate::operation::put_object_tagging::builders::PutObjectTaggingOutputBuilder {
         crate::operation::put_object_tagging::builders::PutObjectTaggingOutputBuilder::default()
-125
+    }
-126
+}
-127
 /// A builder for [`PutObjectTaggingOutput`](crate::operation::put_object_tagging::PutObjectTaggingOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutObjectTaggingOutputBuilder {
     pub(crate) version_id: ::std::option::Option<::std::string::String>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-135
+}
 impl PutObjectTaggingOutputBuilder {
     /// <p>The versionId of the object the tag-set was added to.</p>
     pub fn version_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.version_id = ::std::option::Option::Some(input.into());
         self

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `PutPublicAccessBlock`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutPublicAccessBlock;
 impl PutPublicAccessBlock {
     /// Creates a new `PutPublicAccessBlock`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_public_access_block::PutPublicAccessBlockInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_public_access_block::PutPublicAccessBlockOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::put_public_access_block::PutPublicAccessBlockInput,
     ) -> ::std::result::Result<
         crate::operation::put_public_access_block::PutPublicAccessBlockOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_public_access_block::PutPublicAccessBlockError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::put_public_access_block::PutPublicAccessBlockError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::put_public_access_block::PutPublicAccessBlockOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -179,183 +241,246 @@

↥ Expand context

                                         is_presigned_req,
                                     ) {
                                         (_, _, _, _, true) => {}
                                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)
                                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-189
+                                        }
                                         _ => {},
-191
+                                    }
-192
                                     // We return a bool indicating if the user did set the checksum value, if they did
                                     // we can short circuit and exit the interceptor early.
                                     Ok(user_set_checksum_value)
-196
+                                }
                                 ))
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_public_access_block::PutPublicAccessBlockError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_public_access_block::PutPublicAccessBlockError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_public_access_block::PutPublicAccessBlockError>::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());
-205
         ::std::borrow::Cow::Owned(rcb)
-207
+    }
-208
+}
-209
 #[derive(Debug)]
 struct PutPublicAccessBlockResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutPublicAccessBlockResponseDeserializer {
     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;
-226
+        }

↧ 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_put_public_access_block::de_put_public_access_block_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_public_access_block::de_put_public_access_block_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-234
+    }
-235
+}
 #[derive(Debug)]
 struct PutPublicAccessBlockRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutPublicAccessBlockRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::put_public_access_block::PutPublicAccessBlockInput>()

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

@@ -25,25 +207,238 @@

↥ Expand context

     /// <p>For requests made using the Amazon Web Services Command Line Interface (CLI) or Amazon Web Services SDKs, this field is calculated automatically.</p>
     pub fn content_md5(&self) -> ::std::option::Option<&str> {
         self.content_md5.as_deref()
-28
+    }
     /// <p>Indicates the algorithm used to create the checksum for the object when you use the SDK. This header will not provide any additional functionality if you don't use the SDK. When you send this header, there must be a corresponding <code>x-amz-checksum</code> or <code>x-amz-trailer</code> header sent. Otherwise, Amazon S3 fails the request with the HTTP status code <code>400 Bad Request</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
     /// <p>If you provide an individual checksum, Amazon S3 ignores any provided <code>ChecksumAlgorithm</code> parameter.</p>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-33
+    }
     /// <p>The <code>PublicAccessBlock</code> configuration that you want to apply to this Amazon S3 bucket. You can enable the configuration options in any combination. For more information about when Amazon S3 considers a bucket or object public, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/access-control-block-public-access.html#access-control-block-public-access-policy-status">The Meaning of "Public"</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub fn public_access_block_configuration(&self) -> ::std::option::Option<&crate::types::PublicAccessBlockConfiguration> {
         self.public_access_block_configuration.as_ref()
-37
+    }
     /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
     pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
         self.expected_bucket_owner.as_deref()
-41
+    }
-42
+}
 static PUTPUBLICACCESSBLOCKINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutPublicAccessBlockInput",

     "com.amazonaws.s3.synthetic",
     "PutPublicAccessBlockInput",
 );
 static PUTPUBLICACCESSBLOCKINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutPublicAccessBlockInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutPublicAccessBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-57
+)
 .with_http_label();
 static PUTPUBLICACCESSBLOCKINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutPublicAccessBlockInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutPublicAccessBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-68
+)
 .with_http_header("Content-MD5");
 static PUTPUBLICACCESSBLOCKINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutPublicAccessBlockInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutPublicAccessBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-79
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTPUBLICACCESSBLOCKINPUT_MEMBER_PUBLIC_ACCESS_BLOCK_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutPublicAccessBlockInput$PublicAccessBlockConfiguration",
         "com.amazonaws.s3.synthetic",
         "PutPublicAccessBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "public_access_block_configuration",
     "PublicAccessBlockConfiguration",
 ,
-90
+)
 .with_xml_name("PublicAccessBlockConfiguration")
 .with_http_payload();
 static PUTPUBLICACCESSBLOCKINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutPublicAccessBlockInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutPublicAccessBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-102
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTPUBLICACCESSBLOCKINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTPUBLICACCESSBLOCKINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTPUBLICACCESSBLOCKINPUT_MEMBER_BUCKET,
         &PUTPUBLICACCESSBLOCKINPUT_MEMBER_CONTENT_MD5,
         &PUTPUBLICACCESSBLOCKINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTPUBLICACCESSBLOCKINPUT_MEMBER_PUBLIC_ACCESS_BLOCK_CONFIGURATION,
         &PUTPUBLICACCESSBLOCKINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?publicAccessBlock", None));
 impl PutPublicAccessBlockInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTPUBLICACCESSBLOCKINPUT_SCHEMA;
-119
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutPublicAccessBlockInput {
     #[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.bucket {
             ser.write_string(&PUTPUBLICACCESSBLOCKINPUT_MEMBER_BUCKET, val)?;
-128
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTPUBLICACCESSBLOCKINPUT_MEMBER_CONTENT_MD5, val)?;
-131
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTPUBLICACCESSBLOCKINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-134
+        }
         if let Some(ref val) = self.public_access_block_configuration {
             ser.write_struct(&PUTPUBLICACCESSBLOCKINPUT_MEMBER_PUBLIC_ACCESS_BLOCK_CONFIGURATION, val)?;
-137
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTPUBLICACCESSBLOCKINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-140
+        }
         Ok(())
-142
+    }
-143
+}
 impl PutPublicAccessBlockInput {
     /// 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(&PUTPUBLICACCESSBLOCKINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTPUBLICACCESSBLOCKINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-162
+                }
                 Some(1) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-165
+                }
                 Some(2) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-168
+                }
                 Some(3) => {
                     builder.public_access_block_configuration = Some(crate::types::PublicAccessBlockConfiguration::deserialize(deser)?);
-171
+                }
                 Some(4) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-174
+                }
                 _ => {}
-176
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutPublicAccessBlockInput {
     /// 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-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-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         if !body.is_empty() {
             builder.public_access_block_configuration = Some(crate::types::PublicAccessBlockConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-212
+    }
-213
+}
 impl PutPublicAccessBlockInput {
     /// Creates a new builder-style object to manufacture [`PutPublicAccessBlockInput`](crate::operation::put_public_access_block::PutPublicAccessBlockInput).
     pub fn builder() -> crate::operation::put_public_access_block::builders::PutPublicAccessBlockInputBuilder {
         crate::operation::put_public_access_block::builders::PutPublicAccessBlockInputBuilder::default()
-218
+    }

↧ Expand context

-219
+}
-220
 /// A builder for [`PutPublicAccessBlockInput`](crate::operation::put_public_access_block::PutPublicAccessBlockInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutPublicAccessBlockInputBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) content_md5: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) public_access_block_configuration: ::std::option::Option<crate::types::PublicAccessBlockConfiguration>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-230
+}
 impl PutPublicAccessBlockInputBuilder {
     /// <p>The name of the Amazon S3 bucket whose <code>PublicAccessBlock</code> configuration you want to set.</p>
     /// This field is required.
     pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.bucket = ::std::option::Option::Some(input.into());
         self
-237
+    }
     /// <p>The name of the Amazon S3 bucket whose <code>PublicAccessBlock</code> configuration you want to set.</p>

AWS SDK

Files changed: