AWS SDK

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

@@ -63,63 +353,402 @@

     /// <p>Allows grantee to read the bucket ACL.</p>
     pub fn grant_read_acp(&self) -> ::std::option::Option<&str> {
         self.grant_read_acp.as_deref()
-66
+    }
     /// <p>Allows grantee to create new objects in the bucket.</p>
     /// <p>For the bucket and object owners of existing objects, also allows deletions and overwrites of those objects.</p>
     pub fn grant_write(&self) -> ::std::option::Option<&str> {
         self.grant_write.as_deref()
-71
+    }
     /// <p>Allows grantee to write the ACL for the applicable bucket.</p>
     pub fn grant_write_acp(&self) -> ::std::option::Option<&str> {
         self.grant_write_acp.as_deref()
-75
+    }
     /// <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()
-79
+    }
-80
+}
 static PUTBUCKETACLINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketAclInput",

     "com.amazonaws.s3.synthetic",
     "PutBucketAclInput",
 );
 static PUTBUCKETACLINPUT_MEMBER_ACL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$ACL",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "acl",
     "ACL",
 ,
-95
+)
 .with_http_header("x-amz-acl");
 static PUTBUCKETACLINPUT_MEMBER_ACCESS_CONTROL_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$AccessControlPolicy",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "access_control_policy",
     "AccessControlPolicy",
 ,
-106
+)
 .with_xml_name("AccessControlPolicy")
 .with_http_payload();
 static PUTBUCKETACLINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-118
+)
 .with_http_label();
 static PUTBUCKETACLINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-129
+)
 .with_http_header("Content-MD5");
 static PUTBUCKETACLINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-140
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTBUCKETACLINPUT_MEMBER_GRANT_FULL_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$GrantFullControl",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_full_control",
     "GrantFullControl",
 ,
-151
+)
 .with_http_header("x-amz-grant-full-control");
 static PUTBUCKETACLINPUT_MEMBER_GRANT_READ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$GrantRead",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read",
     "GrantRead",
 ,
-162
+)
 .with_http_header("x-amz-grant-read");
 static PUTBUCKETACLINPUT_MEMBER_GRANT_READ_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$GrantReadACP",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read_acp",
     "GrantReadACP",
 ,
-173
+)
 .with_http_header("x-amz-grant-read-acp");
 static PUTBUCKETACLINPUT_MEMBER_GRANT_WRITE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$GrantWrite",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_write",
     "GrantWrite",
 ,
-184
+)
 .with_http_header("x-amz-grant-write");
 static PUTBUCKETACLINPUT_MEMBER_GRANT_WRITE_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$GrantWriteACP",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_write_acp",
     "GrantWriteACP",
 ,
-195
+)
 .with_http_header("x-amz-grant-write-acp");
 static PUTBUCKETACLINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAclInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutBucketAclInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-206
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTBUCKETACLINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETACLINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTBUCKETACLINPUT_MEMBER_ACL,
         &PUTBUCKETACLINPUT_MEMBER_ACCESS_CONTROL_POLICY,
         &PUTBUCKETACLINPUT_MEMBER_BUCKET,
         &PUTBUCKETACLINPUT_MEMBER_CONTENT_MD5,
         &PUTBUCKETACLINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTBUCKETACLINPUT_MEMBER_GRANT_FULL_CONTROL,
         &PUTBUCKETACLINPUT_MEMBER_GRANT_READ,
         &PUTBUCKETACLINPUT_MEMBER_GRANT_READ_ACP,
         &PUTBUCKETACLINPUT_MEMBER_GRANT_WRITE,
         &PUTBUCKETACLINPUT_MEMBER_GRANT_WRITE_ACP,
         &PUTBUCKETACLINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?acl", None));
 impl PutBucketAclInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETACLINPUT_SCHEMA;
-229
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketAclInput {
     #[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(&PUTBUCKETACLINPUT_MEMBER_ACL, val.as_str())?;
-238
+        }
         if let Some(ref val) = self.access_control_policy {
             ser.write_struct(&PUTBUCKETACLINPUT_MEMBER_ACCESS_CONTROL_POLICY, val)?;
-241
+        }
         if let Some(ref val) = self.bucket {
             ser.write_string(&PUTBUCKETACLINPUT_MEMBER_BUCKET, val)?;
-244
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTBUCKETACLINPUT_MEMBER_CONTENT_MD5, val)?;
-247
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTBUCKETACLINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-250
+        }
         if let Some(ref val) = self.grant_full_control {
             ser.write_string(&PUTBUCKETACLINPUT_MEMBER_GRANT_FULL_CONTROL, val)?;
-253
+        }
         if let Some(ref val) = self.grant_read {
             ser.write_string(&PUTBUCKETACLINPUT_MEMBER_GRANT_READ, val)?;
-256
+        }
         if let Some(ref val) = self.grant_read_acp {
             ser.write_string(&PUTBUCKETACLINPUT_MEMBER_GRANT_READ_ACP, val)?;
-259
+        }
         if let Some(ref val) = self.grant_write {
             ser.write_string(&PUTBUCKETACLINPUT_MEMBER_GRANT_WRITE, val)?;
-262
+        }
         if let Some(ref val) = self.grant_write_acp {
             ser.write_string(&PUTBUCKETACLINPUT_MEMBER_GRANT_WRITE_ACP, val)?;
-265
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTBUCKETACLINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-268
+        }
         Ok(())
-270
+    }
-271
+}
 impl PutBucketAclInput {
     /// 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(&PUTBUCKETACLINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETACLINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.acl = Some(crate::types::BucketCannedAcl::from(deser.read_string(member)?.as_str()));
-290
+                }
                 Some(1) => {
                     builder.access_control_policy = Some(crate::types::AccessControlPolicy::deserialize(deser)?);
-293
+                }
                 Some(2) => {
                     builder.bucket = Some(deser.read_string(member)?);
-296
+                }
                 Some(3) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-299
+                }
                 Some(4) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-302
+                }
                 Some(5) => {
                     builder.grant_full_control = Some(deser.read_string(member)?);
-305
+                }
                 Some(6) => {
                     builder.grant_read = Some(deser.read_string(member)?);
-308
+                }
                 Some(7) => {
                     builder.grant_read_acp = Some(deser.read_string(member)?);
-311
+                }
                 Some(8) => {
                     builder.grant_write = Some(deser.read_string(member)?);
-314
+                }
                 Some(9) => {
                     builder.grant_write_acp = Some(deser.read_string(member)?);
-317
+                }
                 Some(10) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-320
+                }
                 _ => {}
-322
+            }
             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 PutBucketAclInput {
     /// 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::BucketCannedAcl::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-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() })
-376
+    }
-377
+}
 impl PutBucketAclInput {
     /// Creates a new builder-style object to manufacture [`PutBucketAclInput`](crate::operation::put_bucket_acl::PutBucketAclInput).
     pub fn builder() -> crate::operation::put_bucket_acl::builders::PutBucketAclInputBuilder {
         crate::operation::put_bucket_acl::builders::PutBucketAclInputBuilder::default()
-382
+    }

↧ Expand context

-383
+}
-384
 /// A builder for [`PutBucketAclInput`](crate::operation::put_bucket_acl::PutBucketAclInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketAclInputBuilder {
     pub(crate) acl: ::std::option::Option<crate::types::BucketCannedAcl>,
     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) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-400
+}
 impl PutBucketAclInputBuilder {
     /// <p>The canned ACL to apply to the bucket.</p>

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_acl/_put_bucket_acl_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 PutBucketAclOutput {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-8
+}
 static PUTBUCKETACLOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketAclOutput",
     "com.amazonaws.s3.synthetic",
     "PutBucketAclOutput",
 );
 static PUTBUCKETACLOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(PUTBUCKETACLOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static PUTBUCKETACLOUTPUT_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 PUTBUCKETACLOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETACLOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTBUCKETACLOUTPUT_MEMBER__REQUEST_ID],
 );
 impl PutBucketAclOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETACLOUTPUT_SCHEMA;
-29
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketAclOutput {
     #[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 PutBucketAclOutput {
     /// 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(&PUTBUCKETACLOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETACLOUTPUT_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 PutBucketAclOutput {
     /// 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 PutBucketAclOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-86
+    }
-87
+}
 impl ::aws_types::request_id::RequestId for PutBucketAclOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-91
+    }
-92
+}

↧ Expand context

 impl PutBucketAclOutput {
     /// Creates a new builder-style object to manufacture [`PutBucketAclOutput`](crate::operation::put_bucket_acl::PutBucketAclOutput).
     pub fn builder() -> crate::operation::put_bucket_acl::builders::PutBucketAclOutputBuilder {
         crate::operation::put_bucket_acl::builders::PutBucketAclOutputBuilder::default()
-97
+    }
-98
+}
-99
 /// A builder for [`PutBucketAclOutput`](crate::operation::put_bucket_acl::PutBucketAclOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketAclOutputBuilder {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-106
+}
 impl PutBucketAclOutputBuilder {
     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_bucket_analytics_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 `PutBucketAnalyticsConfiguration`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketAnalyticsConfiguration;
 impl PutBucketAnalyticsConfiguration {
     /// Creates a new `PutBucketAnalyticsConfiguration`
     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_bucket_analytics_configuration::PutBucketAnalyticsConfigurationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationInput,
     ) -> ::std::result::Result<
         crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationError,
             ::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_bucket_analytics_configuration::PutBucketAnalyticsConfigurationError>()
                     .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_bucket_analytics_configuration::PutBucketAnalyticsConfigurationOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -132,138 +194,201 @@

↥ Expand context

     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutBucketAnalyticsConfiguration")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutBucketAnalyticsConfigurationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationError,
                 >::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(),
             );
-160
         ::std::borrow::Cow::Owned(rcb)
-162
+    }
-163
+}
-164
 #[derive(Debug)]
 struct PutBucketAnalyticsConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketAnalyticsConfigurationResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-181
+        }

↧ 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_bucket_analytics_configuration::de_put_bucket_analytics_configuration_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_bucket_analytics_configuration::de_put_bucket_analytics_configuration_http_response(
                 status, headers, body,
-188
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-191
+    }
-192
+}
 #[derive(Debug)]
 struct PutBucketAnalyticsConfigurationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutBucketAnalyticsConfigurationRequestSerializer {
     #[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> {

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

@@ -15,15 +179,205 @@

↥ Expand context

 impl PutBucketAnalyticsConfigurationInput {
     /// <p>The name of the bucket to which an analytics configuration is stored.</p>
     pub fn bucket(&self) -> ::std::option::Option<&str> {
         self.bucket.as_deref()
-19
+    }
     /// <p>The ID that identifies the analytics configuration.</p>
     pub fn id(&self) -> ::std::option::Option<&str> {
         self.id.as_deref()
-23
+    }
     /// <p>The configuration and any analyses for the analytics filter.</p>
     pub fn analytics_configuration(&self) -> ::std::option::Option<&crate::types::AnalyticsConfiguration> {
         self.analytics_configuration.as_ref()
-27
+    }
     /// <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()
-31
+    }
-32
+}
 static PUTBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketAnalyticsConfigurationInput",

     "com.amazonaws.s3.synthetic",
     "PutBucketAnalyticsConfigurationInput",
 );
 static PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAnalyticsConfigurationInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutBucketAnalyticsConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-47
+)
 .with_http_label();
 static PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAnalyticsConfigurationInput$Id",
         "com.amazonaws.s3.synthetic",
         "PutBucketAnalyticsConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "id",
     "Id",
 ,
-58
+)
 .with_http_query("id");
 static PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_ANALYTICS_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAnalyticsConfigurationInput$AnalyticsConfiguration",
         "com.amazonaws.s3.synthetic",
         "PutBucketAnalyticsConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "analytics_configuration",
     "AnalyticsConfiguration",
 ,
-69
+)
 .with_xml_name("AnalyticsConfiguration")
 .with_http_payload();
 static PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketAnalyticsConfigurationInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutBucketAnalyticsConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-81
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_BUCKET,
         &PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_ID,
         &PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_ANALYTICS_CONFIGURATION,
         &PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?analytics", None));
 impl PutBucketAnalyticsConfigurationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA;
-97
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketAnalyticsConfigurationInput {
     #[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(&PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_BUCKET, val)?;
-106
+        }
         if let Some(ref val) = self.id {
             ser.write_string(&PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_ID, val)?;
-109
+        }
         if let Some(ref val) = self.analytics_configuration {
             ser.write_struct(&PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_ANALYTICS_CONFIGURATION, val)?;
-112
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-115
+        }
         Ok(())
-117
+    }
-118
+}
 impl PutBucketAnalyticsConfigurationInput {
     /// 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(&PUTBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-137
+                }
                 Some(1) => {
                     builder.id = Some(deser.read_string(member)?);
-140
+                }
                 Some(2) => {
                     builder.analytics_configuration = Some(crate::types::AnalyticsConfiguration::deserialize(deser)?);
-143
+                }
                 Some(3) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-146
+                }
                 _ => {}
-148
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder.id = builder.id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutBucketAnalyticsConfigurationInput {
     /// 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-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         if !body.is_empty() {
             builder.analytics_configuration = Some(crate::types::AnalyticsConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-179
+    }
-180
+}
 impl PutBucketAnalyticsConfigurationInput {
     /// Creates a new builder-style object to manufacture [`PutBucketAnalyticsConfigurationInput`](crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationInput).
     pub fn builder() -> crate::operation::put_bucket_analytics_configuration::builders::PutBucketAnalyticsConfigurationInputBuilder {
         crate::operation::put_bucket_analytics_configuration::builders::PutBucketAnalyticsConfigurationInputBuilder::default()
-185
+    }

↧ Expand context

-186
+}
-187
 /// A builder for [`PutBucketAnalyticsConfigurationInput`](crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketAnalyticsConfigurationInputBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) id: ::std::option::Option<::std::string::String>,
     pub(crate) analytics_configuration: ::std::option::Option<crate::types::AnalyticsConfiguration>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-196
+}
 impl PutBucketAnalyticsConfigurationInputBuilder {
     /// <p>The name of the bucket to which an analytics configuration is stored.</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
-203
+    }
     /// <p>The name of the bucket to which an analytics configuration is stored.</p>
     pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

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

@@ -1,1 +84,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 PutBucketAnalyticsConfigurationOutput {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-8
+}
 static PUTBUCKETANALYTICSCONFIGURATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketAnalyticsConfigurationOutput",
     "com.amazonaws.s3.synthetic",
     "PutBucketAnalyticsConfigurationOutput",
 );
 static PUTBUCKETANALYTICSCONFIGURATIONOUTPUT_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 PUTBUCKETANALYTICSCONFIGURATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETANALYTICSCONFIGURATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
     &[&PUTBUCKETANALYTICSCONFIGURATIONOUTPUT_MEMBER__REQUEST_ID],
 );
 impl PutBucketAnalyticsConfigurationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETANALYTICSCONFIGURATIONOUTPUT_SCHEMA;
-29
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketAnalyticsConfigurationOutput {
     #[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 PutBucketAnalyticsConfigurationOutput {
     /// 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(&PUTBUCKETANALYTICSCONFIGURATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETANALYTICSCONFIGURATIONOUTPUT_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 PutBucketAnalyticsConfigurationOutput {
     /// 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 PutBucketAnalyticsConfigurationOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-86
+    }
-87
+}
 impl ::aws_types::request_id::RequestId for PutBucketAnalyticsConfigurationOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-91
+    }
-92
+}

↧ Expand context

 impl PutBucketAnalyticsConfigurationOutput {
     /// Creates a new builder-style object to manufacture [`PutBucketAnalyticsConfigurationOutput`](crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationOutput).
     pub fn builder() -> crate::operation::put_bucket_analytics_configuration::builders::PutBucketAnalyticsConfigurationOutputBuilder {
         crate::operation::put_bucket_analytics_configuration::builders::PutBucketAnalyticsConfigurationOutputBuilder::default()
-97
+    }
-98
+}
-99
 /// A builder for [`PutBucketAnalyticsConfigurationOutput`](crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketAnalyticsConfigurationOutputBuilder {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-106
+}
 impl PutBucketAnalyticsConfigurationOutputBuilder {
     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_bucket_cors.rs

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

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

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

↥ Expand context

-184
+                    }
-185
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_cors::PutBucketCorsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_cors::PutBucketCorsError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_cors::PutBucketCorsError>::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 PutBucketCorsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketCorsResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-227
+        }

↧ Expand context

         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_put_bucket_cors::de_put_bucket_cors_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_bucket_cors::de_put_bucket_cors_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-235
+    }
-236
+}
 #[derive(Debug)]
 struct PutBucketCorsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutBucketCorsRequestSerializer {
     #[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_bucket_cors::PutBucketCorsInput>()

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

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

↥ Expand context

     pub fn cors_configuration(&self) -> ::std::option::Option<&crate::types::CorsConfiguration> {
         self.cors_configuration.as_ref()
-27
+    }
     /// <p>The Base64 encoded 128-bit <code>MD5</code> digest of the data. This header must be used as a message integrity check to verify that the request body was not corrupted in transit. For more information, go to <a href="http://www.ietf.org/rfc/rfc1864.txt">RFC 1864.</a></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()
-32
+    }
     /// <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()
-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 PUTBUCKETCORSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketCorsInput",

     "com.amazonaws.s3.synthetic",
     "PutBucketCorsInput",
 );
 static PUTBUCKETCORSINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketCorsInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutBucketCorsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-57
+)
 .with_http_label();
 static PUTBUCKETCORSINPUT_MEMBER_CORS_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketCorsInput$CORSConfiguration",
         "com.amazonaws.s3.synthetic",
         "PutBucketCorsInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "cors_configuration",
     "CORSConfiguration",
 ,
-68
+)
 .with_xml_name("CORSConfiguration")
 .with_http_payload();
 static PUTBUCKETCORSINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketCorsInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutBucketCorsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-80
+)
 .with_http_header("Content-MD5");
 static PUTBUCKETCORSINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketCorsInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutBucketCorsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-91
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTBUCKETCORSINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketCorsInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutBucketCorsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-102
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTBUCKETCORSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETCORSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTBUCKETCORSINPUT_MEMBER_BUCKET,
         &PUTBUCKETCORSINPUT_MEMBER_CORS_CONFIGURATION,
         &PUTBUCKETCORSINPUT_MEMBER_CONTENT_MD5,
         &PUTBUCKETCORSINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTBUCKETCORSINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?cors", None));
 impl PutBucketCorsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETCORSINPUT_SCHEMA;
-119
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketCorsInput {
     #[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(&PUTBUCKETCORSINPUT_MEMBER_BUCKET, val)?;
-128
+        }
         if let Some(ref val) = self.cors_configuration {
             ser.write_struct(&PUTBUCKETCORSINPUT_MEMBER_CORS_CONFIGURATION, val)?;
-131
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTBUCKETCORSINPUT_MEMBER_CONTENT_MD5, val)?;
-134
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTBUCKETCORSINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-137
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTBUCKETCORSINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-140
+        }
         Ok(())
-142
+    }
-143
+}
 impl PutBucketCorsInput {
     /// 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(&PUTBUCKETCORSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETCORSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-162
+                }
                 Some(1) => {
                     builder.cors_configuration = Some(crate::types::CorsConfiguration::deserialize(deser)?);
-165
+                }
                 Some(2) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-168
+                }
                 Some(3) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-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 PutBucketCorsInput {
     /// 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.cors_configuration = Some(crate::types::CorsConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-212
+    }
-213
+}
 impl PutBucketCorsInput {
     /// Creates a new builder-style object to manufacture [`PutBucketCorsInput`](crate::operation::put_bucket_cors::PutBucketCorsInput).
     pub fn builder() -> crate::operation::put_bucket_cors::builders::PutBucketCorsInputBuilder {
         crate::operation::put_bucket_cors::builders::PutBucketCorsInputBuilder::default()
-218
+    }

↧ Expand context

-219
+}
-220
 /// A builder for [`PutBucketCorsInput`](crate::operation::put_bucket_cors::PutBucketCorsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketCorsInputBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) cors_configuration: ::std::option::Option<crate::types::CorsConfiguration>,
     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>,
-230
+}
 impl PutBucketCorsInputBuilder {
     /// <p>Specifies the bucket impacted by the <code>cors</code>configuration.</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>Specifies the bucket impacted by the <code>cors</code>configuration.</p>

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_cors/_put_bucket_cors_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 PutBucketCorsOutput {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-8
+}
 static PUTBUCKETCORSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketCorsOutput",
     "com.amazonaws.s3.synthetic",
     "PutBucketCorsOutput",
 );
 static PUTBUCKETCORSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(PUTBUCKETCORSOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static PUTBUCKETCORSOUTPUT_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 PUTBUCKETCORSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETCORSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTBUCKETCORSOUTPUT_MEMBER__REQUEST_ID],
 );
 impl PutBucketCorsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETCORSOUTPUT_SCHEMA;
-29
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketCorsOutput {
     #[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 PutBucketCorsOutput {
     /// 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(&PUTBUCKETCORSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETCORSOUTPUT_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 PutBucketCorsOutput {
     /// 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 PutBucketCorsOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-86
+    }
-87
+}
 impl ::aws_types::request_id::RequestId for PutBucketCorsOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-91
+    }
-92
+}

↧ Expand context

 impl PutBucketCorsOutput {
     /// Creates a new builder-style object to manufacture [`PutBucketCorsOutput`](crate::operation::put_bucket_cors::PutBucketCorsOutput).
     pub fn builder() -> crate::operation::put_bucket_cors::builders::PutBucketCorsOutputBuilder {
         crate::operation::put_bucket_cors::builders::PutBucketCorsOutputBuilder::default()
-97
+    }
-98
+}
-99
 /// A builder for [`PutBucketCorsOutput`](crate::operation::put_bucket_cors::PutBucketCorsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketCorsOutputBuilder {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-106
+}
 impl PutBucketCorsOutputBuilder {
     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_bucket_encryption.rs

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

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

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

↥ Expand context

                                         is_presigned_req,
                                     ) {
                                         (_, _, _, _, true) => {}
                                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)
                                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-186
+                                        }
                                         _ => {},
-188
+                                    }
-189
                                     // We return a bool indicating if the user did set the checksum value, if they did
                                     // we can short circuit and exit the interceptor early.
                                     Ok(user_set_checksum_value)
-193
+                                }
                                 ))
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_bucket_encryption::PutBucketEncryptionError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_bucket_encryption::PutBucketEncryptionError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_encryption::PutBucketEncryptionError>::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 PutBucketEncryptionResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketEncryptionResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-223
+        }

↧ Expand context

         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_put_bucket_encryption::de_put_bucket_encryption_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_bucket_encryption::de_put_bucket_encryption_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-231
+    }
-232
+}
 #[derive(Debug)]
 struct PutBucketEncryptionRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutBucketEncryptionRequestSerializer {
     #[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_bucket_encryption::PutBucketEncryptionInput>()

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

@@ -39,39 +221,252 @@

↥ Expand context

     /// <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><note>
     /// <p>For directory buckets, when you use Amazon Web Services SDKs, <code>CRC32</code> is the default checksum algorithm that's used for performance.</p>
     /// </note>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-45
+    }
     /// <p>Specifies the default server-side-encryption configuration.</p>
     pub fn server_side_encryption_configuration(&self) -> ::std::option::Option<&crate::types::ServerSideEncryptionConfiguration> {
         self.server_side_encryption_configuration.as_ref()
-49
+    }
     /// <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><note>
     /// <p>For directory buckets, this header is not supported in this API operation. If you specify this header, the request fails with the HTTP status code <code>501 Not Implemented</code>.</p>
     /// </note>
     pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
         self.expected_bucket_owner.as_deref()
-55
+    }
-56
+}
 static PUTBUCKETENCRYPTIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketEncryptionInput",

     "com.amazonaws.s3.synthetic",
     "PutBucketEncryptionInput",
 );
 static PUTBUCKETENCRYPTIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketEncryptionInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutBucketEncryptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-71
+)
 .with_http_label();
 static PUTBUCKETENCRYPTIONINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketEncryptionInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "PutBucketEncryptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-82
+)
 .with_http_header("Content-MD5");
 static PUTBUCKETENCRYPTIONINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketEncryptionInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "PutBucketEncryptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-93
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static PUTBUCKETENCRYPTIONINPUT_MEMBER_SERVER_SIDE_ENCRYPTION_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketEncryptionInput$ServerSideEncryptionConfiguration",
         "com.amazonaws.s3.synthetic",
         "PutBucketEncryptionInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "server_side_encryption_configuration",
     "ServerSideEncryptionConfiguration",
 ,
-104
+)
 .with_xml_name("ServerSideEncryptionConfiguration")
 .with_http_payload();
 static PUTBUCKETENCRYPTIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketEncryptionInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutBucketEncryptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-116
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTBUCKETENCRYPTIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETENCRYPTIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTBUCKETENCRYPTIONINPUT_MEMBER_BUCKET,
         &PUTBUCKETENCRYPTIONINPUT_MEMBER_CONTENT_MD5,
         &PUTBUCKETENCRYPTIONINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &PUTBUCKETENCRYPTIONINPUT_MEMBER_SERVER_SIDE_ENCRYPTION_CONFIGURATION,
         &PUTBUCKETENCRYPTIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?encryption", None));
 impl PutBucketEncryptionInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETENCRYPTIONINPUT_SCHEMA;
-133
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketEncryptionInput {
     #[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(&PUTBUCKETENCRYPTIONINPUT_MEMBER_BUCKET, val)?;
-142
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&PUTBUCKETENCRYPTIONINPUT_MEMBER_CONTENT_MD5, val)?;
-145
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTBUCKETENCRYPTIONINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-148
+        }
         if let Some(ref val) = self.server_side_encryption_configuration {
             ser.write_struct(&PUTBUCKETENCRYPTIONINPUT_MEMBER_SERVER_SIDE_ENCRYPTION_CONFIGURATION, val)?;
-151
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTBUCKETENCRYPTIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-154
+        }
         Ok(())
-156
+    }
-157
+}
 impl PutBucketEncryptionInput {
     /// 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(&PUTBUCKETENCRYPTIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETENCRYPTIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-176
+                }
                 Some(1) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-179
+                }
                 Some(2) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-182
+                }
                 Some(3) => {
                     builder.server_side_encryption_configuration = Some(crate::types::ServerSideEncryptionConfiguration::deserialize(deser)?);
-185
+                }
                 Some(4) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-188
+                }
                 _ => {}
-190
+            }
             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 PutBucketEncryptionInput {
     /// 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.server_side_encryption_configuration = Some(crate::types::ServerSideEncryptionConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-226
+    }
-227
+}
 impl PutBucketEncryptionInput {
     /// Creates a new builder-style object to manufacture [`PutBucketEncryptionInput`](crate::operation::put_bucket_encryption::PutBucketEncryptionInput).
     pub fn builder() -> crate::operation::put_bucket_encryption::builders::PutBucketEncryptionInputBuilder {
         crate::operation::put_bucket_encryption::builders::PutBucketEncryptionInputBuilder::default()
-232
+    }

↧ Expand context

-233
+}
-234
 /// A builder for [`PutBucketEncryptionInput`](crate::operation::put_bucket_encryption::PutBucketEncryptionInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketEncryptionInputBuilder {
     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) server_side_encryption_configuration: ::std::option::Option<crate::types::ServerSideEncryptionConfiguration>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-244
+}
 impl PutBucketEncryptionInputBuilder {
     /// <p>Specifies default encryption for a bucket using server-side encryption with different key options.</p>
     /// <p><b>Directory buckets </b> - When you use this operation with a directory bucket, you must use path-style requests in the format <code>https://s3express-control.<i>region-code</i>.amazonaws.com/<i>bucket-name</i> </code>. Virtual-hosted-style requests aren't supported. Directory bucket names must be unique in the chosen Zone (Availability Zone or Local Zone). Bucket names must also follow the format <code> <i>bucket-base-name</i>--<i>zone-id</i>--x-s3</code> (for example, <code> <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</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 {
         self.bucket = ::std::option::Option::Some(input.into());
         self
-252
+    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_encryption/_put_bucket_encryption_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 PutBucketEncryptionOutput {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-8
+}
 static PUTBUCKETENCRYPTIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketEncryptionOutput",
     "com.amazonaws.s3.synthetic",
     "PutBucketEncryptionOutput",
 );
 static PUTBUCKETENCRYPTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(PUTBUCKETENCRYPTIONOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static PUTBUCKETENCRYPTIONOUTPUT_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 PUTBUCKETENCRYPTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETENCRYPTIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTBUCKETENCRYPTIONOUTPUT_MEMBER__REQUEST_ID],
 );
 impl PutBucketEncryptionOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETENCRYPTIONOUTPUT_SCHEMA;
-29
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketEncryptionOutput {
     #[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 PutBucketEncryptionOutput {
     /// 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(&PUTBUCKETENCRYPTIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETENCRYPTIONOUTPUT_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 PutBucketEncryptionOutput {
     /// 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 PutBucketEncryptionOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-86
+    }
-87
+}
 impl ::aws_types::request_id::RequestId for PutBucketEncryptionOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-91
+    }
-92
+}

↧ Expand context

 impl PutBucketEncryptionOutput {
     /// Creates a new builder-style object to manufacture [`PutBucketEncryptionOutput`](crate::operation::put_bucket_encryption::PutBucketEncryptionOutput).
     pub fn builder() -> crate::operation::put_bucket_encryption::builders::PutBucketEncryptionOutputBuilder {
         crate::operation::put_bucket_encryption::builders::PutBucketEncryptionOutputBuilder::default()
-97
+    }
-98
+}
-99
 /// A builder for [`PutBucketEncryptionOutput`](crate::operation::put_bucket_encryption::PutBucketEncryptionOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketEncryptionOutputBuilder {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-106
+}
 impl PutBucketEncryptionOutputBuilder {
     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_bucket_intelligent_tiering_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 `PutBucketIntelligentTieringConfiguration`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketIntelligentTieringConfiguration;
 impl PutBucketIntelligentTieringConfiguration {
     /// Creates a new `PutBucketIntelligentTieringConfiguration`
     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_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput,
     ) -> ::std::result::Result<
         crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationError,
             ::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_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationError>()
                     .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_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -132,138 +194,201 @@

↥ Expand context

     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutBucketIntelligentTieringConfiguration")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutBucketIntelligentTieringConfigurationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationError,
                 >::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(),
             );
-160
         ::std::borrow::Cow::Owned(rcb)
-162
+    }
-163
+}
-164
 #[derive(Debug)]
 struct PutBucketIntelligentTieringConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketIntelligentTieringConfigurationResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-181
+        }

↧ 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_bucket_intelligent_tiering_configuration::de_put_bucket_intelligent_tiering_configuration_http_error(
                 status, headers, body,
-186
+            )
         } else {
             crate::protocol_serde::shape_put_bucket_intelligent_tiering_configuration::de_put_bucket_intelligent_tiering_configuration_http_response(
                 status, headers, body,
-190
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-193
+    }
-194
+}
 #[derive(Debug)]
 struct PutBucketIntelligentTieringConfigurationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutBucketIntelligentTieringConfigurationRequestSerializer {
     #[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,

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

@@ -15,15 +184,210 @@

↥ Expand context

 impl PutBucketIntelligentTieringConfigurationInput {
     /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>
     pub fn bucket(&self) -> ::std::option::Option<&str> {
         self.bucket.as_deref()
-19
+    }
     /// <p>The ID used to identify the S3 Intelligent-Tiering configuration.</p>
     pub fn id(&self) -> ::std::option::Option<&str> {
         self.id.as_deref()
-23
+    }
     /// <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()
-27
+    }
     /// <p>Container for S3 Intelligent-Tiering configuration.</p>
     pub fn intelligent_tiering_configuration(&self) -> ::std::option::Option<&crate::types::IntelligentTieringConfiguration> {
         self.intelligent_tiering_configuration.as_ref()
-31
+    }
-32
+}
 static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketIntelligentTieringConfigurationInput",

     "com.amazonaws.s3.synthetic",
     "PutBucketIntelligentTieringConfigurationInput",
 );
 static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketIntelligentTieringConfigurationInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutBucketIntelligentTieringConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-47
+)
 .with_http_label();
 static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketIntelligentTieringConfigurationInput$Id",
         "com.amazonaws.s3.synthetic",
         "PutBucketIntelligentTieringConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "id",
     "Id",
 ,
-58
+)
 .with_http_query("id");
 static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.s3.synthetic#PutBucketIntelligentTieringConfigurationInput$ExpectedBucketOwner",
             "com.amazonaws.s3.synthetic",
             "PutBucketIntelligentTieringConfigurationInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "expected_bucket_owner",
         "ExpectedBucketOwner",
 ,
-70
+    )
     .with_http_header("x-amz-expected-bucket-owner");
 static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_INTELLIGENT_TIERING_CONFIGURATION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.s3.synthetic#PutBucketIntelligentTieringConfigurationInput$IntelligentTieringConfiguration",
             "com.amazonaws.s3.synthetic",
             "PutBucketIntelligentTieringConfigurationInput",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "intelligent_tiering_configuration",
         "IntelligentTieringConfiguration",
 ,
-82
+    )
     .with_xml_name("IntelligentTieringConfiguration")
     .with_http_payload();
 static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_BUCKET,
         &PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_ID,
         &PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
         &PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_INTELLIGENT_TIERING_CONFIGURATION,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?intelligent-tiering", None));
 impl PutBucketIntelligentTieringConfigurationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_SCHEMA;
-99
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketIntelligentTieringConfigurationInput {
     #[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(&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_BUCKET, val)?;
-108
+        }
         if let Some(ref val) = self.id {
             ser.write_string(&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_ID, val)?;
-111
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-114
+        }
         if let Some(ref val) = self.intelligent_tiering_configuration {
             ser.write_struct(
                 &PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_MEMBER_INTELLIGENT_TIERING_CONFIGURATION,
                 val,
             )?;
-120
+        }
         Ok(())
-122
+    }
-123
+}
 impl PutBucketIntelligentTieringConfigurationInput {
     /// 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(&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-142
+                }
                 Some(1) => {
                     builder.id = Some(deser.read_string(member)?);
-145
+                }
                 Some(2) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-148
+                }
                 Some(3) => {
                     builder.intelligent_tiering_configuration = Some(crate::types::IntelligentTieringConfiguration::deserialize(deser)?);
-151
+                }
                 _ => {}
-153
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder.id = builder.id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutBucketIntelligentTieringConfigurationInput {
     /// 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-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         if !body.is_empty() {
             builder.intelligent_tiering_configuration = Some(crate::types::IntelligentTieringConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-184
+    }
-185
+}
 impl PutBucketIntelligentTieringConfigurationInput {
     /// Creates a new builder-style object to manufacture [`PutBucketIntelligentTieringConfigurationInput`](crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput).
     pub fn builder() -> crate::operation::put_bucket_intelligent_tiering_configuration::builders::PutBucketIntelligentTieringConfigurationInputBuilder
-189
+    {
         crate::operation::put_bucket_intelligent_tiering_configuration::builders::PutBucketIntelligentTieringConfigurationInputBuilder::default()

↧ Expand context

-191
+    }
-192
+}
-193
 /// A builder for [`PutBucketIntelligentTieringConfigurationInput`](crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketIntelligentTieringConfigurationInputBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) id: ::std::option::Option<::std::string::String>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
     pub(crate) intelligent_tiering_configuration: ::std::option::Option<crate::types::IntelligentTieringConfiguration>,
-202
+}
 impl PutBucketIntelligentTieringConfigurationInputBuilder {
     /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</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
-209
+    }
     /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>

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

@@ -1,1 +84,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 PutBucketIntelligentTieringConfigurationOutput {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-8
+}
 static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketIntelligentTieringConfigurationOutput",
     "com.amazonaws.s3.synthetic",
     "PutBucketIntelligentTieringConfigurationOutput",
 );
 static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_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 PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
     &[&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_MEMBER__REQUEST_ID],
 );
 impl PutBucketIntelligentTieringConfigurationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA;
-29
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketIntelligentTieringConfigurationOutput {
     #[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 PutBucketIntelligentTieringConfigurationOutput {
     /// 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(&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_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 PutBucketIntelligentTieringConfigurationOutput {
     /// 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 PutBucketIntelligentTieringConfigurationOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-86
+    }
-87
+}
 impl ::aws_types::request_id::RequestId for PutBucketIntelligentTieringConfigurationOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-91
+    }
-92
+}

↧ Expand context

 impl PutBucketIntelligentTieringConfigurationOutput {
     /// Creates a new builder-style object to manufacture [`PutBucketIntelligentTieringConfigurationOutput`](crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationOutput).
     pub fn builder() -> crate::operation::put_bucket_intelligent_tiering_configuration::builders::PutBucketIntelligentTieringConfigurationOutputBuilder
-96
+    {
         crate::operation::put_bucket_intelligent_tiering_configuration::builders::PutBucketIntelligentTieringConfigurationOutputBuilder::default()
-98
+    }
-99
+}
-100
 /// A builder for [`PutBucketIntelligentTieringConfigurationOutput`](crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketIntelligentTieringConfigurationOutputBuilder {
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-107
+}
 impl PutBucketIntelligentTieringConfigurationOutputBuilder {
     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
-112
+    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_inventory_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 `PutBucketInventoryConfiguration`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketInventoryConfiguration;
 impl PutBucketInventoryConfiguration {
     /// Creates a new `PutBucketInventoryConfiguration`
     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_bucket_inventory_configuration::PutBucketInventoryConfigurationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationInput,
     ) -> ::std::result::Result<
         crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationError,
             ::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_bucket_inventory_configuration::PutBucketInventoryConfigurationError>()
                     .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_bucket_inventory_configuration::PutBucketInventoryConfigurationOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -132,138 +194,201 @@

↥ Expand context

     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutBucketInventoryConfiguration")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutBucketInventoryConfigurationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationError,
                 >::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(),
             );
-160
         ::std::borrow::Cow::Owned(rcb)
-162
+    }
-163
+}
-164
 #[derive(Debug)]
 struct PutBucketInventoryConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketInventoryConfigurationResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-181
+        }

↧ 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_bucket_inventory_configuration::de_put_bucket_inventory_configuration_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_bucket_inventory_configuration::de_put_bucket_inventory_configuration_http_response(
                 status, headers, body,
-188
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-191
+    }
-192
+}
 #[derive(Debug)]
 struct PutBucketInventoryConfigurationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutBucketInventoryConfigurationRequestSerializer {
     #[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> {

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

@@ -15,15 +179,205 @@

↥ Expand context

 impl PutBucketInventoryConfigurationInput {
     /// <p>The name of the bucket where the inventory configuration will be stored.</p>
     pub fn bucket(&self) -> ::std::option::Option<&str> {
         self.bucket.as_deref()
-19
+    }
     /// <p>The ID used to identify the inventory configuration.</p>
     pub fn id(&self) -> ::std::option::Option<&str> {
         self.id.as_deref()
-23
+    }
     /// <p>Specifies the inventory configuration.</p>
     pub fn inventory_configuration(&self) -> ::std::option::Option<&crate::types::InventoryConfiguration> {
         self.inventory_configuration.as_ref()
-27
+    }
     /// <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()
-31
+    }
-32
+}
 static PUTBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#PutBucketInventoryConfigurationInput",

     "com.amazonaws.s3.synthetic",
     "PutBucketInventoryConfigurationInput",
 );
 static PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketInventoryConfigurationInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "PutBucketInventoryConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-47
+)
 .with_http_label();
 static PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketInventoryConfigurationInput$Id",
         "com.amazonaws.s3.synthetic",
         "PutBucketInventoryConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "id",
     "Id",
 ,
-58
+)
 .with_http_query("id");
 static PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_INVENTORY_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketInventoryConfigurationInput$InventoryConfiguration",
         "com.amazonaws.s3.synthetic",
         "PutBucketInventoryConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "inventory_configuration",
     "InventoryConfiguration",
 ,
-69
+)
 .with_xml_name("InventoryConfiguration")
 .with_http_payload();
 static PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#PutBucketInventoryConfigurationInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "PutBucketInventoryConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-81
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static PUTBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_BUCKET,
         &PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_ID,
         &PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_INVENTORY_CONFIGURATION,
         &PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?inventory", None));
 impl PutBucketInventoryConfigurationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA;
-97
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketInventoryConfigurationInput {
     #[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(&PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_BUCKET, val)?;
-106
+        }
         if let Some(ref val) = self.id {
             ser.write_string(&PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_ID, val)?;
-109
+        }
         if let Some(ref val) = self.inventory_configuration {
             ser.write_struct(&PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_INVENTORY_CONFIGURATION, val)?;
-112
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&PUTBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-115
+        }
         Ok(())
-117
+    }
-118
+}
 impl PutBucketInventoryConfigurationInput {
     /// 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(&PUTBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-137
+                }
                 Some(1) => {
                     builder.id = Some(deser.read_string(member)?);
-140
+                }
                 Some(2) => {
                     builder.inventory_configuration = Some(crate::types::InventoryConfiguration::deserialize(deser)?);
-143
+                }
                 Some(3) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-146
+                }
                 _ => {}
-148
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder.id = builder.id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutBucketInventoryConfigurationInput {
     /// 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-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         if !body.is_empty() {
             builder.inventory_configuration = Some(crate::types::InventoryConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-179
+    }
-180
+}
 impl PutBucketInventoryConfigurationInput {
     /// Creates a new builder-style object to manufacture [`PutBucketInventoryConfigurationInput`](crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationInput).
     pub fn builder() -> crate::operation::put_bucket_inventory_configuration::builders::PutBucketInventoryConfigurationInputBuilder {
         crate::operation::put_bucket_inventory_configuration::builders::PutBucketInventoryConfigurationInputBuilder::default()
-185
+    }

↧ Expand context

-186
+}
-187
 /// A builder for [`PutBucketInventoryConfigurationInput`](crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutBucketInventoryConfigurationInputBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) id: ::std::option::Option<::std::string::String>,
     pub(crate) inventory_configuration: ::std::option::Option<crate::types::InventoryConfiguration>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-196
+}
 impl PutBucketInventoryConfigurationInputBuilder {
     /// <p>The name of the bucket where the inventory configuration will be stored.</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
-203
+    }
     /// <p>The name of the bucket where the inventory configuration will be stored.</p>
     pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

AWS SDK

Files changed: