AWS SDK

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

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

     /// <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 request 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>Container for the request.</p>
     pub fn website_configuration(&self) -> ::std::option::Option<&crate::types::WebsiteConfiguration> {
         self.website_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 PUTBUCKETWEBSITEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketWebsiteInput",

     "com.amazonaws.s3.synthetic",
     "PutBucketWebsiteInput",
 );
 static PUTBUCKETWEBSITEINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketWebsiteInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutBucketWebsiteInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-57
+)
 .with_http_label();
 static PUTBUCKETWEBSITEINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketWebsiteInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutBucketWebsiteInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-68
+)
 .with_http_header("Content-MD5");
 static PUTBUCKETWEBSITEINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketWebsiteInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutBucketWebsiteInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-79
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTBUCKETWEBSITEINPUT_MEMBER_WEBSITE_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketWebsiteInput$WebsiteConfiguration",
         "com.amazonaws.s3.synthetic",
         "PutBucketWebsiteInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "website_configuration",
     "WebsiteConfiguration",
 ,
-90
+)
 .with_xml_name("WebsiteConfiguration")
 .with_http_payload();
 static PUTBUCKETWEBSITEINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketWebsiteInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutBucketWebsiteInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-102
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTBUCKETWEBSITEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETWEBSITEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTBUCKETWEBSITEINPUT_MEMBER_BUCKET,
         &PUTBUCKETWEBSITEINPUT_MEMBER_CONTENT_MD5,
         &PUTBUCKETWEBSITEINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTBUCKETWEBSITEINPUT_MEMBER_WEBSITE_CONFIGURATION,
         &PUTBUCKETWEBSITEINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?website", None));
 impl PutBucketWebsiteInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETWEBSITEINPUT_SCHEMA;
-119
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketWebsiteInput {
     #[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(&PUTBUCKETWEBSITEINPUT_MEMBER_BUCKET, val)?;
-128
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTBUCKETWEBSITEINPUT_MEMBER_CONTENT_MD5, val)?;
-131
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTBUCKETWEBSITEINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-134
+        }
         if let Some(ref val) = self.website_configuration {
             ser.write_struct(&PUTBUCKETWEBSITEINPUT_MEMBER_WEBSITE_CONFIGURATION, val)?;
-137
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTBUCKETWEBSITEINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-140
+        }
         Ok(())
-142
+    }
-143
+}
 impl PutBucketWebsiteInput {
     /// 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(&PUTBUCKETWEBSITEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETWEBSITEINPUT_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.website_configuration = Some(crate::types::WebsiteConfiguration::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 PutBucketWebsiteInput {
     /// 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.website_configuration = Some(crate::types::WebsiteConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-212
+    }
-213
+}
 impl PutBucketWebsiteInput {
     /// Creates a new builder-style object to manufacture [`PutBucketWebsiteInput`](crate::operation::put_bucket_website::PutBucketWebsiteInput).
     pub fn builder() -> crate::operation::put_bucket_website::builders::PutBucketWebsiteInputBuilder {
         crate::operation::put_bucket_website::builders::PutBucketWebsiteInputBuilder::default()
-218
+    }

↧ Expand context

-219
+}
-220
 /// A builder for [`PutBucketWebsiteInput`](crate::operation::put_bucket_website::PutBucketWebsiteInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketWebsiteInputBuilder {
     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) website_configuration: ::std::option::Option<crate::types::WebsiteConfiguration>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-230
+}
 impl PutBucketWebsiteInputBuilder {
     /// <p>The bucket name.</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 bucket name.</p>

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

@@ -1,1 +81,112 @@

↥ Expand context

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

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutBucketWebsiteOutput {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-8
+}
 static PUTBUCKETWEBSITEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketWebsiteOutput",
     "com.amazonaws.s3.synthetic",
     "PutBucketWebsiteOutput",
 );
 static PUTBUCKETWEBSITEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(PUTBUCKETWEBSITEOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static PUTBUCKETWEBSITEOUTPUT_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 PUTBUCKETWEBSITEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETWEBSITEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTBUCKETWEBSITEOUTPUT_MEMBER__REQUEST_ID],
 );
 impl PutBucketWebsiteOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETWEBSITEOUTPUT_SCHEMA;
-29
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketWebsiteOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-37
+    }
-38
+}
 impl PutBucketWebsiteOutput {
     /// 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(&PUTBUCKETWEBSITEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETWEBSITEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-59
+            }
             Ok(())
         })?;
         Ok(builder.build())
-63
+    }
-64
+}
 impl PutBucketWebsiteOutput {
     /// 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-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl crate::s3_request_id::RequestIdExt for PutBucketWebsiteOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-86
+    }
-87
+}
 impl ::aws_types::request_id::RequestId for PutBucketWebsiteOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-91
+    }
-92
+}

↧ Expand context

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

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

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

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

@@ -184,188 +243,248 @@

↥ Expand context

                     Ok(user_set_checksum_value)
                 },
             ))
             .with_interceptor(crate::aws_chunked::AwsChunkedContentEncodingInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_object::PutObjectError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_object::PutObjectError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object::PutObjectError>::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(),
             );
-207

         ::std::borrow::Cow::Owned(rcb)
-209
+    }
-210
+}
-211
 #[derive(Debug)]
 struct PutObjectResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectResponseDeserializer {
     fn deserialize_nonstreaming(
         &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;
-228
+        }

↧ 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::de_put_object_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_object::de_put_object_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-236
+    }
-237
+}
 #[derive(Debug)]
 struct PutObjectRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutObjectRequestSerializer {
     #[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::PutObjectInput>().expect("correct type");
         let _header_serialization_settings = _cfg

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

@@ -521,521 +1088,1086 @@

↥ Expand context

         formatter.field("server_side_encryption", &self.server_side_encryption);
         formatter.field("storage_class", &self.storage_class);
         formatter.field("website_redirect_location", &self.website_redirect_location);
         formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
         formatter.field("sse_customer_key", &"*** Sensitive Data Redacted ***");
         formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
         formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
         formatter.field("ssekms_encryption_context", &"*** Sensitive Data Redacted ***");
         formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
         formatter.field("request_payer", &self.request_payer);
         formatter.field("tagging", &self.tagging);
         formatter.field("object_lock_mode", &self.object_lock_mode);
         formatter.field("object_lock_retain_until_date", &self.object_lock_retain_until_date);
         formatter.field("object_lock_legal_hold_status", &self.object_lock_legal_hold_status);
         formatter.field("expected_bucket_owner", &self.expected_bucket_owner);
         formatter.finish()
-537
+    }
-538
+}
 static PUTOBJECTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectInput",

     "com.amazonaws.s3.synthetic",
     "PutObjectInput",
 );
 static PUTOBJECTINPUT_MEMBER_ACL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ACL",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "acl",
     "ACL",
 ,
-553
+)
 .with_http_header("x-amz-acl");
 static PUTOBJECTINPUT_MEMBER_BODY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$Body",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "body",
     "Body",
 ,
-564
+)
 .with_http_payload();
 static PUTOBJECTINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-575
+)
 .with_http_label();
 static PUTOBJECTINPUT_MEMBER_CACHE_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$CacheControl",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "cache_control",
     "CacheControl",
 ,
-586
+)
 .with_http_header("Cache-Control");
 static PUTOBJECTINPUT_MEMBER_CONTENT_DISPOSITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ContentDisposition",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_disposition",
     "ContentDisposition",
 ,
-597
+)
 .with_http_header("Content-Disposition");
 static PUTOBJECTINPUT_MEMBER_CONTENT_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ContentEncoding",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_encoding",
     "ContentEncoding",
 ,
-608
+)
 .with_http_header("Content-Encoding");
 static PUTOBJECTINPUT_MEMBER_CONTENT_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ContentLanguage",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_language",
     "ContentLanguage",
 ,
-619
+)
 .with_http_header("Content-Language");
 static PUTOBJECTINPUT_MEMBER_CONTENT_LENGTH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ContentLength",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "content_length",
     "ContentLength",
 ,
-630
+)
 .with_http_header("Content-Length");
 static PUTOBJECTINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-641
+)
 .with_http_header("Content-MD5");
 static PUTOBJECTINPUT_MEMBER_CONTENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ContentType",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_type",
     "ContentType",
 ,
-652
+)
 .with_http_header("Content-Type");
 static PUTOBJECTINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-663
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTOBJECTINPUT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ChecksumCRC32",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32",
     "ChecksumCRC32",
 ,
-674
+)
 .with_http_header("x-amz-checksum-crc32");
 static PUTOBJECTINPUT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ChecksumCRC32C",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32_c",
     "ChecksumCRC32C",
 ,
-685
+)
 .with_http_header("x-amz-checksum-crc32c");
 static PUTOBJECTINPUT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ChecksumCRC64NVME",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc64_nvme",
     "ChecksumCRC64NVME",
 ,
-696
+)
 .with_http_header("x-amz-checksum-crc64nvme");
 static PUTOBJECTINPUT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ChecksumSHA1",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha1",
     "ChecksumSHA1",
 ,
-707
+)
 .with_http_header("x-amz-checksum-sha1");
 static PUTOBJECTINPUT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ChecksumSHA256",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha256",
     "ChecksumSHA256",
 ,
-718
+)
 .with_http_header("x-amz-checksum-sha256");
 static PUTOBJECTINPUT_MEMBER_EXPIRES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$Expires",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "expires",
     "Expires",
 ,
-729
+)
 .with_http_header("Expires");
 static PUTOBJECTINPUT_MEMBER_IF_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$IfMatch",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "if_match",
     "IfMatch",
 ,
-740
+)
 .with_http_header("If-Match");
 static PUTOBJECTINPUT_MEMBER_IF_NONE_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$IfNoneMatch",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "if_none_match",
     "IfNoneMatch",
 ,
-751
+)
 .with_http_header("If-None-Match");
 static PUTOBJECTINPUT_MEMBER_GRANT_FULL_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$GrantFullControl",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_full_control",
     "GrantFullControl",
 ,
-762
+)
 .with_http_header("x-amz-grant-full-control");
 static PUTOBJECTINPUT_MEMBER_GRANT_READ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$GrantRead",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read",
     "GrantRead",
 ,
-773
+)
 .with_http_header("x-amz-grant-read");
 static PUTOBJECTINPUT_MEMBER_GRANT_READ_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$GrantReadACP",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read_acp",
     "GrantReadACP",
 ,
-784
+)
 .with_http_header("x-amz-grant-read-acp");
 static PUTOBJECTINPUT_MEMBER_GRANT_WRITE_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$GrantWriteACP",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_write_acp",
     "GrantWriteACP",
 ,
-795
+)
 .with_http_header("x-amz-grant-write-acp");
 static PUTOBJECTINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$Key",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
-806
+)
 .with_http_label();
 static PUTOBJECTINPUT_MEMBER_WRITE_OFFSET_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$WriteOffsetBytes",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "write_offset_bytes",
     "WriteOffsetBytes",
 ,
-817
+)
 .with_http_header("x-amz-write-offset-bytes");
 static PUTOBJECTINPUT_MEMBER_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$Metadata",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "metadata",
     "Metadata",
 ,
-828
+)
 .with_http_prefix_headers("x-amz-meta-");
 static PUTOBJECTINPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ServerSideEncryption",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "server_side_encryption",
     "ServerSideEncryption",
 ,
-839
+)
 .with_http_header("x-amz-server-side-encryption");
 static PUTOBJECTINPUT_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$StorageClass",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "storage_class",
     "StorageClass",
 ,
-850
+)
 .with_http_header("x-amz-storage-class");
 static PUTOBJECTINPUT_MEMBER_WEBSITE_REDIRECT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$WebsiteRedirectLocation",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "website_redirect_location",
     "WebsiteRedirectLocation",
 ,
-861
+)
 .with_http_header("x-amz-website-redirect-location");
 static PUTOBJECTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$SSECustomerAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_algorithm",
     "SSECustomerAlgorithm",
 ,
-872
+)
 .with_http_header("x-amz-server-side-encryption-customer-algorithm");
 static PUTOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$SSECustomerKey",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key",
     "SSECustomerKey",
 ,
-883
+)
 .with_http_header("x-amz-server-side-encryption-customer-key");
 static PUTOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$SSECustomerKeyMD5",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key_md5",
     "SSECustomerKeyMD5",
 ,
-894
+)
 .with_http_header("x-amz-server-side-encryption-customer-key-MD5");
 static PUTOBJECTINPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$SSEKMSKeyId",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_key_id",
     "SSEKMSKeyId",
 ,
-905
+)
 .with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
 static PUTOBJECTINPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$SSEKMSEncryptionContext",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_encryption_context",
     "SSEKMSEncryptionContext",
 ,
-916
+)
 .with_http_header("x-amz-server-side-encryption-context");
 static PUTOBJECTINPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$BucketKeyEnabled",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bucket_key_enabled",
     "BucketKeyEnabled",
 ,
-927
+)
 .with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
 static PUTOBJECTINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$RequestPayer",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_payer",
     "RequestPayer",
 ,
-938
+)
 .with_http_header("x-amz-request-payer");
 static PUTOBJECTINPUT_MEMBER_TAGGING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$Tagging",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "tagging",
     "Tagging",
 ,
-949
+)
 .with_http_header("x-amz-tagging");
 static PUTOBJECTINPUT_MEMBER_OBJECT_LOCK_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ObjectLockMode",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "object_lock_mode",
     "ObjectLockMode",
 ,
-960
+)
 .with_http_header("x-amz-object-lock-mode");
 static PUTOBJECTINPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ObjectLockRetainUntilDate",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "object_lock_retain_until_date",
     "ObjectLockRetainUntilDate",
 ,
-971
+)
 .with_http_header("x-amz-object-lock-retain-until-date");
 .with_http_header("x-amz-object-lock-retain-until-date")
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 static PUTOBJECTINPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ObjectLockLegalHoldStatus",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "object_lock_legal_hold_status",
     "ObjectLockLegalHoldStatus",
 ,
-983
+)
 .with_http_header("x-amz-object-lock-legal-hold");
 static PUTOBJECTINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutObjectInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-994
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTOBJECTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTOBJECTINPUT_MEMBER_ACL,
         &PUTOBJECTINPUT_MEMBER_BODY,
         &PUTOBJECTINPUT_MEMBER_BUCKET,
         &PUTOBJECTINPUT_MEMBER_CACHE_CONTROL,
         &PUTOBJECTINPUT_MEMBER_CONTENT_DISPOSITION,
         &PUTOBJECTINPUT_MEMBER_CONTENT_ENCODING,
         &PUTOBJECTINPUT_MEMBER_CONTENT_LANGUAGE,
         &PUTOBJECTINPUT_MEMBER_CONTENT_LENGTH,
         &PUTOBJECTINPUT_MEMBER_CONTENT_MD5,
         &PUTOBJECTINPUT_MEMBER_CONTENT_TYPE,
         &PUTOBJECTINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTOBJECTINPUT_MEMBER_CHECKSUM_CRC32,
         &PUTOBJECTINPUT_MEMBER_CHECKSUM_CRC32_C,
         &PUTOBJECTINPUT_MEMBER_CHECKSUM_CRC64_NVME,
         &PUTOBJECTINPUT_MEMBER_CHECKSUM_SHA1,
         &PUTOBJECTINPUT_MEMBER_CHECKSUM_SHA256,
         &PUTOBJECTINPUT_MEMBER_EXPIRES,
         &PUTOBJECTINPUT_MEMBER_IF_MATCH,
         &PUTOBJECTINPUT_MEMBER_IF_NONE_MATCH,
         &PUTOBJECTINPUT_MEMBER_GRANT_FULL_CONTROL,
         &PUTOBJECTINPUT_MEMBER_GRANT_READ,
         &PUTOBJECTINPUT_MEMBER_GRANT_READ_ACP,
         &PUTOBJECTINPUT_MEMBER_GRANT_WRITE_ACP,
         &PUTOBJECTINPUT_MEMBER_KEY,
         &PUTOBJECTINPUT_MEMBER_WRITE_OFFSET_BYTES,
         &PUTOBJECTINPUT_MEMBER_METADATA,
         &PUTOBJECTINPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
         &PUTOBJECTINPUT_MEMBER_STORAGE_CLASS,
         &PUTOBJECTINPUT_MEMBER_WEBSITE_REDIRECT_LOCATION,
         &PUTOBJECTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
         &PUTOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY,
         &PUTOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
         &PUTOBJECTINPUT_MEMBER_SSEKMS_KEY_ID,
         &PUTOBJECTINPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT,
         &PUTOBJECTINPUT_MEMBER_BUCKET_KEY_ENABLED,
         &PUTOBJECTINPUT_MEMBER_REQUEST_PAYER,
         &PUTOBJECTINPUT_MEMBER_TAGGING,
         &PUTOBJECTINPUT_MEMBER_OBJECT_LOCK_MODE,
         &PUTOBJECTINPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE,
         &PUTOBJECTINPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS,
         &PUTOBJECTINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/{Key+}?x-id=PutObject", None));
 impl PutObjectInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTINPUT_SCHEMA;
-1047
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectInput {
     #[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(&PUTOBJECTINPUT_MEMBER_ACL, val.as_str())?;
-1056
+        }
--
+        {
             let val = &self.body;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         if let Some(ref val) = self.bucket {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_BUCKET, val)?;
-1059
+        }
         if let Some(ref val) = self.cache_control {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_CACHE_CONTROL, val)?;
-1062
+        }
         if let Some(ref val) = self.content_disposition {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_CONTENT_DISPOSITION, val)?;
-1065
+        }
         if let Some(ref val) = self.content_encoding {

↧ Expand context

             ser.write_string(&PUTOBJECTINPUT_MEMBER_CONTENT_ENCODING, val)?;
-1068
+        }
         if let Some(ref val) = self.content_language {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_CONTENT_LANGUAGE, val)?;
-1071
+        }
         if let Some(ref val) = self.content_length {
             ser.write_long(&PUTOBJECTINPUT_MEMBER_CONTENT_LENGTH, *val)?;
-1074
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_CONTENT_MD5, val)?;
-1077
+        }
         if let Some(ref val) = self.content_type {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_CONTENT_TYPE, val)?;
-1080
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-1083
+        }
         if let Some(ref val) = self.checksum_crc32 {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_CHECKSUM_CRC32, val)?;
-1086
+        }

@@ -1160,1158 +1232,1230 @@

↥ Expand context

-1158
+        }
         if let Some(ref val) = self.ssekms_encryption_context {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT, val)?;
-1161
+        }
         if let Some(ref val) = self.bucket_key_enabled {
             ser.write_boolean(&PUTOBJECTINPUT_MEMBER_BUCKET_KEY_ENABLED, *val)?;
-1164
+        }
         if let Some(ref val) = self.request_payer {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
-1167
+        }
         if let Some(ref val) = self.tagging {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_TAGGING, val)?;
-1170
+        }
         if let Some(ref val) = self.object_lock_mode {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_OBJECT_LOCK_MODE, val.as_str())?;
-1173
+        }
         if let Some(ref val) = self.object_lock_retain_until_date {
             ser.write_timestamp(&PUTOBJECTINPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE, val)?;
-1176
+        }
         if let Some(ref val) = self.object_lock_legal_hold_status {

             ser.write_string(&PUTOBJECTINPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS, val.as_str())?;
-1179
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTOBJECTINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-1182
+        }
         Ok(())
-1184
+    }
-1185
+}
 impl PutObjectInput {
     /// 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(&PUTOBJECTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.acl = Some(crate::types::ObjectCannedAcl::from(deser.read_string(member)?.as_str()));
-1204
+                }
                 Some(1) => {
                     builder.body = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-1210
+                }

↧ Expand context

                 Some(2) => {
                     builder.bucket = Some(deser.read_string(member)?);
-1213
+                }
                 Some(3) => {
                     builder.cache_control = Some(deser.read_string(member)?);
-1216
+                }
                 Some(4) => {
                     builder.content_disposition = Some(deser.read_string(member)?);
-1219
+                }
                 Some(5) => {
                     builder.content_encoding = Some(deser.read_string(member)?);
-1222
+                }
                 Some(6) => {
                     builder.content_language = Some(deser.read_string(member)?);
-1225
+                }
                 Some(7) => {
                     builder.content_length = Some(deser.read_long(member)?);
-1228
+                }
                 Some(8) => {
                     builder.content_md5 = Some(deser.read_string(member)?);

@@ -1253,1251 +1373,1565 @@

↥ Expand context

                     builder.checksum_sha256 = Some(deser.read_string(member)?);
-1252
+                }
                 Some(16) => {
                     builder.expires = Some(deser.read_timestamp(member)?);
-1255
+                }
                 Some(17) => {
                     builder.if_match = Some(deser.read_string(member)?);
-1258
+                }
                 Some(18) => {
                     builder.if_none_match = Some(deser.read_string(member)?);
-1261
+                }
                 Some(19) => {
                     builder.grant_full_control = Some(deser.read_string(member)?);
-1264
+                }
                 Some(20) => {
                     builder.grant_read = Some(deser.read_string(member)?);
-1267
+                }
                 Some(21) => {
                     builder.grant_read_acp = Some(deser.read_string(member)?);
-1270
+                }

                 Some(22) => {
                     builder.grant_write_acp = Some(deser.read_string(member)?);
-1273
+                }
                 Some(23) => {
                     builder.key = Some(deser.read_string(member)?);
-1276
+                }
                 Some(24) => {
                     builder.write_offset_bytes = Some(deser.read_long(member)?);
-1279
+                }
                 Some(25) => {
                     builder.metadata = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.metadata = Some(deser.read_string_string_map(member)?);
-1282
+                }
                 Some(26) => {
                     builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
-1285
+                }
                 Some(27) => {
                     builder.storage_class = Some(crate::types::StorageClass::from(deser.read_string(member)?.as_str()));
-1288
+                }
                 Some(28) => {
                     builder.website_redirect_location = Some(deser.read_string(member)?);
-1291
+                }
                 Some(29) => {
                     builder.sse_customer_algorithm = Some(deser.read_string(member)?);
-1294
+                }
                 Some(30) => {
                     builder.sse_customer_key = Some(deser.read_string(member)?);
-1297
+                }
                 Some(31) => {
                     builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
-1300
+                }
                 Some(32) => {
                     builder.ssekms_key_id = Some(deser.read_string(member)?);
-1303
+                }
                 Some(33) => {
                     builder.ssekms_encryption_context = Some(deser.read_string(member)?);
-1306
+                }
                 Some(34) => {
                     builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
-1309
+                }
                 Some(35) => {
                     builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
-1312
+                }
                 Some(36) => {
                     builder.tagging = Some(deser.read_string(member)?);
-1315
+                }
                 Some(37) => {
                     builder.object_lock_mode = Some(crate::types::ObjectLockMode::from(deser.read_string(member)?.as_str()));
-1318
+                }
                 Some(38) => {
                     builder.object_lock_retain_until_date = Some(deser.read_timestamp(member)?);
-1321
+                }
                 Some(39) => {
                     builder.object_lock_legal_hold_status = Some(crate::types::ObjectLockLegalHoldStatus::from(deser.read_string(member)?.as_str()));
-1324
+                }
                 Some(40) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-1327
+                }
                 _ => {}
-1329
+            }
             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 PutObjectInput {
     /// 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("Cache-Control") {
             builder.cache_control = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Content-Disposition") {
             builder.content_disposition = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Content-Encoding") {
             builder.content_encoding = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Content-Language") {
             builder.content_language = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Content-Length") {
             builder.content_length = val.parse::<i64>().ok();
-+
+        }
         if let Some(val) = headers.get("Content-MD5") {
             builder.content_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Content-Type") {
             builder.content_type = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-sdk-checksum-algorithm") {
             builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc32") {
             builder.checksum_crc32 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc32c") {
             builder.checksum_crc32_c = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc64nvme") {
             builder.checksum_crc64_nvme = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-sha1") {
             builder.checksum_sha1 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-sha256") {
             builder.checksum_sha256 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Expires") {
             builder.expires = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
-+
+        }
         if let Some(val) = headers.get("If-Match") {
             builder.if_match = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("If-None-Match") {
             builder.if_none_match = Some(val.to_string());
-+
+        }
         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-acp") {
             builder.grant_write_acp = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-write-offset-bytes") {
             builder.write_offset_bytes = val.parse::<i64>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption") {
             builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-storage-class") {
             builder.storage_class = Some(crate::types::StorageClass::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-website-redirect-location") {
             builder.website_redirect_location = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
             builder.sse_customer_algorithm = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key") {
             builder.sse_customer_key = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
             builder.sse_customer_key_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
             builder.ssekms_key_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-context") {
             builder.ssekms_encryption_context = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
             builder.bucket_key_enabled = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-request-payer") {
             builder.request_payer = Some(crate::types::RequestPayer::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-tagging") {
             builder.tagging = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-object-lock-mode") {
             builder.object_lock_mode = Some(crate::types::ObjectLockMode::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-object-lock-retain-until-date") {
             builder.object_lock_retain_until_date = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::DateTime).ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-object-lock-legal-hold") {
             builder.object_lock_legal_hold_status = Some(crate::types::ObjectLockLegalHoldStatus::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
-+
+        {
             let mut map = ::std::collections::HashMap::new();
             for (key, val) in headers.iter() {
                 if let Some(suffix) = key.strip_prefix("x-amz-meta-") {
                     map.insert(suffix.to_string(), val.to_string());
-+
+                }
-+
+            }
             if !map.is_empty() {
                 builder.metadata = Some(map);
-+
+            }
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PUTOBJECTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.body = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 Some(2) => {
                     builder.bucket = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => { /* read from headers above */ }
                 Some(4) => { /* read from headers above */ }
                 Some(5) => { /* read from headers above */ }
                 Some(6) => { /* read from headers above */ }
                 Some(7) => { /* read from headers above */ }
                 Some(8) => { /* read from headers above */ }
                 Some(9) => { /* read from headers above */ }
                 Some(10) => { /* read from headers above */ }
                 Some(11) => { /* read from headers above */ }
                 Some(12) => { /* read from headers above */ }
                 Some(13) => { /* read from headers above */ }
                 Some(14) => { /* read from headers above */ }
                 Some(15) => { /* read from headers above */ }
                 Some(16) => { /* read from headers above */ }
                 Some(17) => { /* read from headers above */ }
                 Some(18) => { /* read from headers above */ }
                 Some(19) => { /* read from headers above */ }
                 Some(20) => { /* read from headers above */ }
                 Some(21) => { /* read from headers above */ }
                 Some(22) => { /* read from headers above */ }
                 Some(23) => {
                     builder.key = Some(deser.read_string(member)?);
-+
+                }
                 Some(24) => { /* read from headers above */ }
                 Some(25) => { /* read from headers above */ }
                 Some(26) => { /* read from headers above */ }
                 Some(27) => { /* read from headers above */ }
                 Some(28) => { /* read from headers above */ }
                 Some(29) => { /* read from headers above */ }
                 Some(30) => { /* read from headers above */ }
                 Some(31) => { /* read from headers above */ }
                 Some(32) => { /* read from headers above */ }
                 Some(33) => { /* read from headers above */ }
                 Some(34) => { /* read from headers above */ }
                 Some(35) => { /* read from headers above */ }
                 Some(36) => { /* read from headers above */ }
                 Some(37) => { /* read from headers above */ }
                 Some(38) => { /* read from headers above */ }
                 Some(39) => { /* read from headers above */ }
                 Some(40) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-1539
+    }
-1540
+}
 impl PutObjectInput {
     /// Creates a new builder-style object to manufacture [`PutObjectInput`](crate::operation::put_object::PutObjectInput).
     pub fn builder() -> crate::operation::put_object::builders::PutObjectInputBuilder {
         crate::operation::put_object::builders::PutObjectInputBuilder::default()
-1545
+    }

↧ Expand context

-1546
+}
-1547
 /// A builder for [`PutObjectInput`](crate::operation::put_object::PutObjectInput).
 #[derive(::std::default::Default)]
 #[non_exhaustive]
 pub struct PutObjectInputBuilder {
     pub(crate) acl: ::std::option::Option<crate::types::ObjectCannedAcl>,
     pub(crate) body: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) cache_control: ::std::option::Option<::std::string::String>,
     pub(crate) content_disposition: ::std::option::Option<::std::string::String>,
     pub(crate) content_encoding: ::std::option::Option<::std::string::String>,
     pub(crate) content_language: ::std::option::Option<::std::string::String>,
     pub(crate) content_length: ::std::option::Option<i64>,
     pub(crate) content_md5: ::std::option::Option<::std::string::String>,
     pub(crate) content_type: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) checksum_crc32: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc32_c: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc64_nvme: ::std::option::Option<::std::string::String>,

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

@@ -154,154 +414,422 @@

↥ Expand context

         formatter.field("checksum_crc64_nvme", &self.checksum_crc64_nvme);
         formatter.field("checksum_sha1", &self.checksum_sha1);
         formatter.field("checksum_sha256", &self.checksum_sha256);
         formatter.field("checksum_type", &self.checksum_type);
         formatter.field("server_side_encryption", &self.server_side_encryption);
         formatter.field("version_id", &self.version_id);
         formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
         formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
         formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
         formatter.field("ssekms_encryption_context", &"*** Sensitive Data Redacted ***");
         formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
         formatter.field("size", &self.size);
         formatter.field("request_charged", &self.request_charged);
         formatter.field("_extended_request_id", &self._extended_request_id);
         formatter.field("_request_id", &self._request_id);
         formatter.finish()
-170
+    }
-171
+}
 static PUTOBJECTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutObjectOutput",

     "com.amazonaws.s3.synthetic",
     "PutObjectOutput",
 );
 static PUTOBJECTOUTPUT_MEMBER_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$Expiration",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expiration",
     "Expiration",
 ,
-186
+)
 .with_http_header("x-amz-expiration");
 static PUTOBJECTOUTPUT_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$ETag",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "e_tag",
     "ETag",
 ,
-197
+)
 .with_http_header("ETag");
 static PUTOBJECTOUTPUT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$ChecksumCRC32",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32",
     "ChecksumCRC32",
 ,
-208
+)
 .with_http_header("x-amz-checksum-crc32");
 static PUTOBJECTOUTPUT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$ChecksumCRC32C",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32_c",
     "ChecksumCRC32C",
 ,
-219
+)
 .with_http_header("x-amz-checksum-crc32c");
 static PUTOBJECTOUTPUT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$ChecksumCRC64NVME",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc64_nvme",
     "ChecksumCRC64NVME",
 ,
-230
+)
 .with_http_header("x-amz-checksum-crc64nvme");
 static PUTOBJECTOUTPUT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$ChecksumSHA1",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha1",
     "ChecksumSHA1",
 ,
-241
+)
 .with_http_header("x-amz-checksum-sha1");
 static PUTOBJECTOUTPUT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$ChecksumSHA256",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha256",
     "ChecksumSHA256",
 ,
-252
+)
 .with_http_header("x-amz-checksum-sha256");
 static PUTOBJECTOUTPUT_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$ChecksumType",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_type",
     "ChecksumType",
 ,
-263
+)
 .with_http_header("x-amz-checksum-type");
 static PUTOBJECTOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$ServerSideEncryption",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "server_side_encryption",
     "ServerSideEncryption",
 ,
-274
+)
 .with_http_header("x-amz-server-side-encryption");
 static PUTOBJECTOUTPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$VersionId",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "version_id",
     "VersionId",
 ,
-285
+)
 .with_http_header("x-amz-version-id");
 static PUTOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$SSECustomerAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_algorithm",
     "SSECustomerAlgorithm",
 ,
-296
+)
 .with_http_header("x-amz-server-side-encryption-customer-algorithm");
 static PUTOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$SSECustomerKeyMD5",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key_md5",
     "SSECustomerKeyMD5",
 ,
-307
+)
 .with_http_header("x-amz-server-side-encryption-customer-key-MD5");
 static PUTOBJECTOUTPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$SSEKMSKeyId",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_key_id",
     "SSEKMSKeyId",
 ,
-318
+)
 .with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
 static PUTOBJECTOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$SSEKMSEncryptionContext",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_encryption_context",
     "SSEKMSEncryptionContext",
 ,
-329
+)
 .with_http_header("x-amz-server-side-encryption-context");
 static PUTOBJECTOUTPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$BucketKeyEnabled",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bucket_key_enabled",
     "BucketKeyEnabled",
 ,
-340
+)
 .with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
 static PUTOBJECTOUTPUT_MEMBER_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$Size",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "size",
     "Size",
 ,
-351
+)
 .with_http_header("x-amz-object-size");
 static PUTOBJECTOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutObjectOutput$RequestCharged",
         "com.amazonaws.s3.synthetic",
         "PutObjectOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_charged",
     "RequestCharged",
 ,
-362
+)
 .with_http_header("x-amz-request-charged");
 static PUTOBJECTOUTPUT_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 PUTOBJECTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTOBJECTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTOBJECTOUTPUT_MEMBER_EXPIRATION,
         &PUTOBJECTOUTPUT_MEMBER_E_TAG,
         &PUTOBJECTOUTPUT_MEMBER_CHECKSUM_CRC32,
         &PUTOBJECTOUTPUT_MEMBER_CHECKSUM_CRC32_C,
         &PUTOBJECTOUTPUT_MEMBER_CHECKSUM_CRC64_NVME,
         &PUTOBJECTOUTPUT_MEMBER_CHECKSUM_SHA1,
         &PUTOBJECTOUTPUT_MEMBER_CHECKSUM_SHA256,
         &PUTOBJECTOUTPUT_MEMBER_CHECKSUM_TYPE,
         &PUTOBJECTOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
         &PUTOBJECTOUTPUT_MEMBER_VERSION_ID,
         &PUTOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
         &PUTOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
         &PUTOBJECTOUTPUT_MEMBER_SSEKMS_KEY_ID,
         &PUTOBJECTOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT,
         &PUTOBJECTOUTPUT_MEMBER_BUCKET_KEY_ENABLED,
         &PUTOBJECTOUTPUT_MEMBER_SIZE,
         &PUTOBJECTOUTPUT_MEMBER_REQUEST_CHARGED,
         &PUTOBJECTOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl PutObjectOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTOUTPUT_SCHEMA;
-398
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

↧ Expand context

         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.expiration {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_EXPIRATION, val)?;
-407
+        }
         if let Some(ref val) = self.e_tag {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_E_TAG, val)?;
-410
+        }
         if let Some(ref val) = self.checksum_crc32 {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_CHECKSUM_CRC32, val)?;
-413
+        }
         if let Some(ref val) = self.checksum_crc32_c {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_CHECKSUM_CRC32_C, val)?;
-416
+        }
         if let Some(ref val) = self.checksum_crc64_nvme {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_CHECKSUM_CRC64_NVME, val)?;
-419
+        }
         if let Some(ref val) = self.checksum_sha1 {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_CHECKSUM_SHA1, val)?;
-422
+        }

@@ -423,431 +554,634 @@

↥ Expand context

-431
+        }
         if let Some(ref val) = self.version_id {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_VERSION_ID, val)?;
-434
+        }
         if let Some(ref val) = self.sse_customer_algorithm {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM, val)?;
-437
+        }
         if let Some(ref val) = self.sse_customer_key_md5 {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5, val)?;
-440
+        }
         if let Some(ref val) = self.ssekms_key_id {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_SSEKMS_KEY_ID, val)?;
-443
+        }
         if let Some(ref val) = self.ssekms_encryption_context {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT, val)?;
-446
+        }
         if let Some(ref val) = self.bucket_key_enabled {
             ser.write_boolean(&PUTOBJECTOUTPUT_MEMBER_BUCKET_KEY_ENABLED, *val)?;
-449
+        }
         if let Some(ref val) = self.size {

             ser.write_long(&PUTOBJECTOUTPUT_MEMBER_SIZE, *val)?;
-452
+        }
         if let Some(ref val) = self.request_charged {
             ser.write_string(&PUTOBJECTOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
-455
+        }
         Ok(())
-457
+    }
-458
+}
 impl PutObjectOutput {
     /// 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(&PUTOBJECTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTOBJECTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.expiration = Some(deser.read_string(member)?);
-477
+                }
                 Some(1) => {
                     builder.e_tag = Some(deser.read_string(member)?);
-480
+                }
                 Some(2) => {
                     builder.checksum_crc32 = Some(deser.read_string(member)?);
-483
+                }
                 Some(3) => {
                     builder.checksum_crc32_c = Some(deser.read_string(member)?);
-486
+                }
                 Some(4) => {
                     builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
-489
+                }
                 Some(5) => {
                     builder.checksum_sha1 = Some(deser.read_string(member)?);
-492
+                }
                 Some(6) => {
                     builder.checksum_sha256 = Some(deser.read_string(member)?);
-495
+                }
                 Some(7) => {
                     builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
-498
+                }
                 Some(8) => {
                     builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
-501
+                }
                 Some(9) => {
                     builder.version_id = Some(deser.read_string(member)?);
-504
+                }
                 Some(10) => {
                     builder.sse_customer_algorithm = Some(deser.read_string(member)?);
-507
+                }
                 Some(11) => {
                     builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
-510
+                }
                 Some(12) => {
                     builder.ssekms_key_id = Some(deser.read_string(member)?);
-513
+                }
                 Some(13) => {
                     builder.ssekms_encryption_context = Some(deser.read_string(member)?);
-516
+                }
                 Some(14) => {
                     builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
-519
+                }
                 Some(15) => {
                     builder.size = Some(deser.read_long(member)?);
-522
+                }
                 Some(16) => {
                     builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
-525
+                }
                 Some(17) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-530
+            }
             Ok(())
         })?;
         Ok(builder.build())
-534
+    }
-535
+}
 impl PutObjectOutput {
     /// 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-expiration") {
             builder.expiration = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("ETag") {
             builder.e_tag = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc32") {
             builder.checksum_crc32 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc32c") {
             builder.checksum_crc32_c = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-crc64nvme") {
             builder.checksum_crc64_nvme = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-sha1") {
             builder.checksum_sha1 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-sha256") {
             builder.checksum_sha256 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-type") {
             builder.checksum_type = Some(crate::types::ChecksumType::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption") {
             builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-version-id") {
             builder.version_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
             builder.sse_customer_algorithm = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
             builder.sse_customer_key_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
             builder.ssekms_key_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-context") {
             builder.ssekms_encryption_context = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
             builder.bucket_key_enabled = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-object-size") {
             builder.size = val.parse::<i64>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-request-charged") {
             builder.request_charged = Some(crate::types::RequestCharged::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl crate::s3_request_id::RequestIdExt for PutObjectOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-608
+    }
-609
+}
 impl ::aws_types::request_id::RequestId for PutObjectOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-613
+    }
-614
+}

↧ Expand context

 impl PutObjectOutput {
     /// Creates a new builder-style object to manufacture [`PutObjectOutput`](crate::operation::put_object::PutObjectOutput).
     pub fn builder() -> crate::operation::put_object::builders::PutObjectOutputBuilder {
         crate::operation::put_object::builders::PutObjectOutputBuilder::default()
-619
+    }
-620
+}
-621
 /// A builder for [`PutObjectOutput`](crate::operation::put_object::PutObjectOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct PutObjectOutputBuilder {
     pub(crate) expiration: ::std::option::Option<::std::string::String>,
     pub(crate) e_tag: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc32: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc32_c: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc64_nvme: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_sha1: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_sha256: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_type: ::std::option::Option<crate::types::ChecksumType>,
     pub(crate) server_side_encryption: ::std::option::Option<crate::types::ServerSideEncryption>,

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

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

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

@@ -183,187 +242,247 @@

↥ Expand context

                     // 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_acl::PutObjectAclError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_object_acl::PutObjectAclError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_acl::PutObjectAclError>::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 PutObjectAclResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectAclResponseDeserializer {
     fn deserialize_nonstreaming(
         &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_acl::de_put_object_acl_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_object_acl::de_put_object_acl_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-235
+    }
-236
+}
 #[derive(Debug)]
 struct PutObjectAclRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutObjectAclRequestSerializer {
     #[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_acl::PutObjectAclInput>()

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

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

↥ Expand context

-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

@@ -179,183 +238,243 @@

↥ Expand context

                                         (::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(
         &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

@@ -189,195 +248,255 @@

↥ Expand context

                 },
             ))
             .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(
         &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

@@ -179,183 +238,243 @@

↥ Expand context

                                         (::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(
         &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.

AWS SDK

Files changed: