AWS SDK

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

@@ -97,97 +369,415 @@

-97
+    }
     /// <p>Specifies whether you want S3 Object Lock to be enabled for the new bucket.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn object_lock_enabled_for_bucket(&self) -> ::std::option::Option<bool> {
         self.object_lock_enabled_for_bucket
-103
+    }
     /// <p>The container element for object ownership for a bucket's ownership controls.</p>
     /// <p><code>BucketOwnerPreferred</code> - Objects uploaded to the bucket change ownership to the bucket owner if the objects are uploaded with the <code>bucket-owner-full-control</code> canned ACL.</p>
     /// <p><code>ObjectWriter</code> - The uploading account will own the object if the object is uploaded with the <code>bucket-owner-full-control</code> canned ACL.</p>
     /// <p><code>BucketOwnerEnforced</code> - Access control lists (ACLs) are disabled and no longer affect permissions. The bucket owner automatically owns and has full control over every object in the bucket. The bucket only accepts PUT requests that don't specify an ACL or specify bucket owner full control ACLs (such as the predefined <code>bucket-owner-full-control</code> canned ACL or a custom ACL in XML format that grants the same permissions).</p>
     /// <p>By default, <code>ObjectOwnership</code> is set to <code>BucketOwnerEnforced</code> and ACLs are disabled. We recommend keeping ACLs disabled, except in uncommon use cases where you must control access for each object individually. For more information about S3 Object Ownership, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html">Controlling ownership of objects and disabling ACLs for your bucket</a> in the <i>Amazon S3 User Guide</i>.</p><note>
     /// <p>This functionality is not supported for directory buckets. Directory buckets use the bucket owner enforced setting for S3 Object Ownership.</p>
     /// </note>
     pub fn object_ownership(&self) -> ::std::option::Option<&crate::types::ObjectOwnership> {
         self.object_ownership.as_ref()
-113
+    }
-114
+}
 static CREATEBUCKETINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#CreateBucketInput",

     "com.amazonaws.s3.synthetic",
     "CreateBucketInput",
 );
 static CREATEBUCKETINPUT_MEMBER_ACL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketInput$ACL",
         "com.amazonaws.s3.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "acl",
     "ACL",
 ,
-129
+)
 .with_http_header("x-amz-acl");
 static CREATEBUCKETINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-140
+)
 .with_http_label();
 static CREATEBUCKETINPUT_MEMBER_CREATE_BUCKET_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketInput$CreateBucketConfiguration",
         "com.amazonaws.s3.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "create_bucket_configuration",
     "CreateBucketConfiguration",
 ,
-151
+)
 .with_xml_name("CreateBucketConfiguration")
 .with_http_payload();
 static CREATEBUCKETINPUT_MEMBER_GRANT_FULL_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketInput$GrantFullControl",
         "com.amazonaws.s3.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_full_control",
     "GrantFullControl",
 ,
-163
+)
 .with_http_header("x-amz-grant-full-control");
 static CREATEBUCKETINPUT_MEMBER_GRANT_READ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketInput$GrantRead",
         "com.amazonaws.s3.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read",
     "GrantRead",
 ,
-174
+)
 .with_http_header("x-amz-grant-read");
 static CREATEBUCKETINPUT_MEMBER_GRANT_READ_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketInput$GrantReadACP",
         "com.amazonaws.s3.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read_acp",
     "GrantReadACP",
 ,
-185
+)
 .with_http_header("x-amz-grant-read-acp");
 static CREATEBUCKETINPUT_MEMBER_GRANT_WRITE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketInput$GrantWrite",
         "com.amazonaws.s3.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_write",
     "GrantWrite",
 ,
-196
+)
 .with_http_header("x-amz-grant-write");
 static CREATEBUCKETINPUT_MEMBER_GRANT_WRITE_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketInput$GrantWriteACP",
         "com.amazonaws.s3.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_write_acp",
     "GrantWriteACP",
 ,
-207
+)
 .with_http_header("x-amz-grant-write-acp");
 static CREATEBUCKETINPUT_MEMBER_OBJECT_LOCK_ENABLED_FOR_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketInput$ObjectLockEnabledForBucket",
         "com.amazonaws.s3.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "object_lock_enabled_for_bucket",
     "ObjectLockEnabledForBucket",
 ,
-218
+)
 .with_http_header("x-amz-bucket-object-lock-enabled");
 static CREATEBUCKETINPUT_MEMBER_OBJECT_OWNERSHIP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketInput$ObjectOwnership",
         "com.amazonaws.s3.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "object_ownership",
     "ObjectOwnership",
 ,
-229
+)
 .with_http_header("x-amz-object-ownership");
 static CREATEBUCKETINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEBUCKETINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEBUCKETINPUT_MEMBER_ACL,
         &CREATEBUCKETINPUT_MEMBER_BUCKET,
         &CREATEBUCKETINPUT_MEMBER_CREATE_BUCKET_CONFIGURATION,
         &CREATEBUCKETINPUT_MEMBER_GRANT_FULL_CONTROL,
         &CREATEBUCKETINPUT_MEMBER_GRANT_READ,
         &CREATEBUCKETINPUT_MEMBER_GRANT_READ_ACP,
         &CREATEBUCKETINPUT_MEMBER_GRANT_WRITE,
         &CREATEBUCKETINPUT_MEMBER_GRANT_WRITE_ACP,
         &CREATEBUCKETINPUT_MEMBER_OBJECT_LOCK_ENABLED_FOR_BUCKET,
         &CREATEBUCKETINPUT_MEMBER_OBJECT_OWNERSHIP,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/", None));
 impl CreateBucketInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEBUCKETINPUT_SCHEMA;
-251
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateBucketInput {
     #[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(&CREATEBUCKETINPUT_MEMBER_ACL, val.as_str())?;
-260
+        }
         if let Some(ref val) = self.bucket {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_BUCKET, val)?;
-263
+        }
         if let Some(ref val) = self.create_bucket_configuration {
             ser.write_struct(&CREATEBUCKETINPUT_MEMBER_CREATE_BUCKET_CONFIGURATION, val)?;
-266
+        }
         if let Some(ref val) = self.grant_full_control {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_GRANT_FULL_CONTROL, val)?;
-269
+        }
         if let Some(ref val) = self.grant_read {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_GRANT_READ, val)?;
-272
+        }
         if let Some(ref val) = self.grant_read_acp {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_GRANT_READ_ACP, val)?;
-275
+        }
         if let Some(ref val) = self.grant_write {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_GRANT_WRITE, val)?;
-278
+        }
         if let Some(ref val) = self.grant_write_acp {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_GRANT_WRITE_ACP, val)?;
-281
+        }
         if let Some(ref val) = self.object_lock_enabled_for_bucket {
             ser.write_boolean(&CREATEBUCKETINPUT_MEMBER_OBJECT_LOCK_ENABLED_FOR_BUCKET, *val)?;
-284
+        }
         if let Some(ref val) = self.object_ownership {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_OBJECT_OWNERSHIP, val.as_str())?;
-287
+        }
         Ok(())
-289
+    }
-290
+}
 impl CreateBucketInput {
     /// 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(&CREATEBUCKETINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEBUCKETINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.acl = Some(crate::types::BucketCannedAcl::from(deser.read_string(member)?.as_str()));
-309
+                }
                 Some(1) => {
                     builder.bucket = Some(deser.read_string(member)?);
-312
+                }
                 Some(2) => {
                     builder.create_bucket_configuration = Some(crate::types::CreateBucketConfiguration::deserialize(deser)?);
-315
+                }
                 Some(3) => {
                     builder.grant_full_control = Some(deser.read_string(member)?);
-318
+                }
                 Some(4) => {
                     builder.grant_read = Some(deser.read_string(member)?);
-321
+                }
                 Some(5) => {
                     builder.grant_read_acp = Some(deser.read_string(member)?);
-324
+                }
                 Some(6) => {
                     builder.grant_write = Some(deser.read_string(member)?);
-327
+                }
                 Some(7) => {
                     builder.grant_write_acp = Some(deser.read_string(member)?);
-330
+                }
                 Some(8) => {
                     builder.object_lock_enabled_for_bucket = Some(deser.read_boolean(member)?);
-333
+                }
                 Some(9) => {
                     builder.object_ownership = Some(crate::types::ObjectOwnership::from(deser.read_string(member)?.as_str()));
-336
+                }
                 _ => {}
-338
+            }
             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 CreateBucketInput {
     /// 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("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-bucket-object-lock-enabled") {
             builder.object_lock_enabled_for_bucket = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-object-ownership") {
             builder.object_ownership = Some(crate::types::ObjectOwnership::from(val));
-+
+        }
         if !body.is_empty() {
             builder.create_bucket_configuration = Some(crate::types::CreateBucketConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-389
+    }
-390
+}
 impl CreateBucketInput {
     /// Creates a new builder-style object to manufacture [`CreateBucketInput`](crate::operation::create_bucket::CreateBucketInput).
     pub fn builder() -> crate::operation::create_bucket::builders::CreateBucketInputBuilder {
         crate::operation::create_bucket::builders::CreateBucketInputBuilder::default()
-395
+    }

↧ Expand context

-396
+}
-397
 /// A builder for [`CreateBucketInput`](crate::operation::create_bucket::CreateBucketInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateBucketInputBuilder {
     pub(crate) acl: ::std::option::Option<crate::types::BucketCannedAcl>,
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) create_bucket_configuration: ::std::option::Option<crate::types::CreateBucketConfiguration>,
     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) object_lock_enabled_for_bucket: ::std::option::Option<bool>,
     pub(crate) object_ownership: ::std::option::Option<crate::types::ObjectOwnership>,
-412
+}
 impl CreateBucketInputBuilder {
     /// <p>The canned ACL to apply to the bucket.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>

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

@@ -9,9 +136,174 @@

↥ Expand context

     /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>
     /// </note>
     pub bucket_arn: ::std::option::Option<::std::string::String>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-14
+}
 impl CreateBucketOutput {
     /// <p>A forward slash followed by the name of the bucket.</p>
     pub fn location(&self) -> ::std::option::Option<&str> {
         self.location.as_deref()
-19
+    }
     /// <p>The Amazon Resource Name (ARN) of the S3 bucket. ARNs uniquely identify Amazon Web Services resources across all of Amazon Web Services.</p><note>
     /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>
     /// </note>
     pub fn bucket_arn(&self) -> ::std::option::Option<&str> {
         self.bucket_arn.as_deref()
-25
+    }
-26
+}
 static CREATEBUCKETOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#CreateBucketOutput",

     "com.amazonaws.s3.synthetic",
     "CreateBucketOutput",
 );
 static CREATEBUCKETOUTPUT_MEMBER_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketOutput$Location",
         "com.amazonaws.s3.synthetic",
         "CreateBucketOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "location",
     "Location",
 ,
-41
+)
 .with_http_header("Location");
 static CREATEBUCKETOUTPUT_MEMBER_BUCKET_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketOutput$BucketArn",
         "com.amazonaws.s3.synthetic",
         "CreateBucketOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket_arn",
     "BucketArn",
 ,
-52
+)
 .with_http_header("x-amz-bucket-arn");
 static CREATEBUCKETOUTPUT_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 CREATEBUCKETOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEBUCKETOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CREATEBUCKETOUTPUT_MEMBER_LOCATION, &CREATEBUCKETOUTPUT_MEMBER_BUCKET_ARN],
     &[
         &CREATEBUCKETOUTPUT_MEMBER_LOCATION,
         &CREATEBUCKETOUTPUT_MEMBER_BUCKET_ARN,
         &CREATEBUCKETOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateBucketOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEBUCKETOUTPUT_SCHEMA;
-73
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateBucketOutput {
     #[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.location {
             ser.write_string(&CREATEBUCKETOUTPUT_MEMBER_LOCATION, val)?;
-82
+        }
         if let Some(ref val) = self.bucket_arn {
             ser.write_string(&CREATEBUCKETOUTPUT_MEMBER_BUCKET_ARN, val)?;
-85
+        }
         Ok(())
-87
+    }
-88
+}
 impl CreateBucketOutput {
     /// 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(&CREATEBUCKETOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEBUCKETOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.location = Some(deser.read_string(member)?);
-107
+                }
                 Some(1) => {
                     builder.bucket_arn = Some(deser.read_string(member)?);
-110
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-115
+            }
             Ok(())
         })?;
         Ok(builder.build())
-119
+    }
-120
+}
 impl CreateBucketOutput {
     /// 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("Location") {
             builder.location = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-bucket-arn") {
             builder.bucket_arn = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl crate::s3_request_id::RequestIdExt for CreateBucketOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()
-148
+    }
-149
+}
 impl ::aws_types::request_id::RequestId for CreateBucketOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-153
+    }
-154
+}

↧ Expand context

 impl CreateBucketOutput {
     /// Creates a new builder-style object to manufacture [`CreateBucketOutput`](crate::operation::create_bucket::CreateBucketOutput).
     pub fn builder() -> crate::operation::create_bucket::builders::CreateBucketOutputBuilder {
         crate::operation::create_bucket::builders::CreateBucketOutputBuilder::default()
-159
+    }
-160
+}
-161
 /// A builder for [`CreateBucketOutput`](crate::operation::create_bucket::CreateBucketOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateBucketOutputBuilder {
     pub(crate) location: ::std::option::Option<::std::string::String>,
     pub(crate) bucket_arn: ::std::option::Option<::std::string::String>,
     _extended_request_id: Option<String>,
     _request_id: Option<String>,
-170
+}
 impl CreateBucketOutputBuilder {
     /// <p>A forward slash followed by the name of the bucket.</p>
     pub fn location(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.location = ::std::option::Option::Some(input.into());

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

@@ -192,198 +254,261 @@

↥ Expand context

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

↧ 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_create_bucket_metadata_configuration::de_create_bucket_metadata_configuration_http_error(
                 status, headers, body,
-246
+            )
         } else {
             crate::protocol_serde::shape_create_bucket_metadata_configuration::de_create_bucket_metadata_configuration_http_response(
                 status, headers, body,
-250
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-253
+    }
-254
+}
 #[derive(Debug)]
 struct CreateBucketMetadataConfigurationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateBucketMetadataConfigurationRequestSerializer {
     #[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/create_bucket_metadata_configuration/_create_bucket_metadata_configuration_input.rs

@@ -21,21 +203,234 @@

↥ Expand context

-21
+    }
     /// <p>The <code>Content-MD5</code> header for the metadata configuration.</p>
     pub fn content_md5(&self) -> ::std::option::Option<&str> {
         self.content_md5.as_deref()
-25
+    }
     /// <p>The checksum algorithm to use with your metadata configuration.</p>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-29
+    }
     /// <p>The contents of your metadata configuration.</p>
     pub fn metadata_configuration(&self) -> ::std::option::Option<&crate::types::MetadataConfiguration> {
         self.metadata_configuration.as_ref()
-33
+    }
     /// <p>The expected owner of the general purpose bucket that corresponds to your metadata configuration.</p>
     pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
         self.expected_bucket_owner.as_deref()
-37
+    }
-38
+}
 static CREATEBUCKETMETADATACONFIGURATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#CreateBucketMetadataConfigurationInput",

     "com.amazonaws.s3.synthetic",
     "CreateBucketMetadataConfigurationInput",
 );
 static CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketMetadataConfigurationInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "CreateBucketMetadataConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-53
+)
 .with_http_label();
 static CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketMetadataConfigurationInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "CreateBucketMetadataConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-64
+)
 .with_http_header("Content-MD5");
 static CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketMetadataConfigurationInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "CreateBucketMetadataConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-75
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_METADATA_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketMetadataConfigurationInput$MetadataConfiguration",
         "com.amazonaws.s3.synthetic",
         "CreateBucketMetadataConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "metadata_configuration",
     "MetadataConfiguration",
 ,
-86
+)
 .with_xml_name("MetadataConfiguration")
 .with_http_payload();
 static CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketMetadataConfigurationInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "CreateBucketMetadataConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-98
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static CREATEBUCKETMETADATACONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEBUCKETMETADATACONFIGURATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_BUCKET,
         &CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_CONTENT_MD5,
         &CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_METADATA_CONFIGURATION,
         &CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/?metadataConfiguration", None));
 impl CreateBucketMetadataConfigurationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEBUCKETMETADATACONFIGURATIONINPUT_SCHEMA;
-115
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateBucketMetadataConfigurationInput {
     #[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(&CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_BUCKET, val)?;
-124
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_CONTENT_MD5, val)?;
-127
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-130
+        }
         if let Some(ref val) = self.metadata_configuration {
             ser.write_struct(&CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_METADATA_CONFIGURATION, val)?;
-133
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&CREATEBUCKETMETADATACONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-136
+        }
         Ok(())
-138
+    }
-139
+}
 impl CreateBucketMetadataConfigurationInput {
     /// 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(&CREATEBUCKETMETADATACONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEBUCKETMETADATACONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-158
+                }
                 Some(1) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-161
+                }
                 Some(2) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-164
+                }
                 Some(3) => {
                     builder.metadata_configuration = Some(crate::types::MetadataConfiguration::deserialize(deser)?);
-167
+                }
                 Some(4) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-170
+                }
                 _ => {}
-172
+            }
             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 CreateBucketMetadataConfigurationInput {
     /// 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.metadata_configuration = Some(crate::types::MetadataConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-208
+    }
-209
+}
 impl CreateBucketMetadataConfigurationInput {
     /// Creates a new builder-style object to manufacture [`CreateBucketMetadataConfigurationInput`](crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput).
     pub fn builder() -> crate::operation::create_bucket_metadata_configuration::builders::CreateBucketMetadataConfigurationInputBuilder {
         crate::operation::create_bucket_metadata_configuration::builders::CreateBucketMetadataConfigurationInputBuilder::default()
-214
+    }

↧ Expand context

-215
+}
-216
 /// A builder for [`CreateBucketMetadataConfigurationInput`](crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateBucketMetadataConfigurationInputBuilder {
     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) metadata_configuration: ::std::option::Option<crate::types::MetadataConfiguration>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-226
+}
 impl CreateBucketMetadataConfigurationInputBuilder {
     /// <p>The general purpose bucket that you want to create the metadata configuration for.</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
-233
+    }
     /// <p>The general purpose bucket that you want to create the metadata configuration for.</p>

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

↧ Expand context

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

@@ -192,198 +254,261 @@

↥ Expand context

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

↧ 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_create_bucket_metadata_table_configuration::de_create_bucket_metadata_table_configuration_http_error(
                 status, headers, body,
-246
+            )
         } else {
             crate::protocol_serde::shape_create_bucket_metadata_table_configuration::de_create_bucket_metadata_table_configuration_http_response(
                 status, headers, body,
-250
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-253
+    }
-254
+}
 #[derive(Debug)]
 struct CreateBucketMetadataTableConfigurationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateBucketMetadataTableConfigurationRequestSerializer {
     #[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/create_bucket_metadata_table_configuration/_create_bucket_metadata_table_configuration_input.rs

@@ -21,21 +205,236 @@

↥ Expand context

-21
+    }
     /// <p>The <code>Content-MD5</code> header for the metadata table configuration.</p>
     pub fn content_md5(&self) -> ::std::option::Option<&str> {
         self.content_md5.as_deref()
-25
+    }
     /// <p>The checksum algorithm to use with your metadata table configuration.</p>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-29
+    }
     /// <p>The contents of your metadata table configuration.</p>
     pub fn metadata_table_configuration(&self) -> ::std::option::Option<&crate::types::MetadataTableConfiguration> {
         self.metadata_table_configuration.as_ref()
-33
+    }
     /// <p>The expected owner of the general purpose bucket that corresponds to your metadata table configuration.</p>
     pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
         self.expected_bucket_owner.as_deref()
-37
+    }
-38
+}
 static CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#CreateBucketMetadataTableConfigurationInput",

     "com.amazonaws.s3.synthetic",
     "CreateBucketMetadataTableConfigurationInput",
 );
 static CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketMetadataTableConfigurationInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "CreateBucketMetadataTableConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-53
+)
 .with_http_label();
 static CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketMetadataTableConfigurationInput$ContentMD5",
         "com.amazonaws.s3.synthetic",
         "CreateBucketMetadataTableConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_md5",
     "ContentMD5",
 ,
-64
+)
 .with_http_header("Content-MD5");
 static CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateBucketMetadataTableConfigurationInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "CreateBucketMetadataTableConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-75
+)
 .with_http_header("x-amz-sdk-checksum-algorithm");
 static CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_METADATA_TABLE_CONFIGURATION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.s3.synthetic#CreateBucketMetadataTableConfigurationInput$MetadataTableConfiguration",
             "com.amazonaws.s3.synthetic",
             "CreateBucketMetadataTableConfigurationInput",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "metadata_table_configuration",
         "MetadataTableConfiguration",
 ,
-87
+    )
     .with_xml_name("MetadataTableConfiguration")
     .with_http_payload();
 static CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.s3.synthetic#CreateBucketMetadataTableConfigurationInput$ExpectedBucketOwner",
             "com.amazonaws.s3.synthetic",
             "CreateBucketMetadataTableConfigurationInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "expected_bucket_owner",
         "ExpectedBucketOwner",
 ,
-100
+    )
     .with_http_header("x-amz-expected-bucket-owner");
 static CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_BUCKET,
         &CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_CONTENT_MD5,
         &CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_METADATA_TABLE_CONFIGURATION,
         &CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/?metadataTable", None));
 impl CreateBucketMetadataTableConfigurationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_SCHEMA;
-117
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateBucketMetadataTableConfigurationInput {
     #[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(&CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_BUCKET, val)?;
-126
+        }
         if let Some(ref val) = self.content_md5 {
             ser.write_string(&CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_CONTENT_MD5, val)?;
-129
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-132
+        }
         if let Some(ref val) = self.metadata_table_configuration {
             ser.write_struct(&CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_METADATA_TABLE_CONFIGURATION, val)?;
-135
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-138
+        }
         Ok(())
-140
+    }
-141
+}
 impl CreateBucketMetadataTableConfigurationInput {
     /// 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(&CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEBUCKETMETADATATABLECONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-160
+                }
                 Some(1) => {
                     builder.content_md5 = Some(deser.read_string(member)?);
-163
+                }
                 Some(2) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-166
+                }
                 Some(3) => {
                     builder.metadata_table_configuration = Some(crate::types::MetadataTableConfiguration::deserialize(deser)?);
-169
+                }
                 Some(4) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-172
+                }
                 _ => {}
-174
+            }
             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 CreateBucketMetadataTableConfigurationInput {
     /// 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.metadata_table_configuration = Some(crate::types::MetadataTableConfiguration::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-210
+    }
-211
+}
 impl CreateBucketMetadataTableConfigurationInput {
     /// Creates a new builder-style object to manufacture [`CreateBucketMetadataTableConfigurationInput`](crate::operation::create_bucket_metadata_table_configuration::CreateBucketMetadataTableConfigurationInput).
     pub fn builder() -> crate::operation::create_bucket_metadata_table_configuration::builders::CreateBucketMetadataTableConfigurationInputBuilder {
         crate::operation::create_bucket_metadata_table_configuration::builders::CreateBucketMetadataTableConfigurationInputBuilder::default()
-216
+    }

↧ Expand context

-217
+}
-218
 /// A builder for [`CreateBucketMetadataTableConfigurationInput`](crate::operation::create_bucket_metadata_table_configuration::CreateBucketMetadataTableConfigurationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateBucketMetadataTableConfigurationInputBuilder {
     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) metadata_table_configuration: ::std::option::Option<crate::types::MetadataTableConfiguration>,
     pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
-228
+}
 impl CreateBucketMetadataTableConfigurationInputBuilder {
     /// <p>The general purpose bucket that you want to create the metadata table configuration for.</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
-235
+    }
     /// <p>The general purpose bucket that you want to create the metadata table configuration for.</p>

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

↧ Expand context

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

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

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

@@ -128,132 +190,195 @@

↥ Expand context

         #[allow(unused_mut)]
         let mut rcb =
             ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateMultipartUpload")
                 .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
                 .with_interceptor(CreateMultipartUploadEndpointParamsInterceptor)
                 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                     crate::operation::create_multipart_upload::CreateMultipartUploadError,
                 >::new())
                 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                     crate::operation::create_multipart_upload::CreateMultipartUploadError,
                 >::new())
                 .with_retry_classifier(
                     ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                         crate::operation::create_multipart_upload::CreateMultipartUploadError,
                     >::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(),
                 );
-154
         ::std::borrow::Cow::Owned(rcb)
-156
+    }
-157
+}
-158
 #[derive(Debug)]
 struct CreateMultipartUploadResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateMultipartUploadResponseDeserializer {
     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;
-175
+        }

↧ 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_create_multipart_upload::de_create_multipart_upload_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_create_multipart_upload::de_create_multipart_upload_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-183
+    }
-184
+}
 #[derive(Debug)]
 struct CreateMultipartUploadRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateMultipartUploadRequestSerializer {
     #[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::create_multipart_upload::CreateMultipartUploadInput>()

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

@@ -642,642 +1072,1074 @@

↥ Expand context

         formatter.field("website_redirect_location", &self.website_redirect_location);
         formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
         formatter.field("sse_customer_key", &"*** Sensitive Data Redacted ***");
         formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
         formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
         formatter.field("ssekms_encryption_context", &"*** Sensitive Data Redacted ***");
         formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
         formatter.field("request_payer", &self.request_payer);
         formatter.field("tagging", &self.tagging);
         formatter.field("object_lock_mode", &self.object_lock_mode);
         formatter.field("object_lock_retain_until_date", &self.object_lock_retain_until_date);
         formatter.field("object_lock_legal_hold_status", &self.object_lock_legal_hold_status);
         formatter.field("expected_bucket_owner", &self.expected_bucket_owner);
         formatter.field("checksum_algorithm", &self.checksum_algorithm);
         formatter.field("checksum_type", &self.checksum_type);
         formatter.finish()
-658
+    }
-659
+}
 static CREATEMULTIPARTUPLOADINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#CreateMultipartUploadInput",

     "com.amazonaws.s3.synthetic",
     "CreateMultipartUploadInput",
 );
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_ACL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ACL",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "acl",
     "ACL",
 ,
-674
+)
 .with_http_header("x-amz-acl");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-685
+)
 .with_http_label();
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_CACHE_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$CacheControl",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "cache_control",
     "CacheControl",
 ,
-696
+)
 .with_http_header("Cache-Control");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_DISPOSITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ContentDisposition",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_disposition",
     "ContentDisposition",
 ,
-707
+)
 .with_http_header("Content-Disposition");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ContentEncoding",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_encoding",
     "ContentEncoding",
 ,
-718
+)
 .with_http_header("Content-Encoding");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ContentLanguage",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_language",
     "ContentLanguage",
 ,
-729
+)
 .with_http_header("Content-Language");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ContentType",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_type",
     "ContentType",
 ,
-740
+)
 .with_http_header("Content-Type");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_EXPIRES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$Expires",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "expires",
     "Expires",
 ,
-751
+)
 .with_http_header("Expires");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_GRANT_FULL_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$GrantFullControl",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_full_control",
     "GrantFullControl",
 ,
-762
+)
 .with_http_header("x-amz-grant-full-control");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_GRANT_READ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$GrantRead",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read",
     "GrantRead",
 ,
-773
+)
 .with_http_header("x-amz-grant-read");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_GRANT_READ_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$GrantReadACP",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read_acp",
     "GrantReadACP",
 ,
-784
+)
 .with_http_header("x-amz-grant-read-acp");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_GRANT_WRITE_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$GrantWriteACP",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_write_acp",
     "GrantWriteACP",
 ,
-795
+)
 .with_http_header("x-amz-grant-write-acp");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$Key",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
-806
+)
 .with_http_label();
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$Metadata",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "metadata",
     "Metadata",
 ,
-817
+)
 .with_http_prefix_headers("x-amz-meta-");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ServerSideEncryption",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "server_side_encryption",
     "ServerSideEncryption",
 ,
-828
+)
 .with_http_header("x-amz-server-side-encryption");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$StorageClass",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "storage_class",
     "StorageClass",
 ,
-839
+)
 .with_http_header("x-amz-storage-class");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_WEBSITE_REDIRECT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$WebsiteRedirectLocation",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "website_redirect_location",
     "WebsiteRedirectLocation",
 ,
-850
+)
 .with_http_header("x-amz-website-redirect-location");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$SSECustomerAlgorithm",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_algorithm",
     "SSECustomerAlgorithm",
 ,
-861
+)
 .with_http_header("x-amz-server-side-encryption-customer-algorithm");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$SSECustomerKey",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key",
     "SSECustomerKey",
 ,
-872
+)
 .with_http_header("x-amz-server-side-encryption-customer-key");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$SSECustomerKeyMD5",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key_md5",
     "SSECustomerKeyMD5",
 ,
-883
+)
 .with_http_header("x-amz-server-side-encryption-customer-key-MD5");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$SSEKMSKeyId",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_key_id",
     "SSEKMSKeyId",
 ,
-894
+)
 .with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$SSEKMSEncryptionContext",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_encryption_context",
     "SSEKMSEncryptionContext",
 ,
-905
+)
 .with_http_header("x-amz-server-side-encryption-context");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$BucketKeyEnabled",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bucket_key_enabled",
     "BucketKeyEnabled",
 ,
-916
+)
 .with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$RequestPayer",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_payer",
     "RequestPayer",
 ,
-927
+)
 .with_http_header("x-amz-request-payer");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_TAGGING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$Tagging",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "tagging",
     "Tagging",
 ,
-938
+)
 .with_http_header("x-amz-tagging");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_OBJECT_LOCK_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ObjectLockMode",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "object_lock_mode",
     "ObjectLockMode",
 ,
-949
+)
 .with_http_header("x-amz-object-lock-mode");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ObjectLockRetainUntilDate",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "object_lock_retain_until_date",
     "ObjectLockRetainUntilDate",
 ,
-960
+)
 .with_http_header("x-amz-object-lock-retain-until-date");
 .with_http_header("x-amz-object-lock-retain-until-date")
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ObjectLockLegalHoldStatus",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "object_lock_legal_hold_status",
     "ObjectLockLegalHoldStatus",
 ,
-972
+)
 .with_http_header("x-amz-object-lock-legal-hold");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ExpectedBucketOwner",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_bucket_owner",
     "ExpectedBucketOwner",
 ,
-983
+)
 .with_http_header("x-amz-expected-bucket-owner");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-994
+)
 .with_http_header("x-amz-checksum-algorithm");
 static CREATEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadInput$ChecksumType",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_type",
     "ChecksumType",
 ,
-1005
+)
 .with_http_header("x-amz-checksum-type");
 static CREATEMULTIPARTUPLOADINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEMULTIPARTUPLOADINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_ACL,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_BUCKET,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_CACHE_CONTROL,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_DISPOSITION,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_ENCODING,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_LANGUAGE,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_TYPE,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_EXPIRES,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_GRANT_FULL_CONTROL,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_GRANT_READ,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_GRANT_READ_ACP,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_GRANT_WRITE_ACP,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_KEY,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_METADATA,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_STORAGE_CLASS,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_WEBSITE_REDIRECT_LOCATION,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_KEY,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_SSEKMS_KEY_ID,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_BUCKET_KEY_ENABLED,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_REQUEST_PAYER,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_TAGGING,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_OBJECT_LOCK_MODE,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &CREATEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_TYPE,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/{Key+}?uploads", None));
 impl CreateMultipartUploadInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEMULTIPARTUPLOADINPUT_SCHEMA;
-1048
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateMultipartUploadInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {

↧ Expand context

         if let Some(ref val) = self.acl {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_ACL, val.as_str())?;
-1057
+        }
         if let Some(ref val) = self.bucket {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_BUCKET, val)?;
-1060
+        }
         if let Some(ref val) = self.cache_control {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_CACHE_CONTROL, val)?;
-1063
+        }
         if let Some(ref val) = self.content_disposition {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_DISPOSITION, val)?;
-1066
+        }
         if let Some(ref val) = self.content_encoding {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_ENCODING, val)?;
-1069
+        }
         if let Some(ref val) = self.content_language {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_LANGUAGE, val)?;
-1072
+        }
         if let Some(ref val) = self.content_type {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_CONTENT_TYPE, val)?;

@@ -1130,1132 +1310,1464 @@

↥ Expand context

-1132
+        }
         if let Some(ref val) = self.request_payer {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
-1135
+        }
         if let Some(ref val) = self.tagging {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_TAGGING, val)?;
-1138
+        }
         if let Some(ref val) = self.object_lock_mode {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_OBJECT_LOCK_MODE, val.as_str())?;
-1141
+        }
         if let Some(ref val) = self.object_lock_retain_until_date {
             ser.write_timestamp(&CREATEMULTIPARTUPLOADINPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE, val)?;
-1144
+        }
         if let Some(ref val) = self.object_lock_legal_hold_status {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS, val.as_str())?;
-1147
+        }
         if let Some(ref val) = self.expected_bucket_owner {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
-1150
+        }
         if let Some(ref val) = self.checksum_algorithm {

             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-1153
+        }
         if let Some(ref val) = self.checksum_type {
             ser.write_string(&CREATEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_TYPE, val.as_str())?;
-1156
+        }
         Ok(())
-1158
+    }
-1159
+}
 impl CreateMultipartUploadInput {
     /// 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(&CREATEMULTIPARTUPLOADINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEMULTIPARTUPLOADINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.acl = Some(crate::types::ObjectCannedAcl::from(deser.read_string(member)?.as_str()));
-1178
+                }
                 Some(1) => {
                     builder.bucket = Some(deser.read_string(member)?);
-1181
+                }
                 Some(2) => {
                     builder.cache_control = Some(deser.read_string(member)?);
-1184
+                }
                 Some(3) => {
                     builder.content_disposition = Some(deser.read_string(member)?);
-1187
+                }
                 Some(4) => {
                     builder.content_encoding = Some(deser.read_string(member)?);
-1190
+                }
                 Some(5) => {
                     builder.content_language = Some(deser.read_string(member)?);
-1193
+                }
                 Some(6) => {
                     builder.content_type = Some(deser.read_string(member)?);
-1196
+                }
                 Some(7) => {
                     builder.expires = Some(deser.read_timestamp(member)?);
-1199
+                }
                 Some(8) => {
                     builder.grant_full_control = Some(deser.read_string(member)?);
-1202
+                }
                 Some(9) => {
                     builder.grant_read = Some(deser.read_string(member)?);
-1205
+                }
                 Some(10) => {
                     builder.grant_read_acp = Some(deser.read_string(member)?);
-1208
+                }
                 Some(11) => {
                     builder.grant_write_acp = Some(deser.read_string(member)?);
-1211
+                }
                 Some(12) => {
                     builder.key = Some(deser.read_string(member)?);
-1214
+                }
                 Some(13) => {
                     builder.metadata = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.metadata = Some(deser.read_string_string_map(member)?);
-1217
+                }
                 Some(14) => {
                     builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
-1220
+                }
                 Some(15) => {
                     builder.storage_class = Some(crate::types::StorageClass::from(deser.read_string(member)?.as_str()));
-1223
+                }
                 Some(16) => {
                     builder.website_redirect_location = Some(deser.read_string(member)?);
-1226
+                }
                 Some(17) => {
                     builder.sse_customer_algorithm = Some(deser.read_string(member)?);
-1229
+                }
                 Some(18) => {
                     builder.sse_customer_key = Some(deser.read_string(member)?);
-1232
+                }
                 Some(19) => {
                     builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
-1235
+                }
                 Some(20) => {
                     builder.ssekms_key_id = Some(deser.read_string(member)?);
-1238
+                }
                 Some(21) => {
                     builder.ssekms_encryption_context = Some(deser.read_string(member)?);
-1241
+                }
                 Some(22) => {
                     builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
-1244
+                }
                 Some(23) => {
                     builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
-1247
+                }
                 Some(24) => {
                     builder.tagging = Some(deser.read_string(member)?);
-1250
+                }
                 Some(25) => {
                     builder.object_lock_mode = Some(crate::types::ObjectLockMode::from(deser.read_string(member)?.as_str()));
-1253
+                }
                 Some(26) => {
                     builder.object_lock_retain_until_date = Some(deser.read_timestamp(member)?);
-1256
+                }
                 Some(27) => {
                     builder.object_lock_legal_hold_status = Some(crate::types::ObjectLockLegalHoldStatus::from(deser.read_string(member)?.as_str()));
-1259
+                }
                 Some(28) => {
                     builder.expected_bucket_owner = Some(deser.read_string(member)?);
-1262
+                }
                 Some(29) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-1265
+                }
                 Some(30) => {
                     builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
-1268
+                }
                 _ => {}
-1270
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder.key = builder.key.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl CreateMultipartUploadInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-acl") {
             builder.acl = Some(crate::types::ObjectCannedAcl::from(val));
-+
+        }
         if let Some(val) = headers.get("Cache-Control") {
             builder.cache_control = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Content-Disposition") {
             builder.content_disposition = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Content-Encoding") {
             builder.content_encoding = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Content-Language") {
             builder.content_language = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Content-Type") {
             builder.content_type = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("Expires") {
             builder.expires = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-grant-full-control") {
             builder.grant_full_control = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-grant-read") {
             builder.grant_read = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-grant-read-acp") {
             builder.grant_read_acp = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-grant-write-acp") {
             builder.grant_write_acp = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption") {
             builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-storage-class") {
             builder.storage_class = Some(crate::types::StorageClass::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-website-redirect-location") {
             builder.website_redirect_location = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
             builder.sse_customer_algorithm = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key") {
             builder.sse_customer_key = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
             builder.sse_customer_key_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
             builder.ssekms_key_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-context") {
             builder.ssekms_encryption_context = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
             builder.bucket_key_enabled = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-request-payer") {
             builder.request_payer = Some(crate::types::RequestPayer::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-tagging") {
             builder.tagging = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-object-lock-mode") {
             builder.object_lock_mode = Some(crate::types::ObjectLockMode::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-object-lock-retain-until-date") {
             builder.object_lock_retain_until_date = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::DateTime).ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-object-lock-legal-hold") {
             builder.object_lock_legal_hold_status = Some(crate::types::ObjectLockLegalHoldStatus::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
             builder.expected_bucket_owner = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-algorithm") {
             builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-type") {
             builder.checksum_type = Some(crate::types::ChecksumType::from(val));
-+
+        }
-+
+        {
             let mut map = ::std::collections::HashMap::new();
             for (key, val) in headers.iter() {
                 if let Some(suffix) = key.strip_prefix("x-amz-meta-") {
                     map.insert(suffix.to_string(), val.to_string());
-+
+                }
-+
+            }
             if !map.is_empty() {
                 builder.metadata = Some(map);
-+
+            }
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEMULTIPARTUPLOADINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.bucket = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => { /* read from headers above */ }
                 Some(4) => { /* read from headers above */ }
                 Some(5) => { /* read from headers above */ }
                 Some(6) => { /* read from headers above */ }
                 Some(7) => { /* read from headers above */ }
                 Some(8) => { /* read from headers above */ }
                 Some(9) => { /* read from headers above */ }
                 Some(10) => { /* read from headers above */ }
                 Some(11) => { /* read from headers above */ }
                 Some(12) => {
                     builder.key = Some(deser.read_string(member)?);
-+
+                }
                 Some(13) => { /* read from headers above */ }
                 Some(14) => { /* read from headers above */ }
                 Some(15) => { /* read from headers above */ }
                 Some(16) => { /* read from headers above */ }
                 Some(17) => { /* read from headers above */ }
                 Some(18) => { /* read from headers above */ }
                 Some(19) => { /* read from headers above */ }
                 Some(20) => { /* read from headers above */ }
                 Some(21) => { /* read from headers above */ }
                 Some(22) => { /* read from headers above */ }
                 Some(23) => { /* read from headers above */ }
                 Some(24) => { /* read from headers above */ }
                 Some(25) => { /* read from headers above */ }
                 Some(26) => { /* read from headers above */ }
                 Some(27) => { /* read from headers above */ }
                 Some(28) => { /* read from headers above */ }
                 Some(29) => { /* read from headers above */ }
                 Some(30) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-1438
+    }
-1439
+}
 impl CreateMultipartUploadInput {
     /// Creates a new builder-style object to manufacture [`CreateMultipartUploadInput`](crate::operation::create_multipart_upload::CreateMultipartUploadInput).
     pub fn builder() -> crate::operation::create_multipart_upload::builders::CreateMultipartUploadInputBuilder {
         crate::operation::create_multipart_upload::builders::CreateMultipartUploadInputBuilder::default()
-1444
+    }

↧ Expand context

-1445
+}
-1446
 /// A builder for [`CreateMultipartUploadInput`](crate::operation::create_multipart_upload::CreateMultipartUploadInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct CreateMultipartUploadInputBuilder {
     pub(crate) acl: ::std::option::Option<crate::types::ObjectCannedAcl>,
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) cache_control: ::std::option::Option<::std::string::String>,
     pub(crate) content_disposition: ::std::option::Option<::std::string::String>,
     pub(crate) content_encoding: ::std::option::Option<::std::string::String>,
     pub(crate) content_language: ::std::option::Option<::std::string::String>,
     pub(crate) content_type: ::std::option::Option<::std::string::String>,
     pub(crate) expires: ::std::option::Option<::aws_smithy_types::DateTime>,
     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_acp: ::std::option::Option<::std::string::String>,
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) metadata: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,

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

@@ -129,129 +467,562 @@

↥ Expand context

         formatter.field("abort_rule_id", &self.abort_rule_id);
         formatter.field("bucket", &self.bucket);
         formatter.field("key", &self.key);
         formatter.field("upload_id", &self.upload_id);
         formatter.field("server_side_encryption", &self.server_side_encryption);
         formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
         formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
         formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
         formatter.field("ssekms_encryption_context", &"*** Sensitive Data Redacted ***");
         formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
         formatter.field("request_charged", &self.request_charged);
         formatter.field("checksum_algorithm", &self.checksum_algorithm);
         formatter.field("checksum_type", &self.checksum_type);
         formatter.field("_extended_request_id", &self._extended_request_id);
         formatter.field("_request_id", &self._request_id);
         formatter.finish()
-145
+    }
-146
+}
 static CREATEMULTIPARTUPLOADOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput",

     "com.amazonaws.s3.synthetic",
     "CreateMultipartUploadOutput",
 );
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_ABORT_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$AbortDate",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "abort_date",
     "AbortDate",
 ,
-161
+)
 .with_http_header("x-amz-abort-date");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_ABORT_RULE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$AbortRuleId",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "abort_rule_id",
     "AbortRuleId",
 ,
-172
+)
 .with_http_header("x-amz-abort-rule-id");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$Bucket",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-183
+)
 .with_xml_name("Bucket");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$Key",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
 );
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$UploadId",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "upload_id",
     "UploadId",
 ,
 );
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$ServerSideEncryption",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "server_side_encryption",
     "ServerSideEncryption",
 ,
-214
+)
 .with_http_header("x-amz-server-side-encryption");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$SSECustomerAlgorithm",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_algorithm",
     "SSECustomerAlgorithm",
 ,
-225
+)
 .with_http_header("x-amz-server-side-encryption-customer-algorithm");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$SSECustomerKeyMD5",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_customer_key_md5",
     "SSECustomerKeyMD5",
 ,
-236
+)
 .with_http_header("x-amz-server-side-encryption-customer-key-MD5");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$SSEKMSKeyId",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_key_id",
     "SSEKMSKeyId",
 ,
-247
+)
 .with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$SSEKMSEncryptionContext",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_encryption_context",
     "SSEKMSEncryptionContext",
 ,
-258
+)
 .with_http_header("x-amz-server-side-encryption-context");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$BucketKeyEnabled",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bucket_key_enabled",
     "BucketKeyEnabled",
 ,
-269
+)
 .with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$RequestCharged",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_charged",
     "RequestCharged",
 ,
-280
+)
 .with_http_header("x-amz-request-charged");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$ChecksumAlgorithm",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-291
+)
 .with_http_header("x-amz-checksum-algorithm");
 static CREATEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateMultipartUploadOutput$ChecksumType",
         "com.amazonaws.s3.synthetic",
         "CreateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_type",
     "ChecksumType",
 ,
-302
+)
 .with_http_header("x-amz-checksum-type");
 static CREATEMULTIPARTUPLOADOUTPUT_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 CREATEMULTIPARTUPLOADOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEMULTIPARTUPLOADOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_ABORT_DATE,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_ABORT_RULE_ID,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_KEY,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_UPLOAD_ID,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSEKMS_KEY_ID,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET_KEY_ENABLED,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_REQUEST_CHARGED,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_ALGORITHM,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_TYPE,
         &CREATEMULTIPARTUPLOADOUTPUT_MEMBER__REQUEST_ID,
     ],
-331
+)
 .with_xml_name("InitiateMultipartUploadResult");
 impl CreateMultipartUploadOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEMULTIPARTUPLOADOUTPUT_SCHEMA;
-336
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateMultipartUploadOutput {
     #[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.abort_date {
             ser.write_timestamp(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_ABORT_DATE, val)?;
-345
+        }
         if let Some(ref val) = self.abort_rule_id {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_ABORT_RULE_ID, val)?;
-348
+        }
         if let Some(ref val) = self.bucket {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET, val)?;
-351
+        }
         if let Some(ref val) = self.key {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_KEY, val)?;
-354
+        }
         if let Some(ref val) = self.upload_id {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_UPLOAD_ID, val)?;
-357
+        }
         if let Some(ref val) = self.server_side_encryption {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION, val.as_str())?;
-360
+        }
         if let Some(ref val) = self.sse_customer_algorithm {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM, val)?;
-363
+        }
         if let Some(ref val) = self.sse_customer_key_md5 {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5, val)?;
-366
+        }
         if let Some(ref val) = self.ssekms_key_id {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSEKMS_KEY_ID, val)?;
-369
+        }
         if let Some(ref val) = self.ssekms_encryption_context {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT, val)?;
-372
+        }
         if let Some(ref val) = self.bucket_key_enabled {
             ser.write_boolean(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET_KEY_ENABLED, *val)?;
-375
+        }
         if let Some(ref val) = self.request_charged {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
-378
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-381
+        }
         if let Some(ref val) = self.checksum_type {
             ser.write_string(&CREATEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_TYPE, val.as_str())?;
-384
+        }
         Ok(())
-386
+    }
-387
+}
 impl CreateMultipartUploadOutput {
     /// 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(&CREATEMULTIPARTUPLOADOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEMULTIPARTUPLOADOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.abort_date = Some(deser.read_timestamp(member)?);
-406
+                }
                 Some(1) => {
                     builder.abort_rule_id = Some(deser.read_string(member)?);
-409
+                }
                 Some(2) => {
                     builder.bucket = Some(deser.read_string(member)?);
-412
+                }
                 Some(3) => {
                     builder.key = Some(deser.read_string(member)?);
-415
+                }
                 Some(4) => {
                     builder.upload_id = Some(deser.read_string(member)?);
-418
+                }
                 Some(5) => {
                     builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
-421
+                }
                 Some(6) => {
                     builder.sse_customer_algorithm = Some(deser.read_string(member)?);
-424
+                }
                 Some(7) => {
                     builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
-427
+                }
                 Some(8) => {
                     builder.ssekms_key_id = Some(deser.read_string(member)?);
-430
+                }
                 Some(9) => {
                     builder.ssekms_encryption_context = Some(deser.read_string(member)?);
-433
+                }
                 Some(10) => {
                     builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
-436
+                }
                 Some(11) => {
                     builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
-439
+                }
                 Some(12) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-442
+                }
                 Some(13) => {
                     builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
-445
+                }
                 Some(14) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateMultipartUploadOutput {
     /// 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-abort-date") {
             builder.abort_date = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-abort-rule-id") {
             builder.abort_rule_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption") {
             builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
             builder.sse_customer_algorithm = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
             builder.sse_customer_key_md5 = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
             builder.ssekms_key_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-context") {
             builder.ssekms_encryption_context = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
             builder.bucket_key_enabled = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-request-charged") {
             builder.request_charged = Some(crate::types::RequestCharged::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-algorithm") {
             builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-checksum-type") {
             builder.checksum_type = Some(crate::types::ChecksumType::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEMULTIPARTUPLOADOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => { /* read from headers above */ }
                 Some(2) => {
                     builder.bucket = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder.key = Some(deser.read_string(member)?);
-+
+                }
                 Some(4) => {
                     builder.upload_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(5) => { /* read from headers above */ }
                 Some(6) => { /* read from headers above */ }
                 Some(7) => { /* read from headers above */ }
                 Some(8) => { /* read from headers above */ }
                 Some(9) => { /* read from headers above */ }
                 Some(10) => { /* read from headers above */ }
                 Some(11) => { /* read from headers above */ }
                 Some(12) => { /* read from headers above */ }
                 Some(13) => { /* read from headers above */ }
                 _ => {}
-534
+            }
             Ok(())
         })?;
         Ok(builder.build())
-538
+    }
-539
+}
 impl crate::s3_request_id::RequestIdExt for CreateMultipartUploadOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()

↧ Expand context

-543
+    }
-544
+}
 impl ::aws_types::request_id::RequestId for CreateMultipartUploadOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-548
+    }
-549
+}
 impl CreateMultipartUploadOutput {
     /// Creates a new builder-style object to manufacture [`CreateMultipartUploadOutput`](crate::operation::create_multipart_upload::CreateMultipartUploadOutput).
     pub fn builder() -> crate::operation::create_multipart_upload::builders::CreateMultipartUploadOutputBuilder {
         crate::operation::create_multipart_upload::builders::CreateMultipartUploadOutputBuilder::default()
-554
+    }
-555
+}
-556
 /// A builder for [`CreateMultipartUploadOutput`](crate::operation::create_multipart_upload::CreateMultipartUploadOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct CreateMultipartUploadOutputBuilder {
     pub(crate) abort_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) abort_rule_id: ::std::option::Option<::std::string::String>,

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

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

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

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

↥ Expand context

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

                     .build(),
             );
-148
         ::std::borrow::Cow::Owned(rcb)
-150
+    }
-151
+}
-152
 #[derive(Debug)]
 struct CreateSessionResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateSessionResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-169
+        }

↧ Expand context

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

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

@@ -51,51 +250,305 @@

↥ Expand context

     /// <p>Specifies whether Amazon S3 should use an S3 Bucket Key for object encryption with server-side encryption using KMS keys (SSE-KMS).</p>
     /// <p>S3 Bucket Keys are always enabled for <code>GET</code> and <code>PUT</code> operations in a directory bucket and can’t be disabled. S3 Bucket Keys aren't supported, when you copy SSE-KMS encrypted objects from general purpose buckets to directory buckets, from directory buckets to general purpose buckets, or between directory buckets, through <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-objects-Batch-Ops">the Copy operation in Batch Operations</a>, or <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-import-job">the import jobs</a>. In this case, Amazon S3 makes a call to KMS every time a copy request is made for a KMS-encrypted object.</p>
     pub fn bucket_key_enabled(&self) -> ::std::option::Option<bool> {
         self.bucket_key_enabled
-55
+    }
-56
+}
 impl ::std::fmt::Debug for CreateSessionInput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("CreateSessionInput");
         formatter.field("session_mode", &self.session_mode);
         formatter.field("bucket", &self.bucket);
         formatter.field("server_side_encryption", &self.server_side_encryption);
         formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
         formatter.field("ssekms_encryption_context", &"*** Sensitive Data Redacted ***");
         formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
         formatter.finish()
-67
+    }
-68
+}
 static CREATESESSIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#CreateSessionInput",

     "com.amazonaws.s3.synthetic",
     "CreateSessionInput",
 );
 static CREATESESSIONINPUT_MEMBER_SESSION_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionInput$SessionMode",
         "com.amazonaws.s3.synthetic",
         "CreateSessionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "session_mode",
     "SessionMode",
 ,
-83
+)
 .with_http_header("x-amz-create-session-mode");
 static CREATESESSIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionInput$Bucket",
         "com.amazonaws.s3.synthetic",
         "CreateSessionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-94
+)
 .with_http_label();
 static CREATESESSIONINPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionInput$ServerSideEncryption",
         "com.amazonaws.s3.synthetic",
         "CreateSessionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "server_side_encryption",
     "ServerSideEncryption",
 ,
-105
+)
 .with_http_header("x-amz-server-side-encryption");
 static CREATESESSIONINPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionInput$SSEKMSKeyId",
         "com.amazonaws.s3.synthetic",
         "CreateSessionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_key_id",
     "SSEKMSKeyId",
 ,
-116
+)
 .with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
 static CREATESESSIONINPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionInput$SSEKMSEncryptionContext",
         "com.amazonaws.s3.synthetic",
         "CreateSessionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_encryption_context",
     "SSEKMSEncryptionContext",
 ,
-127
+)
 .with_http_header("x-amz-server-side-encryption-context");
 static CREATESESSIONINPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionInput$BucketKeyEnabled",
         "com.amazonaws.s3.synthetic",
         "CreateSessionInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bucket_key_enabled",
     "BucketKeyEnabled",
 ,
-138
+)
 .with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
 static CREATESESSIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATESESSIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATESESSIONINPUT_MEMBER_SESSION_MODE,
         &CREATESESSIONINPUT_MEMBER_BUCKET,
         &CREATESESSIONINPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
         &CREATESESSIONINPUT_MEMBER_SSEKMS_KEY_ID,
         &CREATESESSIONINPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT,
         &CREATESESSIONINPUT_MEMBER_BUCKET_KEY_ENABLED,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/?session", None));
 impl CreateSessionInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATESESSIONINPUT_SCHEMA;
-156
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateSessionInput {
     #[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.session_mode {
             ser.write_string(&CREATESESSIONINPUT_MEMBER_SESSION_MODE, val.as_str())?;
-165
+        }
         if let Some(ref val) = self.bucket {
             ser.write_string(&CREATESESSIONINPUT_MEMBER_BUCKET, val)?;
-168
+        }
         if let Some(ref val) = self.server_side_encryption {
             ser.write_string(&CREATESESSIONINPUT_MEMBER_SERVER_SIDE_ENCRYPTION, val.as_str())?;
-171
+        }
         if let Some(ref val) = self.ssekms_key_id {
             ser.write_string(&CREATESESSIONINPUT_MEMBER_SSEKMS_KEY_ID, val)?;
-174
+        }
         if let Some(ref val) = self.ssekms_encryption_context {
             ser.write_string(&CREATESESSIONINPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT, val)?;
-177
+        }
         if let Some(ref val) = self.bucket_key_enabled {
             ser.write_boolean(&CREATESESSIONINPUT_MEMBER_BUCKET_KEY_ENABLED, *val)?;
-180
+        }
         Ok(())
-182
+    }
-183
+}
 impl CreateSessionInput {
     /// 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(&CREATESESSIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATESESSIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.session_mode = Some(crate::types::SessionMode::from(deser.read_string(member)?.as_str()));
-202
+                }
                 Some(1) => {
                     builder.bucket = Some(deser.read_string(member)?);
-205
+                }
                 Some(2) => {
                     builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
-208
+                }
                 Some(3) => {
                     builder.ssekms_key_id = Some(deser.read_string(member)?);
-211
+                }
                 Some(4) => {
                     builder.ssekms_encryption_context = Some(deser.read_string(member)?);
-214
+                }
                 Some(5) => {
                     builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
-217
+                }
                 _ => {}
-219
+            }
             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 CreateSessionInput {
     /// 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-create-session-mode") {
             builder.session_mode = Some(crate::types::SessionMode::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption") {
             builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
             builder.ssekms_key_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-context") {
             builder.ssekms_encryption_context = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
             builder.bucket_key_enabled = val.parse::<bool>().ok();
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATESESSIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.bucket = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => { /* read from headers above */ }
                 Some(4) => { /* read from headers above */ }
                 Some(5) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-279
+    }
-280
+}
 impl CreateSessionInput {
     /// Creates a new builder-style object to manufacture [`CreateSessionInput`](crate::operation::create_session::CreateSessionInput).
     pub fn builder() -> crate::operation::create_session::builders::CreateSessionInputBuilder {
         crate::operation::create_session::builders::CreateSessionInputBuilder::default()
-285
+    }

↧ Expand context

-286
+}
-287
 /// A builder for [`CreateSessionInput`](crate::operation::create_session::CreateSessionInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct CreateSessionInputBuilder {
     pub(crate) session_mode: ::std::option::Option<crate::types::SessionMode>,
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) server_side_encryption: ::std::option::Option<crate::types::ServerSideEncryption>,
     pub(crate) ssekms_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) ssekms_encryption_context: ::std::option::Option<::std::string::String>,
     pub(crate) bucket_key_enabled: ::std::option::Option<bool>,
-298
+}
 impl CreateSessionInputBuilder {
     /// <p>Specifies the mode of the session that will be created, either <code>ReadWrite</code> or <code>ReadOnly</code>. By default, a <code>ReadWrite</code> session is created. A <code>ReadWrite</code> session is capable of executing all the Zonal endpoint API operations on a directory bucket. A <code>ReadOnly</code> session is constrained to execute the following Zonal endpoint API operations: <code>GetObject</code>, <code>HeadObject</code>, <code>ListObjectsV2</code>, <code>GetObjectAttributes</code>, <code>ListParts</code>, and <code>ListMultipartUploads</code>.</p>
     pub fn session_mode(mut self, input: crate::types::SessionMode) -> Self {
         self.session_mode = ::std::option::Option::Some(input);
         self
-304
+    }
     /// <p>Specifies the mode of the session that will be created, either <code>ReadWrite</code> or <code>ReadOnly</code>. By default, a <code>ReadWrite</code> session is created. A <code>ReadWrite</code> session is capable of executing all the Zonal endpoint API operations on a directory bucket. A <code>ReadOnly</code> session is constrained to execute the following Zonal endpoint API operations: <code>GetObject</code>, <code>HeadObject</code>, <code>ListObjectsV2</code>, <code>GetObjectAttributes</code>, <code>ListParts</code>, and <code>ListMultipartUploads</code>.</p>

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

@@ -40,40 +218,279 @@

↥ Expand context

     /// <p>The established temporary security credentials for the created session.</p>
     pub fn credentials(&self) -> ::std::option::Option<&crate::types::SessionCredentials> {
         self.credentials.as_ref()
-43
+    }
-44
+}
 impl ::std::fmt::Debug for CreateSessionOutput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("CreateSessionOutput");
         formatter.field("server_side_encryption", &self.server_side_encryption);
         formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
         formatter.field("ssekms_encryption_context", &"*** Sensitive Data Redacted ***");
         formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
         formatter.field("credentials", &self.credentials);
         formatter.field("_extended_request_id", &self._extended_request_id);
         formatter.field("_request_id", &self._request_id);
         formatter.finish()
-56
+    }
-57
+}
 static CREATESESSIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3.synthetic#CreateSessionOutput",

     "com.amazonaws.s3.synthetic",
     "CreateSessionOutput",
 );
 static CREATESESSIONOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionOutput$ServerSideEncryption",
         "com.amazonaws.s3.synthetic",
         "CreateSessionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "server_side_encryption",
     "ServerSideEncryption",
 ,
-72
+)
 .with_http_header("x-amz-server-side-encryption");
 static CREATESESSIONOUTPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionOutput$SSEKMSKeyId",
         "com.amazonaws.s3.synthetic",
         "CreateSessionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_key_id",
     "SSEKMSKeyId",
 ,
-83
+)
 .with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
 static CREATESESSIONOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionOutput$SSEKMSEncryptionContext",
         "com.amazonaws.s3.synthetic",
         "CreateSessionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssekms_encryption_context",
     "SSEKMSEncryptionContext",
 ,
-94
+)
 .with_http_header("x-amz-server-side-encryption-context");
 static CREATESESSIONOUTPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionOutput$BucketKeyEnabled",
         "com.amazonaws.s3.synthetic",
         "CreateSessionOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bucket_key_enabled",
     "BucketKeyEnabled",
 ,
-105
+)
 .with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
 static CREATESESSIONOUTPUT_MEMBER_CREDENTIALS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3.synthetic#CreateSessionOutput$Credentials",
         "com.amazonaws.s3.synthetic",
         "CreateSessionOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "credentials",
     "Credentials",
 ,
-116
+)
 .with_xml_name("Credentials");
 static CREATESESSIONOUTPUT_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 CREATESESSIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATESESSIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATESESSIONOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
         &CREATESESSIONOUTPUT_MEMBER_SSEKMS_KEY_ID,
         &CREATESESSIONOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT,
         &CREATESESSIONOUTPUT_MEMBER_BUCKET_KEY_ENABLED,
         &CREATESESSIONOUTPUT_MEMBER_CREDENTIALS,
         &CREATESESSIONOUTPUT_MEMBER__REQUEST_ID,
     ],
-136
+)
 .with_xml_name("CreateSessionResult");
 impl CreateSessionOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATESESSIONOUTPUT_SCHEMA;
-141
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateSessionOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.server_side_encryption {
             ser.write_string(&CREATESESSIONOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION, val.as_str())?;
-150
+        }
         if let Some(ref val) = self.ssekms_key_id {
             ser.write_string(&CREATESESSIONOUTPUT_MEMBER_SSEKMS_KEY_ID, val)?;
-153
+        }
         if let Some(ref val) = self.ssekms_encryption_context {
             ser.write_string(&CREATESESSIONOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT, val)?;
-156
+        }
         if let Some(ref val) = self.bucket_key_enabled {
             ser.write_boolean(&CREATESESSIONOUTPUT_MEMBER_BUCKET_KEY_ENABLED, *val)?;
-159
+        }
         if let Some(ref val) = self.credentials {
             ser.write_struct(&CREATESESSIONOUTPUT_MEMBER_CREDENTIALS, val)?;
-162
+        }
         Ok(())
-164
+    }
-165
+}
 impl CreateSessionOutput {
     /// 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(&CREATESESSIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATESESSIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
-184
+                }
                 Some(1) => {
                     builder.ssekms_key_id = Some(deser.read_string(member)?);
-187
+                }
                 Some(2) => {
                     builder.ssekms_encryption_context = Some(deser.read_string(member)?);
-190
+                }
                 Some(3) => {
                     builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
-193
+                }
                 Some(4) => {
                     builder.credentials = Some(crate::types::SessionCredentials::deserialize(deser)?);
-196
+                }
                 Some(5) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateSessionOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-server-side-encryption") {
             builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
             builder.ssekms_key_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-context") {
             builder.ssekms_encryption_context = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
             builder.bucket_key_enabled = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATESESSIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => { /* read from headers above */ }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => { /* read from headers above */ }
                 Some(4) => {
                     builder.credentials = Some(crate::types::SessionCredentials::deserialize(deser)?);
-+
+                }
                 _ => {}
-251
+            }
             Ok(())
         })?;
         Ok(builder.build())
-255
+    }
-256
+}
 impl crate::s3_request_id::RequestIdExt for CreateSessionOutput {
     fn extended_request_id(&self) -> Option<&str> {
         self._extended_request_id.as_deref()

↧ Expand context

-260
+    }
-261
+}
 impl ::aws_types::request_id::RequestId for CreateSessionOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-265
+    }
-266
+}
 impl CreateSessionOutput {
     /// Creates a new builder-style object to manufacture [`CreateSessionOutput`](crate::operation::create_session::CreateSessionOutput).
     pub fn builder() -> crate::operation::create_session::builders::CreateSessionOutputBuilder {
         crate::operation::create_session::builders::CreateSessionOutputBuilder::default()
-271
+    }
-272
+}
-273
 /// A builder for [`CreateSessionOutput`](crate::operation::create_session::CreateSessionOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct CreateSessionOutputBuilder {
     pub(crate) server_side_encryption: ::std::option::Option<crate::types::ServerSideEncryption>,
     pub(crate) ssekms_key_id: ::std::option::Option<::std::string::String>,

AWS SDK

Files changed:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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