AWS SDK

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

@@ -27,27 +216,227 @@

     /// <p>Date and time at which the object was uploaded.</p>
     pub fn last_modified(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.last_modified.as_ref()
-30
+    }
     /// <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent. This header specifies the Base64 encoded, 32-bit <code>CRC32</code> checksum of the part. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub fn checksum_crc32(&self) -> ::std::option::Option<&str> {
         self.checksum_crc32.as_deref()
-34
+    }
     /// <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent. This header specifies the Base64 encoded, 32-bit <code>CRC32C</code> checksum of the part. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub fn checksum_crc32_c(&self) -> ::std::option::Option<&str> {
         self.checksum_crc32_c.as_deref()
-38
+    }
     /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the part. This checksum is present if the multipart upload request was created with the <code>CRC64NVME</code> checksum algorithm to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub fn checksum_crc64_nvme(&self) -> ::std::option::Option<&str> {
         self.checksum_crc64_nvme.as_deref()
-42
+    }
     /// <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent. This header specifies the Base64 encoded, 160-bit <code>SHA1</code> checksum of the part. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub fn checksum_sha1(&self) -> ::std::option::Option<&str> {
         self.checksum_sha1.as_deref()
-46
+    }

     /// <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent. This header specifies the Base64 encoded, 256-bit <code>SHA256</code> checksum of the part. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
     pub fn checksum_sha256(&self) -> ::std::option::Option<&str> {
         self.checksum_sha256.as_deref()
-50
+    }
-51
+}
 static COPYPARTRESULT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult", "com.amazonaws.s3", "CopyPartResult");
 static COPYPARTRESULT_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ETag", "com.amazonaws.s3", "CopyPartResult"),
     ::aws_smithy_schema::ShapeType::String,
     "e_tag",
     "ETag",
 ,
 );
 static COPYPARTRESULT_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$LastModified", "com.amazonaws.s3", "CopyPartResult"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "last_modified",
     "LastModified",
 ,
 );
 static COPYPARTRESULT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ChecksumCRC32", "com.amazonaws.s3", "CopyPartResult"),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32",
     "ChecksumCRC32",
 ,
 );
 static COPYPARTRESULT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ChecksumCRC32C", "com.amazonaws.s3", "CopyPartResult"),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc32_c",
     "ChecksumCRC32C",
 ,
 );
 static COPYPARTRESULT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ChecksumCRC64NVME", "com.amazonaws.s3", "CopyPartResult"),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_crc64_nvme",
     "ChecksumCRC64NVME",
 ,
 );
 static COPYPARTRESULT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ChecksumSHA1", "com.amazonaws.s3", "CopyPartResult"),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha1",
     "ChecksumSHA1",
 ,
 );
 static COPYPARTRESULT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ChecksumSHA256", "com.amazonaws.s3", "CopyPartResult"),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_sha256",
     "ChecksumSHA256",
 ,
 );
 static COPYPARTRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COPYPARTRESULT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &COPYPARTRESULT_MEMBER_E_TAG,
         &COPYPARTRESULT_MEMBER_LAST_MODIFIED,
         &COPYPARTRESULT_MEMBER_CHECKSUM_CRC32,
         &COPYPARTRESULT_MEMBER_CHECKSUM_CRC32_C,
         &COPYPARTRESULT_MEMBER_CHECKSUM_CRC64_NVME,
         &COPYPARTRESULT_MEMBER_CHECKSUM_SHA1,
         &COPYPARTRESULT_MEMBER_CHECKSUM_SHA256,
     ],
 );
 impl CopyPartResult {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYPARTRESULT_SCHEMA;
-112
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CopyPartResult {
     #[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.e_tag {
             ser.write_string(&COPYPARTRESULT_MEMBER_E_TAG, val)?;
-121
+        }
         if let Some(ref val) = self.last_modified {
             ser.write_timestamp(&COPYPARTRESULT_MEMBER_LAST_MODIFIED, val)?;
-124
+        }
         if let Some(ref val) = self.checksum_crc32 {
             ser.write_string(&COPYPARTRESULT_MEMBER_CHECKSUM_CRC32, val)?;
-127
+        }
         if let Some(ref val) = self.checksum_crc32_c {
             ser.write_string(&COPYPARTRESULT_MEMBER_CHECKSUM_CRC32_C, val)?;
-130
+        }
         if let Some(ref val) = self.checksum_crc64_nvme {
             ser.write_string(&COPYPARTRESULT_MEMBER_CHECKSUM_CRC64_NVME, val)?;
-133
+        }
         if let Some(ref val) = self.checksum_sha1 {
             ser.write_string(&COPYPARTRESULT_MEMBER_CHECKSUM_SHA1, val)?;
-136
+        }
         if let Some(ref val) = self.checksum_sha256 {
             ser.write_string(&COPYPARTRESULT_MEMBER_CHECKSUM_SHA256, val)?;
-139
+        }
         Ok(())
-141
+    }
-142
+}
 impl CopyPartResult {
     /// 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(&COPYPARTRESULT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COPYPARTRESULT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.e_tag = Some(deser.read_string(member)?);
-161
+                }
                 Some(1) => {
                     builder.last_modified = Some(deser.read_timestamp(member)?);
-164
+                }
                 Some(2) => {
                     builder.checksum_crc32 = Some(deser.read_string(member)?);
-167
+                }
                 Some(3) => {
                     builder.checksum_crc32_c = Some(deser.read_string(member)?);
-170
+                }
                 Some(4) => {
                     builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
-173
+                }
                 Some(5) => {
                     builder.checksum_sha1 = Some(deser.read_string(member)?);
-176
+                }
                 Some(6) => {
                     builder.checksum_sha256 = Some(deser.read_string(member)?);
-179
+                }
                 _ => {}
-181
+            }
             Ok(())
         })?;
         Ok(builder.build())
-185
+    }
-186
+}
 impl CopyPartResult {
     /// 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 CopyPartResult {
     /// Creates a new builder-style object to manufacture [`CopyPartResult`](crate::types::CopyPartResult).
     pub fn builder() -> crate::types::builders::CopyPartResultBuilder {
         crate::types::builders::CopyPartResultBuilder::default()
-202
+    }
-203
+}
-204
 /// A builder for [`CopyPartResult`](crate::types::CopyPartResult).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CopyPartResultBuilder {
     pub(crate) e_tag: ::std::option::Option<::std::string::String>,
     pub(crate) last_modified: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) checksum_crc32: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc32_c: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_crc64_nvme: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_sha1: ::std::option::Option<::std::string::String>,
     pub(crate) checksum_sha256: ::std::option::Option<::std::string::String>,
-216
+}
 impl CopyPartResultBuilder {
     /// <p>Entity tag of the object.</p>
     pub fn e_tag(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.e_tag = ::std::option::Option::Some(input.into());
         self
-222
+    }
     /// <p>Entity tag of the object.</p>
     pub fn set_e_tag(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.e_tag = input;
         self
-227
+    }

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

@@ -1,1 +125,134 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Describes the cross-origin access configuration for objects in an Amazon S3 bucket. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/cors.html">Enabling Cross-Origin Resource Sharing</a> in the <i>Amazon S3 User Guide</i>.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CorsConfiguration {
     /// <p>A set of origins and methods (cross-origin access that you want to allow). You can add up to 100 rules to the configuration.</p>
     pub cors_rules: ::std::vec::Vec<crate::types::CorsRule>,
-9
+}
 impl CorsConfiguration {
     /// <p>A set of origins and methods (cross-origin access that you want to allow). You can add up to 100 rules to the configuration.</p>

     pub fn cors_rules(&self) -> &[crate::types::CorsRule] {
         use std::ops::Deref;
         self.cors_rules.deref()
-15
+    }
-16
+}
 static CORSCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSConfiguration", "com.amazonaws.s3", "CORSConfiguration");
 static CORSCONFIGURATION_MEMBER_CORS_RULES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSConfiguration$CORSRules", "com.amazonaws.s3", "CORSConfiguration"),
     ::aws_smithy_schema::ShapeType::List,
     "cors_rules",
     "CORSRules",
 ,
-24
+)
 .with_xml_name("CORSRule")
 .with_xml_flattened();
 static CORSCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CORSCONFIGURATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CORSCONFIGURATION_MEMBER_CORS_RULES],
 );
 impl CorsConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CORSCONFIGURATION_SCHEMA;
-35
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CorsConfiguration {
     #[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> {
-42
+        {
             let val = &self.cors_rules;
-44
             ser.write_list(
                 &CORSCONFIGURATION_MEMBER_CORS_RULES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::CorsRule::SCHEMA, item)?;
-50
+                    }
                     Ok(())
                 },
             )?;
-54
+        }
         Ok(())
-56
+    }
-57
+}
 impl CorsConfiguration {
     /// 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(&CORSCONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CORSCONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cors_rules = 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::CorsRule::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::CorsRule::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-83
+                }
                 _ => {}
-85
+            }
             Ok(())
         })?;
         builder.cors_rules = builder.cors_rules.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-92
+    }
-93
+}
 impl CorsConfiguration {
     /// 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 CorsConfiguration {
     /// Creates a new builder-style object to manufacture [`CorsConfiguration`](crate::types::CorsConfiguration).
     pub fn builder() -> crate::types::builders::CorsConfigurationBuilder {
         crate::types::builders::CorsConfigurationBuilder::default()
-109
+    }
-110
+}
-111
 /// A builder for [`CorsConfiguration`](crate::types::CorsConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CorsConfigurationBuilder {
     pub(crate) cors_rules: ::std::option::Option<::std::vec::Vec<crate::types::CorsRule>>,
-117
+}
 impl CorsConfigurationBuilder {
     /// Appends an item to `cors_rules`.
     ///
     /// To override the contents of this collection use [`set_cors_rules`](Self::set_cors_rules).
     ///
     /// <p>A set of origins and methods (cross-origin access that you want to allow). You can add up to 100 rules to the configuration.</p>
     pub fn cors_rules(mut self, input: crate::types::CorsRule) -> Self {
         let mut v = self.cors_rules.unwrap_or_default();
         v.push(input);
         self.cors_rules = ::std::option::Option::Some(v);
         self
-129
+    }
     /// <p>A set of origins and methods (cross-origin access that you want to allow). You can add up to 100 rules to the configuration.</p>
     pub fn set_cors_rules(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::CorsRule>>) -> Self {
         self.cors_rules = input;
         self
-134
+    }

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

@@ -27,27 +125,125 @@

↥ Expand context

     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.allowed_headers.is_none()`.
     pub fn allowed_headers(&self) -> &[::std::string::String] {
         self.allowed_headers.as_deref().unwrap_or_default()
-30
+    }
     /// <p>An HTTP method that you allow the origin to execute. Valid values are <code>GET</code>, <code>PUT</code>, <code>HEAD</code>, <code>POST</code>, and <code>DELETE</code>.</p>
     pub fn allowed_methods(&self) -> &[::std::string::String] {
         use std::ops::Deref;
         self.allowed_methods.deref()
-35
+    }
     /// <p>One or more origins you want customers to be able to access the bucket from.</p>
     pub fn allowed_origins(&self) -> &[::std::string::String] {
         use std::ops::Deref;
         self.allowed_origins.deref()
-40
+    }
     /// <p>One or more headers in the response that you want customers to be able to access from their applications (for example, from a JavaScript <code>XMLHttpRequest</code> object).</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 `.expose_headers.is_none()`.
     pub fn expose_headers(&self) -> &[::std::string::String] {
         self.expose_headers.as_deref().unwrap_or_default()
-46
+    }

     /// <p>The time in seconds that your browser is to cache the preflight response for the specified resource.</p>
     pub fn max_age_seconds(&self) -> ::std::option::Option<i32> {
         self.max_age_seconds
-50
+    }
-51
+}
 static CORSRULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule", "com.amazonaws.s3", "CORSRule");
 static CORSRULE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$ID", "com.amazonaws.s3", "CORSRule"),
     ::aws_smithy_schema::ShapeType::String,
     "id",
     "ID",
 ,
 );
 static CORSRULE_MEMBER_ALLOWED_HEADERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$AllowedHeaders", "com.amazonaws.s3", "CORSRule"),
     ::aws_smithy_schema::ShapeType::List,
     "allowed_headers",
     "AllowedHeaders",
 ,
-65
+)
 .with_xml_name("AllowedHeader")
 .with_xml_flattened();
 static CORSRULE_MEMBER_ALLOWED_METHODS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$AllowedMethods", "com.amazonaws.s3", "CORSRule"),
     ::aws_smithy_schema::ShapeType::List,
     "allowed_methods",
     "AllowedMethods",
 ,
-73
+)
 .with_xml_name("AllowedMethod")
 .with_xml_flattened();
 static CORSRULE_MEMBER_ALLOWED_ORIGINS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$AllowedOrigins", "com.amazonaws.s3", "CORSRule"),
     ::aws_smithy_schema::ShapeType::List,
     "allowed_origins",
     "AllowedOrigins",
 ,
-81
+)
 .with_xml_name("AllowedOrigin")
 .with_xml_flattened();
 static CORSRULE_MEMBER_EXPOSE_HEADERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$ExposeHeaders", "com.amazonaws.s3", "CORSRule"),
     ::aws_smithy_schema::ShapeType::List,
     "expose_headers",
     "ExposeHeaders",
 ,
-89
+)
 .with_xml_name("ExposeHeader")
 .with_xml_flattened();
 static CORSRULE_MEMBER_MAX_AGE_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$MaxAgeSeconds", "com.amazonaws.s3", "CORSRule"),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_age_seconds",
     "MaxAgeSeconds",
 ,
 );
 static CORSRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CORSRULE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CORSRULE_MEMBER_ID,
         &CORSRULE_MEMBER_ALLOWED_HEADERS,
         &CORSRULE_MEMBER_ALLOWED_METHODS,
         &CORSRULE_MEMBER_ALLOWED_ORIGINS,

↧ Expand context

         &CORSRULE_MEMBER_EXPOSE_HEADERS,
         &CORSRULE_MEMBER_MAX_AGE_SECONDS,
     ],
 );
 impl CorsRule {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CORSRULE_SCHEMA;
-113
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CorsRule {
     #[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(&CORSRULE_MEMBER_ID, val)?;
-122
+        }
         if let Some(ref val) = self.allowed_headers {
             ser.write_list(
                 &CORSRULE_MEMBER_ALLOWED_HEADERS,

@@ -149,149 +289,262 @@

↥ Expand context

-149
             ser.write_list(
                 &CORSRULE_MEMBER_ALLOWED_ORIGINS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-155
+                    }
                     Ok(())
                 },
             )?;
-159
+        }
         if let Some(ref val) = self.expose_headers {
             ser.write_list(
                 &CORSRULE_MEMBER_EXPOSE_HEADERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-166
+                    }
                     Ok(())
                 },

             )?;
-170
+        }
         if let Some(ref val) = self.max_age_seconds {
             ser.write_integer(&CORSRULE_MEMBER_MAX_AGE_SECONDS, *val)?;
-173
+        }
         Ok(())
-175
+    }
-176
+}
 impl CorsRule {
     /// 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(&CORSRULE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CORSRULE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.id = Some(deser.read_string(member)?);
-195
+                }
                 Some(1) => {
                     builder.allowed_headers = 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(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.allowed_headers = Some(deser.read_string_list(member)?);
-198
+                }
                 Some(2) => {
                     builder.allowed_methods = 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(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.allowed_methods = Some(deser.read_string_list(member)?);
-201
+                }
                 Some(3) => {
                     builder.allowed_origins = 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(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.allowed_origins = Some(deser.read_string_list(member)?);
-204
+                }
                 Some(4) => {
                     builder.expose_headers = 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(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.expose_headers = Some(deser.read_string_list(member)?);
-207
+                }
                 Some(5) => {
                     builder.max_age_seconds = Some(deser.read_integer(member)?);
-210
+                }
                 _ => {}
-212
+            }
             Ok(())
         })?;
         builder.allowed_methods = builder.allowed_methods.or(Some(Vec::new()));
         builder.allowed_origins = builder.allowed_origins.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-220
+    }
-221
+}
 impl CorsRule {
     /// 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 CorsRule {
     /// Creates a new builder-style object to manufacture [`CorsRule`](crate::types::CorsRule).
     pub fn builder() -> crate::types::builders::CorsRuleBuilder {
         crate::types::builders::CorsRuleBuilder::default()
-237
+    }
-238
+}
-239
 /// A builder for [`CorsRule`](crate::types::CorsRule).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CorsRuleBuilder {
     pub(crate) id: ::std::option::Option<::std::string::String>,
     pub(crate) allowed_headers: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) allowed_methods: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) allowed_origins: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) expose_headers: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) max_age_seconds: ::std::option::Option<i32>,
-250
+}
 impl CorsRuleBuilder {
     /// <p>Unique identifier for the rule. The value cannot be longer than 255 characters.</p>
     pub fn id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.id = ::std::option::Option::Some(input.into());
         self
-256
+    }
     /// <p>Unique identifier for the rule. The value cannot be longer than 255 characters.</p>
     pub fn set_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.id = input;
         self
-261
+    }
     /// <p>Unique identifier for the rule. The value cannot be longer than 255 characters.</p>

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

@@ -40,40 +220,228 @@

↥ Expand context

     pub fn location(&self) -> ::std::option::Option<&crate::types::LocationInfo> {
         self.location.as_ref()
-42
+    }
     /// <p>Specifies the information about the bucket that will be created.</p><note>
     /// <p>This functionality is only supported by directory buckets.</p>
     /// </note>
     pub fn bucket(&self) -> ::std::option::Option<&crate::types::BucketInfo> {
         self.bucket.as_ref()
-48
+    }
     /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p>
     /// <p>You must have the <code>s3:TagResource</code> permission to create a general purpose bucket with tags or the <code>s3express:TagResource</code> permission to create a directory bucket with tags.</p>
     /// <p>When creating buckets with tags, note that tag-based conditions using <code>aws:ResourceTag</code> and <code>s3:BucketTag</code> condition keys are applicable only after ABAC is enabled on the bucket. To learn more, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/buckets-tagging-enable-abac.html">Enabling ABAC in general purpose buckets</a>.</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()
-56
+    }
-57
+}
 static CREATEBUCKETCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.s3#CreateBucketConfiguration",

     "com.amazonaws.s3",
     "CreateBucketConfiguration",
 );
 static CREATEBUCKETCONFIGURATION_MEMBER_LOCATION_CONSTRAINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#CreateBucketConfiguration$LocationConstraint",
         "com.amazonaws.s3",
         "CreateBucketConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "location_constraint",
     "LocationConstraint",
 ,
 );
 static CREATEBUCKETCONFIGURATION_MEMBER_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#CreateBucketConfiguration$Location",
         "com.amazonaws.s3",
         "CreateBucketConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "location",
     "Location",
 ,
 );
 static CREATEBUCKETCONFIGURATION_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#CreateBucketConfiguration$Bucket",
         "com.amazonaws.s3",
         "CreateBucketConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "bucket",
     "Bucket",
 ,
 );
 static CREATEBUCKETCONFIGURATION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#CreateBucketConfiguration$Tags",
         "com.amazonaws.s3",
         "CreateBucketConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
 );
 static CREATEBUCKETCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEBUCKETCONFIGURATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEBUCKETCONFIGURATION_MEMBER_LOCATION_CONSTRAINT,
         &CREATEBUCKETCONFIGURATION_MEMBER_LOCATION,
         &CREATEBUCKETCONFIGURATION_MEMBER_BUCKET,
         &CREATEBUCKETCONFIGURATION_MEMBER_TAGS,
     ],
 );
 impl CreateBucketConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEBUCKETCONFIGURATION_SCHEMA;
-116
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateBucketConfiguration {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.location_constraint {
             ser.write_string(&CREATEBUCKETCONFIGURATION_MEMBER_LOCATION_CONSTRAINT, val.as_str())?;
-125
+        }
         if let Some(ref val) = self.location {
             ser.write_struct(&CREATEBUCKETCONFIGURATION_MEMBER_LOCATION, val)?;
-128
+        }
         if let Some(ref val) = self.bucket {
             ser.write_struct(&CREATEBUCKETCONFIGURATION_MEMBER_BUCKET, val)?;
-131
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &CREATEBUCKETCONFIGURATION_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-138
+                    }
                     Ok(())
                 },
             )?;
-142
+        }
         Ok(())
-144
+    }
-145
+}
 impl CreateBucketConfiguration {
     /// 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(&CREATEBUCKETCONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEBUCKETCONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.location_constraint = Some(crate::types::BucketLocationConstraint::from(deser.read_string(member)?.as_str()));
-164
+                }
                 Some(1) => {
                     builder.location = Some(crate::types::LocationInfo::deserialize(deser)?);
-167
+                }
                 Some(2) => {
                     builder.bucket = Some(crate::types::BucketInfo::deserialize(deser)?);
-170
+                }
                 Some(3) => {
                     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
                     });
-180
+                }
                 _ => {}
-182
+            }
             Ok(())
         })?;
         Ok(builder.build())
-186
+    }
-187
+}
 impl CreateBucketConfiguration {
     /// 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 CreateBucketConfiguration {
     /// Creates a new builder-style object to manufacture [`CreateBucketConfiguration`](crate::types::CreateBucketConfiguration).
     pub fn builder() -> crate::types::builders::CreateBucketConfigurationBuilder {
         crate::types::builders::CreateBucketConfigurationBuilder::default()
-203
+    }
-204
+}
-205
 /// A builder for [`CreateBucketConfiguration`](crate::types::CreateBucketConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateBucketConfigurationBuilder {
     pub(crate) location_constraint: ::std::option::Option<crate::types::BucketLocationConstraint>,
     pub(crate) location: ::std::option::Option<crate::types::LocationInfo>,
     pub(crate) bucket: ::std::option::Option<crate::types::BucketInfo>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-214
+}
 impl CreateBucketConfigurationBuilder {
     /// <p>Specifies the Region where the bucket will be created. You might choose a Region to optimize latency, minimize costs, or address regulatory requirements. For example, if you reside in Europe, you will probably find it advantageous to create buckets in the Europe (Ireland) Region.</p>
     /// <p>If you don't specify a Region, the bucket is created in the US East (N. Virginia) Region (us-east-1) by default. Configurations using the value <code>EU</code> will create a bucket in <code>eu-west-1</code>.</p>
     /// <p>For a list of the valid values for all of the Amazon Web Services Regions, see <a href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions and Endpoints</a>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn location_constraint(mut self, input: crate::types::BucketLocationConstraint) -> Self {
         self.location_constraint = ::std::option::Option::Some(input);
         self
-224
+    }
     /// <p>Specifies the Region where the bucket will be created. You might choose a Region to optimize latency, minimize costs, or address regulatory requirements. For example, if you reside in Europe, you will probably find it advantageous to create buckets in the Europe (Ireland) Region.</p>
     /// <p>If you don't specify a Region, the bucket is created in the US East (N. Virginia) Region (us-east-1) by default. Configurations using the value <code>EU</code> will create a bucket in <code>eu-west-1</code>.</p>
     /// <p>For a list of the valid values for all of the Amazon Web Services Regions, see <a href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions and Endpoints</a>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>

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

@@ -51,51 +240,251 @@

↥ Expand context

-51
+    }
     /// <p>A single character used for escaping the quotation mark character inside an already escaped value. For example, the value <code>""" a , b """</code> is parsed as <code>" a , b "</code>.</p>
     pub fn quote_escape_character(&self) -> ::std::option::Option<&str> {
         self.quote_escape_character.as_deref()
-55
+    }
     /// <p>A single character used to separate individual records in the input. Instead of the default value, you can specify an arbitrary delimiter.</p>
     pub fn record_delimiter(&self) -> ::std::option::Option<&str> {
         self.record_delimiter.as_deref()
-59
+    }
     /// <p>A single character used to separate individual fields in a record. You can specify an arbitrary delimiter.</p>
     pub fn field_delimiter(&self) -> ::std::option::Option<&str> {
         self.field_delimiter.as_deref()
-63
+    }
     /// <p>A single character used for escaping when the field delimiter is part of the value. For example, if the value is <code>a, b</code>, Amazon S3 wraps this field value in quotation marks, as follows: <code>" a , b "</code>.</p>
     /// <p>Type: String</p>
     /// <p>Default: <code>"</code></p>
     /// <p>Ancestors: <code>CSV</code></p>
     pub fn quote_character(&self) -> ::std::option::Option<&str> {
         self.quote_character.as_deref()
-70
+    }

     /// <p>Specifies that CSV field values may contain quoted record delimiters and such records should be allowed. Default value is FALSE. Setting this value to TRUE may lower performance.</p>
     pub fn allow_quoted_record_delimiter(&self) -> ::std::option::Option<bool> {
         self.allow_quoted_record_delimiter
-74
+    }
-75
+}
 static CSVINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput", "com.amazonaws.s3", "CSVInput");
 static CSVINPUT_MEMBER_FILE_HEADER_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$FileHeaderInfo", "com.amazonaws.s3", "CSVInput"),
     ::aws_smithy_schema::ShapeType::String,
     "file_header_info",
     "FileHeaderInfo",
 ,
 );
 static CSVINPUT_MEMBER_COMMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$Comments", "com.amazonaws.s3", "CSVInput"),
     ::aws_smithy_schema::ShapeType::String,
     "comments",
     "Comments",
 ,
 );
 static CSVINPUT_MEMBER_QUOTE_ESCAPE_CHARACTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$QuoteEscapeCharacter", "com.amazonaws.s3", "CSVInput"),
     ::aws_smithy_schema::ShapeType::String,
     "quote_escape_character",
     "QuoteEscapeCharacter",
 ,
 );
 static CSVINPUT_MEMBER_RECORD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$RecordDelimiter", "com.amazonaws.s3", "CSVInput"),
     ::aws_smithy_schema::ShapeType::String,
     "record_delimiter",
     "RecordDelimiter",
 ,
 );
 static CSVINPUT_MEMBER_FIELD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$FieldDelimiter", "com.amazonaws.s3", "CSVInput"),
     ::aws_smithy_schema::ShapeType::String,
     "field_delimiter",
     "FieldDelimiter",
 ,
 );
 static CSVINPUT_MEMBER_QUOTE_CHARACTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$QuoteCharacter", "com.amazonaws.s3", "CSVInput"),
     ::aws_smithy_schema::ShapeType::String,
     "quote_character",
     "QuoteCharacter",
 ,
 );
 static CSVINPUT_MEMBER_ALLOW_QUOTED_RECORD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$AllowQuotedRecordDelimiter", "com.amazonaws.s3", "CSVInput"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "allow_quoted_record_delimiter",
     "AllowQuotedRecordDelimiter",
 ,
 );
 static CSVINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CSVINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CSVINPUT_MEMBER_FILE_HEADER_INFO,
         &CSVINPUT_MEMBER_COMMENTS,
         &CSVINPUT_MEMBER_QUOTE_ESCAPE_CHARACTER,
         &CSVINPUT_MEMBER_RECORD_DELIMITER,
         &CSVINPUT_MEMBER_FIELD_DELIMITER,
         &CSVINPUT_MEMBER_QUOTE_CHARACTER,
         &CSVINPUT_MEMBER_ALLOW_QUOTED_RECORD_DELIMITER,
     ],
 );
 impl CsvInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CSVINPUT_SCHEMA;
-136
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CsvInput {
     #[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.file_header_info {
             ser.write_string(&CSVINPUT_MEMBER_FILE_HEADER_INFO, val.as_str())?;
-145
+        }
         if let Some(ref val) = self.comments {
             ser.write_string(&CSVINPUT_MEMBER_COMMENTS, val)?;
-148
+        }
         if let Some(ref val) = self.quote_escape_character {
             ser.write_string(&CSVINPUT_MEMBER_QUOTE_ESCAPE_CHARACTER, val)?;
-151
+        }
         if let Some(ref val) = self.record_delimiter {
             ser.write_string(&CSVINPUT_MEMBER_RECORD_DELIMITER, val)?;
-154
+        }
         if let Some(ref val) = self.field_delimiter {
             ser.write_string(&CSVINPUT_MEMBER_FIELD_DELIMITER, val)?;
-157
+        }
         if let Some(ref val) = self.quote_character {
             ser.write_string(&CSVINPUT_MEMBER_QUOTE_CHARACTER, val)?;
-160
+        }
         if let Some(ref val) = self.allow_quoted_record_delimiter {
             ser.write_boolean(&CSVINPUT_MEMBER_ALLOW_QUOTED_RECORD_DELIMITER, *val)?;
-163
+        }
         Ok(())
-165
+    }
-166
+}
 impl CsvInput {
     /// 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(&CSVINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CSVINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.file_header_info = Some(crate::types::FileHeaderInfo::from(deser.read_string(member)?.as_str()));
-185
+                }
                 Some(1) => {
                     builder.comments = Some(deser.read_string(member)?);
-188
+                }
                 Some(2) => {
                     builder.quote_escape_character = Some(deser.read_string(member)?);
-191
+                }
                 Some(3) => {
                     builder.record_delimiter = Some(deser.read_string(member)?);
-194
+                }
                 Some(4) => {
                     builder.field_delimiter = Some(deser.read_string(member)?);
-197
+                }
                 Some(5) => {
                     builder.quote_character = Some(deser.read_string(member)?);
-200
+                }
                 Some(6) => {
                     builder.allow_quoted_record_delimiter = Some(deser.read_boolean(member)?);
-203
+                }
                 _ => {}
-205
+            }
             Ok(())
         })?;
         Ok(builder.build())
-209
+    }
-210
+}
 impl CsvInput {
     /// 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 CsvInput {
     /// Creates a new builder-style object to manufacture [`CsvInput`](crate::types::CsvInput).
     pub fn builder() -> crate::types::builders::CsvInputBuilder {
         crate::types::builders::CsvInputBuilder::default()
-226
+    }
-227
+}
-228
 /// A builder for [`CsvInput`](crate::types::CsvInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CsvInputBuilder {
     pub(crate) file_header_info: ::std::option::Option<crate::types::FileHeaderInfo>,
     pub(crate) comments: ::std::option::Option<::std::string::String>,
     pub(crate) quote_escape_character: ::std::option::Option<::std::string::String>,
     pub(crate) record_delimiter: ::std::option::Option<::std::string::String>,
     pub(crate) field_delimiter: ::std::option::Option<::std::string::String>,
     pub(crate) quote_character: ::std::option::Option<::std::string::String>,
     pub(crate) allow_quoted_record_delimiter: ::std::option::Option<bool>,
-240
+}
 impl CsvInputBuilder {
     /// <p>Describes the first line of input. Valid values are:</p>
     /// <ul>
     /// <li>
     /// <p><code>NONE</code>: First line is not a header.</p></li>
     /// <li>
     /// <p><code>IGNORE</code>: First line is a header, but you can't use the header values to indicate the column in an expression. You can use column position (such as _1, _2, …) to indicate the column (<code>SELECT s._1 FROM OBJECT s</code>).</p></li>
     /// <li>
     /// <p><code>Use</code>: First line is a header, and you can use the header value to identify a column in an expression (<code>SELECT "name" FROM OBJECT</code>).</p></li>
     /// </ul>
     pub fn file_header_info(mut self, input: crate::types::FileHeaderInfo) -> Self {

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

@@ -27,27 +190,201 @@

↥ Expand context

     /// <li>
     /// <p><code>ALWAYS</code>: Always use quotation marks for output fields.</p></li>
     /// <li>
     /// <p><code>ASNEEDED</code>: Use quotation marks for output fields when needed.</p></li>
     /// </ul>
     pub fn quote_fields(&self) -> ::std::option::Option<&crate::types::QuoteFields> {
         self.quote_fields.as_ref()
-34
+    }
     /// <p>The single character used for escaping the quote character inside an already escaped value.</p>
     pub fn quote_escape_character(&self) -> ::std::option::Option<&str> {
         self.quote_escape_character.as_deref()
-38
+    }
     /// <p>A single character used to separate individual records in the output. Instead of the default value, you can specify an arbitrary delimiter.</p>
     pub fn record_delimiter(&self) -> ::std::option::Option<&str> {
         self.record_delimiter.as_deref()
-42
+    }
     /// <p>The value used to separate individual fields in a record. You can specify an arbitrary delimiter.</p>
     pub fn field_delimiter(&self) -> ::std::option::Option<&str> {
         self.field_delimiter.as_deref()
-46
+    }

     /// <p>A single character used for escaping when the field delimiter is part of the value. For example, if the value is <code>a, b</code>, Amazon S3 wraps this field value in quotation marks, as follows: <code>" a , b "</code>.</p>
     pub fn quote_character(&self) -> ::std::option::Option<&str> {
         self.quote_character.as_deref()
-50
+    }
-51
+}
 static CSVOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput", "com.amazonaws.s3", "CSVOutput");
 static CSVOUTPUT_MEMBER_QUOTE_FIELDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput$QuoteFields", "com.amazonaws.s3", "CSVOutput"),
     ::aws_smithy_schema::ShapeType::String,
     "quote_fields",
     "QuoteFields",
 ,
 );
 static CSVOUTPUT_MEMBER_QUOTE_ESCAPE_CHARACTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput$QuoteEscapeCharacter", "com.amazonaws.s3", "CSVOutput"),
     ::aws_smithy_schema::ShapeType::String,
     "quote_escape_character",
     "QuoteEscapeCharacter",
 ,
 );
 static CSVOUTPUT_MEMBER_RECORD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput$RecordDelimiter", "com.amazonaws.s3", "CSVOutput"),
     ::aws_smithy_schema::ShapeType::String,
     "record_delimiter",
     "RecordDelimiter",
 ,
 );
 static CSVOUTPUT_MEMBER_FIELD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput$FieldDelimiter", "com.amazonaws.s3", "CSVOutput"),
     ::aws_smithy_schema::ShapeType::String,
     "field_delimiter",
     "FieldDelimiter",
 ,
 );
 static CSVOUTPUT_MEMBER_QUOTE_CHARACTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput$QuoteCharacter", "com.amazonaws.s3", "CSVOutput"),
     ::aws_smithy_schema::ShapeType::String,
     "quote_character",
     "QuoteCharacter",
 ,
 );
 static CSVOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CSVOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CSVOUTPUT_MEMBER_QUOTE_FIELDS,
         &CSVOUTPUT_MEMBER_QUOTE_ESCAPE_CHARACTER,
         &CSVOUTPUT_MEMBER_RECORD_DELIMITER,
         &CSVOUTPUT_MEMBER_FIELD_DELIMITER,
         &CSVOUTPUT_MEMBER_QUOTE_CHARACTER,
     ],
 );
 impl CsvOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CSVOUTPUT_SCHEMA;
-98
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CsvOutput {
     #[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.quote_fields {
             ser.write_string(&CSVOUTPUT_MEMBER_QUOTE_FIELDS, val.as_str())?;
-107
+        }
         if let Some(ref val) = self.quote_escape_character {
             ser.write_string(&CSVOUTPUT_MEMBER_QUOTE_ESCAPE_CHARACTER, val)?;
-110
+        }
         if let Some(ref val) = self.record_delimiter {
             ser.write_string(&CSVOUTPUT_MEMBER_RECORD_DELIMITER, val)?;
-113
+        }
         if let Some(ref val) = self.field_delimiter {
             ser.write_string(&CSVOUTPUT_MEMBER_FIELD_DELIMITER, val)?;
-116
+        }
         if let Some(ref val) = self.quote_character {
             ser.write_string(&CSVOUTPUT_MEMBER_QUOTE_CHARACTER, val)?;
-119
+        }
         Ok(())
-121
+    }
-122
+}
 impl CsvOutput {
     /// 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(&CSVOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CSVOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.quote_fields = Some(crate::types::QuoteFields::from(deser.read_string(member)?.as_str()));
-141
+                }
                 Some(1) => {
                     builder.quote_escape_character = Some(deser.read_string(member)?);
-144
+                }
                 Some(2) => {
                     builder.record_delimiter = Some(deser.read_string(member)?);
-147
+                }
                 Some(3) => {
                     builder.field_delimiter = Some(deser.read_string(member)?);
-150
+                }
                 Some(4) => {
                     builder.quote_character = Some(deser.read_string(member)?);
-153
+                }
                 _ => {}
-155
+            }
             Ok(())
         })?;
         Ok(builder.build())
-159
+    }
-160
+}
 impl CsvOutput {
     /// 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 CsvOutput {
     /// Creates a new builder-style object to manufacture [`CsvOutput`](crate::types::CsvOutput).
     pub fn builder() -> crate::types::builders::CsvOutputBuilder {
         crate::types::builders::CsvOutputBuilder::default()
-176
+    }
-177
+}
-178
 /// A builder for [`CsvOutput`](crate::types::CsvOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CsvOutputBuilder {
     pub(crate) quote_fields: ::std::option::Option<crate::types::QuoteFields>,
     pub(crate) quote_escape_character: ::std::option::Option<::std::string::String>,
     pub(crate) record_delimiter: ::std::option::Option<::std::string::String>,
     pub(crate) field_delimiter: ::std::option::Option<::std::string::String>,
     pub(crate) quote_character: ::std::option::Option<::std::string::String>,
-188
+}
 impl CsvOutputBuilder {
     /// <p>Indicates whether to use quotation marks around output fields.</p>
     /// <ul>
     /// <li>
     /// <p><code>ALWAYS</code>: Always use quotation marks for output fields.</p></li>
     /// <li>
     /// <p><code>ASNEEDED</code>: Use quotation marks for output fields when needed.</p></li>
     /// </ul>
     pub fn quote_fields(mut self, input: crate::types::QuoteFields) -> Self {
         self.quote_fields = ::std::option::Option::Some(input);
         self
-200
+    }
     /// <p>Indicates whether to use quotation marks around output fields.</p>

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

@@ -10,10 +147,158 @@

↥ Expand context

 /// </note>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct DefaultRetention {
     /// <p>The default Object Lock retention mode you want to apply to new objects placed in the specified bucket. Must be used with either <code>Days</code> or <code>Years</code>.</p>
     pub mode: ::std::option::Option<crate::types::ObjectLockRetentionMode>,
     /// <p>The number of days that you want to specify for the default retention period. Must be used with <code>Mode</code>.</p>
     pub days: ::std::option::Option<i32>,
     /// <p>The number of years that you want to specify for the default retention period. Must be used with <code>Mode</code>.</p>
     pub years: ::std::option::Option<i32>,
-20
+}
 impl DefaultRetention {
     /// <p>The default Object Lock retention mode you want to apply to new objects placed in the specified bucket. Must be used with either <code>Days</code> or <code>Years</code>.</p>
     pub fn mode(&self) -> ::std::option::Option<&crate::types::ObjectLockRetentionMode> {
         self.mode.as_ref()
-25
+    }
     /// <p>The number of days that you want to specify for the default retention period. Must be used with <code>Mode</code>.</p>
     pub fn days(&self) -> ::std::option::Option<i32> {
         self.days
-29
+    }

     /// <p>The number of years that you want to specify for the default retention period. Must be used with <code>Mode</code>.</p>
     pub fn years(&self) -> ::std::option::Option<i32> {
         self.years
-33
+    }
-34
+}
 static DEFAULTRETENTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DefaultRetention", "com.amazonaws.s3", "DefaultRetention");
 static DEFAULTRETENTION_MEMBER_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DefaultRetention$Mode", "com.amazonaws.s3", "DefaultRetention"),
     ::aws_smithy_schema::ShapeType::String,
     "mode",
     "Mode",
 ,
 );
 static DEFAULTRETENTION_MEMBER_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DefaultRetention$Days", "com.amazonaws.s3", "DefaultRetention"),
     ::aws_smithy_schema::ShapeType::Integer,
     "days",
     "Days",
 ,
 );
 static DEFAULTRETENTION_MEMBER_YEARS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DefaultRetention$Years", "com.amazonaws.s3", "DefaultRetention"),
     ::aws_smithy_schema::ShapeType::Integer,
     "years",
     "Years",
 ,
 );
 static DEFAULTRETENTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DEFAULTRETENTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DEFAULTRETENTION_MEMBER_MODE,
         &DEFAULTRETENTION_MEMBER_DAYS,
         &DEFAULTRETENTION_MEMBER_YEARS,
     ],
 );
 impl DefaultRetention {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEFAULTRETENTION_SCHEMA;
-67
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DefaultRetention {
     #[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.mode {
             ser.write_string(&DEFAULTRETENTION_MEMBER_MODE, val.as_str())?;
-76
+        }
         if let Some(ref val) = self.days {
             ser.write_integer(&DEFAULTRETENTION_MEMBER_DAYS, *val)?;
-79
+        }
         if let Some(ref val) = self.years {
             ser.write_integer(&DEFAULTRETENTION_MEMBER_YEARS, *val)?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl DefaultRetention {
     /// 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(&DEFAULTRETENTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DEFAULTRETENTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.mode = Some(crate::types::ObjectLockRetentionMode::from(deser.read_string(member)?.as_str()));
-104
+                }
                 Some(1) => {
                     builder.days = Some(deser.read_integer(member)?);
-107
+                }
                 Some(2) => {
                     builder.years = Some(deser.read_integer(member)?);
-110
+                }
                 _ => {}
-112
+            }
             Ok(())
         })?;
         Ok(builder.build())
-116
+    }
-117
+}
 impl DefaultRetention {
     /// 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 DefaultRetention {
     /// Creates a new builder-style object to manufacture [`DefaultRetention`](crate::types::DefaultRetention).
     pub fn builder() -> crate::types::builders::DefaultRetentionBuilder {
         crate::types::builders::DefaultRetentionBuilder::default()
-133
+    }
-134
+}
-135
 /// A builder for [`DefaultRetention`](crate::types::DefaultRetention).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DefaultRetentionBuilder {
     pub(crate) mode: ::std::option::Option<crate::types::ObjectLockRetentionMode>,
     pub(crate) days: ::std::option::Option<i32>,
     pub(crate) years: ::std::option::Option<i32>,
-143
+}
 impl DefaultRetentionBuilder {
     /// <p>The default Object Lock retention mode you want to apply to new objects placed in the specified bucket. Must be used with either <code>Days</code> or <code>Years</code>.</p>
     pub fn mode(mut self, input: crate::types::ObjectLockRetentionMode) -> Self {
         self.mode = ::std::option::Option::Some(input);
         self
-149
+    }
     /// <p>The default Object Lock retention mode you want to apply to new objects placed in the specified bucket. Must be used with either <code>Days</code> or <code>Years</code>.</p>
     pub fn set_mode(mut self, input: ::std::option::Option<crate::types::ObjectLockRetentionMode>) -> Self {
         self.mode = input;
         self
-154
+    }
     /// <p>The default Object Lock retention mode you want to apply to new objects placed in the specified bucket. Must be used with either <code>Days</code> or <code>Years</code>.</p>
     pub fn get_mode(&self) -> &::std::option::Option<crate::types::ObjectLockRetentionMode> {
         &self.mode
-158
+    }

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

@@ -2,2 +144,153 @@

↥ Expand context

-2
 /// <p>Container for the objects to delete.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct Delete {
     /// <p>The object to delete.</p><note>
     /// <p><b>Directory buckets</b> - For directory buckets, an object that's composed entirely of whitespace characters is not supported by the <code>DeleteObjects</code> API operation. The request will receive a <code>400 Bad Request</code> error and none of the objects in the request will be deleted.</p>
     /// </note>
     pub objects: ::std::vec::Vec<crate::types::ObjectIdentifier>,
     /// <p>Element to enable quiet mode for the request. When you add this element, you must set its value to <code>true</code>.</p>
     pub quiet: ::std::option::Option<bool>,
-13
+}
 impl Delete {
     /// <p>The object to delete.</p><note>
     /// <p><b>Directory buckets</b> - For directory buckets, an object that's composed entirely of whitespace characters is not supported by the <code>DeleteObjects</code> API operation. The request will receive a <code>400 Bad Request</code> error and none of the objects in the request will be deleted.</p>
     /// </note>
     pub fn objects(&self) -> &[crate::types::ObjectIdentifier] {
         use std::ops::Deref;
         self.objects.deref()
-21
+    }

     /// <p>Element to enable quiet mode for the request. When you add this element, you must set its value to <code>true</code>.</p>
     pub fn quiet(&self) -> ::std::option::Option<bool> {
         self.quiet
-25
+    }
-26
+}
 static DELETE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Delete", "com.amazonaws.s3", "Delete");
 static DELETE_MEMBER_OBJECTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Delete$Objects", "com.amazonaws.s3", "Delete"),
     ::aws_smithy_schema::ShapeType::List,
     "objects",
     "Objects",
 ,
-34
+)
 .with_xml_name("Object")
 .with_xml_flattened();
 static DELETE_MEMBER_QUIET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Delete$Quiet", "com.amazonaws.s3", "Delete"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "quiet",
     "Quiet",
 ,
 );
 static DELETE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DELETE_MEMBER_OBJECTS, &DELETE_MEMBER_QUIET],
 );
 impl Delete {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETE_SCHEMA;
-51
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Delete {
     #[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> {
-58
+        {
             let val = &self.objects;
-60
             ser.write_list(&DELETE_MEMBER_OBJECTS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for item in val {
                     ser.write_struct(crate::types::ObjectIdentifier::SCHEMA, item)?;
-64
+                }
                 Ok(())
             })?;
-67
+        }
         if let Some(ref val) = self.quiet {
             ser.write_boolean(&DELETE_MEMBER_QUIET, *val)?;
-70
+        }
         Ok(())
-72
+    }
-73
+}
 impl Delete {
     /// 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(&DELETE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.objects = 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::ObjectIdentifier::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ObjectIdentifier::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-99
+                }
                 Some(1) => {
                     builder.quiet = Some(deser.read_boolean(member)?);
-102
+                }
                 _ => {}
-104
+            }
             Ok(())
         })?;
         builder.objects = builder.objects.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-111
+    }
-112
+}
 impl Delete {
     /// 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 Delete {
     /// Creates a new builder-style object to manufacture [`Delete`](crate::types::Delete).
     pub fn builder() -> crate::types::builders::DeleteBuilder {
         crate::types::builders::DeleteBuilder::default()
-128
+    }
-129
+}
-130
 /// A builder for [`Delete`](crate::types::Delete).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeleteBuilder {
     pub(crate) objects: ::std::option::Option<::std::vec::Vec<crate::types::ObjectIdentifier>>,
     pub(crate) quiet: ::std::option::Option<bool>,
-137
+}
 impl DeleteBuilder {
     /// Appends an item to `objects`.
     ///
     /// To override the contents of this collection use [`set_objects`](Self::set_objects).
     ///
     /// <p>The object to delete.</p><note>
     /// <p><b>Directory buckets</b> - For directory buckets, an object that's composed entirely of whitespace characters is not supported by the <code>DeleteObjects</code> API operation. The request will receive a <code>400 Bad Request</code> error and none of the objects in the request will be deleted.</p>
     /// </note>
     pub fn objects(mut self, input: crate::types::ObjectIdentifier) -> Self {
         let mut v = self.objects.unwrap_or_default();
         v.push(input);
         self.objects = ::std::option::Option::Some(v);
         self
-151
+    }
     /// <p>The object to delete.</p><note>
     /// <p><b>Directory buckets</b> - For directory buckets, an object that's composed entirely of whitespace characters is not supported by the <code>DeleteObjects</code> API operation. The request will receive a <code>400 Bad Request</code> error and none of the objects in the request will be deleted.</p>

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

@@ -15,15 +178,189 @@

↥ Expand context

     /// <p>Date and time when the object was last modified.</p>
     pub last_modified: ::std::option::Option<::aws_smithy_types::DateTime>,
-17
+}
 impl DeleteMarkerEntry {
     /// <p>The account that created the delete marker.</p>
     pub fn owner(&self) -> ::std::option::Option<&crate::types::Owner> {
         self.owner.as_ref()
-22
+    }
     /// <p>The object key.</p>
     pub fn key(&self) -> ::std::option::Option<&str> {
         self.key.as_deref()
-26
+    }
     /// <p>Version ID of an object.</p>
     pub fn version_id(&self) -> ::std::option::Option<&str> {
         self.version_id.as_deref()
-30
+    }
     /// <p>Specifies whether the object is (true) or is not (false) the latest version of an object.</p>
     pub fn is_latest(&self) -> ::std::option::Option<bool> {
         self.is_latest
-34
+    }

     /// <p>Date and time when the object was last modified.</p>
     pub fn last_modified(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.last_modified.as_ref()
-38
+    }
-39
+}
 static DELETEMARKERENTRY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry", "com.amazonaws.s3", "DeleteMarkerEntry");
 static DELETEMARKERENTRY_MEMBER_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry$Owner", "com.amazonaws.s3", "DeleteMarkerEntry"),
     ::aws_smithy_schema::ShapeType::Structure,
     "owner",
     "Owner",
 ,
 );
 static DELETEMARKERENTRY_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry$Key", "com.amazonaws.s3", "DeleteMarkerEntry"),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
 );
 static DELETEMARKERENTRY_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry$VersionId", "com.amazonaws.s3", "DeleteMarkerEntry"),
     ::aws_smithy_schema::ShapeType::String,
     "version_id",
     "VersionId",
 ,
 );
 static DELETEMARKERENTRY_MEMBER_IS_LATEST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry$IsLatest", "com.amazonaws.s3", "DeleteMarkerEntry"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "is_latest",
     "IsLatest",
 ,
 );
 static DELETEMARKERENTRY_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry$LastModified", "com.amazonaws.s3", "DeleteMarkerEntry"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "last_modified",
     "LastModified",
 ,
 );
 static DELETEMARKERENTRY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETEMARKERENTRY_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DELETEMARKERENTRY_MEMBER_OWNER,
         &DELETEMARKERENTRY_MEMBER_KEY,
         &DELETEMARKERENTRY_MEMBER_VERSION_ID,
         &DELETEMARKERENTRY_MEMBER_IS_LATEST,
         &DELETEMARKERENTRY_MEMBER_LAST_MODIFIED,
     ],
 );
 impl DeleteMarkerEntry {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEMARKERENTRY_SCHEMA;
-86
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeleteMarkerEntry {
     #[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.owner {
             ser.write_struct(&DELETEMARKERENTRY_MEMBER_OWNER, val)?;
-95
+        }
         if let Some(ref val) = self.key {
             ser.write_string(&DELETEMARKERENTRY_MEMBER_KEY, val)?;
-98
+        }
         if let Some(ref val) = self.version_id {
             ser.write_string(&DELETEMARKERENTRY_MEMBER_VERSION_ID, val)?;
-101
+        }
         if let Some(ref val) = self.is_latest {
             ser.write_boolean(&DELETEMARKERENTRY_MEMBER_IS_LATEST, *val)?;
-104
+        }
         if let Some(ref val) = self.last_modified {
             ser.write_timestamp(&DELETEMARKERENTRY_MEMBER_LAST_MODIFIED, val)?;
-107
+        }
         Ok(())
-109
+    }
-110
+}
 impl DeleteMarkerEntry {
     /// 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(&DELETEMARKERENTRY_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETEMARKERENTRY_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.owner = Some(crate::types::Owner::deserialize(deser)?);
-129
+                }
                 Some(1) => {
                     builder.key = Some(deser.read_string(member)?);
-132
+                }
                 Some(2) => {
                     builder.version_id = Some(deser.read_string(member)?);
-135
+                }
                 Some(3) => {
                     builder.is_latest = Some(deser.read_boolean(member)?);
-138
+                }
                 Some(4) => {
                     builder.last_modified = Some(deser.read_timestamp(member)?);
-141
+                }
                 _ => {}
-143
+            }
             Ok(())
         })?;
         Ok(builder.build())
-147
+    }
-148
+}
 impl DeleteMarkerEntry {
     /// 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 DeleteMarkerEntry {
     /// Creates a new builder-style object to manufacture [`DeleteMarkerEntry`](crate::types::DeleteMarkerEntry).
     pub fn builder() -> crate::types::builders::DeleteMarkerEntryBuilder {
         crate::types::builders::DeleteMarkerEntryBuilder::default()
-164
+    }
-165
+}
-166
 /// A builder for [`DeleteMarkerEntry`](crate::types::DeleteMarkerEntry).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeleteMarkerEntryBuilder {
     pub(crate) owner: ::std::option::Option<crate::types::Owner>,
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) version_id: ::std::option::Option<::std::string::String>,
     pub(crate) is_latest: ::std::option::Option<bool>,
     pub(crate) last_modified: ::std::option::Option<::aws_smithy_types::DateTime>,
-176
+}
 impl DeleteMarkerEntryBuilder {
     /// <p>The account that created the delete marker.</p>
     pub fn owner(mut self, input: crate::types::Owner) -> Self {
         self.owner = ::std::option::Option::Some(input);
         self
-182
+    }
     /// <p>The account that created the delete marker.</p>
     pub fn set_owner(mut self, input: ::std::option::Option<crate::types::Owner>) -> Self {
         self.owner = input;
         self
-187
+    }
     /// <p>The account that created the delete marker.</p>
     pub fn get_owner(&self) -> &::std::option::Option<crate::types::Owner> {

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

@@ -2,2 +111,122 @@

↥ Expand context

-2
 /// <p>Specifies whether Amazon S3 replicates delete markers. If you specify a <code>Filter</code> in your replication configuration, you must also include a <code>DeleteMarkerReplication</code> element. If your <code>Filter</code> includes a <code>Tag</code> element, the <code>DeleteMarkerReplication</code> <code>Status</code> must be set to Disabled, because Amazon S3 does not support replicating delete markers for tag-based rules. For an example configuration, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html#replication-config-min-rule-config">Basic Rule Configuration</a>.</p>
 /// <p>For more information about delete marker replication, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/delete-marker-replication.html">Basic Rule Configuration</a>.</p><note>
 /// <p>If you are using an earlier version of the replication configuration, Amazon S3 handles replication of delete markers differently. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html#replication-backward-compat-considerations">Backward Compatibility</a>.</p>
 /// </note>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct DeleteMarkerReplication {
     /// <p>Indicates whether to replicate delete markers.</p><note>
     /// <p>Indicates whether to replicate delete markers.</p>
     /// </note>
     pub status: ::std::option::Option<crate::types::DeleteMarkerReplicationStatus>,
-14
+}
 impl DeleteMarkerReplication {
     /// <p>Indicates whether to replicate delete markers.</p><note>
     /// <p>Indicates whether to replicate delete markers.</p>
     /// </note>
     pub fn status(&self) -> ::std::option::Option<&crate::types::DeleteMarkerReplicationStatus> {
         self.status.as_ref()
-21
+    }

-22
+}
 static DELETEMARKERREPLICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerReplication", "com.amazonaws.s3", "DeleteMarkerReplication");
 static DELETEMARKERREPLICATION_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#DeleteMarkerReplication$Status",
         "com.amazonaws.s3",
         "DeleteMarkerReplication",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status",
     "Status",
 ,
 );
 static DELETEMARKERREPLICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETEMARKERREPLICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DELETEMARKERREPLICATION_MEMBER_STATUS],
 );
 impl DeleteMarkerReplication {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEMARKERREPLICATION_SCHEMA;
-43
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeleteMarkerReplication {
     #[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.status {
             ser.write_string(&DELETEMARKERREPLICATION_MEMBER_STATUS, val.as_str())?;
-52
+        }
         Ok(())
-54
+    }
-55
+}
 impl DeleteMarkerReplication {
     /// 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(&DELETEMARKERREPLICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETEMARKERREPLICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.status = Some(crate::types::DeleteMarkerReplicationStatus::from(deser.read_string(member)?.as_str()));
-74
+                }
                 _ => {}
-76
+            }
             Ok(())
         })?;
         Ok(builder.build())
-80
+    }
-81
+}
 impl DeleteMarkerReplication {
     /// 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 DeleteMarkerReplication {
     /// Creates a new builder-style object to manufacture [`DeleteMarkerReplication`](crate::types::DeleteMarkerReplication).
     pub fn builder() -> crate::types::builders::DeleteMarkerReplicationBuilder {
         crate::types::builders::DeleteMarkerReplicationBuilder::default()
-97
+    }
-98
+}
-99
 /// A builder for [`DeleteMarkerReplication`](crate::types::DeleteMarkerReplication).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeleteMarkerReplicationBuilder {
     pub(crate) status: ::std::option::Option<crate::types::DeleteMarkerReplicationStatus>,
-105
+}
 impl DeleteMarkerReplicationBuilder {
     /// <p>Indicates whether to replicate delete markers.</p><note>
     /// <p>Indicates whether to replicate delete markers.</p>
     /// </note>
     pub fn status(mut self, input: crate::types::DeleteMarkerReplicationStatus) -> Self {
         self.status = ::std::option::Option::Some(input);
         self
-113
+    }
     /// <p>Indicates whether to replicate delete markers.</p><note>
     /// <p>Indicates whether to replicate delete markers.</p>
     /// </note>
     pub fn set_status(mut self, input: ::std::option::Option<crate::types::DeleteMarkerReplicationStatus>) -> Self {
         self.status = input;
         self
-120
+    }
     /// <p>Indicates whether to replicate delete markers.</p><note>
     /// <p>Indicates whether to replicate delete markers.</p>

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

@@ -21,21 +175,186 @@

↥ Expand context

-21
+}
 impl DeletedObject {
     /// <p>The name of the deleted object.</p>
     pub fn key(&self) -> ::std::option::Option<&str> {
         self.key.as_deref()
-26
+    }
     /// <p>The version ID of the deleted object.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn version_id(&self) -> ::std::option::Option<&str> {
         self.version_id.as_deref()
-32
+    }
     /// <p>Indicates whether the specified object version that was permanently deleted was (true) or was not (false) a delete marker before deletion. In a simple DELETE, this header indicates whether (true) or not (false) the current version of the object is a delete marker. To learn more about delete markers, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/DeleteMarker.html">Working with delete markers</a>.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>
     /// </note>
     pub fn delete_marker(&self) -> ::std::option::Option<bool> {
         self.delete_marker
-38
+    }
     /// <p>The version ID of the delete marker created as a result of the DELETE operation. If you delete a specific object version, the value returned by this header is the version ID of the object version deleted.</p><note>
     /// <p>This functionality is not supported for directory buckets.</p>

     /// </note>
     pub fn delete_marker_version_id(&self) -> ::std::option::Option<&str> {
         self.delete_marker_version_id.as_deref()
-44
+    }
-45
+}
 static DELETEDOBJECT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeletedObject", "com.amazonaws.s3", "DeletedObject");
 static DELETEDOBJECT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeletedObject$Key", "com.amazonaws.s3", "DeletedObject"),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
 );
 static DELETEDOBJECT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeletedObject$VersionId", "com.amazonaws.s3", "DeletedObject"),
     ::aws_smithy_schema::ShapeType::String,
     "version_id",
     "VersionId",
 ,
 );
 static DELETEDOBJECT_MEMBER_DELETE_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeletedObject$DeleteMarker", "com.amazonaws.s3", "DeletedObject"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "delete_marker",
     "DeleteMarker",
 ,
 );
 static DELETEDOBJECT_MEMBER_DELETE_MARKER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#DeletedObject$DeleteMarkerVersionId",
         "com.amazonaws.s3",
         "DeletedObject",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "delete_marker_version_id",
     "DeleteMarkerVersionId",
 ,
 );
 static DELETEDOBJECT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETEDOBJECT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DELETEDOBJECT_MEMBER_KEY,
         &DELETEDOBJECT_MEMBER_VERSION_ID,
         &DELETEDOBJECT_MEMBER_DELETE_MARKER,
         &DELETEDOBJECT_MEMBER_DELETE_MARKER_VERSION_ID,
     ],
 );
 impl DeletedObject {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEDOBJECT_SCHEMA;
-89
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeletedObject {
     #[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(&DELETEDOBJECT_MEMBER_KEY, val)?;
-98
+        }
         if let Some(ref val) = self.version_id {
             ser.write_string(&DELETEDOBJECT_MEMBER_VERSION_ID, val)?;
-101
+        }
         if let Some(ref val) = self.delete_marker {
             ser.write_boolean(&DELETEDOBJECT_MEMBER_DELETE_MARKER, *val)?;
-104
+        }
         if let Some(ref val) = self.delete_marker_version_id {
             ser.write_string(&DELETEDOBJECT_MEMBER_DELETE_MARKER_VERSION_ID, val)?;
-107
+        }
         Ok(())
-109
+    }
-110
+}
 impl DeletedObject {
     /// 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(&DELETEDOBJECT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETEDOBJECT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.key = Some(deser.read_string(member)?);
-129
+                }
                 Some(1) => {
                     builder.version_id = Some(deser.read_string(member)?);
-132
+                }
                 Some(2) => {
                     builder.delete_marker = Some(deser.read_boolean(member)?);
-135
+                }
                 Some(3) => {
                     builder.delete_marker_version_id = Some(deser.read_string(member)?);
-138
+                }
                 _ => {}
-140
+            }
             Ok(())
         })?;
         Ok(builder.build())
-144
+    }
-145
+}
 impl DeletedObject {
     /// 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 DeletedObject {
     /// Creates a new builder-style object to manufacture [`DeletedObject`](crate::types::DeletedObject).
     pub fn builder() -> crate::types::builders::DeletedObjectBuilder {
         crate::types::builders::DeletedObjectBuilder::default()
-161
+    }
-162
+}
-163
 /// A builder for [`DeletedObject`](crate::types::DeletedObject).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeletedObjectBuilder {
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) version_id: ::std::option::Option<::std::string::String>,
     pub(crate) delete_marker: ::std::option::Option<bool>,
     pub(crate) delete_marker_version_id: ::std::option::Option<::std::string::String>,
-172
+}
 impl DeletedObjectBuilder {
     /// <p>The name of the deleted object.</p>
     pub fn key(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.key = ::std::option::Option::Some(input.into());
         self
-178
+    }
     /// <p>The name of the deleted object.</p>
     pub fn set_key(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.key = input;
         self
-183
+    }
     /// <p>The name of the deleted object.</p>
     pub fn get_key(&self) -> &::std::option::Option<::std::string::String> {
         &self.key

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

@@ -32,32 +224,236 @@

↥ Expand context

         self.account.as_deref()
-33
+    }
     /// <p>The storage class to use when replicating objects, such as S3 Standard or reduced redundancy. By default, Amazon S3 uses the storage class of the source object to create the object replica.</p>
     /// <p>For valid values, see the <code>StorageClass</code> element of the <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTreplication.html">PUT Bucket replication</a> action in the <i>Amazon S3 API Reference</i>.</p>
     /// <p><code>FSX_OPENZFS</code> is not an accepted value when replicating objects.</p>
     pub fn storage_class(&self) -> ::std::option::Option<&crate::types::StorageClass> {
         self.storage_class.as_ref()
-39
+    }
     /// <p>Specify this only in a cross-account scenario (where source and destination bucket owners are not the same), and you want to change replica ownership to the Amazon Web Services account that owns the destination bucket. If this is not specified in the replication configuration, the replicas are owned by same Amazon Web Services account that owns the source object.</p>
     pub fn access_control_translation(&self) -> ::std::option::Option<&crate::types::AccessControlTranslation> {
         self.access_control_translation.as_ref()
-43
+    }
     /// <p>A container that provides information about encryption. If <code>SourceSelectionCriteria</code> is specified, you must specify this element.</p>
     pub fn encryption_configuration(&self) -> ::std::option::Option<&crate::types::EncryptionConfiguration> {
         self.encryption_configuration.as_ref()
-47
+    }
     /// <p>A container specifying S3 Replication Time Control (S3 RTC), including whether S3 RTC is enabled and the time when all objects and operations on objects must be replicated. Must be specified together with a <code>Metrics</code> block.</p>
     pub fn replication_time(&self) -> ::std::option::Option<&crate::types::ReplicationTime> {
         self.replication_time.as_ref()
-51
+    }

     /// <p>A container specifying replication metrics-related settings enabling replication metrics and events.</p>
     pub fn metrics(&self) -> ::std::option::Option<&crate::types::Metrics> {
         self.metrics.as_ref()
-55
+    }
-56
+}
 static DESTINATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination", "com.amazonaws.s3", "Destination");
 static DESTINATION_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$Bucket", "com.amazonaws.s3", "Destination"),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
 );
 static DESTINATION_MEMBER_ACCOUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$Account", "com.amazonaws.s3", "Destination"),
     ::aws_smithy_schema::ShapeType::String,
     "account",
     "Account",
 ,
 );
 static DESTINATION_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$StorageClass", "com.amazonaws.s3", "Destination"),
     ::aws_smithy_schema::ShapeType::String,
     "storage_class",
     "StorageClass",
 ,
 );
 static DESTINATION_MEMBER_ACCESS_CONTROL_TRANSLATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$AccessControlTranslation", "com.amazonaws.s3", "Destination"),
     ::aws_smithy_schema::ShapeType::Structure,
     "access_control_translation",
     "AccessControlTranslation",
 ,
 );
 static DESTINATION_MEMBER_ENCRYPTION_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$EncryptionConfiguration", "com.amazonaws.s3", "Destination"),
     ::aws_smithy_schema::ShapeType::Structure,
     "encryption_configuration",
     "EncryptionConfiguration",
 ,
 );
 static DESTINATION_MEMBER_REPLICATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$ReplicationTime", "com.amazonaws.s3", "Destination"),
     ::aws_smithy_schema::ShapeType::Structure,
     "replication_time",
     "ReplicationTime",
 ,
 );
 static DESTINATION_MEMBER_METRICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$Metrics", "com.amazonaws.s3", "Destination"),
     ::aws_smithy_schema::ShapeType::Structure,
     "metrics",
     "Metrics",
 ,
 );
 static DESTINATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DESTINATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DESTINATION_MEMBER_BUCKET,
         &DESTINATION_MEMBER_ACCOUNT,
         &DESTINATION_MEMBER_STORAGE_CLASS,
         &DESTINATION_MEMBER_ACCESS_CONTROL_TRANSLATION,
         &DESTINATION_MEMBER_ENCRYPTION_CONFIGURATION,
         &DESTINATION_MEMBER_REPLICATION_TIME,
         &DESTINATION_MEMBER_METRICS,
     ],
 );
 impl Destination {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESTINATION_SCHEMA;
-117
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Destination {
     #[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> {
-124
+        {
             let val = &self.bucket;
             ser.write_string(&DESTINATION_MEMBER_BUCKET, val)?;
-127
+        }
         if let Some(ref val) = self.account {
             ser.write_string(&DESTINATION_MEMBER_ACCOUNT, val)?;
-130
+        }
         if let Some(ref val) = self.storage_class {
             ser.write_string(&DESTINATION_MEMBER_STORAGE_CLASS, val.as_str())?;
-133
+        }
         if let Some(ref val) = self.access_control_translation {
             ser.write_struct(&DESTINATION_MEMBER_ACCESS_CONTROL_TRANSLATION, val)?;
-136
+        }
         if let Some(ref val) = self.encryption_configuration {
             ser.write_struct(&DESTINATION_MEMBER_ENCRYPTION_CONFIGURATION, val)?;
-139
+        }
         if let Some(ref val) = self.replication_time {
             ser.write_struct(&DESTINATION_MEMBER_REPLICATION_TIME, val)?;
-142
+        }
         if let Some(ref val) = self.metrics {
             ser.write_struct(&DESTINATION_MEMBER_METRICS, val)?;
-145
+        }
         Ok(())
-147
+    }
-148
+}
 impl Destination {
     /// 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(&DESTINATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DESTINATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.bucket = Some(deser.read_string(member)?);
-167
+                }
                 Some(1) => {
                     builder.account = Some(deser.read_string(member)?);
-170
+                }
                 Some(2) => {
                     builder.storage_class = Some(crate::types::StorageClass::from(deser.read_string(member)?.as_str()));
-173
+                }
                 Some(3) => {
                     builder.access_control_translation = Some(crate::types::AccessControlTranslation::deserialize(deser)?);
-176
+                }
                 Some(4) => {
                     builder.encryption_configuration = Some(crate::types::EncryptionConfiguration::deserialize(deser)?);
-179
+                }
                 Some(5) => {
                     builder.replication_time = Some(crate::types::ReplicationTime::deserialize(deser)?);
-182
+                }
                 Some(6) => {
                     builder.metrics = Some(crate::types::Metrics::deserialize(deser)?);
-185
+                }
                 _ => {}
-187
+            }
             Ok(())
         })?;
         builder.bucket = builder.bucket.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-194
+    }
-195
+}
 impl Destination {
     /// 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 Destination {
     /// Creates a new builder-style object to manufacture [`Destination`](crate::types::Destination).
     pub fn builder() -> crate::types::builders::DestinationBuilder {
         crate::types::builders::DestinationBuilder::default()
-211
+    }
-212
+}
-213
 /// A builder for [`Destination`](crate::types::Destination).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DestinationBuilder {
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) account: ::std::option::Option<::std::string::String>,
     pub(crate) storage_class: ::std::option::Option<crate::types::StorageClass>,
     pub(crate) access_control_translation: ::std::option::Option<crate::types::AccessControlTranslation>,
     pub(crate) encryption_configuration: ::std::option::Option<crate::types::EncryptionConfiguration>,
     pub(crate) replication_time: ::std::option::Option<crate::types::ReplicationTime>,
     pub(crate) metrics: ::std::option::Option<crate::types::Metrics>,
-225
+}
 impl DestinationBuilder {
     /// <p>The Amazon Resource Name (ARN) of the bucket where you want Amazon S3 to store the results.</p>
     /// This field is required.
     pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.bucket = ::std::option::Option::Some(input.into());
         self
-232
+    }
     /// <p>The Amazon Resource Name (ARN) of the bucket where you want Amazon S3 to store the results.</p>
     pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.bucket = input;
         self

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

@@ -7,7 +152,163 @@

↥ Expand context

     /// <p>The type of the table bucket where the metadata configuration is stored. The <code>aws</code> value indicates an Amazon Web Services managed table bucket, and the <code>customer</code> value indicates a customer-managed table bucket. V2 metadata configurations are stored in Amazon Web Services managed table buckets, and V1 metadata configurations are stored in customer-managed table buckets.</p>
     pub table_bucket_type: ::std::option::Option<crate::types::S3TablesBucketType>,
     /// <p>The Amazon Resource Name (ARN) of the table bucket where the metadata configuration is stored.</p>
     pub table_bucket_arn: ::std::option::Option<::std::string::String>,
     /// <p>The namespace in the table bucket where the metadata tables for a metadata configuration are stored.</p>
     pub table_namespace: ::std::option::Option<::std::string::String>,
-13
+}
 impl DestinationResult {
     /// <p>The type of the table bucket where the metadata configuration is stored. The <code>aws</code> value indicates an Amazon Web Services managed table bucket, and the <code>customer</code> value indicates a customer-managed table bucket. V2 metadata configurations are stored in Amazon Web Services managed table buckets, and V1 metadata configurations are stored in customer-managed table buckets.</p>
     pub fn table_bucket_type(&self) -> ::std::option::Option<&crate::types::S3TablesBucketType> {
         self.table_bucket_type.as_ref()
-18
+    }
     /// <p>The Amazon Resource Name (ARN) of the table bucket where the metadata configuration is stored.</p>
     pub fn table_bucket_arn(&self) -> ::std::option::Option<&str> {
         self.table_bucket_arn.as_deref()
-22
+    }
     /// <p>The namespace in the table bucket where the metadata tables for a metadata configuration are stored.</p>
     pub fn table_namespace(&self) -> ::std::option::Option<&str> {
         self.table_namespace.as_deref()
-26
+    }

-27
+}
 static DESTINATIONRESULT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DestinationResult", "com.amazonaws.s3", "DestinationResult");
 static DESTINATIONRESULT_MEMBER_TABLE_BUCKET_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#DestinationResult$TableBucketType",
         "com.amazonaws.s3",
         "DestinationResult",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_bucket_type",
     "TableBucketType",
 ,
 );
 static DESTINATIONRESULT_MEMBER_TABLE_BUCKET_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#DestinationResult$TableBucketArn",
         "com.amazonaws.s3",
         "DestinationResult",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_bucket_arn",
     "TableBucketArn",
 ,
 );
 static DESTINATIONRESULT_MEMBER_TABLE_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#DestinationResult$TableNamespace",
         "com.amazonaws.s3",
         "DestinationResult",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_namespace",
     "TableNamespace",
 ,
 );
 static DESTINATIONRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DESTINATIONRESULT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DESTINATIONRESULT_MEMBER_TABLE_BUCKET_TYPE,
         &DESTINATIONRESULT_MEMBER_TABLE_BUCKET_ARN,
         &DESTINATIONRESULT_MEMBER_TABLE_NAMESPACE,
     ],
 );
 impl DestinationResult {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESTINATIONRESULT_SCHEMA;
-72
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DestinationResult {
     #[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.table_bucket_type {
             ser.write_string(&DESTINATIONRESULT_MEMBER_TABLE_BUCKET_TYPE, val.as_str())?;
-81
+        }
         if let Some(ref val) = self.table_bucket_arn {
             ser.write_string(&DESTINATIONRESULT_MEMBER_TABLE_BUCKET_ARN, val)?;
-84
+        }
         if let Some(ref val) = self.table_namespace {
             ser.write_string(&DESTINATIONRESULT_MEMBER_TABLE_NAMESPACE, val)?;
-87
+        }
         Ok(())
-89
+    }
-90
+}
 impl DestinationResult {
     /// 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(&DESTINATIONRESULT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DESTINATIONRESULT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_bucket_type = Some(crate::types::S3TablesBucketType::from(deser.read_string(member)?.as_str()));
-109
+                }
                 Some(1) => {
                     builder.table_bucket_arn = Some(deser.read_string(member)?);
-112
+                }
                 Some(2) => {
                     builder.table_namespace = Some(deser.read_string(member)?);
-115
+                }
                 _ => {}
-117
+            }
             Ok(())
         })?;
         Ok(builder.build())
-121
+    }
-122
+}
 impl DestinationResult {
     /// 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 DestinationResult {
     /// Creates a new builder-style object to manufacture [`DestinationResult`](crate::types::DestinationResult).
     pub fn builder() -> crate::types::builders::DestinationResultBuilder {
         crate::types::builders::DestinationResultBuilder::default()
-138
+    }
-139
+}
-140
 /// A builder for [`DestinationResult`](crate::types::DestinationResult).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DestinationResultBuilder {
     pub(crate) table_bucket_type: ::std::option::Option<crate::types::S3TablesBucketType>,
     pub(crate) table_bucket_arn: ::std::option::Option<::std::string::String>,
     pub(crate) table_namespace: ::std::option::Option<::std::string::String>,
-148
+}
 impl DestinationResultBuilder {
     /// <p>The type of the table bucket where the metadata configuration is stored. The <code>aws</code> value indicates an Amazon Web Services managed table bucket, and the <code>customer</code> value indicates a customer-managed table bucket. V2 metadata configurations are stored in Amazon Web Services managed table buckets, and V1 metadata configurations are stored in customer-managed table buckets.</p>
     pub fn table_bucket_type(mut self, input: crate::types::S3TablesBucketType) -> Self {
         self.table_bucket_type = ::std::option::Option::Some(input);
         self
-154
+    }
     /// <p>The type of the table bucket where the metadata configuration is stored. The <code>aws</code> value indicates an Amazon Web Services managed table bucket, and the <code>customer</code> value indicates a customer-managed table bucket. V2 metadata configurations are stored in Amazon Web Services managed table buckets, and V1 metadata configurations are stored in customer-managed table buckets.</p>
     pub fn set_table_bucket_type(mut self, input: ::std::option::Option<crate::types::S3TablesBucketType>) -> Self {
         self.table_bucket_type = input;
         self
-159
+    }
     /// <p>The type of the table bucket where the metadata configuration is stored. The <code>aws</code> value indicates an Amazon Web Services managed table bucket, and the <code>customer</code> value indicates a customer-managed table bucket. V2 metadata configurations are stored in Amazon Web Services managed table buckets, and V1 metadata configurations are stored in customer-managed table buckets.</p>
     pub fn get_table_bucket_type(&self) -> &::std::option::Option<crate::types::S3TablesBucketType> {
         &self.table_bucket_type
-163
+    }

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

@@ -12,12 +152,163 @@

↥ Expand context

     pub kms_context: ::std::option::Option<::std::string::String>,
-13
+}
 impl Encryption {
     /// <p>The server-side encryption algorithm used when storing job results in Amazon S3 (for example, AES256, <code>aws:kms</code>).</p>
     pub fn encryption_type(&self) -> &crate::types::ServerSideEncryption {
         &self.encryption_type
-18
+    }
     /// <p>If the encryption type is <code>aws:kms</code>, this optional value specifies the ID of the symmetric encryption customer managed key to use for encryption of job results. Amazon S3 only supports symmetric encryption KMS keys. For more information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Asymmetric keys in KMS</a> in the <i>Amazon Web Services Key Management Service Developer Guide</i>.</p>
     pub fn kms_key_id(&self) -> ::std::option::Option<&str> {
         self.kms_key_id.as_deref()
-22
+    }
     /// <p>If the encryption type is <code>aws:kms</code>, this optional value can be used to specify the encryption context for the restore results.</p>
     pub fn kms_context(&self) -> ::std::option::Option<&str> {
         self.kms_context.as_deref()
-26
+    }
-27
+}
 impl ::std::fmt::Debug for Encryption {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("Encryption");
         formatter.field("encryption_type", &self.encryption_type);

         formatter.field("kms_key_id", &"*** Sensitive Data Redacted ***");
         formatter.field("kms_context", &self.kms_context);
         formatter.finish()
-35
+    }
-36
+}
 static ENCRYPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Encryption", "com.amazonaws.s3", "Encryption");
 static ENCRYPTION_MEMBER_ENCRYPTION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Encryption$EncryptionType", "com.amazonaws.s3", "Encryption"),
     ::aws_smithy_schema::ShapeType::String,
     "encryption_type",
     "EncryptionType",
 ,
 );
 static ENCRYPTION_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Encryption$KMSKeyId", "com.amazonaws.s3", "Encryption"),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_id",
     "KMSKeyId",
 ,
 );
 static ENCRYPTION_MEMBER_KMS_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Encryption$KMSContext", "com.amazonaws.s3", "Encryption"),
     ::aws_smithy_schema::ShapeType::String,
     "kms_context",
     "KMSContext",
 ,
 );
 static ENCRYPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ENCRYPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ENCRYPTION_MEMBER_ENCRYPTION_TYPE,
         &ENCRYPTION_MEMBER_KMS_KEY_ID,
         &ENCRYPTION_MEMBER_KMS_CONTEXT,
     ],
 );
 impl Encryption {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ENCRYPTION_SCHEMA;
-69
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Encryption {
     #[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> {
-76
+        {
             let val = &self.encryption_type;
             ser.write_string(&ENCRYPTION_MEMBER_ENCRYPTION_TYPE, val.as_str())?;
-79
+        }
         if let Some(ref val) = self.kms_key_id {
             ser.write_string(&ENCRYPTION_MEMBER_KMS_KEY_ID, val)?;
-82
+        }
         if let Some(ref val) = self.kms_context {
             ser.write_string(&ENCRYPTION_MEMBER_KMS_CONTEXT, val)?;
-85
+        }
         Ok(())
-87
+    }
-88
+}
 impl Encryption {
     /// 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(&ENCRYPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ENCRYPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.encryption_type = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
-107
+                }
                 Some(1) => {
                     builder.kms_key_id = Some(deser.read_string(member)?);
-110
+                }
                 Some(2) => {
                     builder.kms_context = Some(deser.read_string(member)?);
-113
+                }
                 _ => {}
-115
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-121
+    }
-122
+}
 impl Encryption {
     /// 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 Encryption {
     /// Creates a new builder-style object to manufacture [`Encryption`](crate::types::Encryption).
     pub fn builder() -> crate::types::builders::EncryptionBuilder {
         crate::types::builders::EncryptionBuilder::default()
-138
+    }
-139
+}
-140
 /// A builder for [`Encryption`](crate::types::Encryption).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct EncryptionBuilder {
     pub(crate) encryption_type: ::std::option::Option<crate::types::ServerSideEncryption>,
     pub(crate) kms_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) kms_context: ::std::option::Option<::std::string::String>,
-148
+}
 impl EncryptionBuilder {
     /// <p>The server-side encryption algorithm used when storing job results in Amazon S3 (for example, AES256, <code>aws:kms</code>).</p>
     /// This field is required.
     pub fn encryption_type(mut self, input: crate::types::ServerSideEncryption) -> Self {
         self.encryption_type = ::std::option::Option::Some(input);
         self
-155
+    }
     /// <p>The server-side encryption algorithm used when storing job results in Amazon S3 (for example, AES256, <code>aws:kms</code>).</p>
     pub fn set_encryption_type(mut self, input: ::std::option::Option<crate::types::ServerSideEncryption>) -> Self {
         self.encryption_type = input;
         self
-160
+    }
     /// <p>The server-side encryption algorithm used when storing job results in Amazon S3 (for example, AES256, <code>aws:kms</code>).</p>
     pub fn get_encryption_type(&self) -> &::std::option::Option<crate::types::ServerSideEncryption> {
         &self.encryption_type

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

@@ -1,1 +106,117 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Specifies encryption-related information for an Amazon S3 bucket that is a destination for replicated objects.</p><note>
 /// <p>If you're specifying a customer managed KMS key, we recommend using a fully qualified KMS key ARN. If you use a KMS key alias instead, then KMS resolves the key within the requester’s account. This behavior can result in data that's encrypted with a KMS key that belongs to the requester, and not the bucket owner.</p>
 /// </note>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct EncryptionConfiguration {
     /// <p>Specifies the ID (Key ARN or Alias ARN) of the customer managed Amazon Web Services KMS key stored in Amazon Web Services Key Management Service (KMS) for the destination bucket. Amazon S3 uses this key to encrypt replica objects. Amazon S3 only supports symmetric encryption KMS keys. For more information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Asymmetric keys in Amazon Web Services KMS</a> in the <i>Amazon Web Services Key Management Service Developer Guide</i>.</p>
     pub replica_kms_key_id: ::std::option::Option<::std::string::String>,
-11
+}
 impl EncryptionConfiguration {
     /// <p>Specifies the ID (Key ARN or Alias ARN) of the customer managed Amazon Web Services KMS key stored in Amazon Web Services Key Management Service (KMS) for the destination bucket. Amazon S3 uses this key to encrypt replica objects. Amazon S3 only supports symmetric encryption KMS keys. For more information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Asymmetric keys in Amazon Web Services KMS</a> in the <i>Amazon Web Services Key Management Service Developer Guide</i>.</p>
     pub fn replica_kms_key_id(&self) -> ::std::option::Option<&str> {
         self.replica_kms_key_id.as_deref()
-16
+    }

-17
+}
 static ENCRYPTIONCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#EncryptionConfiguration", "com.amazonaws.s3", "EncryptionConfiguration");
 static ENCRYPTIONCONFIGURATION_MEMBER_REPLICA_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.s3#EncryptionConfiguration$ReplicaKmsKeyID",
         "com.amazonaws.s3",
         "EncryptionConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "replica_kms_key_id",
     "ReplicaKmsKeyID",
 ,
 );
 static ENCRYPTIONCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ENCRYPTIONCONFIGURATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ENCRYPTIONCONFIGURATION_MEMBER_REPLICA_KMS_KEY_ID],
 );
 impl EncryptionConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ENCRYPTIONCONFIGURATION_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EncryptionConfiguration {
     #[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.replica_kms_key_id {
             ser.write_string(&ENCRYPTIONCONFIGURATION_MEMBER_REPLICA_KMS_KEY_ID, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl EncryptionConfiguration {
     /// 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(&ENCRYPTIONCONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ENCRYPTIONCONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.replica_kms_key_id = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl EncryptionConfiguration {
     /// 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 EncryptionConfiguration {
     /// Creates a new builder-style object to manufacture [`EncryptionConfiguration`](crate::types::EncryptionConfiguration).
     pub fn builder() -> crate::types::builders::EncryptionConfigurationBuilder {
         crate::types::builders::EncryptionConfigurationBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`EncryptionConfiguration`](crate::types::EncryptionConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EncryptionConfigurationBuilder {
     pub(crate) replica_kms_key_id: ::std::option::Option<::std::string::String>,
-100
+}
 impl EncryptionConfigurationBuilder {
     /// <p>Specifies the ID (Key ARN or Alias ARN) of the customer managed Amazon Web Services KMS key stored in Amazon Web Services Key Management Service (KMS) for the destination bucket. Amazon S3 uses this key to encrypt replica objects. Amazon S3 only supports symmetric encryption KMS keys. For more information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Asymmetric keys in Amazon Web Services KMS</a> in the <i>Amazon Web Services Key Management Service Developer Guide</i>.</p>
     pub fn replica_kms_key_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.replica_kms_key_id = ::std::option::Option::Some(input.into());
         self
-106
+    }
     /// <p>Specifies the ID (Key ARN or Alias ARN) of the customer managed Amazon Web Services KMS key stored in Amazon Web Services Key Management Service (KMS) for the destination bucket. Amazon S3 uses this key to encrypt replica objects. Amazon S3 only supports symmetric encryption KMS keys. For more information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Asymmetric keys in Amazon Web Services KMS</a> in the <i>Amazon Web Services Key Management Service Developer Guide</i>.</p>
     pub fn set_replica_kms_key_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.replica_kms_key_id = input;
         self
-111
+    }
     /// <p>Specifies the ID (Key ARN or Alias ARN) of the customer managed Amazon Web Services KMS key stored in Amazon Web Services Key Management Service (KMS) for the destination bucket. Amazon S3 uses this key to encrypt replica objects. Amazon S3 only supports symmetric encryption KMS keys. For more information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Asymmetric keys in Amazon Web Services KMS</a> in the <i>Amazon Web Services Key Management Service Developer Guide</i>.</p>
     pub fn get_replica_kms_key_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.replica_kms_key_id
-115
+    }
     /// Consumes the builder and constructs a [`EncryptionConfiguration`](crate::types::EncryptionConfiguration).
     pub fn build(self) -> crate::types::EncryptionConfiguration {

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

@@ -1,1 +63,74 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>A message that indicates the request is complete and no more messages will be sent. You should not assume that the request is complete until the client receives an <code>EndEvent</code>.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct EndEvent {}
 static ENDEVENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#EndEvent", "com.amazonaws.s3", "EndEvent");
 static ENDEVENT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(ENDEVENT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl EndEvent {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ENDEVENT_SCHEMA;
-14
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EndEvent {

     #[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(())
-22
+    }
-23
+}
 impl EndEvent {
     /// 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(&ENDEVENT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ENDEVENT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-41
+            }
             Ok(())
         })?;
         Ok(builder.build())
-45
+    }
-46
+}
 impl EndEvent {
     /// 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 EndEvent {
     /// Creates a new builder-style object to manufacture [`EndEvent`](crate::types::EndEvent).
     pub fn builder() -> crate::types::builders::EndEventBuilder {
         crate::types::builders::EndEventBuilder::default()
-62
+    }
-63
+}
-64
 /// A builder for [`EndEvent`](crate::types::EndEvent).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EndEventBuilder {}
 impl EndEventBuilder {
     /// Consumes the builder and constructs a [`EndEvent`](crate::types::EndEvent).
     pub fn build(self) -> crate::types::EndEvent {
         crate::types::EndEvent {}
-73
+    }
-74
+}

AWS SDK

Files changed: