AWS SDK

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_error.rs

@@ -1955,1955 +2100,2111 @@

     /// <p><i>HTTP Status Code:</i> 400 Bad Request</p></li>
     /// <li>
     /// <p><i>SOAP Fault Code Prefix:</i> Client</p></li>
     /// </ul></li>
     /// <li>
     /// <ul>
     /// <li>
     /// <p><i>Code:</i> UserKeyMustBeSpecified</p></li>
     /// <li>
     /// <p><i>Description:</i> The bucket POST must contain the specified field name. If it is specified, check the order of the fields.</p></li>
     /// <li>
     /// <p><i>HTTP Status Code:</i> 400 Bad Request</p></li>
     /// <li>
     /// <p><i>SOAP Fault Code Prefix:</i> Client</p></li>
     /// </ul></li>
     /// </ul>
     /// <p></p>
     pub fn code(&self) -> ::std::option::Option<&str> {
         self.code.as_deref()
-1974
+    }

     /// <p>The error message contains a generic description of the error condition in English. It is intended for a human audience. Simple programs display the message directly to the end user if they encounter an error condition they don't know how or don't care to handle. Sophisticated programs with more exhaustive error handling and proper internationalization are more likely to ignore the error message.</p>
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-1978
+    }
-1979
+}
 static ERROR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Error", "com.amazonaws.s3", "Error");
 static ERROR_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Error$Key", "com.amazonaws.s3", "Error"),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
 );
 static ERROR_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Error$VersionId", "com.amazonaws.s3", "Error"),
     ::aws_smithy_schema::ShapeType::String,
     "version_id",
     "VersionId",
 ,
 );
 static ERROR_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Error$Code", "com.amazonaws.s3", "Error"),
     ::aws_smithy_schema::ShapeType::String,
     "code",
     "Code",
 ,
 );
 static ERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Error$Message", "com.amazonaws.s3", "Error"),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static ERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ERROR_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ERROR_MEMBER_KEY, &ERROR_MEMBER_VERSION_ID, &ERROR_MEMBER_CODE, &ERROR_MEMBER_MESSAGE],
 );
 impl Error {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ERROR_SCHEMA;
-2014
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Error {
     #[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.key {
             ser.write_string(&ERROR_MEMBER_KEY, val)?;
-2023
+        }
         if let Some(ref val) = self.version_id {
             ser.write_string(&ERROR_MEMBER_VERSION_ID, val)?;
-2026
+        }
         if let Some(ref val) = self.code {
             ser.write_string(&ERROR_MEMBER_CODE, val)?;
-2029
+        }
         if let Some(ref val) = self.message {
             ser.write_string(&ERROR_MEMBER_MESSAGE, val)?;
-2032
+        }
         Ok(())
-2034
+    }
-2035
+}
 impl Error {
     /// 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(&ERROR_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ERROR_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.key = Some(deser.read_string(member)?);
-2054
+                }
                 Some(1) => {
                     builder.version_id = Some(deser.read_string(member)?);
-2057
+                }
                 Some(2) => {
                     builder.code = Some(deser.read_string(member)?);
-2060
+                }
                 Some(3) => {
                     builder.message = Some(deser.read_string(member)?);
-2063
+                }
                 _ => {}
-2065
+            }
             Ok(())
         })?;
         Ok(builder.build())
-2069
+    }
-2070
+}
 impl Error {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Error {
     /// Creates a new builder-style object to manufacture [`Error`](crate::types::Error).
     pub fn builder() -> crate::types::builders::ErrorBuilder {
         crate::types::builders::ErrorBuilder::default()
-2086
+    }
-2087
+}
-2088
 /// A builder for [`Error`](crate::types::Error).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ErrorBuilder {
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) version_id: ::std::option::Option<::std::string::String>,
     pub(crate) code: ::std::option::Option<::std::string::String>,
     pub(crate) message: ::std::option::Option<::std::string::String>,
-2097
+}
 impl ErrorBuilder {
     /// <p>The error key.</p>
     pub fn key(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.key = ::std::option::Option::Some(input.into());
         self
-2103
+    }
     /// <p>The error key.</p>
     pub fn set_key(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.key = input;
         self
-2108
+    }
     /// <p>The error key.</p>
     pub fn get_key(&self) -> &::std::option::Option<::std::string::String> {
         &self.key

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_error_details.rs

@@ -131,131 +252,263 @@

↥ Expand context

     /// <p><code>TableBucketNotFound</code> - The table bucket that you specified doesn't exist in this Amazon Web Services Region and account. Create or choose a different table bucket. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// </ul>
     /// <p>If the V2 <code>CreateBucketMetadataConfiguration</code> request succeeds, but S3 Metadata was unable to create the table, this structure contains the error code. The possible error codes and error messages are as follows:</p>
     /// <ul>
     /// <li>
     /// <p><code>AccessDeniedCreatingResources</code> - You don't have sufficient permissions to create the required resources. Make sure that you have <code>s3tables:CreateTableBucket</code>, <code>s3tables:CreateNamespace</code>, <code>s3tables:CreateTable</code>, <code>s3tables:GetTable</code>, <code>s3tables:PutTablePolicy</code>, <code>kms:DescribeKey</code>, and <code>s3tables:PutTableEncryption</code> permissions. Additionally, ensure that the KMS key used to encrypt the table still exists, is active and has a resource policy granting access to the S3 service principals '<code>maintenance.s3tables.amazonaws.com</code>' and '<code>metadata.s3.amazonaws.com</code>'. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>AccessDeniedWritingToTable</code> - Unable to write to the metadata table because of missing resource permissions. To fix the resource policy, Amazon S3 needs to create a new metadata table. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>DestinationTableNotFound</code> - The destination table doesn't exist. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>ServerInternalError</code> - An internal error has occurred. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>JournalTableAlreadyExists</code> - A journal table already exists in the Amazon Web Services managed table bucket's namespace. Delete the journal table, and then try again. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>InventoryTableAlreadyExists</code> - An inventory table already exists in the Amazon Web Services managed table bucket's namespace. Delete the inventory table, and then try again. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>JournalTableNotAvailable</code> - The journal table that the inventory table relies on has a <code>FAILED</code> status. An inventory table requires a journal table with an <code>ACTIVE</code> status. To create a new journal or inventory table, you must delete the metadata configuration for this bucket, along with any journal or inventory tables, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>NoSuchBucket</code> - The specified general purpose bucket does not exist.</p></li>

     /// </ul>
     pub fn error_message(&self) -> ::std::option::Option<&str> {
         self.error_message.as_deref()
-154
+    }
-155
+}
 static ERRORDETAILS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ErrorDetails", "com.amazonaws.s3", "ErrorDetails");
 static ERRORDETAILS_MEMBER_ERROR_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ErrorDetails$ErrorCode", "com.amazonaws.s3", "ErrorDetails"),
     ::aws_smithy_schema::ShapeType::String,
     "error_code",
     "ErrorCode",
 ,
 );
 static ERRORDETAILS_MEMBER_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ErrorDetails$ErrorMessage", "com.amazonaws.s3", "ErrorDetails"),
     ::aws_smithy_schema::ShapeType::String,
     "error_message",
     "ErrorMessage",
 ,
 );
 static ERRORDETAILS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ERRORDETAILS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ERRORDETAILS_MEMBER_ERROR_CODE, &ERRORDETAILS_MEMBER_ERROR_MESSAGE],
 );
 impl ErrorDetails {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ERRORDETAILS_SCHEMA;
-178
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ErrorDetails {
     #[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.error_code {
             ser.write_string(&ERRORDETAILS_MEMBER_ERROR_CODE, val)?;
-187
+        }
         if let Some(ref val) = self.error_message {
             ser.write_string(&ERRORDETAILS_MEMBER_ERROR_MESSAGE, val)?;
-190
+        }
         Ok(())
-192
+    }
-193
+}
 impl ErrorDetails {
     /// 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(&ERRORDETAILS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ERRORDETAILS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.error_code = Some(deser.read_string(member)?);
-212
+                }
                 Some(1) => {
                     builder.error_message = Some(deser.read_string(member)?);
-215
+                }
                 _ => {}
-217
+            }
             Ok(())
         })?;
         Ok(builder.build())
-221
+    }
-222
+}
 impl ErrorDetails {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ErrorDetails {
     /// Creates a new builder-style object to manufacture [`ErrorDetails`](crate::types::ErrorDetails).
     pub fn builder() -> crate::types::builders::ErrorDetailsBuilder {
         crate::types::builders::ErrorDetailsBuilder::default()
-238
+    }
-239
+}
-240
 /// A builder for [`ErrorDetails`](crate::types::ErrorDetails).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ErrorDetailsBuilder {
     pub(crate) error_code: ::std::option::Option<::std::string::String>,
     pub(crate) error_message: ::std::option::Option<::std::string::String>,
-247
+}
 impl ErrorDetailsBuilder {
     /// <p>If the V1 <code>CreateBucketMetadataTableConfiguration</code> request succeeds, but S3 Metadata was unable to create the table, this structure contains the error code. The possible error codes and error messages are as follows:</p>
     /// <ul>
     /// <li>
     /// <p><code>AccessDeniedCreatingResources</code> - You don't have sufficient permissions to create the required resources. Make sure that you have <code>s3tables:CreateNamespace</code>, <code>s3tables:CreateTable</code>, <code>s3tables:GetTable</code> and <code>s3tables:PutTablePolicy</code> permissions, and then try again. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>AccessDeniedWritingToTable</code> - Unable to write to the metadata table because of missing resource permissions. To fix the resource policy, Amazon S3 needs to create a new metadata table. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>DestinationTableNotFound</code> - The destination table doesn't exist. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>ServerInternalError</code> - An internal error has occurred. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>TableAlreadyExists</code> - The table that you specified already exists in the table bucket's namespace. Specify a different table name. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// <li>
     /// <p><code>TableBucketNotFound</code> - The table bucket that you specified doesn't exist in this Amazon Web Services Region and account. Create or choose a different table bucket. To create a new metadata table, you must delete the metadata configuration for this bucket, and then create a new metadata configuration.</p></li>
     /// </ul>

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_error_document.rs

@@ -1,1 +108,120 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The error information.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ErrorDocument {
     /// <p>The object key name to use when a 4XX class error occurs.</p><important>
     /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
     /// </important>
     pub key: ::std::string::String,
-11
+}
 impl ErrorDocument {
     /// <p>The object key name to use when a 4XX class error occurs.</p><important>
     /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
     /// </important>

     pub fn key(&self) -> &str {
         use std::ops::Deref;
         self.key.deref()
-19
+    }
-20
+}
 static ERRORDOCUMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ErrorDocument", "com.amazonaws.s3", "ErrorDocument");
 static ERRORDOCUMENT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ErrorDocument$Key", "com.amazonaws.s3", "ErrorDocument"),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
 );
 static ERRORDOCUMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ERRORDOCUMENT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ERRORDOCUMENT_MEMBER_KEY],
 );
 impl ErrorDocument {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ERRORDOCUMENT_SCHEMA;
-37
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ErrorDocument {
     #[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> {
-44
+        {
             let val = &self.key;
             ser.write_string(&ERRORDOCUMENT_MEMBER_KEY, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl ErrorDocument {
     /// 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(&ERRORDOCUMENT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ERRORDOCUMENT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.key = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder.key = builder.key.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-78
+    }
-79
+}
 impl ErrorDocument {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ErrorDocument {
     /// Creates a new builder-style object to manufacture [`ErrorDocument`](crate::types::ErrorDocument).
     pub fn builder() -> crate::types::builders::ErrorDocumentBuilder {
         crate::types::builders::ErrorDocumentBuilder::default()
-95
+    }
-96
+}
-97
 /// A builder for [`ErrorDocument`](crate::types::ErrorDocument).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ErrorDocumentBuilder {
     pub(crate) key: ::std::option::Option<::std::string::String>,
-103
+}
 impl ErrorDocumentBuilder {
     /// <p>The object key name to use when a 4XX class error occurs.</p><important>
     /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
     /// </important>
     /// This field is required.
     pub fn key(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.key = ::std::option::Option::Some(input.into());
         self
-112
+    }
     /// <p>The object key name to use when a 4XX class error occurs.</p><important>
     /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
     /// </important>
     pub fn set_key(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.key = input;
         self
-119
+    }
     /// <p>The object key name to use when a 4XX class error occurs.</p><important>

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_event_bridge_configuration.rs

@@ -1,1 +66,77 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>A container for specifying the configuration for Amazon EventBridge.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct EventBridgeConfiguration {}
 static EVENTBRIDGECONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3#EventBridgeConfiguration",
     "com.amazonaws.s3",
     "EventBridgeConfiguration",
 );
 static EVENTBRIDGECONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(EVENTBRIDGECONFIGURATION_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl EventBridgeConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EVENTBRIDGECONFIGURATION_SCHEMA;
-17
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EventBridgeConfiguration {

     #[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(())
-25
+    }
-26
+}
 impl EventBridgeConfiguration {
     /// 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(&EVENTBRIDGECONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EVENTBRIDGECONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-44
+            }
             Ok(())
         })?;
         Ok(builder.build())
-48
+    }
-49
+}
 impl EventBridgeConfiguration {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Ok(Self::builder().build())
-+
+    }
-+
+}
 impl EventBridgeConfiguration {
     /// Creates a new builder-style object to manufacture [`EventBridgeConfiguration`](crate::types::EventBridgeConfiguration).
     pub fn builder() -> crate::types::builders::EventBridgeConfigurationBuilder {
         crate::types::builders::EventBridgeConfigurationBuilder::default()
-65
+    }
-66
+}
-67
 /// A builder for [`EventBridgeConfiguration`](crate::types::EventBridgeConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EventBridgeConfigurationBuilder {}
 impl EventBridgeConfigurationBuilder {
     /// Consumes the builder and constructs a [`EventBridgeConfiguration`](crate::types::EventBridgeConfiguration).
     pub fn build(self) -> crate::types::EventBridgeConfiguration {
         crate::types::EventBridgeConfiguration {}
-76
+    }
-77
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_existing_object_replication.rs

@@ -1,1 +112,123 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Optional configuration to replicate existing source bucket objects.</p><note>
 /// <p>This parameter is no longer supported. To replicate existing objects, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-batch-replication-batch.html">Replicating existing objects with S3 Batch Replication</a> in the <i>Amazon S3 User Guide</i>.</p>
 /// </note>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ExistingObjectReplication {
     /// <p>Specifies whether Amazon S3 replicates existing source bucket objects.</p>
     pub status: crate::types::ExistingObjectReplicationStatus,
-11
+}
 impl ExistingObjectReplication {
     /// <p>Specifies whether Amazon S3 replicates existing source bucket objects.</p>
     pub fn status(&self) -> &crate::types::ExistingObjectReplicationStatus {
         &self.status
-16
+    }
-17
+}
 static EXISTINGOBJECTREPLICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3#ExistingObjectReplication",

     "com.amazonaws.s3",
     "ExistingObjectReplication",
 );
 static EXISTINGOBJECTREPLICATION_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#ExistingObjectReplication$Status",
         "com.amazonaws.s3",
         "ExistingObjectReplication",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status",
     "Status",
 ,
 );
 static EXISTINGOBJECTREPLICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EXISTINGOBJECTREPLICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&EXISTINGOBJECTREPLICATION_MEMBER_STATUS],
 );
 impl ExistingObjectReplication {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXISTINGOBJECTREPLICATION_SCHEMA;
-41
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ExistingObjectReplication {
     #[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> {
-48
+        {
             let val = &self.status;
             ser.write_string(&EXISTINGOBJECTREPLICATION_MEMBER_STATUS, val.as_str())?;
-51
+        }
         Ok(())
-53
+    }
-54
+}
 impl ExistingObjectReplication {
     /// 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(&EXISTINGOBJECTREPLICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EXISTINGOBJECTREPLICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.status = Some(crate::types::ExistingObjectReplicationStatus::from(deser.read_string(member)?.as_str()));
-73
+                }
                 _ => {}
-75
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-81
+    }
-82
+}
 impl ExistingObjectReplication {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ExistingObjectReplication {
     /// Creates a new builder-style object to manufacture [`ExistingObjectReplication`](crate::types::ExistingObjectReplication).
     pub fn builder() -> crate::types::builders::ExistingObjectReplicationBuilder {
         crate::types::builders::ExistingObjectReplicationBuilder::default()
-98
+    }
-99
+}
-100
 /// A builder for [`ExistingObjectReplication`](crate::types::ExistingObjectReplication).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ExistingObjectReplicationBuilder {
     pub(crate) status: ::std::option::Option<crate::types::ExistingObjectReplicationStatus>,
-106
+}
 impl ExistingObjectReplicationBuilder {
     /// <p>Specifies whether Amazon S3 replicates existing source bucket objects.</p>
     /// This field is required.
     pub fn status(mut self, input: crate::types::ExistingObjectReplicationStatus) -> Self {
         self.status = ::std::option::Option::Some(input);
         self
-113
+    }
     /// <p>Specifies whether Amazon S3 replicates existing source bucket objects.</p>
     pub fn set_status(mut self, input: ::std::option::Option<crate::types::ExistingObjectReplicationStatus>) -> Self {
         self.status = input;
         self
-118
+    }
     /// <p>Specifies whether Amazon S3 replicates existing source bucket objects.</p>
     pub fn get_status(&self) -> &::std::option::Option<crate::types::ExistingObjectReplicationStatus> {
         &self.status
-122
+    }
     /// Consumes the builder and constructs a [`ExistingObjectReplication`](crate::types::ExistingObjectReplication).

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_filter_rule.rs

@@ -1,1 +118,129 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Specifies the Amazon S3 object key name to filter on. An object key name is the name assigned to an object in your Amazon S3 bucket. You specify whether to filter on the suffix or prefix of the object key name. A prefix is a specific string of characters at the beginning of an object key name, which you can use to organize objects. For example, you can start the key names of related objects with a prefix, such as <code>2023-</code> or <code>engineering/</code>. Then, you can use <code>FilterRule</code> to find objects in a bucket with key names that have the same prefix. A suffix is similar to a prefix, but it is at the end of the object key name instead of at the beginning.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct FilterRule {
     /// <p>The object key name prefix or suffix identifying one or more objects to which the filtering rule applies. The maximum length is 1,024 characters. Overlapping prefixes and suffixes are not supported. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html">Configuring Event Notifications</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub name: ::std::option::Option<crate::types::FilterRuleName>,
     /// <p>The value that the filter searches for in object key names.</p>
     pub value: ::std::option::Option<::std::string::String>,
-11
+}
 impl FilterRule {
     /// <p>The object key name prefix or suffix identifying one or more objects to which the filtering rule applies. The maximum length is 1,024 characters. Overlapping prefixes and suffixes are not supported. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html">Configuring Event Notifications</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub fn name(&self) -> ::std::option::Option<&crate::types::FilterRuleName> {
         self.name.as_ref()
-16
+    }

     /// <p>The value that the filter searches for in object key names.</p>
     pub fn value(&self) -> ::std::option::Option<&str> {
         self.value.as_deref()
-20
+    }
-21
+}
 static FILTERRULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#FilterRule", "com.amazonaws.s3", "FilterRule");
 static FILTERRULE_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#FilterRule$Name", "com.amazonaws.s3", "FilterRule"),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
 );
 static FILTERRULE_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#FilterRule$Value", "com.amazonaws.s3", "FilterRule"),
     ::aws_smithy_schema::ShapeType::String,
     "value",
     "Value",
 ,
 );
 static FILTERRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FILTERRULE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&FILTERRULE_MEMBER_NAME, &FILTERRULE_MEMBER_VALUE],
 );
 impl FilterRule {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FILTERRULE_SCHEMA;
-44
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FilterRule {
     #[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.name {
             ser.write_string(&FILTERRULE_MEMBER_NAME, val.as_str())?;
-53
+        }
         if let Some(ref val) = self.value {
             ser.write_string(&FILTERRULE_MEMBER_VALUE, val)?;
-56
+        }
         Ok(())
-58
+    }
-59
+}
 impl FilterRule {
     /// 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(&FILTERRULE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FILTERRULE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.name = Some(crate::types::FilterRuleName::from(deser.read_string(member)?.as_str()));
-78
+                }
                 Some(1) => {
                     builder.value = Some(deser.read_string(member)?);
-81
+                }
                 _ => {}
-83
+            }
             Ok(())
         })?;
         Ok(builder.build())
-87
+    }
-88
+}
 impl FilterRule {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl FilterRule {
     /// Creates a new builder-style object to manufacture [`FilterRule`](crate::types::FilterRule).
     pub fn builder() -> crate::types::builders::FilterRuleBuilder {
         crate::types::builders::FilterRuleBuilder::default()
-104
+    }
-105
+}
-106
 /// A builder for [`FilterRule`](crate::types::FilterRule).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FilterRuleBuilder {
     pub(crate) name: ::std::option::Option<crate::types::FilterRuleName>,
     pub(crate) value: ::std::option::Option<::std::string::String>,
-113
+}
 impl FilterRuleBuilder {
     /// <p>The object key name prefix or suffix identifying one or more objects to which the filtering rule applies. The maximum length is 1,024 characters. Overlapping prefixes and suffixes are not supported. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html">Configuring Event Notifications</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub fn name(mut self, input: crate::types::FilterRuleName) -> Self {
         self.name = ::std::option::Option::Some(input);
         self
-119
+    }
     /// <p>The object key name prefix or suffix identifying one or more objects to which the filtering rule applies. The maximum length is 1,024 characters. Overlapping prefixes and suffixes are not supported. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html">Configuring Event Notifications</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub fn set_name(mut self, input: ::std::option::Option<crate::types::FilterRuleName>) -> Self {
         self.name = input;
         self
-124
+    }
     /// <p>The object key name prefix or suffix identifying one or more objects to which the filtering rule applies. The maximum length is 1,024 characters. Overlapping prefixes and suffixes are not supported. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html">Configuring Event Notifications</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub fn get_name(&self) -> &::std::option::Option<crate::types::FilterRuleName> {
         &self.name
-128
+    }
     /// <p>The value that the filter searches for in object key names.</p>

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_get_bucket_metadata_configuration_result.rs

@@ -1,1 +108,119 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The S3 Metadata configuration for a general purpose bucket.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GetBucketMetadataConfigurationResult {
     /// <p>The metadata configuration for a general purpose bucket.</p>
     pub metadata_configuration_result: ::std::option::Option<crate::types::MetadataConfigurationResult>,
-9
+}
 impl GetBucketMetadataConfigurationResult {
     /// <p>The metadata configuration for a general purpose bucket.</p>
     pub fn metadata_configuration_result(&self) -> ::std::option::Option<&crate::types::MetadataConfigurationResult> {
         self.metadata_configuration_result.as_ref()
-14
+    }
-15
+}
 static GETBUCKETMETADATACONFIGURATIONRESULT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3#GetBucketMetadataConfigurationResult",
     "com.amazonaws.s3",

     "GetBucketMetadataConfigurationResult",
 );
 static GETBUCKETMETADATACONFIGURATIONRESULT_MEMBER_METADATA_CONFIGURATION_RESULT: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.s3#GetBucketMetadataConfigurationResult$MetadataConfigurationResult",
             "com.amazonaws.s3",
             "GetBucketMetadataConfigurationResult",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "metadata_configuration_result",
         "MetadataConfigurationResult",
 ,
     );
 static GETBUCKETMETADATACONFIGURATIONRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETBUCKETMETADATACONFIGURATIONRESULT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETBUCKETMETADATACONFIGURATIONRESULT_MEMBER_METADATA_CONFIGURATION_RESULT],
 );
 impl GetBucketMetadataConfigurationResult {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETBUCKETMETADATACONFIGURATIONRESULT_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetBucketMetadataConfigurationResult {
     #[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.metadata_configuration_result {
             ser.write_struct(&GETBUCKETMETADATACONFIGURATIONRESULT_MEMBER_METADATA_CONFIGURATION_RESULT, val)?;
-49
+        }
         Ok(())
-51
+    }
-52
+}
 impl GetBucketMetadataConfigurationResult {
     /// 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(&GETBUCKETMETADATACONFIGURATIONRESULT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETBUCKETMETADATACONFIGURATIONRESULT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.metadata_configuration_result = Some(crate::types::MetadataConfigurationResult::deserialize(deser)?);
-71
+                }
                 _ => {}
-73
+            }
             Ok(())
         })?;
         Ok(builder.build())
-77
+    }
-78
+}
 impl GetBucketMetadataConfigurationResult {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl GetBucketMetadataConfigurationResult {
     /// Creates a new builder-style object to manufacture [`GetBucketMetadataConfigurationResult`](crate::types::GetBucketMetadataConfigurationResult).
     pub fn builder() -> crate::types::builders::GetBucketMetadataConfigurationResultBuilder {
         crate::types::builders::GetBucketMetadataConfigurationResultBuilder::default()
-94
+    }
-95
+}
-96
 /// A builder for [`GetBucketMetadataConfigurationResult`](crate::types::GetBucketMetadataConfigurationResult).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetBucketMetadataConfigurationResultBuilder {
     pub(crate) metadata_configuration_result: ::std::option::Option<crate::types::MetadataConfigurationResult>,
-102
+}
 impl GetBucketMetadataConfigurationResultBuilder {
     /// <p>The metadata configuration for a general purpose bucket.</p>
     /// This field is required.
     pub fn metadata_configuration_result(mut self, input: crate::types::MetadataConfigurationResult) -> Self {
         self.metadata_configuration_result = ::std::option::Option::Some(input);
         self
-109
+    }
     /// <p>The metadata configuration for a general purpose bucket.</p>
     pub fn set_metadata_configuration_result(mut self, input: ::std::option::Option<crate::types::MetadataConfigurationResult>) -> Self {
         self.metadata_configuration_result = input;
         self
-114
+    }
     /// <p>The metadata configuration for a general purpose bucket.</p>
     pub fn get_metadata_configuration_result(&self) -> &::std::option::Option<crate::types::MetadataConfigurationResult> {
         &self.metadata_configuration_result
-118
+    }
     /// Consumes the builder and constructs a [`GetBucketMetadataConfigurationResult`](crate::types::GetBucketMetadataConfigurationResult).

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_get_bucket_metadata_table_configuration_result.rs

@@ -30,30 +178,190 @@

↥ Expand context

     /// <ul>
     /// <li>
     /// <p><code>CREATING</code> - The metadata table is in the process of being created in the specified table bucket.</p></li>
     /// <li>
     /// <p><code>ACTIVE</code> - The metadata table has been created successfully, and records are being delivered to the table.</p></li>
     /// <li>
     /// <p><code>FAILED</code> - Amazon S3 is unable to create the metadata table, or Amazon S3 is unable to deliver records. See <code>ErrorDetails</code> for details.</p></li>
     /// </ul>
     pub fn status(&self) -> &str {
         use std::ops::Deref;
         self.status.deref()
-41
+    }
     /// <p>If the <code>CreateBucketMetadataTableConfiguration</code> request succeeds, but S3 Metadata was unable to create the table, this structure contains the error code and error message.</p>
     pub fn error(&self) -> ::std::option::Option<&crate::types::ErrorDetails> {
         self.error.as_ref()
-45
+    }
-46
+}
 static GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3#GetBucketMetadataTableConfigurationResult",
     "com.amazonaws.s3",

     "GetBucketMetadataTableConfigurationResult",
 );
 static GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_METADATA_TABLE_CONFIGURATION_RESULT: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.s3#GetBucketMetadataTableConfigurationResult$MetadataTableConfigurationResult",
             "com.amazonaws.s3",
             "GetBucketMetadataTableConfigurationResult",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "metadata_table_configuration_result",
         "MetadataTableConfigurationResult",
 ,
     );
 static GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#GetBucketMetadataTableConfigurationResult$Status",
         "com.amazonaws.s3",
         "GetBucketMetadataTableConfigurationResult",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status",
     "Status",
 ,
 );
 static GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#GetBucketMetadataTableConfigurationResult$Error",
         "com.amazonaws.s3",
         "GetBucketMetadataTableConfigurationResult",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "error",
     "Error",
 ,
 );
 static GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_METADATA_TABLE_CONFIGURATION_RESULT,
         &GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_STATUS,
         &GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_ERROR,
     ],
 );
 impl GetBucketMetadataTableConfigurationResult {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA;
-95
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetBucketMetadataTableConfigurationResult {
     #[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.metadata_table_configuration_result {
             ser.write_struct(&GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_METADATA_TABLE_CONFIGURATION_RESULT, val)?;
-104
+        }
-105
+        {
             let val = &self.status;
             ser.write_string(&GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_STATUS, val)?;
-108
+        }
         if let Some(ref val) = self.error {
             ser.write_struct(&GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_ERROR, val)?;
-111
+        }
         Ok(())
-113
+    }
-114
+}
 impl GetBucketMetadataTableConfigurationResult {
     /// 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(&GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.metadata_table_configuration_result = Some(crate::types::MetadataTableConfigurationResult::deserialize(deser)?);
-133
+                }
                 Some(1) => {
                     builder.status = Some(deser.read_string(member)?);
-136
+                }
                 Some(2) => {
                     builder.error = Some(crate::types::ErrorDetails::deserialize(deser)?);
-139
+                }
                 _ => {}
-141
+            }
             Ok(())
         })?;
         builder.status = builder.status.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-148
+    }
-149
+}
 impl GetBucketMetadataTableConfigurationResult {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl GetBucketMetadataTableConfigurationResult {
     /// Creates a new builder-style object to manufacture [`GetBucketMetadataTableConfigurationResult`](crate::types::GetBucketMetadataTableConfigurationResult).
     pub fn builder() -> crate::types::builders::GetBucketMetadataTableConfigurationResultBuilder {
         crate::types::builders::GetBucketMetadataTableConfigurationResultBuilder::default()
-165
+    }
-166
+}
-167
 /// A builder for [`GetBucketMetadataTableConfigurationResult`](crate::types::GetBucketMetadataTableConfigurationResult).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetBucketMetadataTableConfigurationResultBuilder {
     pub(crate) metadata_table_configuration_result: ::std::option::Option<crate::types::MetadataTableConfigurationResult>,
     pub(crate) status: ::std::option::Option<::std::string::String>,
     pub(crate) error: ::std::option::Option<crate::types::ErrorDetails>,
-175
+}
 impl GetBucketMetadataTableConfigurationResultBuilder {
     /// <p>The V1 S3 Metadata configuration for a general purpose bucket.</p>
     /// This field is required.
     pub fn metadata_table_configuration_result(mut self, input: crate::types::MetadataTableConfigurationResult) -> Self {
         self.metadata_table_configuration_result = ::std::option::Option::Some(input);
         self
-182
+    }
     /// <p>The V1 S3 Metadata configuration for a general purpose bucket.</p>
     pub fn set_metadata_table_configuration_result(mut self, input: ::std::option::Option<crate::types::MetadataTableConfigurationResult>) -> Self {
         self.metadata_table_configuration_result = input;
         self
-187
+    }
     /// <p>The V1 S3 Metadata configuration for a general purpose bucket.</p>
     pub fn get_metadata_table_configuration_result(&self) -> &::std::option::Option<crate::types::MetadataTableConfigurationResult> {
         &self.metadata_table_configuration_result

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_get_object_attributes_parts.rs

@@ -44,44 +261,269 @@

↥ Expand context

     /// <p>Indicates whether the returned list of parts is truncated. A value of <code>true</code> indicates that the list was truncated. A list can be truncated if the number of parts exceeds the limit returned in the <code>MaxParts</code> element.</p>
     pub fn is_truncated(&self) -> ::std::option::Option<bool> {
         self.is_truncated
-47
+    }
     /// <p>A container for elements related to a particular part. A response can contain zero or more <code>Parts</code> elements.</p><note>
     /// <ul>
     /// <li>
     /// <p><b>General purpose buckets</b> - For <code>GetObjectAttributes</code>, if an additional checksum (including <code>x-amz-checksum-crc32</code>, <code>x-amz-checksum-crc32c</code>, <code>x-amz-checksum-sha1</code>, or <code>x-amz-checksum-sha256</code>) isn't applied to the object specified in the request, the response doesn't return the <code>Part</code> element.</p></li>
     /// <li>
     /// <p><b>Directory buckets</b> - For <code>GetObjectAttributes</code>, regardless of whether an additional checksum is applied to the object specified in the request, the response returns the <code>Part</code> element.</p></li>
     /// </ul>
     /// </note>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.parts.is_none()`.
     pub fn parts(&self) -> &[crate::types::ObjectPart] {
         self.parts.as_deref().unwrap_or_default()
-60
+    }
-61
+}
 static GETOBJECTATTRIBUTESPARTS_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3#GetObjectAttributesParts",

     "com.amazonaws.s3",
     "GetObjectAttributesParts",
 );
 static GETOBJECTATTRIBUTESPARTS_MEMBER_TOTAL_PARTS_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#GetObjectAttributesParts$TotalPartsCount",
         "com.amazonaws.s3",
         "GetObjectAttributesParts",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "total_parts_count",
     "TotalPartsCount",
 ,
-76
+)
 .with_xml_name("PartsCount");
 static GETOBJECTATTRIBUTESPARTS_MEMBER_PART_NUMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#GetObjectAttributesParts$PartNumberMarker",
         "com.amazonaws.s3",
         "GetObjectAttributesParts",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "part_number_marker",
     "PartNumberMarker",
 ,
 );
 static GETOBJECTATTRIBUTESPARTS_MEMBER_NEXT_PART_NUMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#GetObjectAttributesParts$NextPartNumberMarker",
         "com.amazonaws.s3",
         "GetObjectAttributesParts",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_part_number_marker",
     "NextPartNumberMarker",
 ,
 );
 static GETOBJECTATTRIBUTESPARTS_MEMBER_MAX_PARTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#GetObjectAttributesParts$MaxParts",
         "com.amazonaws.s3",
         "GetObjectAttributesParts",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_parts",
     "MaxParts",
 ,
 );
 static GETOBJECTATTRIBUTESPARTS_MEMBER_IS_TRUNCATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#GetObjectAttributesParts$IsTruncated",
         "com.amazonaws.s3",
         "GetObjectAttributesParts",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "is_truncated",
     "IsTruncated",
 ,
 );
 static GETOBJECTATTRIBUTESPARTS_MEMBER_PARTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#GetObjectAttributesParts$Parts",
         "com.amazonaws.s3",
         "GetObjectAttributesParts",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "parts",
     "Parts",
 ,
-127
+)
 .with_xml_name("Part")
 .with_xml_flattened();
 static GETOBJECTATTRIBUTESPARTS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETOBJECTATTRIBUTESPARTS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETOBJECTATTRIBUTESPARTS_MEMBER_TOTAL_PARTS_COUNT,
         &GETOBJECTATTRIBUTESPARTS_MEMBER_PART_NUMBER_MARKER,
         &GETOBJECTATTRIBUTESPARTS_MEMBER_NEXT_PART_NUMBER_MARKER,
         &GETOBJECTATTRIBUTESPARTS_MEMBER_MAX_PARTS,
         &GETOBJECTATTRIBUTESPARTS_MEMBER_IS_TRUNCATED,
         &GETOBJECTATTRIBUTESPARTS_MEMBER_PARTS,
     ],
 );
 impl GetObjectAttributesParts {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETOBJECTATTRIBUTESPARTS_SCHEMA;
-145
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetObjectAttributesParts {
     #[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.total_parts_count {
             ser.write_integer(&GETOBJECTATTRIBUTESPARTS_MEMBER_TOTAL_PARTS_COUNT, *val)?;
-154
+        }
         if let Some(ref val) = self.part_number_marker {
             ser.write_string(&GETOBJECTATTRIBUTESPARTS_MEMBER_PART_NUMBER_MARKER, val)?;
-157
+        }
         if let Some(ref val) = self.next_part_number_marker {
             ser.write_string(&GETOBJECTATTRIBUTESPARTS_MEMBER_NEXT_PART_NUMBER_MARKER, val)?;
-160
+        }
         if let Some(ref val) = self.max_parts {
             ser.write_integer(&GETOBJECTATTRIBUTESPARTS_MEMBER_MAX_PARTS, *val)?;
-163
+        }
         if let Some(ref val) = self.is_truncated {
             ser.write_boolean(&GETOBJECTATTRIBUTESPARTS_MEMBER_IS_TRUNCATED, *val)?;
-166
+        }
         if let Some(ref val) = self.parts {
             ser.write_list(
                 &GETOBJECTATTRIBUTESPARTS_MEMBER_PARTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ObjectPart::SCHEMA, item)?;
-173
+                    }
                     Ok(())
                 },
             )?;
-177
+        }
         Ok(())
-179
+    }
-180
+}
 impl GetObjectAttributesParts {
     /// 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(&GETOBJECTATTRIBUTESPARTS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETOBJECTATTRIBUTESPARTS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.total_parts_count = Some(deser.read_integer(member)?);
-199
+                }
                 Some(1) => {
                     builder.part_number_marker = Some(deser.read_string(member)?);
-202
+                }
                 Some(2) => {
                     builder.next_part_number_marker = Some(deser.read_string(member)?);
-205
+                }
                 Some(3) => {
                     builder.max_parts = Some(deser.read_integer(member)?);
-208
+                }
                 Some(4) => {
                     builder.is_truncated = Some(deser.read_boolean(member)?);
-211
+                }
                 Some(5) => {
                     builder.parts = 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::ObjectPart::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ObjectPart::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-221
+                }
                 _ => {}
-223
+            }
             Ok(())
         })?;
         Ok(builder.build())
-227
+    }
-228
+}
 impl GetObjectAttributesParts {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl GetObjectAttributesParts {
     /// Creates a new builder-style object to manufacture [`GetObjectAttributesParts`](crate::types::GetObjectAttributesParts).
     pub fn builder() -> crate::types::builders::GetObjectAttributesPartsBuilder {
         crate::types::builders::GetObjectAttributesPartsBuilder::default()
-244
+    }
-245
+}
-246
 /// A builder for [`GetObjectAttributesParts`](crate::types::GetObjectAttributesParts).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetObjectAttributesPartsBuilder {
     pub(crate) total_parts_count: ::std::option::Option<i32>,
     pub(crate) part_number_marker: ::std::option::Option<::std::string::String>,
     pub(crate) next_part_number_marker: ::std::option::Option<::std::string::String>,
     pub(crate) max_parts: ::std::option::Option<i32>,
     pub(crate) is_truncated: ::std::option::Option<bool>,
     pub(crate) parts: ::std::option::Option<::std::vec::Vec<crate::types::ObjectPart>>,
-257
+}
 impl GetObjectAttributesPartsBuilder {
     /// <p>The total number of parts.</p>
     pub fn total_parts_count(mut self, input: i32) -> Self {
         self.total_parts_count = ::std::option::Option::Some(input);
         self
-263
+    }
     /// <p>The total number of parts.</p>
     pub fn set_total_parts_count(mut self, input: ::std::option::Option<i32>) -> Self {
         self.total_parts_count = input;
         self
-268
+    }
     /// <p>The total number of parts.</p>

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_glacier_job_parameters.rs

@@ -1,1 +103,114 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Container for S3 Glacier job parameters.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GlacierJobParameters {
     /// <p>Retrieval tier at which the restore will be processed.</p>
     pub tier: crate::types::Tier,
-9
+}
 impl GlacierJobParameters {

     /// <p>Retrieval tier at which the restore will be processed.</p>
     pub fn tier(&self) -> &crate::types::Tier {
         &self.tier
-14
+    }
-15
+}
 static GLACIERJOBPARAMETERS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#GlacierJobParameters", "com.amazonaws.s3", "GlacierJobParameters");
 static GLACIERJOBPARAMETERS_MEMBER_TIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#GlacierJobParameters$Tier", "com.amazonaws.s3", "GlacierJobParameters"),
     ::aws_smithy_schema::ShapeType::String,
     "tier",
     "Tier",
 ,
 );
 static GLACIERJOBPARAMETERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GLACIERJOBPARAMETERS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GLACIERJOBPARAMETERS_MEMBER_TIER],
 );
 impl GlacierJobParameters {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GLACIERJOBPARAMETERS_SCHEMA;
-32
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GlacierJobParameters {
     #[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> {
-39
+        {
             let val = &self.tier;
             ser.write_string(&GLACIERJOBPARAMETERS_MEMBER_TIER, val.as_str())?;
-42
+        }
         Ok(())
-44
+    }
-45
+}
 impl GlacierJobParameters {
     /// 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(&GLACIERJOBPARAMETERS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GLACIERJOBPARAMETERS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.tier = Some(crate::types::Tier::from(deser.read_string(member)?.as_str()));
-64
+                }
                 _ => {}
-66
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-72
+    }
-73
+}
 impl GlacierJobParameters {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl GlacierJobParameters {
     /// Creates a new builder-style object to manufacture [`GlacierJobParameters`](crate::types::GlacierJobParameters).
     pub fn builder() -> crate::types::builders::GlacierJobParametersBuilder {
         crate::types::builders::GlacierJobParametersBuilder::default()
-89
+    }
-90
+}
-91
 /// A builder for [`GlacierJobParameters`](crate::types::GlacierJobParameters).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GlacierJobParametersBuilder {
     pub(crate) tier: ::std::option::Option<crate::types::Tier>,
-97
+}
 impl GlacierJobParametersBuilder {
     /// <p>Retrieval tier at which the restore will be processed.</p>
     /// This field is required.
     pub fn tier(mut self, input: crate::types::Tier) -> Self {
         self.tier = ::std::option::Option::Some(input);
         self
-104
+    }
     /// <p>Retrieval tier at which the restore will be processed.</p>
     pub fn set_tier(mut self, input: ::std::option::Option<crate::types::Tier>) -> Self {
         self.tier = input;
         self
-109
+    }
     /// <p>Retrieval tier at which the restore will be processed.</p>
     pub fn get_tier(&self) -> &::std::option::Option<crate::types::Tier> {
         &self.tier
-113
+    }
     /// Consumes the builder and constructs a [`GlacierJobParameters`](crate::types::GlacierJobParameters).

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_grant.rs

@@ -1,1 +119,130 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Container for grant information.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct Grant {
     /// <p>The person being granted permissions.</p>
     pub grantee: ::std::option::Option<crate::types::Grantee>,
     /// <p>Specifies the permission given to the grantee.</p>
     pub permission: ::std::option::Option<crate::types::Permission>,
-11
+}
 impl Grant {
     /// <p>The person being granted permissions.</p>
     pub fn grantee(&self) -> ::std::option::Option<&crate::types::Grantee> {
         self.grantee.as_ref()
-16
+    }

     /// <p>Specifies the permission given to the grantee.</p>
     pub fn permission(&self) -> ::std::option::Option<&crate::types::Permission> {
         self.permission.as_ref()
-20
+    }
-21
+}
 static GRANT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grant", "com.amazonaws.s3", "Grant");
 static GRANT_MEMBER_GRANTEE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grant$Grantee", "com.amazonaws.s3", "Grant"),
     ::aws_smithy_schema::ShapeType::Structure,
     "grantee",
     "Grantee",
 ,
-29
+)
 .with_xml_namespace();
 static GRANT_MEMBER_PERMISSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grant$Permission", "com.amazonaws.s3", "Grant"),
     ::aws_smithy_schema::ShapeType::String,
     "permission",
     "Permission",
 ,
 );
 static GRANT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GRANT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GRANT_MEMBER_GRANTEE, &GRANT_MEMBER_PERMISSION],
 );
 impl Grant {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GRANT_SCHEMA;
-45
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Grant {
     #[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.grantee {
             ser.write_struct(&GRANT_MEMBER_GRANTEE, val)?;
-54
+        }
         if let Some(ref val) = self.permission {
             ser.write_string(&GRANT_MEMBER_PERMISSION, val.as_str())?;
-57
+        }
         Ok(())
-59
+    }
-60
+}
 impl Grant {
     /// 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(&GRANT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GRANT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.grantee = Some(crate::types::Grantee::deserialize(deser)?);
-79
+                }
                 Some(1) => {
                     builder.permission = Some(crate::types::Permission::from(deser.read_string(member)?.as_str()));
-82
+                }
                 _ => {}
-84
+            }
             Ok(())
         })?;
         Ok(builder.build())
-88
+    }
-89
+}
 impl Grant {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Grant {
     /// Creates a new builder-style object to manufacture [`Grant`](crate::types::Grant).
     pub fn builder() -> crate::types::builders::GrantBuilder {
         crate::types::builders::GrantBuilder::default()
-105
+    }
-106
+}
-107
 /// A builder for [`Grant`](crate::types::Grant).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GrantBuilder {
     pub(crate) grantee: ::std::option::Option<crate::types::Grantee>,
     pub(crate) permission: ::std::option::Option<crate::types::Permission>,
-114
+}
 impl GrantBuilder {
     /// <p>The person being granted permissions.</p>
     pub fn grantee(mut self, input: crate::types::Grantee) -> Self {
         self.grantee = ::std::option::Option::Some(input);
         self
-120
+    }
     /// <p>The person being granted permissions.</p>
     pub fn set_grantee(mut self, input: ::std::option::Option<crate::types::Grantee>) -> Self {
         self.grantee = input;
         self
-125
+    }
     /// <p>The person being granted permissions.</p>
     pub fn get_grantee(&self) -> &::std::option::Option<crate::types::Grantee> {
         &self.grantee
-129
+    }
     /// <p>Specifies the permission given to the grantee.</p>

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_grantee.rs

@@ -15,15 +183,194 @@

↥ Expand context

     /// <p>Type of grantee</p>
     pub r#type: crate::types::Type,
-17
+}
 impl Grantee {
     /// <p></p>
     pub fn display_name(&self) -> ::std::option::Option<&str> {
         self.display_name.as_deref()
-22
+    }
     /// <p></p>
     pub fn email_address(&self) -> ::std::option::Option<&str> {
         self.email_address.as_deref()
-26
+    }
     /// <p>The canonical user ID of the grantee.</p>
     pub fn id(&self) -> ::std::option::Option<&str> {
         self.id.as_deref()
-30
+    }
     /// <p>URI of the grantee group.</p>
     pub fn uri(&self) -> ::std::option::Option<&str> {
         self.uri.as_deref()
-34
+    }

     /// <p>Type of grantee</p>
     pub fn r#type(&self) -> &crate::types::Type {
         &self.r#type
-38
+    }
-39
+}
 static GRANTEE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee", "com.amazonaws.s3", "Grantee");
 static GRANTEE_MEMBER_DISPLAY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee$DisplayName", "com.amazonaws.s3", "Grantee"),
     ::aws_smithy_schema::ShapeType::String,
     "display_name",
     "DisplayName",
 ,
 );
 static GRANTEE_MEMBER_EMAIL_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee$EmailAddress", "com.amazonaws.s3", "Grantee"),
     ::aws_smithy_schema::ShapeType::String,
     "email_address",
     "EmailAddress",
 ,
 );
 static GRANTEE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee$ID", "com.amazonaws.s3", "Grantee"),
     ::aws_smithy_schema::ShapeType::String,
     "id",
     "ID",
 ,
 );
 static GRANTEE_MEMBER_URI: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee$URI", "com.amazonaws.s3", "Grantee"),
     ::aws_smithy_schema::ShapeType::String,
     "uri",
     "URI",
 ,
 );
 static GRANTEE_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee$Type", "com.amazonaws.s3", "Grantee"),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
-71
+)
 .with_xml_name("xsi:type")
 .with_xml_attribute();
 static GRANTEE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GRANTEE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GRANTEE_MEMBER_DISPLAY_NAME,
         &GRANTEE_MEMBER_EMAIL_ADDRESS,
         &GRANTEE_MEMBER_ID,
         &GRANTEE_MEMBER_URI,
         &GRANTEE_MEMBER_TYPE,
     ],
 );
 impl Grantee {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GRANTEE_SCHEMA;
-88
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Grantee {
     #[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.display_name {
             ser.write_string(&GRANTEE_MEMBER_DISPLAY_NAME, val)?;
-97
+        }
         if let Some(ref val) = self.email_address {
             ser.write_string(&GRANTEE_MEMBER_EMAIL_ADDRESS, val)?;
-100
+        }
         if let Some(ref val) = self.id {
             ser.write_string(&GRANTEE_MEMBER_ID, val)?;
-103
+        }
         if let Some(ref val) = self.uri {
             ser.write_string(&GRANTEE_MEMBER_URI, val)?;
-106
+        }
-107
+        {
             let val = &self.r#type;
             ser.write_string(&GRANTEE_MEMBER_TYPE, val.as_str())?;
-110
+        }
         Ok(())
-112
+    }
-113
+}
 impl Grantee {
     /// 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(&GRANTEE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GRANTEE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.display_name = Some(deser.read_string(member)?);
-132
+                }
                 Some(1) => {
                     builder.email_address = Some(deser.read_string(member)?);
-135
+                }
                 Some(2) => {
                     builder.id = Some(deser.read_string(member)?);
-138
+                }
                 Some(3) => {
                     builder.uri = Some(deser.read_string(member)?);
-141
+                }
                 Some(4) => {
                     builder.r#type = Some(crate::types::Type::from(deser.read_string(member)?.as_str()));
-144
+                }
                 _ => {}
-146
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-152
+    }
-153
+}
 impl Grantee {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Grantee {
     /// Creates a new builder-style object to manufacture [`Grantee`](crate::types::Grantee).
     pub fn builder() -> crate::types::builders::GranteeBuilder {
         crate::types::builders::GranteeBuilder::default()
-169
+    }
-170
+}
-171
 /// A builder for [`Grantee`](crate::types::Grantee).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GranteeBuilder {
     pub(crate) display_name: ::std::option::Option<::std::string::String>,
     pub(crate) email_address: ::std::option::Option<::std::string::String>,
     pub(crate) id: ::std::option::Option<::std::string::String>,
     pub(crate) uri: ::std::option::Option<::std::string::String>,
     pub(crate) r#type: ::std::option::Option<crate::types::Type>,
-181
+}
 impl GranteeBuilder {
     /// <p></p>
     pub fn display_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.display_name = ::std::option::Option::Some(input.into());
         self
-187
+    }
     /// <p></p>
     pub fn set_display_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.display_name = input;
         self
-192
+    }
     /// <p></p>
     pub fn get_display_name(&self) -> &::std::option::Option<::std::string::String> {

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_index_document.rs

@@ -1,1 +108,120 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Container for the <code>Suffix</code> element.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct IndexDocument {
     /// <p>A suffix that is appended to a request that is for a directory on the website endpoint. (For example, if the suffix is <code>index.html</code> and you make a request to <code>samplebucket/images/</code>, the data that is returned will be for the object with the key name <code>images/index.html</code>.) The suffix must not be empty and must not include a slash character.</p><important>
     /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
     /// </important>
     pub suffix: ::std::string::String,
-11
+}
 impl IndexDocument {
     /// <p>A suffix that is appended to a request that is for a directory on the website endpoint. (For example, if the suffix is <code>index.html</code> and you make a request to <code>samplebucket/images/</code>, the data that is returned will be for the object with the key name <code>images/index.html</code>.) The suffix must not be empty and must not include a slash character.</p><important>
     /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
     /// </important>

     pub fn suffix(&self) -> &str {
         use std::ops::Deref;
         self.suffix.deref()
-19
+    }
-20
+}
 static INDEXDOCUMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#IndexDocument", "com.amazonaws.s3", "IndexDocument");
 static INDEXDOCUMENT_MEMBER_SUFFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#IndexDocument$Suffix", "com.amazonaws.s3", "IndexDocument"),
     ::aws_smithy_schema::ShapeType::String,
     "suffix",
     "Suffix",
 ,
 );
 static INDEXDOCUMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INDEXDOCUMENT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&INDEXDOCUMENT_MEMBER_SUFFIX],
 );
 impl IndexDocument {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INDEXDOCUMENT_SCHEMA;
-37
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for IndexDocument {
     #[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> {
-44
+        {
             let val = &self.suffix;
             ser.write_string(&INDEXDOCUMENT_MEMBER_SUFFIX, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl IndexDocument {
     /// 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(&INDEXDOCUMENT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INDEXDOCUMENT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.suffix = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder.suffix = builder.suffix.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-78
+    }
-79
+}
 impl IndexDocument {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl IndexDocument {
     /// Creates a new builder-style object to manufacture [`IndexDocument`](crate::types::IndexDocument).
     pub fn builder() -> crate::types::builders::IndexDocumentBuilder {
         crate::types::builders::IndexDocumentBuilder::default()
-95
+    }
-96
+}
-97
 /// A builder for [`IndexDocument`](crate::types::IndexDocument).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct IndexDocumentBuilder {
     pub(crate) suffix: ::std::option::Option<::std::string::String>,
-103
+}
 impl IndexDocumentBuilder {
     /// <p>A suffix that is appended to a request that is for a directory on the website endpoint. (For example, if the suffix is <code>index.html</code> and you make a request to <code>samplebucket/images/</code>, the data that is returned will be for the object with the key name <code>images/index.html</code>.) The suffix must not be empty and must not include a slash character.</p><important>
     /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
     /// </important>
     /// This field is required.
     pub fn suffix(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.suffix = ::std::option::Option::Some(input.into());
         self
-112
+    }
     /// <p>A suffix that is appended to a request that is for a directory on the website endpoint. (For example, if the suffix is <code>index.html</code> and you make a request to <code>samplebucket/images/</code>, the data that is returned will be for the object with the key name <code>images/index.html</code>.) The suffix must not be empty and must not include a slash character.</p><important>
     /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
     /// </important>
     pub fn set_suffix(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.suffix = input;
         self
-119
+    }
     /// <p>A suffix that is appended to a request that is for a directory on the website endpoint. (For example, if the suffix is <code>index.html</code> and you make a request to <code>samplebucket/images/</code>, the data that is returned will be for the object with the key name <code>images/index.html</code>.) The suffix must not be empty and must not include a slash character.</p><important>

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_initiator.rs

@@ -5,5 +126,137 @@

↥ Expand context

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct Initiator {
     /// <p>If the principal is an Amazon Web Services account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.</p><note>
     /// <p><b>Directory buckets</b> - If the principal is an Amazon Web Services account, it provides the Amazon Web Services account ID. If the principal is an IAM User, it provides a user ARN value.</p>
     /// </note>
     pub id: ::std::option::Option<::std::string::String>,
     /// <p></p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub display_name: ::std::option::Option<::std::string::String>,
-15
+}
 impl Initiator {
     /// <p>If the principal is an Amazon Web Services account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.</p><note>
     /// <p><b>Directory buckets</b> - If the principal is an Amazon Web Services account, it provides the Amazon Web Services account ID. If the principal is an IAM User, it provides a user ARN value.</p>
     /// </note>
     pub fn id(&self) -> ::std::option::Option<&str> {
         self.id.as_deref()
-22
+    }
     /// <p></p><note>
     /// <p>This functionality is not supported for directory buckets.</p>

     /// </note>
     pub fn display_name(&self) -> ::std::option::Option<&str> {
         self.display_name.as_deref()
-28
+    }
-29
+}
 static INITIATOR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Initiator", "com.amazonaws.s3", "Initiator");
 static INITIATOR_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Initiator$ID", "com.amazonaws.s3", "Initiator"),
     ::aws_smithy_schema::ShapeType::String,
     "id",
     "ID",
 ,
 );
 static INITIATOR_MEMBER_DISPLAY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Initiator$DisplayName", "com.amazonaws.s3", "Initiator"),
     ::aws_smithy_schema::ShapeType::String,
     "display_name",
     "DisplayName",
 ,
 );
 static INITIATOR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INITIATOR_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&INITIATOR_MEMBER_ID, &INITIATOR_MEMBER_DISPLAY_NAME],
 );
 impl Initiator {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INITIATOR_SCHEMA;
-52
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Initiator {
     #[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.id {
             ser.write_string(&INITIATOR_MEMBER_ID, val)?;
-61
+        }
         if let Some(ref val) = self.display_name {
             ser.write_string(&INITIATOR_MEMBER_DISPLAY_NAME, val)?;
-64
+        }
         Ok(())
-66
+    }
-67
+}
 impl Initiator {
     /// 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(&INITIATOR_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INITIATOR_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.id = Some(deser.read_string(member)?);
-86
+                }
                 Some(1) => {
                     builder.display_name = Some(deser.read_string(member)?);
-89
+                }
                 _ => {}
-91
+            }
             Ok(())
         })?;
         Ok(builder.build())
-95
+    }
-96
+}
 impl Initiator {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Initiator {
     /// Creates a new builder-style object to manufacture [`Initiator`](crate::types::Initiator).
     pub fn builder() -> crate::types::builders::InitiatorBuilder {
         crate::types::builders::InitiatorBuilder::default()
-112
+    }
-113
+}
-114
 /// A builder for [`Initiator`](crate::types::Initiator).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct InitiatorBuilder {
     pub(crate) id: ::std::option::Option<::std::string::String>,
     pub(crate) display_name: ::std::option::Option<::std::string::String>,
-121
+}
 impl InitiatorBuilder {
     /// <p>If the principal is an Amazon Web Services account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.</p><note>
     /// <p><b>Directory buckets</b> - If the principal is an Amazon Web Services account, it provides the Amazon Web Services account ID. If the principal is an IAM User, it provides a user ARN value.</p>
     /// </note>
     pub fn id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.id = ::std::option::Option::Some(input.into());
         self
-129
+    }
     /// <p>If the principal is an Amazon Web Services account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.</p><note>
     /// <p><b>Directory buckets</b> - If the principal is an Amazon Web Services account, it provides the Amazon Web Services account ID. If the principal is an IAM User, it provides a user ARN value.</p>
     /// </note>
     pub fn set_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.id = input;
         self
-136
+    }
     /// <p>If the principal is an Amazon Web Services account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.</p><note>

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_input_serialization.rs

@@ -9,9 +163,174 @@

↥ Expand context

     /// <p>Specifies object's compression format. Valid values: NONE, GZIP, BZIP2. Default Value: NONE.</p>
     pub compression_type: ::std::option::Option<crate::types::CompressionType>,
     /// <p>Specifies JSON as object's input serialization format.</p>
     pub json: ::std::option::Option<crate::types::JsonInput>,
     /// <p>Specifies Parquet as object's input serialization format.</p>
     pub parquet: ::std::option::Option<crate::types::ParquetInput>,
-15
+}
 impl InputSerialization {
     /// <p>Describes the serialization of a CSV-encoded object.</p>
     pub fn csv(&self) -> ::std::option::Option<&crate::types::CsvInput> {
         self.csv.as_ref()
-20
+    }
     /// <p>Specifies object's compression format. Valid values: NONE, GZIP, BZIP2. Default Value: NONE.</p>
     pub fn compression_type(&self) -> ::std::option::Option<&crate::types::CompressionType> {
         self.compression_type.as_ref()
-24
+    }
     /// <p>Specifies JSON as object's input serialization format.</p>
     pub fn json(&self) -> ::std::option::Option<&crate::types::JsonInput> {
         self.json.as_ref()
-28
+    }

     /// <p>Specifies Parquet as object's input serialization format.</p>
     pub fn parquet(&self) -> ::std::option::Option<&crate::types::ParquetInput> {
         self.parquet.as_ref()
-32
+    }
-33
+}
 static INPUTSERIALIZATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InputSerialization", "com.amazonaws.s3", "InputSerialization");
 static INPUTSERIALIZATION_MEMBER_CSV: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InputSerialization$CSV", "com.amazonaws.s3", "InputSerialization"),
     ::aws_smithy_schema::ShapeType::Structure,
     "csv",
     "CSV",
 ,
 );
 static INPUTSERIALIZATION_MEMBER_COMPRESSION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#InputSerialization$CompressionType",
         "com.amazonaws.s3",
         "InputSerialization",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "compression_type",
     "CompressionType",
 ,
 );
 static INPUTSERIALIZATION_MEMBER_JSON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InputSerialization$JSON", "com.amazonaws.s3", "InputSerialization"),
     ::aws_smithy_schema::ShapeType::Structure,
     "json",
     "JSON",
 ,
 );
 static INPUTSERIALIZATION_MEMBER_PARQUET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InputSerialization$Parquet", "com.amazonaws.s3", "InputSerialization"),
     ::aws_smithy_schema::ShapeType::Structure,
     "parquet",
     "Parquet",
 ,
 );
 static INPUTSERIALIZATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INPUTSERIALIZATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &INPUTSERIALIZATION_MEMBER_CSV,
         &INPUTSERIALIZATION_MEMBER_COMPRESSION_TYPE,
         &INPUTSERIALIZATION_MEMBER_JSON,
         &INPUTSERIALIZATION_MEMBER_PARQUET,
     ],
 );
 impl InputSerialization {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INPUTSERIALIZATION_SCHEMA;
-77
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for InputSerialization {
     #[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.csv {
             ser.write_struct(&INPUTSERIALIZATION_MEMBER_CSV, val)?;
-86
+        }
         if let Some(ref val) = self.compression_type {
             ser.write_string(&INPUTSERIALIZATION_MEMBER_COMPRESSION_TYPE, val.as_str())?;
-89
+        }
         if let Some(ref val) = self.json {
             ser.write_struct(&INPUTSERIALIZATION_MEMBER_JSON, val)?;
-92
+        }
         if let Some(ref val) = self.parquet {
             ser.write_struct(&INPUTSERIALIZATION_MEMBER_PARQUET, val)?;
-95
+        }
         Ok(())
-97
+    }
-98
+}
 impl InputSerialization {
     /// 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(&INPUTSERIALIZATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INPUTSERIALIZATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.csv = Some(crate::types::CsvInput::deserialize(deser)?);
-117
+                }
                 Some(1) => {
                     builder.compression_type = Some(crate::types::CompressionType::from(deser.read_string(member)?.as_str()));
-120
+                }
                 Some(2) => {
                     builder.json = Some(crate::types::JsonInput::deserialize(deser)?);
-123
+                }
                 Some(3) => {
                     builder.parquet = Some(crate::types::ParquetInput::deserialize(deser)?);
-126
+                }
                 _ => {}
-128
+            }
             Ok(())
         })?;
         Ok(builder.build())
-132
+    }
-133
+}
 impl InputSerialization {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl InputSerialization {
     /// Creates a new builder-style object to manufacture [`InputSerialization`](crate::types::InputSerialization).
     pub fn builder() -> crate::types::builders::InputSerializationBuilder {
         crate::types::builders::InputSerializationBuilder::default()
-149
+    }
-150
+}
-151
 /// A builder for [`InputSerialization`](crate::types::InputSerialization).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct InputSerializationBuilder {
     pub(crate) csv: ::std::option::Option<crate::types::CsvInput>,
     pub(crate) compression_type: ::std::option::Option<crate::types::CompressionType>,
     pub(crate) json: ::std::option::Option<crate::types::JsonInput>,
     pub(crate) parquet: ::std::option::Option<crate::types::ParquetInput>,
-160
+}
 impl InputSerializationBuilder {
     /// <p>Describes the serialization of a CSV-encoded object.</p>
     pub fn csv(mut self, input: crate::types::CsvInput) -> Self {
         self.csv = ::std::option::Option::Some(input);
         self
-166
+    }
     /// <p>Describes the serialization of a CSV-encoded object.</p>
     pub fn set_csv(mut self, input: ::std::option::Option<crate::types::CsvInput>) -> Self {
         self.csv = input;
         self
-171
+    }
     /// <p>Describes the serialization of a CSV-encoded object.</p>
     pub fn get_csv(&self) -> &::std::option::Option<crate::types::CsvInput> {
         &self.csv

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_intelligent_tiering_and_operator.rs

@@ -6,6 +151,159 @@

↥ Expand context

 pub struct IntelligentTieringAndOperator {
     /// <p>An object key name prefix that identifies the subset of objects to which the configuration applies.</p>
     pub prefix: ::std::option::Option<::std::string::String>,
     /// <p>All of these tags must exist in the object's tag set in order for the configuration to apply.</p>
     pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-11
+}
 impl IntelligentTieringAndOperator {
     /// <p>An object key name prefix that identifies the subset of objects to which the configuration applies.</p>
     pub fn prefix(&self) -> ::std::option::Option<&str> {
         self.prefix.as_deref()
-16
+    }
     /// <p>All of these tags must exist in the object's tag set in order for the configuration to apply.</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()
-22
+    }
-23
+}
 static INTELLIGENTTIERINGANDOPERATOR_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3#IntelligentTieringAndOperator",

     "com.amazonaws.s3",
     "IntelligentTieringAndOperator",
 );
 static INTELLIGENTTIERINGANDOPERATOR_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#IntelligentTieringAndOperator$Prefix",
         "com.amazonaws.s3",
         "IntelligentTieringAndOperator",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "prefix",
     "Prefix",
 ,
 );
 static INTELLIGENTTIERINGANDOPERATOR_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#IntelligentTieringAndOperator$Tags",
         "com.amazonaws.s3",
         "IntelligentTieringAndOperator",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-48
+)
 .with_xml_name("Tag")
 .with_xml_flattened();
 static INTELLIGENTTIERINGANDOPERATOR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INTELLIGENTTIERINGANDOPERATOR_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&INTELLIGENTTIERINGANDOPERATOR_MEMBER_PREFIX, &INTELLIGENTTIERINGANDOPERATOR_MEMBER_TAGS],
 );
 impl IntelligentTieringAndOperator {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INTELLIGENTTIERINGANDOPERATOR_SCHEMA;
-59
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for IntelligentTieringAndOperator {
     #[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.prefix {
             ser.write_string(&INTELLIGENTTIERINGANDOPERATOR_MEMBER_PREFIX, val)?;
-68
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &INTELLIGENTTIERINGANDOPERATOR_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-75
+                    }
                     Ok(())
                 },
             )?;
-79
+        }
         Ok(())
-81
+    }
-82
+}
 impl IntelligentTieringAndOperator {
     /// 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(&INTELLIGENTTIERINGANDOPERATOR_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INTELLIGENTTIERINGANDOPERATOR_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.prefix = Some(deser.read_string(member)?);
-101
+                }
                 Some(1) => {
                     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
                     });
-111
+                }
                 _ => {}
-113
+            }
             Ok(())
         })?;
         Ok(builder.build())
-117
+    }
-118
+}
 impl IntelligentTieringAndOperator {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl IntelligentTieringAndOperator {
     /// Creates a new builder-style object to manufacture [`IntelligentTieringAndOperator`](crate::types::IntelligentTieringAndOperator).
     pub fn builder() -> crate::types::builders::IntelligentTieringAndOperatorBuilder {
         crate::types::builders::IntelligentTieringAndOperatorBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`IntelligentTieringAndOperator`](crate::types::IntelligentTieringAndOperator).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct IntelligentTieringAndOperatorBuilder {
     pub(crate) prefix: ::std::option::Option<::std::string::String>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-143
+}
 impl IntelligentTieringAndOperatorBuilder {
     /// <p>An object key name prefix that identifies the subset of objects to which the configuration applies.</p>
     pub fn prefix(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.prefix = ::std::option::Option::Some(input.into());
         self
-149
+    }
     /// <p>An object key name prefix that identifies the subset of objects to which the configuration applies.</p>
     pub fn set_prefix(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.prefix = input;
         self
-154
+    }
     /// <p>An object key name prefix that identifies the subset of objects to which the configuration applies.</p>
     pub fn get_prefix(&self) -> &::std::option::Option<::std::string::String> {
         &self.prefix
-158
+    }
     /// Appends an item to `tags`.

AWS SDK

Files changed: