AWS SDK

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

@@ -87,87 +359,405 @@

     /// <p>This is not supported by Amazon S3 on Outposts buckets.</p>
     /// </note>
     pub fn grant_write_acp(&self) -> ::std::option::Option<&str> {
         self.grant_write_acp.as_deref()
-91
+    }
     /// <p>Specifies whether you want S3 Object Lock to be enabled for the new bucket.</p><note>
     /// <p>This is not supported by Amazon S3 on Outposts buckets.</p>
     /// </note>
     pub fn object_lock_enabled_for_bucket(&self) -> ::std::option::Option<bool> {
         self.object_lock_enabled_for_bucket
-97
+    }
     /// <p>The ID of the Outposts where the bucket is being created.</p><note>
     /// <p>This ID is required by Amazon S3 on Outposts buckets.</p>
     /// </note>
     pub fn outpost_id(&self) -> ::std::option::Option<&str> {
         self.outpost_id.as_deref()
-103
+    }
-104
+}
 static CREATEBUCKETINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#CreateBucketInput",

     "com.amazonaws.s3control.synthetic",
     "CreateBucketInput",
 );
 static CREATEBUCKETINPUT_MEMBER_ACL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateBucketInput$ACL",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "acl",
     "ACL",
 ,
-119
+)
 .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.s3control.synthetic#CreateBucketInput$Bucket",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-130
+)
 .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.s3control.synthetic#CreateBucketInput$CreateBucketConfiguration",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "create_bucket_configuration",
     "CreateBucketConfiguration",
 ,
-141
+)
 .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.s3control.synthetic#CreateBucketInput$GrantFullControl",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_full_control",
     "GrantFullControl",
 ,
-153
+)
 .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.s3control.synthetic#CreateBucketInput$GrantRead",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read",
     "GrantRead",
 ,
-164
+)
 .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.s3control.synthetic#CreateBucketInput$GrantReadACP",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_read_acp",
     "GrantReadACP",
 ,
-175
+)
 .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.s3control.synthetic#CreateBucketInput$GrantWrite",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_write",
     "GrantWrite",
 ,
-186
+)
 .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.s3control.synthetic#CreateBucketInput$GrantWriteACP",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_write_acp",
     "GrantWriteACP",
 ,
-197
+)
 .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.s3control.synthetic#CreateBucketInput$ObjectLockEnabledForBucket",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "object_lock_enabled_for_bucket",
     "ObjectLockEnabledForBucket",
 ,
-208
+)
 .with_http_header("x-amz-bucket-object-lock-enabled");
 static CREATEBUCKETINPUT_MEMBER_OUTPOST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateBucketInput$OutpostId",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "outpost_id",
     "OutpostId",
 ,
-219
+)
 .with_http_header("x-amz-outpost-id");
 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_OUTPOST_ID,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/v20180820/bucket/{Bucket}", None));
 impl CreateBucketInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEBUCKETINPUT_SCHEMA;
-241
+}
 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())?;
-250
+        }
         if let Some(ref val) = self.bucket {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_BUCKET, val)?;
-253
+        }
         if let Some(ref val) = self.create_bucket_configuration {
             ser.write_struct(&CREATEBUCKETINPUT_MEMBER_CREATE_BUCKET_CONFIGURATION, val)?;
-256
+        }
         if let Some(ref val) = self.grant_full_control {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_GRANT_FULL_CONTROL, val)?;
-259
+        }
         if let Some(ref val) = self.grant_read {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_GRANT_READ, val)?;
-262
+        }
         if let Some(ref val) = self.grant_read_acp {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_GRANT_READ_ACP, val)?;
-265
+        }
         if let Some(ref val) = self.grant_write {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_GRANT_WRITE, val)?;
-268
+        }
         if let Some(ref val) = self.grant_write_acp {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_GRANT_WRITE_ACP, val)?;
-271
+        }
         if let Some(ref val) = self.object_lock_enabled_for_bucket {
             ser.write_boolean(&CREATEBUCKETINPUT_MEMBER_OBJECT_LOCK_ENABLED_FOR_BUCKET, *val)?;
-274
+        }
         if let Some(ref val) = self.outpost_id {
             ser.write_string(&CREATEBUCKETINPUT_MEMBER_OUTPOST_ID, val)?;
-277
+        }
         Ok(())
-279
+    }
-280
+}
 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()));
-299
+                }
                 Some(1) => {
                     builder.bucket = Some(deser.read_string(member)?);
-302
+                }
                 Some(2) => {
                     builder.create_bucket_configuration = Some(crate::types::CreateBucketConfiguration::deserialize(deser)?);
-305
+                }
                 Some(3) => {
                     builder.grant_full_control = Some(deser.read_string(member)?);
-308
+                }
                 Some(4) => {
                     builder.grant_read = Some(deser.read_string(member)?);
-311
+                }
                 Some(5) => {
                     builder.grant_read_acp = Some(deser.read_string(member)?);
-314
+                }
                 Some(6) => {
                     builder.grant_write = Some(deser.read_string(member)?);
-317
+                }
                 Some(7) => {
                     builder.grant_write_acp = Some(deser.read_string(member)?);
-320
+                }
                 Some(8) => {
                     builder.object_lock_enabled_for_bucket = Some(deser.read_boolean(member)?);
-323
+                }
                 Some(9) => {
                     builder.outpost_id = Some(deser.read_string(member)?);
-326
+                }
                 _ => {}
-328
+            }
             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-outpost-id") {
             builder.outpost_id = Some(val.to_string());
-+
+        }
         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() })
-379
+    }
-380
+}
 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()
-385
+    }

↧ Expand context

-386
+}
-387
 /// 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) outpost_id: ::std::option::Option<::std::string::String>,
-402
+}
 impl CreateBucketInputBuilder {
     /// <p>The canned ACL to apply to the bucket.</p><note>
     /// <p>This is not supported by Amazon S3 on Outposts buckets.</p>

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

@@ -26,26 +145,197 @@

↥ Expand context

         self.location.as_deref()
-27
+    }
     /// <p>The Amazon Resource Name (ARN) of the bucket.</p>
     /// <p>For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.</p>
     /// <p>For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format <code>arn:aws:s3-outposts:<region>
     /// :
     /// <account-id>
     /// :outpost/
     /// <outpost-id>
     /// /bucket/
     /// <my-bucket-name></my-bucket-name>
     /// </outpost-id>
     /// </account-id>
     /// </region></code>. For example, to access the bucket <code>reports</code> through Outpost <code>my-outpost</code> owned by account <code>123456789012</code> in Region <code>us-west-2</code>, use the URL encoding of <code>arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports</code>. The value must be URL encoded.</p>
     pub fn bucket_arn(&self) -> ::std::option::Option<&str> {
         self.bucket_arn.as_deref()
-42
+    }
-43
+}
 static CREATEBUCKETOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#CreateBucketOutput",

     "com.amazonaws.s3control.synthetic",
     "CreateBucketOutput",
 );
 static CREATEBUCKETOUTPUT_MEMBER_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateBucketOutput$Location",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "location",
     "Location",
 ,
-58
+)
 .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.s3control.synthetic#CreateBucketOutput$BucketArn",
         "com.amazonaws.s3control.synthetic",
         "CreateBucketOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "bucket_arn",
     "BucketArn",
 ,
 );
 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;
-89
+}
 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)?;
-98
+        }
         if let Some(ref val) = self.bucket_arn {
             ser.write_string(&CREATEBUCKETOUTPUT_MEMBER_BUCKET_ARN, val)?;
-101
+        }
         Ok(())
-103
+    }
-104
+}
 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)?);
-123
+                }
                 Some(1) => {
                     builder.bucket_arn = Some(deser.read_string(member)?);
-126
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 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-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(&CREATEBUCKETOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.bucket_arn = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-169
+            }
             Ok(())
         })?;
         Ok(builder.build())
-173
+    }
-174
+}
 impl ::aws_types::request_id::RequestId for CreateBucketOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()

↧ Expand context

-178
+    }
-179
+}
 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()
-184
+    }
-185
+}
-186
 /// 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>,
     _request_id: Option<String>,
-194
+}
 impl CreateBucketOutputBuilder {
     /// <p>The location of the bucket.</p>
     pub fn location(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_job.rs

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

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

@@ -125,129 +184,189 @@

↥ Expand context

-129
+    }
-130
     fn runtime_components(
         &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("CreateJob")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateJobEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_job::CreateJobError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_job::CreateJobError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::create_job::CreateJobError,
             >::new());
-148

         ::std::borrow::Cow::Owned(rcb)
-150
+    }
-151
+}
-152
 #[derive(Debug)]
 struct CreateJobResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateJobResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_create_job::de_create_job_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_create_job::de_create_job_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-173
+    }
-174
+}
 #[derive(Debug)]
 struct CreateJobRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateJobRequestSerializer {
     #[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_job::CreateJobInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_job/_create_job_input.rs

@@ -59,59 +356,426 @@

↥ Expand context

     pub fn priority(&self) -> ::std::option::Option<i32> {
         self.priority
-61
+    }
     /// <p>The Amazon Resource Name (ARN) for the Identity and Access Management (IAM) role that Batch Operations will use to run this job's action on every object in the manifest.</p>
     pub fn role_arn(&self) -> ::std::option::Option<&str> {
         self.role_arn.as_deref()
-65
+    }
     /// <p>A set of tags to associate with the S3 Batch Operations job. This is an optional parameter.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::S3Tag] {
         self.tags.as_deref().unwrap_or_default()
-71
+    }
     /// <p>The attribute container for the ManifestGenerator details. Jobs must be created with either a manifest file or a ManifestGenerator, but not both.</p>
     pub fn manifest_generator(&self) -> ::std::option::Option<&crate::types::JobManifestGenerator> {
         self.manifest_generator.as_ref()
-75
+    }
-76
+}
 static CREATEJOBINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#CreateJobInput",

     "com.amazonaws.s3control.synthetic",
     "CreateJobInput",
 );
 static CREATEJOBINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$AccountId",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "AccountId",
 ,
-91
+)
 .with_host_label()
 .with_http_header("x-amz-account-id");
 static CREATEJOBINPUT_MEMBER_CONFIRMATION_REQUIRED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$ConfirmationRequired",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "confirmation_required",
     "ConfirmationRequired",
 ,
 );
 static CREATEJOBINPUT_MEMBER_OPERATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$Operation",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "operation",
     "Operation",
 ,
 );
 static CREATEJOBINPUT_MEMBER_REPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$Report",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "report",
     "Report",
 ,
 );
 static CREATEJOBINPUT_MEMBER_CLIENT_REQUEST_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$ClientRequestToken",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_request_token",
     "ClientRequestToken",
 ,
 );
 static CREATEJOBINPUT_MEMBER_MANIFEST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$Manifest",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "manifest",
     "Manifest",
 ,
 );
 static CREATEJOBINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$Description",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "description",
     "Description",
 ,
 );
 static CREATEJOBINPUT_MEMBER_PRIORITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$Priority",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "priority",
     "Priority",
 ,
 );
 static CREATEJOBINPUT_MEMBER_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$RoleArn",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "role_arn",
     "RoleArn",
 ,
 );
 static CREATEJOBINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$Tags",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
 );
 static CREATEJOBINPUT_MEMBER_MANIFEST_GENERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobInput$ManifestGenerator",
         "com.amazonaws.s3control.synthetic",
         "CreateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "manifest_generator",
     "ManifestGenerator",
 ,
 );
 static CREATEJOBINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEJOBINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEJOBINPUT_MEMBER_ACCOUNT_ID,
         &CREATEJOBINPUT_MEMBER_CONFIRMATION_REQUIRED,
         &CREATEJOBINPUT_MEMBER_OPERATION,
         &CREATEJOBINPUT_MEMBER_REPORT,
         &CREATEJOBINPUT_MEMBER_CLIENT_REQUEST_TOKEN,
         &CREATEJOBINPUT_MEMBER_MANIFEST,
         &CREATEJOBINPUT_MEMBER_DESCRIPTION,
         &CREATEJOBINPUT_MEMBER_PRIORITY,
         &CREATEJOBINPUT_MEMBER_ROLE_ARN,
         &CREATEJOBINPUT_MEMBER_TAGS,
         &CREATEJOBINPUT_MEMBER_MANIFEST_GENERATOR,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/v20180820/jobs", None));
 impl CreateJobInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEJOBINPUT_SCHEMA;
-215
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateJobInput {
     #[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.account_id {
             ser.write_string(&CREATEJOBINPUT_MEMBER_ACCOUNT_ID, val)?;
-224
+        }
         if let Some(ref val) = self.confirmation_required {
             ser.write_boolean(&CREATEJOBINPUT_MEMBER_CONFIRMATION_REQUIRED, *val)?;
-227
+        }
         if let Some(ref val) = self.operation {
             ser.write_struct(&CREATEJOBINPUT_MEMBER_OPERATION, val)?;
-230
+        }
         if let Some(ref val) = self.report {
             ser.write_struct(&CREATEJOBINPUT_MEMBER_REPORT, val)?;
-233
+        }
         if let Some(ref val) = self.client_request_token {
             ser.write_string(&CREATEJOBINPUT_MEMBER_CLIENT_REQUEST_TOKEN, val)?;
-236
+        }
         if let Some(ref val) = self.manifest {
             ser.write_struct(&CREATEJOBINPUT_MEMBER_MANIFEST, val)?;
-239
+        }
         if let Some(ref val) = self.description {
             ser.write_string(&CREATEJOBINPUT_MEMBER_DESCRIPTION, val)?;
-242
+        }
         if let Some(ref val) = self.priority {
             ser.write_integer(&CREATEJOBINPUT_MEMBER_PRIORITY, *val)?;
-245
+        }
         if let Some(ref val) = self.role_arn {
             ser.write_string(&CREATEJOBINPUT_MEMBER_ROLE_ARN, val)?;
-248
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &CREATEJOBINPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::S3Tag::SCHEMA, item)?;
-255
+                    }
                     Ok(())
                 },
             )?;
-259
+        }
         if let Some(ref val) = self.manifest_generator {
             ser.write_null(&CREATEJOBINPUT_MEMBER_MANIFEST_GENERATOR)?;
             ser.write_struct(&CREATEJOBINPUT_MEMBER_MANIFEST_GENERATOR, val)?;
-262
+        }
         Ok(())
-264
+    }
-265
+}
 impl CreateJobInput {
     /// 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(&CREATEJOBINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEJOBINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-284
+                }
                 Some(1) => {
                     builder.confirmation_required = Some(deser.read_boolean(member)?);
-287
+                }
                 Some(2) => {
                     builder.operation = Some(crate::types::JobOperation::deserialize(deser)?);
-290
+                }
                 Some(3) => {
                     builder.report = Some(crate::types::JobReport::deserialize(deser)?);
-293
+                }
                 Some(4) => {
                     builder.client_request_token = Some(deser.read_string(member)?);
-296
+                }
                 Some(5) => {
                     builder.manifest = Some(crate::types::JobManifest::deserialize(deser)?);
-299
+                }
                 Some(6) => {
                     builder.description = Some(deser.read_string(member)?);
-302
+                }
                 Some(7) => {
                     builder.priority = Some(deser.read_integer(member)?);
-305
+                }
                 Some(8) => {
                     builder.role_arn = Some(deser.read_string(member)?);
-308
+                }
                 Some(9) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::S3Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::S3Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-318
+                }
                 Some(10) => {
                     builder.manifest_generator = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                     builder.manifest_generator = Some(crate::types::JobManifestGenerator::deserialize(deser)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.account_id = builder.account_id.or(Some(String::new()));
         builder.client_request_token = builder.client_request_token.or(Some(String::new()));
         builder.priority = builder.priority.or(Some(0i32));
         builder.role_arn = builder.role_arn.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl CreateJobInput {
     /// 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-account-id") {
             builder.account_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEJOBINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.confirmation_required = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(2) => {
                     builder.operation = Some(crate::types::JobOperation::deserialize(deser)?);
-+
+                }
                 Some(3) => {
                     builder.report = Some(crate::types::JobReport::deserialize(deser)?);
-+
+                }
                 Some(4) => {
                     builder.client_request_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(5) => {
                     builder.manifest = Some(crate::types::JobManifest::deserialize(deser)?);
-+
+                }
                 Some(6) => {
                     builder.description = Some(deser.read_string(member)?);
-+
+                }
                 Some(7) => {
                     builder.priority = Some(deser.read_integer(member)?);
-+
+                }
                 Some(8) => {
                     builder.role_arn = Some(deser.read_string(member)?);
-+
+                }
                 Some(9) => {
                     builder.tags = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::S3Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-393
+                }
                 Some(10) => {
                     builder.manifest_generator = Some(crate::types::JobManifestGenerator::deserialize(deser)?);
-+
+                }
                 _ => {}
-398
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-404
+    }
-405
+}
 impl CreateJobInput {

↧ Expand context

     /// Creates a new builder-style object to manufacture [`CreateJobInput`](crate::operation::create_job::CreateJobInput).
     pub fn builder() -> crate::operation::create_job::builders::CreateJobInputBuilder {
         crate::operation::create_job::builders::CreateJobInputBuilder::default()
-410
+    }
-411
+}
-412
 /// A builder for [`CreateJobInput`](crate::operation::create_job::CreateJobInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateJobInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) confirmation_required: ::std::option::Option<bool>,
     pub(crate) operation: ::std::option::Option<crate::types::JobOperation>,
     pub(crate) report: ::std::option::Option<crate::types::JobReport>,
     pub(crate) client_request_token: ::std::option::Option<::std::string::String>,
     pub(crate) manifest: ::std::option::Option<crate::types::JobManifest>,
     pub(crate) description: ::std::option::Option<::std::string::String>,
     pub(crate) priority: ::std::option::Option<i32>,
     pub(crate) role_arn: ::std::option::Option<::std::string::String>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::S3Tag>>,

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_job/_create_job_output.rs

@@ -1,1 +96,140 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CreateJobOutput {
     /// <p>The ID for this job. Amazon S3 generates this ID automatically and returns it after a successful <code>Create Job</code> request.</p>
     pub job_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-9
+}
 impl CreateJobOutput {
     /// <p>The ID for this job. Amazon S3 generates this ID automatically and returns it after a successful <code>Create Job</code> request.</p>
     pub fn job_id(&self) -> ::std::option::Option<&str> {
         self.job_id.as_deref()
-14
+    }
-15
+}
 static CREATEJOBOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#CreateJobOutput",

     "com.amazonaws.s3control.synthetic",
     "CreateJobOutput",
 );
 static CREATEJOBOUTPUT_MEMBER_JOB_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateJobOutput$JobId",
         "com.amazonaws.s3control.synthetic",
         "CreateJobOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "job_id",
     "JobId",
 ,
 );
 static CREATEJOBOUTPUT_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 CREATEJOBOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEJOBOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CREATEJOBOUTPUT_MEMBER_JOB_ID],
     &[&CREATEJOBOUTPUT_MEMBER_JOB_ID, &CREATEJOBOUTPUT_MEMBER__REQUEST_ID],
 );
 impl CreateJobOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEJOBOUTPUT_SCHEMA;
-46
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateJobOutput {
     #[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.job_id {
             ser.write_string(&CREATEJOBOUTPUT_MEMBER_JOB_ID, val)?;
-55
+        }
         Ok(())
-57
+    }
-58
+}
 impl CreateJobOutput {
     /// 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(&CREATEJOBOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEJOBOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.job_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateJobOutput {
     /// 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());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEJOBOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.job_id = Some(deser.read_string(member)?);
-114
+                }
                 _ => {}
-116
+            }
             Ok(())
         })?;
         Ok(builder.build())
-120
+    }

↧ Expand context

-121
+}
 impl ::aws_types::request_id::RequestId for CreateJobOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-125
+    }
-126
+}
 impl CreateJobOutput {
     /// Creates a new builder-style object to manufacture [`CreateJobOutput`](crate::operation::create_job::CreateJobOutput).
     pub fn builder() -> crate::operation::create_job::builders::CreateJobOutputBuilder {
         crate::operation::create_job::builders::CreateJobOutputBuilder::default()
-131
+    }
-132
+}
-133
 /// A builder for [`CreateJobOutput`](crate::operation::create_job::CreateJobOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateJobOutputBuilder {
     pub(crate) job_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-140
+}

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_multi_region_access_point.rs

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

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

@@ -137,143 +196,203 @@

↥ Expand context

-143
+    }
-144
     fn runtime_components(
         &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("CreateMultiRegionAccessPoint")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateMultiRegionAccessPointEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointError,
             >::new());
-162

         ::std::borrow::Cow::Owned(rcb)
-164
+    }
-165
+}
-166
 #[derive(Debug)]
 struct CreateMultiRegionAccessPointResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateMultiRegionAccessPointResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_create_multi_region_access_point::de_create_multi_region_access_point_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_create_multi_region_access_point::de_create_multi_region_access_point_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-187
+    }
-188
+}
 #[derive(Debug)]
 struct CreateMultiRegionAccessPointRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateMultiRegionAccessPointRequestSerializer {
     #[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_multi_region_access_point::CreateMultiRegionAccessPointInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_multi_region_access_point/_create_multi_region_access_point_input.rs

@@ -9,9 +153,200 @@

↥ Expand context

     pub client_token: ::std::option::Option<::std::string::String>,
     /// <p>A container element containing details about the Multi-Region Access Point.</p>
     pub details: ::std::option::Option<crate::types::CreateMultiRegionAccessPointInput>,
-12
+}
 impl CreateMultiRegionAccessPointInput {
     /// <p>The Amazon Web Services account ID for the owner of the Multi-Region Access Point. The owner of the Multi-Region Access Point also must own the underlying buckets.</p>
     pub fn account_id(&self) -> ::std::option::Option<&str> {
         self.account_id.as_deref()
-17
+    }
     /// <p>An idempotency token used to identify the request and guarantee that requests are unique.</p>
     pub fn client_token(&self) -> ::std::option::Option<&str> {
         self.client_token.as_deref()
-21
+    }
     /// <p>A container element containing details about the Multi-Region Access Point.</p>
     pub fn details(&self) -> ::std::option::Option<&crate::types::CreateMultiRegionAccessPointInput> {
         self.details.as_ref()
-25
+    }
-26
+}
 static CREATEMULTIREGIONACCESSPOINTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#CreateMultiRegionAccessPointInput",

     "com.amazonaws.s3control.synthetic",
     "CreateMultiRegionAccessPointInput",
 );
 static CREATEMULTIREGIONACCESSPOINTINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateMultiRegionAccessPointInput$AccountId",
         "com.amazonaws.s3control.synthetic",
         "CreateMultiRegionAccessPointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "AccountId",
 ,
-41
+)
 .with_host_label()
 .with_http_header("x-amz-account-id");
 static CREATEMULTIREGIONACCESSPOINTINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateMultiRegionAccessPointInput$ClientToken",
         "com.amazonaws.s3control.synthetic",
         "CreateMultiRegionAccessPointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static CREATEMULTIREGIONACCESSPOINTINPUT_MEMBER_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateMultiRegionAccessPointInput$Details",
         "com.amazonaws.s3control.synthetic",
         "CreateMultiRegionAccessPointInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "details",
     "Details",
 ,
 );
 static CREATEMULTIREGIONACCESSPOINTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEMULTIREGIONACCESSPOINTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEMULTIREGIONACCESSPOINTINPUT_MEMBER_ACCOUNT_ID,
         &CREATEMULTIREGIONACCESSPOINTINPUT_MEMBER_CLIENT_TOKEN,
         &CREATEMULTIREGIONACCESSPOINTINPUT_MEMBER_DETAILS,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/v20180820/async-requests/mrap/create",
     None,
 ));
 impl CreateMultiRegionAccessPointInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEMULTIREGIONACCESSPOINTINPUT_SCHEMA;
-81
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateMultiRegionAccessPointInput {
     #[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.account_id {
             ser.write_string(&CREATEMULTIREGIONACCESSPOINTINPUT_MEMBER_ACCOUNT_ID, val)?;
-90
+        }
         if let Some(ref val) = self.client_token {
             ser.write_string(&CREATEMULTIREGIONACCESSPOINTINPUT_MEMBER_CLIENT_TOKEN, val)?;
-93
+        }
         if let Some(ref val) = self.details {
             ser.write_struct(&CREATEMULTIREGIONACCESSPOINTINPUT_MEMBER_DETAILS, val)?;
-96
+        }
         Ok(())
-98
+    }
-99
+}
 impl CreateMultiRegionAccessPointInput {
     /// 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(&CREATEMULTIREGIONACCESSPOINTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEMULTIREGIONACCESSPOINTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-118
+                }
                 Some(1) => {
                     builder.client_token = Some(deser.read_string(member)?);
-121
+                }
                 Some(2) => {
                     builder.details = Some(crate::types::CreateMultiRegionAccessPointInput::deserialize(deser)?);
-124
+                }
                 _ => {}
-126
+            }
             Ok(())
         })?;
         builder.account_id = builder.account_id.or(Some(String::new()));
         builder.client_token = builder.client_token.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl CreateMultiRegionAccessPointInput {
     /// 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-account-id") {
             builder.account_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEMULTIREGIONACCESSPOINTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.client_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.details = Some(crate::types::CreateMultiRegionAccessPointInput::deserialize(deser)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-174
+    }
-175
+}
 impl CreateMultiRegionAccessPointInput {
     /// Creates a new builder-style object to manufacture [`CreateMultiRegionAccessPointInput`](crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointInput).
     pub fn builder() -> crate::operation::create_multi_region_access_point::builders::CreateMultiRegionAccessPointInputBuilder {
         crate::operation::create_multi_region_access_point::builders::CreateMultiRegionAccessPointInputBuilder::default()
-180
+    }

↧ Expand context

-181
+}
-182
 /// A builder for [`CreateMultiRegionAccessPointInput`](crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateMultiRegionAccessPointInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) details: ::std::option::Option<crate::types::CreateMultiRegionAccessPointInput>,
-190
+}
 impl CreateMultiRegionAccessPointInputBuilder {
     /// <p>The Amazon Web Services account ID for the owner of the Multi-Region Access Point. The owner of the Multi-Region Access Point also must own the underlying buckets.</p>
     /// This field is required.
     pub fn account_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.account_id = ::std::option::Option::Some(input.into());
         self
-197
+    }
     /// <p>The Amazon Web Services account ID for the owner of the Multi-Region Access Point. The owner of the Multi-Region Access Point also must own the underlying buckets.</p>
     pub fn set_account_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.account_id = input;

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_multi_region_access_point/_create_multi_region_access_point_output.rs

@@ -1,1 +96,143 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CreateMultiRegionAccessPointOutput {
     /// <p>The request token associated with the request. You can use this token with <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeMultiRegionAccessPointOperation.html">DescribeMultiRegionAccessPointOperation</a> to determine the status of asynchronous requests.</p>
     pub request_token_arn: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-9
+}
 impl CreateMultiRegionAccessPointOutput {
     /// <p>The request token associated with the request. You can use this token with <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeMultiRegionAccessPointOperation.html">DescribeMultiRegionAccessPointOperation</a> to determine the status of asynchronous requests.</p>
     pub fn request_token_arn(&self) -> ::std::option::Option<&str> {
         self.request_token_arn.as_deref()
-14
+    }
-15
+}
 static CREATEMULTIREGIONACCESSPOINTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#CreateMultiRegionAccessPointOutput",

     "com.amazonaws.s3control.synthetic",
     "CreateMultiRegionAccessPointOutput",
 );
 static CREATEMULTIREGIONACCESSPOINTOUTPUT_MEMBER_REQUEST_TOKEN_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateMultiRegionAccessPointOutput$RequestTokenARN",
         "com.amazonaws.s3control.synthetic",
         "CreateMultiRegionAccessPointOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_token_arn",
     "RequestTokenARN",
 ,
 );
 static CREATEMULTIREGIONACCESSPOINTOUTPUT_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 CREATEMULTIREGIONACCESSPOINTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEMULTIREGIONACCESSPOINTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CREATEMULTIREGIONACCESSPOINTOUTPUT_MEMBER_REQUEST_TOKEN_ARN],
     &[
         &CREATEMULTIREGIONACCESSPOINTOUTPUT_MEMBER_REQUEST_TOKEN_ARN,
         &CREATEMULTIREGIONACCESSPOINTOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateMultiRegionAccessPointOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEMULTIREGIONACCESSPOINTOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateMultiRegionAccessPointOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.request_token_arn {
             ser.write_string(&CREATEMULTIREGIONACCESSPOINTOUTPUT_MEMBER_REQUEST_TOKEN_ARN, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl CreateMultiRegionAccessPointOutput {
     /// 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(&CREATEMULTIREGIONACCESSPOINTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEMULTIREGIONACCESSPOINTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_token_arn = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateMultiRegionAccessPointOutput {
     /// 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());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEMULTIREGIONACCESSPOINTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_token_arn = Some(deser.read_string(member)?);
-117
+                }
                 _ => {}
-119
+            }
             Ok(())
         })?;
         Ok(builder.build())
-123
+    }

↧ Expand context

-124
+}
 impl ::aws_types::request_id::RequestId for CreateMultiRegionAccessPointOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-128
+    }
-129
+}
 impl CreateMultiRegionAccessPointOutput {
     /// Creates a new builder-style object to manufacture [`CreateMultiRegionAccessPointOutput`](crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointOutput).
     pub fn builder() -> crate::operation::create_multi_region_access_point::builders::CreateMultiRegionAccessPointOutputBuilder {
         crate::operation::create_multi_region_access_point::builders::CreateMultiRegionAccessPointOutputBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`CreateMultiRegionAccessPointOutput`](crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateMultiRegionAccessPointOutputBuilder {
     pub(crate) request_token_arn: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-143
+}

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_storage_lens_group.rs

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

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

@@ -121,125 +180,185 @@

↥ Expand context

-125
+    }
-126
     fn runtime_components(
         &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("CreateStorageLensGroup")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateStorageLensGroupEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_storage_lens_group::CreateStorageLensGroupError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_storage_lens_group::CreateStorageLensGroupError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::create_storage_lens_group::CreateStorageLensGroupError,
             >::new());
-144

         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct CreateStorageLensGroupResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateStorageLensGroupResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_create_storage_lens_group::de_create_storage_lens_group_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_create_storage_lens_group::de_create_storage_lens_group_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-169
+    }
-170
+}
 #[derive(Debug)]
 struct CreateStorageLensGroupRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateStorageLensGroupRequestSerializer {
     #[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_storage_lens_group::CreateStorageLensGroupInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_storage_lens_group/_create_storage_lens_group_input.rs

@@ -11,11 +167,217 @@

↥ Expand context

     pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-12
+}
 impl CreateStorageLensGroupInput {
     /// <p>The Amazon Web Services account ID that the Storage Lens group is created from and associated with.</p>
     pub fn account_id(&self) -> ::std::option::Option<&str> {
         self.account_id.as_deref()
-17
+    }
     /// <p>The Storage Lens group configuration.</p>
     pub fn storage_lens_group(&self) -> ::std::option::Option<&crate::types::StorageLensGroup> {
         self.storage_lens_group.as_ref()
-21
+    }
     /// <p>The Amazon Web Services resource tags that you're adding to your Storage Lens group. This parameter is optional.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-27
+    }
-28
+}
 static CREATESTORAGELENSGROUPINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#CreateStorageLensGroupInput",

     "com.amazonaws.s3control.synthetic",
     "CreateStorageLensGroupInput",
 );
 static CREATESTORAGELENSGROUPINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateStorageLensGroupInput$AccountId",
         "com.amazonaws.s3control.synthetic",
         "CreateStorageLensGroupInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "AccountId",
 ,
-43
+)
 .with_host_label()
 .with_http_header("x-amz-account-id");
 static CREATESTORAGELENSGROUPINPUT_MEMBER_STORAGE_LENS_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateStorageLensGroupInput$StorageLensGroup",
         "com.amazonaws.s3control.synthetic",
         "CreateStorageLensGroupInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "storage_lens_group",
     "StorageLensGroup",
 ,
 );
 static CREATESTORAGELENSGROUPINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#CreateStorageLensGroupInput$Tags",
         "com.amazonaws.s3control.synthetic",
         "CreateStorageLensGroupInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
 );
 static CREATESTORAGELENSGROUPINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATESTORAGELENSGROUPINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATESTORAGELENSGROUPINPUT_MEMBER_ACCOUNT_ID,
         &CREATESTORAGELENSGROUPINPUT_MEMBER_STORAGE_LENS_GROUP,
         &CREATESTORAGELENSGROUPINPUT_MEMBER_TAGS,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/v20180820/storagelensgroup",
     Some(204),
 ));
 impl CreateStorageLensGroupInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATESTORAGELENSGROUPINPUT_SCHEMA;
-83
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateStorageLensGroupInput {
     #[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.account_id {
             ser.write_string(&CREATESTORAGELENSGROUPINPUT_MEMBER_ACCOUNT_ID, val)?;
-92
+        }
         if let Some(ref val) = self.storage_lens_group {
             ser.write_struct(&CREATESTORAGELENSGROUPINPUT_MEMBER_STORAGE_LENS_GROUP, val)?;
-95
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &CREATESTORAGELENSGROUPINPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-102
+                    }
                     Ok(())
                 },
             )?;
-106
+        }
         Ok(())
-108
+    }
-109
+}
 impl CreateStorageLensGroupInput {
     /// 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(&CREATESTORAGELENSGROUPINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATESTORAGELENSGROUPINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-128
+                }
                 Some(1) => {
                     builder.storage_lens_group = Some(crate::types::StorageLensGroup::deserialize(deser)?);
-131
+                }
                 Some(2) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.account_id = builder.account_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl CreateStorageLensGroupInput {
     /// 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-account-id") {
             builder.account_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATESTORAGELENSGROUPINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.storage_lens_group = Some(crate::types::StorageLensGroup::deserialize(deser)?);
-+
+                }
                 Some(2) => {
                     builder.tags = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-189
+                }
                 _ => {}
-191
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-197
+    }

↧ Expand context

-198
+}
 impl CreateStorageLensGroupInput {
     /// Creates a new builder-style object to manufacture [`CreateStorageLensGroupInput`](crate::operation::create_storage_lens_group::CreateStorageLensGroupInput).
     pub fn builder() -> crate::operation::create_storage_lens_group::builders::CreateStorageLensGroupInputBuilder {
         crate::operation::create_storage_lens_group::builders::CreateStorageLensGroupInputBuilder::default()
-203
+    }
-204
+}
-205
 /// A builder for [`CreateStorageLensGroupInput`](crate::operation::create_storage_lens_group::CreateStorageLensGroupInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateStorageLensGroupInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) storage_lens_group: ::std::option::Option<crate::types::StorageLensGroup>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-213
+}
 impl CreateStorageLensGroupInputBuilder {
     /// <p>The Amazon Web Services account ID that the Storage Lens group is created from and associated with.</p>
     /// This field is required.
     pub fn account_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_storage_lens_group/_create_storage_lens_group_output.rs

@@ -1,1 +80,111 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CreateStorageLensGroupOutput {
     _request_id: Option<String>,
-7
+}
 static CREATESTORAGELENSGROUPOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#CreateStorageLensGroupOutput",
     "com.amazonaws.s3control.synthetic",
     "CreateStorageLensGroupOutput",
 );
 static CREATESTORAGELENSGROUPOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(CREATESTORAGELENSGROUPOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static CREATESTORAGELENSGROUPOUTPUT_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 CREATESTORAGELENSGROUPOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATESTORAGELENSGROUPOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CREATESTORAGELENSGROUPOUTPUT_MEMBER__REQUEST_ID],
 );
 impl CreateStorageLensGroupOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATESTORAGELENSGROUPOUTPUT_SCHEMA;
-28
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateStorageLensGroupOutput {
     #[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(())
-36
+    }
-37
+}
 impl CreateStorageLensGroupOutput {
     /// 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(&CREATESTORAGELENSGROUPOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATESTORAGELENSGROUPOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-58
+            }
             Ok(())
         })?;
         Ok(builder.build())
-62
+    }
-63
+}
 impl CreateStorageLensGroupOutput {
     /// 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 ::aws_types::request_id::RequestId for CreateStorageLensGroupOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-85
+    }
-86
+}
 impl CreateStorageLensGroupOutput {
     /// Creates a new builder-style object to manufacture [`CreateStorageLensGroupOutput`](crate::operation::create_storage_lens_group::CreateStorageLensGroupOutput).
     pub fn builder() -> crate::operation::create_storage_lens_group::builders::CreateStorageLensGroupOutputBuilder {
         crate::operation::create_storage_lens_group::builders::CreateStorageLensGroupOutputBuilder::default()
-91
+    }

↧ Expand context

-92
+}
-93
 /// A builder for [`CreateStorageLensGroupOutput`](crate::operation::create_storage_lens_group::CreateStorageLensGroupOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateStorageLensGroupOutputBuilder {
     _request_id: Option<String>,
-99
+}
 impl CreateStorageLensGroupOutputBuilder {
     pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         self._request_id = Some(request_id.into());
         self
-104
+    }
-105
     pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         self._request_id = request_id;
         self
-109
+    }
     /// Consumes the builder and constructs a [`CreateStorageLensGroupOutput`](crate::operation::create_storage_lens_group::CreateStorageLensGroupOutput).
     pub fn build(self) -> crate::operation::create_storage_lens_group::CreateStorageLensGroupOutput {

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/delete_access_grant.rs

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

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

@@ -121,125 +180,185 @@

↥ Expand context

-125
+    }
-126
     fn runtime_components(
         &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("DeleteAccessGrant")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteAccessGrantEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_access_grant::DeleteAccessGrantError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_access_grant::DeleteAccessGrantError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::delete_access_grant::DeleteAccessGrantError,
             >::new());
-144

         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct DeleteAccessGrantResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteAccessGrantResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_delete_access_grant::de_delete_access_grant_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_delete_access_grant::de_delete_access_grant_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-169
+    }
-170
+}
 #[derive(Debug)]
 struct DeleteAccessGrantRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DeleteAccessGrantRequestSerializer {
     #[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::delete_access_grant::DeleteAccessGrantInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/delete_access_grant/_delete_access_grant_input.rs

@@ -3,3 +128,172 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct DeleteAccessGrantInput {
     /// <p>The Amazon Web Services account ID of the S3 Access Grants instance.</p>
     pub account_id: ::std::option::Option<::std::string::String>,
     /// <p>The ID of the access grant. S3 Access Grants auto-generates this ID when you create the access grant.</p>
     pub access_grant_id: ::std::option::Option<::std::string::String>,
-10
+}
 impl DeleteAccessGrantInput {
     /// <p>The Amazon Web Services account ID of the S3 Access Grants instance.</p>
     pub fn account_id(&self) -> ::std::option::Option<&str> {
         self.account_id.as_deref()
-15
+    }
     /// <p>The ID of the access grant. S3 Access Grants auto-generates this ID when you create the access grant.</p>
     pub fn access_grant_id(&self) -> ::std::option::Option<&str> {
         self.access_grant_id.as_deref()
-19
+    }
-20
+}
 static DELETEACCESSGRANTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#DeleteAccessGrantInput",

     "com.amazonaws.s3control.synthetic",
     "DeleteAccessGrantInput",
 );
 static DELETEACCESSGRANTINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#DeleteAccessGrantInput$AccountId",
         "com.amazonaws.s3control.synthetic",
         "DeleteAccessGrantInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "AccountId",
 ,
-35
+)
 .with_host_label()
 .with_http_header("x-amz-account-id");
 static DELETEACCESSGRANTINPUT_MEMBER_ACCESS_GRANT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#DeleteAccessGrantInput$AccessGrantId",
         "com.amazonaws.s3control.synthetic",
         "DeleteAccessGrantInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "access_grant_id",
     "AccessGrantId",
 ,
-47
+)
 .with_http_label();
 static DELETEACCESSGRANTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETEACCESSGRANTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DELETEACCESSGRANTINPUT_MEMBER_ACCOUNT_ID, &DELETEACCESSGRANTINPUT_MEMBER_ACCESS_GRANT_ID],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "DELETE",
     "/v20180820/accessgrantsinstance/grant/{AccessGrantId}",
     None,
 ));
 impl DeleteAccessGrantInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEACCESSGRANTINPUT_SCHEMA;
-62
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeleteAccessGrantInput {
     #[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.account_id {
             ser.write_string(&DELETEACCESSGRANTINPUT_MEMBER_ACCOUNT_ID, val)?;
-71
+        }
         if let Some(ref val) = self.access_grant_id {
             ser.write_string(&DELETEACCESSGRANTINPUT_MEMBER_ACCESS_GRANT_ID, val)?;
-74
+        }
         Ok(())
-76
+    }
-77
+}
 impl DeleteAccessGrantInput {
     /// 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(&DELETEACCESSGRANTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETEACCESSGRANTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-96
+                }
                 Some(1) => {
                     builder.access_grant_id = Some(deser.read_string(member)?);
-99
+                }
                 _ => {}
-101
+            }
             Ok(())
         })?;
         builder.account_id = builder.account_id.or(Some(String::new()));
         builder.access_grant_id = builder.access_grant_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl DeleteAccessGrantInput {
     /// 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-account-id") {
             builder.account_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&DELETEACCESSGRANTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.access_grant_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-146
+    }
-147
+}
 impl DeleteAccessGrantInput {
     /// Creates a new builder-style object to manufacture [`DeleteAccessGrantInput`](crate::operation::delete_access_grant::DeleteAccessGrantInput).
     pub fn builder() -> crate::operation::delete_access_grant::builders::DeleteAccessGrantInputBuilder {
         crate::operation::delete_access_grant::builders::DeleteAccessGrantInputBuilder::default()
-152
+    }

↧ Expand context

-153
+}
-154
 /// A builder for [`DeleteAccessGrantInput`](crate::operation::delete_access_grant::DeleteAccessGrantInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct DeleteAccessGrantInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) access_grant_id: ::std::option::Option<::std::string::String>,
-161
+}
 impl DeleteAccessGrantInputBuilder {
     /// <p>The Amazon Web Services account ID of the S3 Access Grants instance.</p>
     /// This field is required.
     pub fn account_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.account_id = ::std::option::Option::Some(input.into());
         self
-168
+    }
     /// <p>The Amazon Web Services account ID of the S3 Access Grants instance.</p>
     pub fn set_account_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.account_id = input;
         self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/delete_access_grant/_delete_access_grant_output.rs

@@ -1,1 +80,111 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct DeleteAccessGrantOutput {
     _request_id: Option<String>,
-7
+}
 static DELETEACCESSGRANTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#DeleteAccessGrantOutput",
     "com.amazonaws.s3control.synthetic",
     "DeleteAccessGrantOutput",
 );
 static DELETEACCESSGRANTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(DELETEACCESSGRANTOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static DELETEACCESSGRANTOUTPUT_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 DELETEACCESSGRANTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETEACCESSGRANTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DELETEACCESSGRANTOUTPUT_MEMBER__REQUEST_ID],
 );
 impl DeleteAccessGrantOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEACCESSGRANTOUTPUT_SCHEMA;
-28
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeleteAccessGrantOutput {
     #[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(())
-36
+    }
-37
+}
 impl DeleteAccessGrantOutput {
     /// 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(&DELETEACCESSGRANTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETEACCESSGRANTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-58
+            }
             Ok(())
         })?;
         Ok(builder.build())
-62
+    }
-63
+}
 impl DeleteAccessGrantOutput {
     /// 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 ::aws_types::request_id::RequestId for DeleteAccessGrantOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-85
+    }
-86
+}
 impl DeleteAccessGrantOutput {
     /// Creates a new builder-style object to manufacture [`DeleteAccessGrantOutput`](crate::operation::delete_access_grant::DeleteAccessGrantOutput).
     pub fn builder() -> crate::operation::delete_access_grant::builders::DeleteAccessGrantOutputBuilder {
         crate::operation::delete_access_grant::builders::DeleteAccessGrantOutputBuilder::default()
-91
+    }

↧ Expand context

-92
+}
-93
 /// A builder for [`DeleteAccessGrantOutput`](crate::operation::delete_access_grant::DeleteAccessGrantOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct DeleteAccessGrantOutputBuilder {
     _request_id: Option<String>,
-99
+}
 impl DeleteAccessGrantOutputBuilder {
     pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         self._request_id = Some(request_id.into());
         self
-104
+    }
-105
     pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         self._request_id = request_id;
         self
-109
+    }
     /// Consumes the builder and constructs a [`DeleteAccessGrantOutput`](crate::operation::delete_access_grant::DeleteAccessGrantOutput).
     pub fn build(self) -> crate::operation::delete_access_grant::DeleteAccessGrantOutput {

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/delete_access_grants_instance.rs

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

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

@@ -127,133 +186,193 @@

↥ Expand context

-133
+    }
-134
     fn runtime_components(
         &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("DeleteAccessGrantsInstance")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteAccessGrantsInstanceEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_access_grants_instance::DeleteAccessGrantsInstanceError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_access_grants_instance::DeleteAccessGrantsInstanceError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::delete_access_grants_instance::DeleteAccessGrantsInstanceError,
             >::new());
-152

         ::std::borrow::Cow::Owned(rcb)
-154
+    }
-155
+}
-156
 #[derive(Debug)]
 struct DeleteAccessGrantsInstanceResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteAccessGrantsInstanceResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_delete_access_grants_instance::de_delete_access_grants_instance_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_delete_access_grants_instance::de_delete_access_grants_instance_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-177
+    }
-178
+}
 #[derive(Debug)]
 struct DeleteAccessGrantsInstanceRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DeleteAccessGrantsInstanceRequestSerializer {
     #[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::delete_access_grants_instance::DeleteAccessGrantsInstanceInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/delete_access_grants_instance/_delete_access_grants_instance_input.rs

@@ -1,1 +105,131 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct DeleteAccessGrantsInstanceInput {
     /// <p>The Amazon Web Services account ID of the S3 Access Grants instance.</p>
     pub account_id: ::std::option::Option<::std::string::String>,
-8
+}
 impl DeleteAccessGrantsInstanceInput {
     /// <p>The Amazon Web Services account ID of the S3 Access Grants instance.</p>
     pub fn account_id(&self) -> ::std::option::Option<&str> {
         self.account_id.as_deref()
-13
+    }
-14
+}
 static DELETEACCESSGRANTSINSTANCEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3control.synthetic#DeleteAccessGrantsInstanceInput",

     "com.amazonaws.s3control.synthetic",
     "DeleteAccessGrantsInstanceInput",
 );
 static DELETEACCESSGRANTSINSTANCEINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3control.synthetic#DeleteAccessGrantsInstanceInput$AccountId",
         "com.amazonaws.s3control.synthetic",
         "DeleteAccessGrantsInstanceInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "AccountId",
 ,
-29
+)
 .with_host_label()
 .with_http_header("x-amz-account-id");
 static DELETEACCESSGRANTSINSTANCEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETEACCESSGRANTSINSTANCEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DELETEACCESSGRANTSINSTANCEINPUT_MEMBER_ACCOUNT_ID],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "DELETE",
     "/v20180820/accessgrantsinstance",
     None,
 ));
 impl DeleteAccessGrantsInstanceInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEACCESSGRANTSINSTANCEINPUT_SCHEMA;
-45
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeleteAccessGrantsInstanceInput {
     #[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.account_id {
             ser.write_string(&DELETEACCESSGRANTSINSTANCEINPUT_MEMBER_ACCOUNT_ID, val)?;
-54
+        }
         Ok(())
-56
+    }
-57
+}
 impl DeleteAccessGrantsInstanceInput {
     /// 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(&DELETEACCESSGRANTSINSTANCEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETEACCESSGRANTSINSTANCEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-76
+                }
                 _ => {}
-78
+            }
             Ok(())
         })?;
         builder.account_id = builder.account_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl DeleteAccessGrantsInstanceInput {
     /// 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-account-id") {
             builder.account_id = Some(val.to_string());
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-105
+    }
-106
+}
 impl DeleteAccessGrantsInstanceInput {
     /// Creates a new builder-style object to manufacture [`DeleteAccessGrantsInstanceInput`](crate::operation::delete_access_grants_instance::DeleteAccessGrantsInstanceInput).
     pub fn builder() -> crate::operation::delete_access_grants_instance::builders::DeleteAccessGrantsInstanceInputBuilder {
         crate::operation::delete_access_grants_instance::builders::DeleteAccessGrantsInstanceInputBuilder::default()
-111
+    }

↧ Expand context

-112
+}
-113
 /// A builder for [`DeleteAccessGrantsInstanceInput`](crate::operation::delete_access_grants_instance::DeleteAccessGrantsInstanceInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct DeleteAccessGrantsInstanceInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
-119
+}
 impl DeleteAccessGrantsInstanceInputBuilder {
     /// <p>The Amazon Web Services account ID of the S3 Access Grants instance.</p>
     /// This field is required.
     pub fn account_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.account_id = ::std::option::Option::Some(input.into());
         self
-126
+    }
     /// <p>The Amazon Web Services account ID of the S3 Access Grants instance.</p>
     pub fn set_account_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.account_id = input;
         self
-131
+    }

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

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

AWS SDK

Files changed: