AWS SDK

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_import_summary.rs

@@ -37,37 +259,270 @@

     /// <p>The path and S3 bucket of the source file that is being imported. This includes the S3Bucket (required), S3KeyPrefix (optional) and S3BucketOwner (optional if the bucket is owned by the requester).</p>
     pub fn s3_bucket_source(&self) -> ::std::option::Option<&crate::types::S3BucketSource> {
         self.s3_bucket_source.as_ref()
-40
+    }
     /// <p>The Amazon Resource Number (ARN) of the Cloudwatch Log Group associated with this import task.</p>
     pub fn cloud_watch_log_group_arn(&self) -> ::std::option::Option<&str> {
         self.cloud_watch_log_group_arn.as_deref()
-44
+    }
     /// <p>The format of the source data. Valid values are <code>CSV</code>, <code>DYNAMODB_JSON</code> or <code>ION</code>.</p>
     pub fn input_format(&self) -> ::std::option::Option<&crate::types::InputFormat> {
         self.input_format.as_ref()
-48
+    }
     /// <p>The time at which this import task began.</p>
     pub fn start_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.start_time.as_ref()
-52
+    }
     /// <p>The time at which this import task ended. (Does this include the successful complete creation of the table it was imported to?)</p>
     pub fn end_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.end_time.as_ref()
-56
+    }

-57
+}
 static IMPORTSUMMARY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#ImportSummary", "com.amazonaws.dynamodb", "ImportSummary");
 static IMPORTSUMMARY_MEMBER_IMPORT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportSummary$ImportArn",
         "com.amazonaws.dynamodb",
         "ImportSummary",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "import_arn",
     "ImportArn",
 ,
 );
 static IMPORTSUMMARY_MEMBER_IMPORT_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportSummary$ImportStatus",
         "com.amazonaws.dynamodb",
         "ImportSummary",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "import_status",
     "ImportStatus",
 ,
 );
 static IMPORTSUMMARY_MEMBER_TABLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#ImportSummary$TableArn", "com.amazonaws.dynamodb", "ImportSummary"),
     ::aws_smithy_schema::ShapeType::String,
     "table_arn",
     "TableArn",
 ,
 );
 static IMPORTSUMMARY_MEMBER_S3_BUCKET_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportSummary$S3BucketSource",
         "com.amazonaws.dynamodb",
         "ImportSummary",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "s3_bucket_source",
     "S3BucketSource",
 ,
 );
 static IMPORTSUMMARY_MEMBER_CLOUD_WATCH_LOG_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportSummary$CloudWatchLogGroupArn",
         "com.amazonaws.dynamodb",
         "ImportSummary",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "cloud_watch_log_group_arn",
     "CloudWatchLogGroupArn",
 ,
 );
 static IMPORTSUMMARY_MEMBER_INPUT_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportSummary$InputFormat",
         "com.amazonaws.dynamodb",
         "ImportSummary",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "input_format",
     "InputFormat",
 ,
 );
 static IMPORTSUMMARY_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportSummary$StartTime",
         "com.amazonaws.dynamodb",
         "ImportSummary",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "start_time",
     "StartTime",
 ,
 );
 static IMPORTSUMMARY_MEMBER_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#ImportSummary$EndTime", "com.amazonaws.dynamodb", "ImportSummary"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "end_time",
     "EndTime",
 ,
 );
 static IMPORTSUMMARY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     IMPORTSUMMARY_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &IMPORTSUMMARY_MEMBER_IMPORT_ARN,
         &IMPORTSUMMARY_MEMBER_IMPORT_STATUS,
         &IMPORTSUMMARY_MEMBER_TABLE_ARN,
         &IMPORTSUMMARY_MEMBER_S3_BUCKET_SOURCE,
         &IMPORTSUMMARY_MEMBER_CLOUD_WATCH_LOG_GROUP_ARN,
         &IMPORTSUMMARY_MEMBER_INPUT_FORMAT,
         &IMPORTSUMMARY_MEMBER_START_TIME,
         &IMPORTSUMMARY_MEMBER_END_TIME,
     ],
 );
 impl ImportSummary {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IMPORTSUMMARY_SCHEMA;
-149
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ImportSummary {
     #[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.import_arn {
             ser.write_string(&IMPORTSUMMARY_MEMBER_IMPORT_ARN, val)?;
-158
+        }
         if let Some(ref val) = self.import_status {
             ser.write_string(&IMPORTSUMMARY_MEMBER_IMPORT_STATUS, val.as_str())?;
-161
+        }
         if let Some(ref val) = self.table_arn {
             ser.write_string(&IMPORTSUMMARY_MEMBER_TABLE_ARN, val)?;
-164
+        }
         if let Some(ref val) = self.s3_bucket_source {
             ser.write_struct(&IMPORTSUMMARY_MEMBER_S3_BUCKET_SOURCE, val)?;
-167
+        }
         if let Some(ref val) = self.cloud_watch_log_group_arn {
             ser.write_string(&IMPORTSUMMARY_MEMBER_CLOUD_WATCH_LOG_GROUP_ARN, val)?;
-170
+        }
         if let Some(ref val) = self.input_format {
             ser.write_string(&IMPORTSUMMARY_MEMBER_INPUT_FORMAT, val.as_str())?;
-173
+        }
         if let Some(ref val) = self.start_time {
             ser.write_timestamp(&IMPORTSUMMARY_MEMBER_START_TIME, val)?;
-176
+        }
         if let Some(ref val) = self.end_time {
             ser.write_timestamp(&IMPORTSUMMARY_MEMBER_END_TIME, val)?;
-179
+        }
         Ok(())
-181
+    }
-182
+}
 impl ImportSummary {
     /// 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(&IMPORTSUMMARY_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&IMPORTSUMMARY_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.import_arn = Some(deser.read_string(member)?);
-201
+                }
                 Some(1) => {
                     builder.import_status = Some(crate::types::ImportStatus::from(deser.read_string(member)?.as_str()));
-204
+                }
                 Some(2) => {
                     builder.table_arn = Some(deser.read_string(member)?);
-207
+                }
                 Some(3) => {
                     builder.s3_bucket_source = Some(crate::types::S3BucketSource::deserialize(deser)?);
-210
+                }
                 Some(4) => {
                     builder.cloud_watch_log_group_arn = Some(deser.read_string(member)?);
-213
+                }
                 Some(5) => {
                     builder.input_format = Some(crate::types::InputFormat::from(deser.read_string(member)?.as_str()));
-216
+                }
                 Some(6) => {
                     builder.start_time = Some(deser.read_timestamp(member)?);
-219
+                }
                 Some(7) => {
                     builder.end_time = Some(deser.read_timestamp(member)?);
-222
+                }
                 _ => {}
-224
+            }
             Ok(())
         })?;
         Ok(builder.build())
-228
+    }
-229
+}
 impl ImportSummary {
     /// 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 ImportSummary {
     /// Creates a new builder-style object to manufacture [`ImportSummary`](crate::types::ImportSummary).
     pub fn builder() -> crate::types::builders::ImportSummaryBuilder {
         crate::types::builders::ImportSummaryBuilder::default()
-245
+    }
-246
+}
-247
 /// A builder for [`ImportSummary`](crate::types::ImportSummary).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ImportSummaryBuilder {
     pub(crate) import_arn: ::std::option::Option<::std::string::String>,
     pub(crate) import_status: ::std::option::Option<crate::types::ImportStatus>,
     pub(crate) table_arn: ::std::option::Option<::std::string::String>,
     pub(crate) s3_bucket_source: ::std::option::Option<crate::types::S3BucketSource>,
     pub(crate) cloud_watch_log_group_arn: ::std::option::Option<::std::string::String>,
     pub(crate) input_format: ::std::option::Option<crate::types::InputFormat>,
     pub(crate) start_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) end_time: ::std::option::Option<::aws_smithy_types::DateTime>,
-260
+}
 impl ImportSummaryBuilder {
     /// <p>The Amazon Resource Number (ARN) corresponding to the import request.</p>
     pub fn import_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.import_arn = ::std::option::Option::Some(input.into());
         self
-266
+    }
     /// <p>The Amazon Resource Number (ARN) corresponding to the import request.</p>
     pub fn set_import_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.import_arn = input;
         self

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_import_table_description.rs

@@ -106,106 +346,346 @@

↥ Expand context

-106
+    }
     /// <p>The total number of items processed from the source file.</p>
     pub fn processed_item_count(&self) -> i64 {
         self.processed_item_count
-110
+    }
     /// <p>The number of items successfully imported into the new table.</p>
     pub fn imported_item_count(&self) -> i64 {
         self.imported_item_count
-114
+    }
     /// <p>The error code corresponding to the failure that the import job ran into during execution.</p>
     pub fn failure_code(&self) -> ::std::option::Option<&str> {
         self.failure_code.as_deref()
-118
+    }
     /// <p>The error message corresponding to the failure that the import job ran into during execution.</p>
     pub fn failure_message(&self) -> ::std::option::Option<&str> {
         self.failure_message.as_deref()
-122
+    }
-123
+}
 static IMPORTTABLEDESCRIPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#ImportTableDescription",

     "com.amazonaws.dynamodb",
     "ImportTableDescription",
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_IMPORT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$ImportArn",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "import_arn",
     "ImportArn",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_IMPORT_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$ImportStatus",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "import_status",
     "ImportStatus",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_TABLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$TableArn",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_arn",
     "TableArn",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$TableId",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_id",
     "TableId",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$ClientToken",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_S3_BUCKET_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$S3BucketSource",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "s3_bucket_source",
     "S3BucketSource",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_ERROR_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$ErrorCount",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "error_count",
     "ErrorCount",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_CLOUD_WATCH_LOG_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$CloudWatchLogGroupArn",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "cloud_watch_log_group_arn",
     "CloudWatchLogGroupArn",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_INPUT_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$InputFormat",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "input_format",
     "InputFormat",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_INPUT_FORMAT_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$InputFormatOptions",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "input_format_options",
     "InputFormatOptions",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_INPUT_COMPRESSION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$InputCompressionType",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "input_compression_type",
     "InputCompressionType",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_TABLE_CREATION_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$TableCreationParameters",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "table_creation_parameters",
     "TableCreationParameters",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$StartTime",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "start_time",
     "StartTime",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$EndTime",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "end_time",
     "EndTime",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_PROCESSED_SIZE_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$ProcessedSizeBytes",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "processed_size_bytes",
     "ProcessedSizeBytes",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_PROCESSED_ITEM_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$ProcessedItemCount",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "processed_item_count",
     "ProcessedItemCount",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_IMPORTED_ITEM_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$ImportedItemCount",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "imported_item_count",
     "ImportedItemCount",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_FAILURE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$FailureCode",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "failure_code",
     "FailureCode",
 ,
 );
 static IMPORTTABLEDESCRIPTION_MEMBER_FAILURE_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ImportTableDescription$FailureMessage",
         "com.amazonaws.dynamodb",
         "ImportTableDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "failure_message",
     "FailureMessage",
 ,
 );
 static IMPORTTABLEDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     IMPORTTABLEDESCRIPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &IMPORTTABLEDESCRIPTION_MEMBER_IMPORT_ARN,
         &IMPORTTABLEDESCRIPTION_MEMBER_IMPORT_STATUS,
         &IMPORTTABLEDESCRIPTION_MEMBER_TABLE_ARN,
         &IMPORTTABLEDESCRIPTION_MEMBER_TABLE_ID,

↧ Expand context

         &IMPORTTABLEDESCRIPTION_MEMBER_CLIENT_TOKEN,
         &IMPORTTABLEDESCRIPTION_MEMBER_S3_BUCKET_SOURCE,
         &IMPORTTABLEDESCRIPTION_MEMBER_ERROR_COUNT,
         &IMPORTTABLEDESCRIPTION_MEMBER_CLOUD_WATCH_LOG_GROUP_ARN,
         &IMPORTTABLEDESCRIPTION_MEMBER_INPUT_FORMAT,
         &IMPORTTABLEDESCRIPTION_MEMBER_INPUT_FORMAT_OPTIONS,
         &IMPORTTABLEDESCRIPTION_MEMBER_INPUT_COMPRESSION_TYPE,
         &IMPORTTABLEDESCRIPTION_MEMBER_TABLE_CREATION_PARAMETERS,
         &IMPORTTABLEDESCRIPTION_MEMBER_START_TIME,
         &IMPORTTABLEDESCRIPTION_MEMBER_END_TIME,
         &IMPORTTABLEDESCRIPTION_MEMBER_PROCESSED_SIZE_BYTES,
         &IMPORTTABLEDESCRIPTION_MEMBER_PROCESSED_ITEM_COUNT,
         &IMPORTTABLEDESCRIPTION_MEMBER_IMPORTED_ITEM_COUNT,
         &IMPORTTABLEDESCRIPTION_MEMBER_FAILURE_CODE,
         &IMPORTTABLEDESCRIPTION_MEMBER_FAILURE_MESSAGE,
     ],
 );
 impl ImportTableDescription {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IMPORTTABLEDESCRIPTION_SCHEMA;

@@ -389,389 +461,461 @@

↥ Expand context

             ser.write_struct(&IMPORTTABLEDESCRIPTION_MEMBER_TABLE_CREATION_PARAMETERS, val)?;
-390
+        }
         if let Some(ref val) = self.start_time {
             ser.write_timestamp(&IMPORTTABLEDESCRIPTION_MEMBER_START_TIME, val)?;
-393
+        }
         if let Some(ref val) = self.end_time {
             ser.write_timestamp(&IMPORTTABLEDESCRIPTION_MEMBER_END_TIME, val)?;
-396
+        }
         if let Some(ref val) = self.processed_size_bytes {
             ser.write_long(&IMPORTTABLEDESCRIPTION_MEMBER_PROCESSED_SIZE_BYTES, *val)?;
-399
+        }
-400
+        {
             let val = &self.processed_item_count;
             ser.write_long(&IMPORTTABLEDESCRIPTION_MEMBER_PROCESSED_ITEM_COUNT, *val)?;
-403
+        }
-404
+        {
             let val = &self.imported_item_count;
             ser.write_long(&IMPORTTABLEDESCRIPTION_MEMBER_IMPORTED_ITEM_COUNT, *val)?;
-407
+        }
         if let Some(ref val) = self.failure_code {

             ser.write_string(&IMPORTTABLEDESCRIPTION_MEMBER_FAILURE_CODE, val)?;
-410
+        }
         if let Some(ref val) = self.failure_message {
             ser.write_string(&IMPORTTABLEDESCRIPTION_MEMBER_FAILURE_MESSAGE, val)?;
-413
+        }
         Ok(())
-415
+    }
-416
+}
 impl ImportTableDescription {
     /// 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(&IMPORTTABLEDESCRIPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&IMPORTTABLEDESCRIPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.import_arn = Some(deser.read_string(member)?);
-435
+                }
                 Some(1) => {
                     builder.import_status = Some(crate::types::ImportStatus::from(deser.read_string(member)?.as_str()));
-438
+                }
                 Some(2) => {
                     builder.table_arn = Some(deser.read_string(member)?);
-441
+                }

↧ Expand context

                 Some(3) => {
                     builder.table_id = Some(deser.read_string(member)?);
-444
+                }
                 Some(4) => {
                     builder.client_token = Some(deser.read_string(member)?);
-447
+                }
                 Some(5) => {
                     builder.s3_bucket_source = Some(crate::types::S3BucketSource::deserialize(deser)?);
-450
+                }
                 Some(6) => {
                     builder.error_count = Some(deser.read_long(member)?);
-453
+                }
                 Some(7) => {
                     builder.cloud_watch_log_group_arn = Some(deser.read_string(member)?);
-456
+                }
                 Some(8) => {
                     builder.input_format = Some(crate::types::InputFormat::from(deser.read_string(member)?.as_str()));
-459
+                }
                 Some(9) => {
                     builder.input_format_options = Some(crate::types::InputFormatOptions::deserialize(deser)?);

@@ -467,467 +526,537 @@

↥ Expand context

                     builder.table_creation_parameters = Some(crate::types::TableCreationParameters::deserialize(deser)?);
-468
+                }
                 Some(12) => {
                     builder.start_time = Some(deser.read_timestamp(member)?);
-471
+                }
                 Some(13) => {
                     builder.end_time = Some(deser.read_timestamp(member)?);
-474
+                }
                 Some(14) => {
                     builder.processed_size_bytes = Some(deser.read_long(member)?);
-477
+                }
                 Some(15) => {
                     builder.processed_item_count = Some(deser.read_long(member)?);
-480
+                }
                 Some(16) => {
                     builder.imported_item_count = Some(deser.read_long(member)?);
-483
+                }
                 Some(17) => {
                     builder.failure_code = Some(deser.read_string(member)?);
-486
+                }

                 Some(18) => {
                     builder.failure_message = Some(deser.read_string(member)?);
-489
+                }
                 _ => {}
-491
+            }
             Ok(())
         })?;
         Ok(builder.build())
-495
+    }
-496
+}
 impl ImportTableDescription {
     /// 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 ImportTableDescription {
     /// Creates a new builder-style object to manufacture [`ImportTableDescription`](crate::types::ImportTableDescription).
     pub fn builder() -> crate::types::builders::ImportTableDescriptionBuilder {
         crate::types::builders::ImportTableDescriptionBuilder::default()
-512
+    }
-513
+}
-514
 /// A builder for [`ImportTableDescription`](crate::types::ImportTableDescription).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ImportTableDescriptionBuilder {
     pub(crate) import_arn: ::std::option::Option<::std::string::String>,
     pub(crate) import_status: ::std::option::Option<crate::types::ImportStatus>,
     pub(crate) table_arn: ::std::option::Option<::std::string::String>,
     pub(crate) table_id: ::std::option::Option<::std::string::String>,
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) s3_bucket_source: ::std::option::Option<crate::types::S3BucketSource>,
     pub(crate) error_count: ::std::option::Option<i64>,
     pub(crate) cloud_watch_log_group_arn: ::std::option::Option<::std::string::String>,
     pub(crate) input_format: ::std::option::Option<crate::types::InputFormat>,
     pub(crate) input_format_options: ::std::option::Option<crate::types::InputFormatOptions>,
     pub(crate) input_compression_type: ::std::option::Option<crate::types::InputCompressionType>,
     pub(crate) table_creation_parameters: ::std::option::Option<crate::types::TableCreationParameters>,
     pub(crate) start_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) end_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) processed_size_bytes: ::std::option::Option<i64>,
     pub(crate) processed_item_count: ::std::option::Option<i64>,
     pub(crate) imported_item_count: ::std::option::Option<i64>,
     pub(crate) failure_code: ::std::option::Option<::std::string::String>,
     pub(crate) failure_message: ::std::option::Option<::std::string::String>,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_incremental_export_specification.rs

@@ -10,10 +155,166 @@

↥ Expand context

     pub export_to_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     /// <p>The view type that was chosen for the export. Valid values are <code>NEW_AND_OLD_IMAGES</code> and <code>NEW_IMAGES</code>. The default value is <code>NEW_AND_OLD_IMAGES</code>.</p>
     pub export_view_type: ::std::option::Option<crate::types::ExportViewType>,
-13
+}
 impl IncrementalExportSpecification {
     /// <p>Time in the past which provides the inclusive start range for the export table's data, counted in seconds from the start of the Unix epoch. The incremental export will reflect the table's state including and after this point in time.</p>
     pub fn export_from_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.export_from_time.as_ref()
-18
+    }
     /// <p>Time in the past which provides the exclusive end range for the export table's data, counted in seconds from the start of the Unix epoch. The incremental export will reflect the table's state just prior to this point in time. If this is not provided, the latest time with data available will be used.</p>
     pub fn export_to_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.export_to_time.as_ref()
-22
+    }
     /// <p>The view type that was chosen for the export. Valid values are <code>NEW_AND_OLD_IMAGES</code> and <code>NEW_IMAGES</code>. The default value is <code>NEW_AND_OLD_IMAGES</code>.</p>
     pub fn export_view_type(&self) -> ::std::option::Option<&crate::types::ExportViewType> {
         self.export_view_type.as_ref()
-26
+    }
-27
+}
 static INCREMENTALEXPORTSPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#IncrementalExportSpecification",

     "com.amazonaws.dynamodb",
     "IncrementalExportSpecification",
 );
 static INCREMENTALEXPORTSPECIFICATION_MEMBER_EXPORT_FROM_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#IncrementalExportSpecification$ExportFromTime",
         "com.amazonaws.dynamodb",
         "IncrementalExportSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "export_from_time",
     "ExportFromTime",
 ,
 );
 static INCREMENTALEXPORTSPECIFICATION_MEMBER_EXPORT_TO_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#IncrementalExportSpecification$ExportToTime",
         "com.amazonaws.dynamodb",
         "IncrementalExportSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "export_to_time",
     "ExportToTime",
 ,
 );
 static INCREMENTALEXPORTSPECIFICATION_MEMBER_EXPORT_VIEW_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#IncrementalExportSpecification$ExportViewType",
         "com.amazonaws.dynamodb",
         "IncrementalExportSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "export_view_type",
     "ExportViewType",
 ,
 );
 static INCREMENTALEXPORTSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INCREMENTALEXPORTSPECIFICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &INCREMENTALEXPORTSPECIFICATION_MEMBER_EXPORT_FROM_TIME,
         &INCREMENTALEXPORTSPECIFICATION_MEMBER_EXPORT_TO_TIME,
         &INCREMENTALEXPORTSPECIFICATION_MEMBER_EXPORT_VIEW_TYPE,
     ],
 );
 impl IncrementalExportSpecification {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INCREMENTALEXPORTSPECIFICATION_SCHEMA;
-75
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for IncrementalExportSpecification {
     #[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.export_from_time {
             ser.write_timestamp(&INCREMENTALEXPORTSPECIFICATION_MEMBER_EXPORT_FROM_TIME, val)?;
-84
+        }
         if let Some(ref val) = self.export_to_time {
             ser.write_timestamp(&INCREMENTALEXPORTSPECIFICATION_MEMBER_EXPORT_TO_TIME, val)?;
-87
+        }
         if let Some(ref val) = self.export_view_type {
             ser.write_string(&INCREMENTALEXPORTSPECIFICATION_MEMBER_EXPORT_VIEW_TYPE, val.as_str())?;
-90
+        }
         Ok(())
-92
+    }
-93
+}
 impl IncrementalExportSpecification {
     /// 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(&INCREMENTALEXPORTSPECIFICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INCREMENTALEXPORTSPECIFICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.export_from_time = Some(deser.read_timestamp(member)?);
-112
+                }
                 Some(1) => {
                     builder.export_to_time = Some(deser.read_timestamp(member)?);
-115
+                }
                 Some(2) => {
                     builder.export_view_type = Some(crate::types::ExportViewType::from(deser.read_string(member)?.as_str()));
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         Ok(builder.build())
-124
+    }
-125
+}
 impl IncrementalExportSpecification {
     /// 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 IncrementalExportSpecification {
     /// Creates a new builder-style object to manufacture [`IncrementalExportSpecification`](crate::types::IncrementalExportSpecification).
     pub fn builder() -> crate::types::builders::IncrementalExportSpecificationBuilder {
         crate::types::builders::IncrementalExportSpecificationBuilder::default()
-141
+    }
-142
+}
-143
 /// A builder for [`IncrementalExportSpecification`](crate::types::IncrementalExportSpecification).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct IncrementalExportSpecificationBuilder {
     pub(crate) export_from_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) export_to_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) export_view_type: ::std::option::Option<crate::types::ExportViewType>,
-151
+}
 impl IncrementalExportSpecificationBuilder {
     /// <p>Time in the past which provides the inclusive start range for the export table's data, counted in seconds from the start of the Unix epoch. The incremental export will reflect the table's state including and after this point in time.</p>
     pub fn export_from_time(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         self.export_from_time = ::std::option::Option::Some(input);
         self
-157
+    }
     /// <p>Time in the past which provides the inclusive start range for the export table's data, counted in seconds from the start of the Unix epoch. The incremental export will reflect the table's state including and after this point in time.</p>
     pub fn set_export_from_time(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         self.export_from_time = input;
         self
-162
+    }
     /// <p>Time in the past which provides the inclusive start range for the export table's data, counted in seconds from the start of the Unix epoch. The incremental export will reflect the table's state including and after this point in time.</p>
     pub fn get_export_from_time(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         &self.export_from_time
-166
+    }

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_input_format_options.rs

@@ -1,1 +107,118 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The format options for the data that was imported into the target table. There is one value, CsvOption.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct InputFormatOptions {
     /// <p>The options for imported source files in CSV format. The values are Delimiter and HeaderList.</p>
     pub csv: ::std::option::Option<crate::types::CsvOptions>,
-9
+}
 impl InputFormatOptions {
     /// <p>The options for imported source files in CSV format. The values are Delimiter and HeaderList.</p>
     pub fn csv(&self) -> ::std::option::Option<&crate::types::CsvOptions> {
         self.csv.as_ref()
-14
+    }
-15
+}
 static INPUTFORMATOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#InputFormatOptions",

     "com.amazonaws.dynamodb",
     "InputFormatOptions",
 );
 static INPUTFORMATOPTIONS_MEMBER_CSV: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#InputFormatOptions$Csv",
         "com.amazonaws.dynamodb",
         "InputFormatOptions",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "csv",
     "Csv",
 ,
 );
 static INPUTFORMATOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INPUTFORMATOPTIONS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&INPUTFORMATOPTIONS_MEMBER_CSV],
 );
 impl InputFormatOptions {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INPUTFORMATOPTIONS_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for InputFormatOptions {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.csv {
             ser.write_struct(&INPUTFORMATOPTIONS_MEMBER_CSV, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl InputFormatOptions {
     /// 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(&INPUTFORMATOPTIONS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INPUTFORMATOPTIONS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.csv = Some(crate::types::CsvOptions::deserialize(deser)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl InputFormatOptions {
     /// 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 InputFormatOptions {
     /// Creates a new builder-style object to manufacture [`InputFormatOptions`](crate::types::InputFormatOptions).
     pub fn builder() -> crate::types::builders::InputFormatOptionsBuilder {
         crate::types::builders::InputFormatOptionsBuilder::default()
-93
+    }
-94
+}
-95
 /// A builder for [`InputFormatOptions`](crate::types::InputFormatOptions).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct InputFormatOptionsBuilder {
     pub(crate) csv: ::std::option::Option<crate::types::CsvOptions>,
-101
+}
 impl InputFormatOptionsBuilder {
     /// <p>The options for imported source files in CSV format. The values are Delimiter and HeaderList.</p>
     pub fn csv(mut self, input: crate::types::CsvOptions) -> Self {
         self.csv = ::std::option::Option::Some(input);
         self
-107
+    }
     /// <p>The options for imported source files in CSV format. The values are Delimiter and HeaderList.</p>
     pub fn set_csv(mut self, input: ::std::option::Option<crate::types::CsvOptions>) -> Self {
         self.csv = input;
         self
-112
+    }
     /// <p>The options for imported source files in CSV format. The values are Delimiter and HeaderList.</p>
     pub fn get_csv(&self) -> &::std::option::Option<crate::types::CsvOptions> {
         &self.csv
-116
+    }
     /// Consumes the builder and constructs a [`InputFormatOptions`](crate::types::InputFormatOptions).
     pub fn build(self) -> crate::types::InputFormatOptions {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_item_collection_metrics.rs

@@ -8,8 +173,178 @@

↥ Expand context

     pub item_collection_key: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
     /// <p>An estimate of item collection size, in gigabytes. This value is a two-element array containing a lower bound and an upper bound for the estimate. The estimate includes the size of all the items in the table, plus the size of all attributes projected into all of the local secondary indexes on that table. Use this estimate to measure whether a local secondary index is approaching its size limit.</p>
     /// <p>The estimate is subject to change over time; therefore, do not rely on the precision or accuracy of the estimate.</p>
     pub size_estimate_range_gb: ::std::option::Option<::std::vec::Vec<f64>>,
-12
+}
 impl ItemCollectionMetrics {
     /// <p>The partition key value of the item collection. This value is the same as the partition key value of the item.</p>
     pub fn item_collection_key(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {
         self.item_collection_key.as_ref()
-17
+    }
     /// <p>An estimate of item collection size, in gigabytes. This value is a two-element array containing a lower bound and an upper bound for the estimate. The estimate includes the size of all the items in the table, plus the size of all attributes projected into all of the local secondary indexes on that table. Use this estimate to measure whether a local secondary index is approaching its size limit.</p>
     /// <p>The estimate is subject to change over time; therefore, do not rely on the precision or accuracy of the estimate.</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 `.size_estimate_range_gb.is_none()`.
     pub fn size_estimate_range_gb(&self) -> &[f64] {
         self.size_estimate_range_gb.as_deref().unwrap_or_default()
-24
+    }
-25
+}
 static ITEMCOLLECTIONMETRICS_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#ItemCollectionMetrics",

     "com.amazonaws.dynamodb",
     "ItemCollectionMetrics",
 );
 static ITEMCOLLECTIONMETRICS_MEMBER_ITEM_COLLECTION_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ItemCollectionMetrics$ItemCollectionKey",
         "com.amazonaws.dynamodb",
         "ItemCollectionMetrics",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "item_collection_key",
     "ItemCollectionKey",
 ,
 );
 static ITEMCOLLECTIONMETRICS_MEMBER_SIZE_ESTIMATE_RANGE_GB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ItemCollectionMetrics$SizeEstimateRangeGB",
         "com.amazonaws.dynamodb",
         "ItemCollectionMetrics",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "size_estimate_range_gb",
     "SizeEstimateRangeGB",
 ,
 );
 static ITEMCOLLECTIONMETRICS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ITEMCOLLECTIONMETRICS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ITEMCOLLECTIONMETRICS_MEMBER_ITEM_COLLECTION_KEY,
         &ITEMCOLLECTIONMETRICS_MEMBER_SIZE_ESTIMATE_RANGE_GB,
     ],
 );
 impl ItemCollectionMetrics {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ITEMCOLLECTIONMETRICS_SCHEMA;
-62
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ItemCollectionMetrics {
     #[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.item_collection_key {
             ser.write_map(
                 &ITEMCOLLECTIONMETRICS_MEMBER_ITEM_COLLECTION_KEY,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
                         ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-76
+                    }
                     Ok(())
                 },
             )?;
-80
+        }
         if let Some(ref val) = self.size_estimate_range_gb {
             ser.write_list(
                 &ITEMCOLLECTIONMETRICS_MEMBER_SIZE_ESTIMATE_RANGE_GB,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_double(&aws_smithy_schema::prelude::DOUBLE, *item)?;
-87
+                    }
                     Ok(())
                 },
             )?;
-91
+        }
         Ok(())
-93
+    }
-94
+}
 impl ItemCollectionMetrics {
     /// 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(&ITEMCOLLECTIONMETRICS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ITEMCOLLECTIONMETRICS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.item_collection_key = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-120
+                }
                 Some(1) => {
                     builder.size_estimate_range_gb = 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_double(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_double(member)?);
                             Ok(())
                         })?;
                         container
                     });
-130
+                }
                 _ => {}
-132
+            }
             Ok(())
         })?;
         Ok(builder.build())
-136
+    }
-137
+}
 impl ItemCollectionMetrics {
     /// 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 ItemCollectionMetrics {
     /// Creates a new builder-style object to manufacture [`ItemCollectionMetrics`](crate::types::ItemCollectionMetrics).
     pub fn builder() -> crate::types::builders::ItemCollectionMetricsBuilder {
         crate::types::builders::ItemCollectionMetricsBuilder::default()
-153
+    }
-154
+}
-155
 /// A builder for [`ItemCollectionMetrics`](crate::types::ItemCollectionMetrics).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ItemCollectionMetricsBuilder {
     pub(crate) item_collection_key: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
     pub(crate) size_estimate_range_gb: ::std::option::Option<::std::vec::Vec<f64>>,
-162
+}
 impl ItemCollectionMetricsBuilder {
     /// Adds a key-value pair to `item_collection_key`.
     ///
     /// To override the contents of this collection use [`set_item_collection_key`](Self::set_item_collection_key).
     ///
     /// <p>The partition key value of the item collection. This value is the same as the partition key value of the item.</p>
     pub fn item_collection_key(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::AttributeValue) -> Self {
         let mut hash_map = self.item_collection_key.unwrap_or_default();
         hash_map.insert(k.into(), v);
         self.item_collection_key = ::std::option::Option::Some(hash_map);
         self
-174
+    }
     /// <p>The partition key value of the item collection. This value is the same as the partition key value of the item.</p>
     pub fn set_item_collection_key(
         mut self,
         input: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_item_response.rs

@@ -1,1 +116,124 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Details for the requested item.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ItemResponse {
     /// <p>Map of attribute data consisting of the data type and attribute value.</p>
     pub item: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
-9
+}
 impl ItemResponse {

     /// <p>Map of attribute data consisting of the data type and attribute value.</p>
     pub fn item(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {
         self.item.as_ref()
-14
+    }
-15
+}
 static ITEMRESPONSE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#ItemResponse", "com.amazonaws.dynamodb", "ItemResponse");
 static ITEMRESPONSE_MEMBER_ITEM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#ItemResponse$Item", "com.amazonaws.dynamodb", "ItemResponse"),
     ::aws_smithy_schema::ShapeType::Map,
     "item",
     "Item",
 ,
 );
 static ITEMRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ITEMRESPONSE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ITEMRESPONSE_MEMBER_ITEM],
 );
 impl ItemResponse {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ITEMRESPONSE_SCHEMA;
-32
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ItemResponse {
     #[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.item {
             ser.write_map(&ITEMRESPONSE_MEMBER_ITEM, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for (key, value) in val {
                     ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                     todo!("schema: unsupported map value type");
                     ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-44
+                }
                 Ok(())
             })?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl ItemResponse {
     /// 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(&ITEMRESPONSE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ITEMRESPONSE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.item = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-76
+                }
                 _ => {}
-78
+            }
             Ok(())
         })?;
         Ok(builder.build())
-82
+    }
-83
+}
 impl ItemResponse {
     /// 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 ItemResponse {
     /// Creates a new builder-style object to manufacture [`ItemResponse`](crate::types::ItemResponse).
     pub fn builder() -> crate::types::builders::ItemResponseBuilder {
         crate::types::builders::ItemResponseBuilder::default()
-99
+    }
-100
+}
-101
 /// A builder for [`ItemResponse`](crate::types::ItemResponse).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ItemResponseBuilder {
     pub(crate) item: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
-107
+}
 impl ItemResponseBuilder {
     /// Adds a key-value pair to `item`.
     ///
     /// To override the contents of this collection use [`set_item`](Self::set_item).
     ///
     /// <p>Map of attribute data consisting of the data type and attribute value.</p>
     pub fn item(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::AttributeValue) -> Self {
         let mut hash_map = self.item.unwrap_or_default();
         hash_map.insert(k.into(), v);
         self.item = ::std::option::Option::Some(hash_map);
         self
-119
+    }
     /// <p>Map of attribute data consisting of the data type and attribute value.</p>
     pub fn set_item(
         mut self,
         input: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
     ) -> Self {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_key_schema_element.rs

@@ -22,22 +151,163 @@

↥ Expand context

-22
+}
 impl KeySchemaElement {
     /// <p>The name of a key attribute.</p>
     pub fn attribute_name(&self) -> &str {
         use std::ops::Deref;
         self.attribute_name.deref()
-28
+    }
     /// <p>The role that this key attribute will assume:</p>
     /// <ul>
     /// <li>
     /// <p><code>HASH</code> - partition key</p></li>
     /// <li>
     /// <p><code>RANGE</code> - sort key</p></li>
     /// </ul><note>
     /// <p>The partition key of an item is also known as its <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage of an internal hash function to evenly distribute data items across partitions, based on their partition key values.</p>
     /// <p>The sort key of an item is also known as its <i>range attribute</i>. The term "range attribute" derives from the way DynamoDB stores items with the same partition key physically close together, in sorted order by the sort key value.</p>
     /// </note>
     pub fn key_type(&self) -> &crate::types::KeyType {
         &self.key_type
-41
+    }

-42
+}
 static KEYSCHEMAELEMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#KeySchemaElement", "com.amazonaws.dynamodb", "KeySchemaElement");
 static KEYSCHEMAELEMENT_MEMBER_ATTRIBUTE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#KeySchemaElement$AttributeName",
         "com.amazonaws.dynamodb",
         "KeySchemaElement",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "attribute_name",
     "AttributeName",
 ,
 );
 static KEYSCHEMAELEMENT_MEMBER_KEY_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#KeySchemaElement$KeyType",
         "com.amazonaws.dynamodb",
         "KeySchemaElement",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key_type",
     "KeyType",
 ,
 );
 static KEYSCHEMAELEMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     KEYSCHEMAELEMENT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&KEYSCHEMAELEMENT_MEMBER_ATTRIBUTE_NAME, &KEYSCHEMAELEMENT_MEMBER_KEY_TYPE],
 );
 impl KeySchemaElement {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &KEYSCHEMAELEMENT_SCHEMA;
-73
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for KeySchemaElement {
     #[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> {
-80
+        {
             let val = &self.attribute_name;
             ser.write_string(&KEYSCHEMAELEMENT_MEMBER_ATTRIBUTE_NAME, val)?;
-83
+        }
-84
+        {
             let val = &self.key_type;
             ser.write_string(&KEYSCHEMAELEMENT_MEMBER_KEY_TYPE, val.as_str())?;
-87
+        }
         Ok(())
-89
+    }
-90
+}
 impl KeySchemaElement {
     /// 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(&KEYSCHEMAELEMENT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&KEYSCHEMAELEMENT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.attribute_name = Some(deser.read_string(member)?);
-109
+                }
                 Some(1) => {
                     builder.key_type = Some(crate::types::KeyType::from(deser.read_string(member)?.as_str()));
-112
+                }
                 _ => {}
-114
+            }
             Ok(())
         })?;
         builder.attribute_name = builder.attribute_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-121
+    }
-122
+}
 impl KeySchemaElement {
     /// 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 KeySchemaElement {
     /// Creates a new builder-style object to manufacture [`KeySchemaElement`](crate::types::KeySchemaElement).
     pub fn builder() -> crate::types::builders::KeySchemaElementBuilder {
         crate::types::builders::KeySchemaElementBuilder::default()
-138
+    }
-139
+}
-140
 /// A builder for [`KeySchemaElement`](crate::types::KeySchemaElement).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct KeySchemaElementBuilder {
     pub(crate) attribute_name: ::std::option::Option<::std::string::String>,
     pub(crate) key_type: ::std::option::Option<crate::types::KeyType>,
-147
+}
 impl KeySchemaElementBuilder {
     /// <p>The name of a key attribute.</p>
     /// This field is required.
     pub fn attribute_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.attribute_name = ::std::option::Option::Some(input.into());
         self
-154
+    }
     /// <p>The name of a key attribute.</p>
     pub fn set_attribute_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.attribute_name = input;
         self
-159
+    }
     /// <p>The name of a key attribute.</p>
     pub fn get_attribute_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.attribute_name
-163
+    }

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_keys_and_attributes.rs

@@ -79,79 +317,323 @@

↥ Expand context

     /// <ul>
     /// <li>
     /// <p><code>Percentile</code></p></li>
     /// </ul>
     /// <p>The name of this attribute conflicts with a reserved word, so it cannot be used directly in an expression. (For the complete list of reserved words, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved Words</a> in the <i>Amazon DynamoDB Developer Guide</i>). To work around this, you could specify the following for <code>ExpressionAttributeNames</code>:</p>
     /// <ul>
     /// <li>
     /// <p><code>{"#P":"Percentile"}</code></p></li>
     /// </ul>
     /// <p>You could then use this substitution in an expression, as in this example:</p>
     /// <ul>
     /// <li>
     /// <p><code>#P = :val</code></p></li>
     /// </ul><note>
     /// <p>Tokens that begin with the <b>:</b> character are <i>expression attribute values</i>, which are placeholders for the actual value at runtime.</p>
     /// </note>
     /// <p>For more information on expression attribute names, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Accessing Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     pub fn expression_attribute_names(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.expression_attribute_names.as_ref()
-98
+    }

-99
+}
 static KEYSANDATTRIBUTES_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#KeysAndAttributes", "com.amazonaws.dynamodb", "KeysAndAttributes");
 static KEYSANDATTRIBUTES_MEMBER_KEYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#KeysAndAttributes$Keys",
         "com.amazonaws.dynamodb",
         "KeysAndAttributes",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "keys",
     "Keys",
 ,
 );
 static KEYSANDATTRIBUTES_MEMBER_ATTRIBUTES_TO_GET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#KeysAndAttributes$AttributesToGet",
         "com.amazonaws.dynamodb",
         "KeysAndAttributes",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "attributes_to_get",
     "AttributesToGet",
 ,
 );
 static KEYSANDATTRIBUTES_MEMBER_CONSISTENT_READ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#KeysAndAttributes$ConsistentRead",
         "com.amazonaws.dynamodb",
         "KeysAndAttributes",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "consistent_read",
     "ConsistentRead",
 ,
 );
 static KEYSANDATTRIBUTES_MEMBER_PROJECTION_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#KeysAndAttributes$ProjectionExpression",
         "com.amazonaws.dynamodb",
         "KeysAndAttributes",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "projection_expression",
     "ProjectionExpression",
 ,
 );
 static KEYSANDATTRIBUTES_MEMBER_EXPRESSION_ATTRIBUTE_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#KeysAndAttributes$ExpressionAttributeNames",
         "com.amazonaws.dynamodb",
         "KeysAndAttributes",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expression_attribute_names",
     "ExpressionAttributeNames",
 ,
 );
 static KEYSANDATTRIBUTES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     KEYSANDATTRIBUTES_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &KEYSANDATTRIBUTES_MEMBER_KEYS,
         &KEYSANDATTRIBUTES_MEMBER_ATTRIBUTES_TO_GET,
         &KEYSANDATTRIBUTES_MEMBER_CONSISTENT_READ,
         &KEYSANDATTRIBUTES_MEMBER_PROJECTION_EXPRESSION,
         &KEYSANDATTRIBUTES_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
     ],
 );
 impl KeysAndAttributes {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &KEYSANDATTRIBUTES_SCHEMA;
-166
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for KeysAndAttributes {
     #[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> {
-173
+        {
             let val = &self.keys;
-175
             ser.write_list(
                 &KEYSANDATTRIBUTES_MEMBER_KEYS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_map(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for (key, value) in item {
                                     ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                                     ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-190
+                    }
                     Ok(())
                 },
             )?;
-194
+        }
         if let Some(ref val) = self.attributes_to_get {
             ser.write_list(
                 &KEYSANDATTRIBUTES_MEMBER_ATTRIBUTES_TO_GET,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-201
+                    }
                     Ok(())
                 },
             )?;
-205
+        }
         if let Some(ref val) = self.consistent_read {
             ser.write_boolean(&KEYSANDATTRIBUTES_MEMBER_CONSISTENT_READ, *val)?;
-208
+        }
         if let Some(ref val) = self.projection_expression {
             ser.write_string(&KEYSANDATTRIBUTES_MEMBER_PROJECTION_EXPRESSION, val)?;
-211
+        }
         if let Some(ref val) = self.expression_attribute_names {
             ser.write_map(
                 &KEYSANDATTRIBUTES_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-219
+                    }
                     Ok(())
                 },
             )?;
-223
+        }
         Ok(())
-225
+    }
-226
+}
 impl KeysAndAttributes {
     /// 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(&KEYSANDATTRIBUTES_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&KEYSANDATTRIBUTES_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.keys = 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(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push({
                                 let mut map = ::std::collections::HashMap::new();
                                 deser.read_map(member, &mut |key, deser| {
                                     let value = crate::types::AttributeValue::deserialize(deser)?;
                                     map.insert(key, value);
                                     Ok(())
                                 })?;
                                 map
                             });
                             Ok(())
                         })?;
                         container
                     });
-260
+                }
                 Some(1) => {
                     builder.attributes_to_get = 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.attributes_to_get = Some(deser.read_string_list(member)?);
-263
+                }
                 Some(2) => {
                     builder.consistent_read = Some(deser.read_boolean(member)?);
-266
+                }
                 Some(3) => {
                     builder.projection_expression = Some(deser.read_string(member)?);
-269
+                }
                 Some(4) => {
                     builder.expression_attribute_names = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.expression_attribute_names = Some(deser.read_string_string_map(member)?);
-272
+                }
                 _ => {}
-274
+            }
             Ok(())
         })?;
         builder.keys = builder.keys.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-281
+    }
-282
+}
 impl KeysAndAttributes {
     /// 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 KeysAndAttributes {
     /// Creates a new builder-style object to manufacture [`KeysAndAttributes`](crate::types::KeysAndAttributes).
     pub fn builder() -> crate::types::builders::KeysAndAttributesBuilder {
         crate::types::builders::KeysAndAttributesBuilder::default()
-298
+    }
-299
+}
-300
 /// A builder for [`KeysAndAttributes`](crate::types::KeysAndAttributes).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct KeysAndAttributesBuilder {
     pub(crate) keys: ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>>,
     pub(crate) attributes_to_get: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) consistent_read: ::std::option::Option<bool>,
     pub(crate) projection_expression: ::std::option::Option<::std::string::String>,
     pub(crate) expression_attribute_names: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
-310
+}
 impl KeysAndAttributesBuilder {
     /// Appends an item to `keys`.
     ///
     /// To override the contents of this collection use [`set_keys`](Self::set_keys).
     ///
     /// <p>The primary key attribute values that define the items and the attributes associated with the items.</p>
     pub fn keys(mut self, input: ::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>) -> Self {
         let mut v = self.keys.unwrap_or_default();
         v.push(input);
         self.keys = ::std::option::Option::Some(v);
         self
-322
+    }
     /// <p>The primary key attribute values that define the items and the attributes associated with the items.</p>

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_kinesis_data_stream_destination.rs

@@ -16,16 +184,195 @@

↥ Expand context

 impl KinesisDataStreamDestination {
     /// <p>The ARN for a specific Kinesis data stream.</p>
     pub fn stream_arn(&self) -> ::std::option::Option<&str> {
         self.stream_arn.as_deref()
-20
+    }
     /// <p>The current status of replication.</p>
     pub fn destination_status(&self) -> ::std::option::Option<&crate::types::DestinationStatus> {
         self.destination_status.as_ref()
-24
+    }
     /// <p>The human-readable string that corresponds to the replica status.</p>
     pub fn destination_status_description(&self) -> ::std::option::Option<&str> {
         self.destination_status_description.as_deref()
-28
+    }
     /// <p>The precision of the Kinesis data stream timestamp. The values are either <code>MILLISECOND</code> or <code>MICROSECOND</code>.</p>
     pub fn approximate_creation_date_time_precision(&self) -> ::std::option::Option<&crate::types::ApproximateCreationDateTimePrecision> {
         self.approximate_creation_date_time_precision.as_ref()
-32
+    }
-33
+}
 static KINESISDATASTREAMDESTINATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#KinesisDataStreamDestination",

     "com.amazonaws.dynamodb",
     "KinesisDataStreamDestination",
 );
 static KINESISDATASTREAMDESTINATION_MEMBER_STREAM_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#KinesisDataStreamDestination$StreamArn",
         "com.amazonaws.dynamodb",
         "KinesisDataStreamDestination",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "stream_arn",
     "StreamArn",
 ,
 );
 static KINESISDATASTREAMDESTINATION_MEMBER_DESTINATION_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#KinesisDataStreamDestination$DestinationStatus",
         "com.amazonaws.dynamodb",
         "KinesisDataStreamDestination",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "destination_status",
     "DestinationStatus",
 ,
 );
 static KINESISDATASTREAMDESTINATION_MEMBER_DESTINATION_STATUS_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#KinesisDataStreamDestination$DestinationStatusDescription",
         "com.amazonaws.dynamodb",
         "KinesisDataStreamDestination",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "destination_status_description",
     "DestinationStatusDescription",
 ,
 );
 static KINESISDATASTREAMDESTINATION_MEMBER_APPROXIMATE_CREATION_DATE_TIME_PRECISION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.dynamodb#KinesisDataStreamDestination$ApproximateCreationDateTimePrecision",
             "com.amazonaws.dynamodb",
             "KinesisDataStreamDestination",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "approximate_creation_date_time_precision",
         "ApproximateCreationDateTimePrecision",
 ,
     );
 static KINESISDATASTREAMDESTINATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     KINESISDATASTREAMDESTINATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &KINESISDATASTREAMDESTINATION_MEMBER_STREAM_ARN,
         &KINESISDATASTREAMDESTINATION_MEMBER_DESTINATION_STATUS,
         &KINESISDATASTREAMDESTINATION_MEMBER_DESTINATION_STATUS_DESCRIPTION,
         &KINESISDATASTREAMDESTINATION_MEMBER_APPROXIMATE_CREATION_DATE_TIME_PRECISION,
     ],
 );
 impl KinesisDataStreamDestination {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &KINESISDATASTREAMDESTINATION_SCHEMA;
-93
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for KinesisDataStreamDestination {
     #[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.stream_arn {
             ser.write_string(&KINESISDATASTREAMDESTINATION_MEMBER_STREAM_ARN, val)?;
-102
+        }
         if let Some(ref val) = self.destination_status {
             ser.write_string(&KINESISDATASTREAMDESTINATION_MEMBER_DESTINATION_STATUS, val.as_str())?;
-105
+        }
         if let Some(ref val) = self.destination_status_description {
             ser.write_string(&KINESISDATASTREAMDESTINATION_MEMBER_DESTINATION_STATUS_DESCRIPTION, val)?;
-108
+        }
         if let Some(ref val) = self.approximate_creation_date_time_precision {
             ser.write_string(
                 &KINESISDATASTREAMDESTINATION_MEMBER_APPROXIMATE_CREATION_DATE_TIME_PRECISION,
                 val.as_str(),
             )?;
-114
+        }
         Ok(())
-116
+    }
-117
+}
 impl KinesisDataStreamDestination {
     /// 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(&KINESISDATASTREAMDESTINATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&KINESISDATASTREAMDESTINATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.stream_arn = Some(deser.read_string(member)?);
-136
+                }
                 Some(1) => {
                     builder.destination_status = Some(crate::types::DestinationStatus::from(deser.read_string(member)?.as_str()));
-139
+                }
                 Some(2) => {
                     builder.destination_status_description = Some(deser.read_string(member)?);
-142
+                }
                 Some(3) => {
                     builder.approximate_creation_date_time_precision = Some(crate::types::ApproximateCreationDateTimePrecision::from(
                         deser.read_string(member)?.as_str(),
                     ));
-147
+                }
                 _ => {}
-149
+            }
             Ok(())
         })?;
         Ok(builder.build())
-153
+    }
-154
+}
 impl KinesisDataStreamDestination {
     /// 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 KinesisDataStreamDestination {
     /// Creates a new builder-style object to manufacture [`KinesisDataStreamDestination`](crate::types::KinesisDataStreamDestination).
     pub fn builder() -> crate::types::builders::KinesisDataStreamDestinationBuilder {
         crate::types::builders::KinesisDataStreamDestinationBuilder::default()
-170
+    }
-171
+}
-172
 /// A builder for [`KinesisDataStreamDestination`](crate::types::KinesisDataStreamDestination).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct KinesisDataStreamDestinationBuilder {
     pub(crate) stream_arn: ::std::option::Option<::std::string::String>,
     pub(crate) destination_status: ::std::option::Option<crate::types::DestinationStatus>,
     pub(crate) destination_status_description: ::std::option::Option<::std::string::String>,
     pub(crate) approximate_creation_date_time_precision: ::std::option::Option<crate::types::ApproximateCreationDateTimePrecision>,
-181
+}
 impl KinesisDataStreamDestinationBuilder {
     /// <p>The ARN for a specific Kinesis data stream.</p>
     pub fn stream_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.stream_arn = ::std::option::Option::Some(input.into());
         self
-187
+    }
     /// <p>The ARN for a specific Kinesis data stream.</p>
     pub fn set_stream_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.stream_arn = input;
         self
-192
+    }
     /// <p>The ARN for a specific Kinesis data stream.</p>
     pub fn get_stream_arn(&self) -> &::std::option::Option<::std::string::String> {
         &self.stream_arn

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_local_secondary_index.rs

@@ -30,30 +198,208 @@

↥ Expand context

     /// <ul>
     /// <li>
     /// <p><code>HASH</code> - partition key</p></li>
     /// <li>
     /// <p><code>RANGE</code> - sort key</p></li>
     /// </ul><note>
     /// <p>The partition key of an item is also known as its <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage of an internal hash function to evenly distribute data items across partitions, based on their partition key values.</p>
     /// <p>The sort key of an item is also known as its <i>range attribute</i>. The term "range attribute" derives from the way DynamoDB stores items with the same partition key physically close together, in sorted order by the sort key value.</p>
     /// </note>
     pub fn key_schema(&self) -> &[crate::types::KeySchemaElement] {
         use std::ops::Deref;
         self.key_schema.deref()
-42
+    }
     /// <p>Represents attributes that are copied (projected) from the table into the local secondary index. These are in addition to the primary key attributes and index key attributes, which are automatically projected.</p>
     pub fn projection(&self) -> ::std::option::Option<&crate::types::Projection> {
         self.projection.as_ref()
-46
+    }
-47
+}
 static LOCALSECONDARYINDEX_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#LocalSecondaryIndex",

     "com.amazonaws.dynamodb",
     "LocalSecondaryIndex",
 );
 static LOCALSECONDARYINDEX_MEMBER_INDEX_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndex$IndexName",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndex",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "index_name",
     "IndexName",
 ,
 );
 static LOCALSECONDARYINDEX_MEMBER_KEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndex$KeySchema",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndex",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "key_schema",
     "KeySchema",
 ,
 );
 static LOCALSECONDARYINDEX_MEMBER_PROJECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndex$Projection",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndex",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "projection",
     "Projection",
 ,
 );
 static LOCALSECONDARYINDEX_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LOCALSECONDARYINDEX_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LOCALSECONDARYINDEX_MEMBER_INDEX_NAME,
         &LOCALSECONDARYINDEX_MEMBER_KEY_SCHEMA,
         &LOCALSECONDARYINDEX_MEMBER_PROJECTION,
     ],
 );
 impl LocalSecondaryIndex {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LOCALSECONDARYINDEX_SCHEMA;
-95
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LocalSecondaryIndex {
     #[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> {
-102
+        {
             let val = &self.index_name;
             ser.write_string(&LOCALSECONDARYINDEX_MEMBER_INDEX_NAME, val)?;
-105
+        }
-106
+        {
             let val = &self.key_schema;
-108
             ser.write_list(
                 &LOCALSECONDARYINDEX_MEMBER_KEY_SCHEMA,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::KeySchemaElement::SCHEMA, item)?;
-114
+                    }
                     Ok(())
                 },
             )?;
-118
+        }
         if let Some(ref val) = self.projection {
             ser.write_struct(&LOCALSECONDARYINDEX_MEMBER_PROJECTION, val)?;
-121
+        }
         Ok(())
-123
+    }
-124
+}
 impl LocalSecondaryIndex {
     /// 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(&LOCALSECONDARYINDEX_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LOCALSECONDARYINDEX_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.index_name = Some(deser.read_string(member)?);
-143
+                }
                 Some(1) => {
                     builder.key_schema = 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::KeySchemaElement::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::KeySchemaElement::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-153
+                }
                 Some(2) => {
                     builder.projection = Some(crate::types::Projection::deserialize(deser)?);
-156
+                }
                 _ => {}
-158
+            }
             Ok(())
         })?;
         builder.index_name = builder.index_name.or(Some(String::new()));
         builder.key_schema = builder.key_schema.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-166
+    }
-167
+}
 impl LocalSecondaryIndex {
     /// 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 LocalSecondaryIndex {
     /// Creates a new builder-style object to manufacture [`LocalSecondaryIndex`](crate::types::LocalSecondaryIndex).
     pub fn builder() -> crate::types::builders::LocalSecondaryIndexBuilder {
         crate::types::builders::LocalSecondaryIndexBuilder::default()
-183
+    }
-184
+}
-185
 /// A builder for [`LocalSecondaryIndex`](crate::types::LocalSecondaryIndex).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LocalSecondaryIndexBuilder {
     pub(crate) index_name: ::std::option::Option<::std::string::String>,
     pub(crate) key_schema: ::std::option::Option<::std::vec::Vec<crate::types::KeySchemaElement>>,
     pub(crate) projection: ::std::option::Option<crate::types::Projection>,
-193
+}
 impl LocalSecondaryIndexBuilder {
     /// <p>The name of the local secondary index. The name must be unique among all other indexes on this table.</p>
     /// This field is required.
     pub fn index_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.index_name = ::std::option::Option::Some(input.into());
         self
-200
+    }
     /// <p>The name of the local secondary index. The name must be unique among all other indexes on this table.</p>
     pub fn set_index_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.index_name = input;
         self
-205
+    }
     /// <p>The name of the local secondary index. The name must be unique among all other indexes on this table.</p>
     pub fn get_index_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.index_name

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_local_secondary_index_description.rs

@@ -48,48 +262,270 @@

↥ Expand context

-48
+    }
     /// <p>Represents attributes that are copied (projected) from the table into the global secondary index. These are in addition to the primary key attributes and index key attributes, which are automatically projected.</p>
     pub fn projection(&self) -> ::std::option::Option<&crate::types::Projection> {
         self.projection.as_ref()
-52
+    }
     /// <p>The total size of the specified index, in bytes. DynamoDB updates this value approximately every six hours. Recent changes might not be reflected in this value.</p>
     pub fn index_size_bytes(&self) -> ::std::option::Option<i64> {
         self.index_size_bytes
-56
+    }
     /// <p>The number of items in the specified index. DynamoDB updates this value approximately every six hours. Recent changes might not be reflected in this value.</p>
     pub fn item_count(&self) -> ::std::option::Option<i64> {
         self.item_count
-60
+    }
     /// <p>The Amazon Resource Name (ARN) that uniquely identifies the index.</p>
     pub fn index_arn(&self) -> ::std::option::Option<&str> {
         self.index_arn.as_deref()
-64
+    }
-65
+}
 static LOCALSECONDARYINDEXDESCRIPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#LocalSecondaryIndexDescription",

     "com.amazonaws.dynamodb",
     "LocalSecondaryIndexDescription",
 );
 static LOCALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndexDescription$IndexName",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndexDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "index_name",
     "IndexName",
 ,
 );
 static LOCALSECONDARYINDEXDESCRIPTION_MEMBER_KEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndexDescription$KeySchema",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndexDescription",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "key_schema",
     "KeySchema",
 ,
 );
 static LOCALSECONDARYINDEXDESCRIPTION_MEMBER_PROJECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndexDescription$Projection",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndexDescription",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "projection",
     "Projection",
 ,
 );
 static LOCALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_SIZE_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndexDescription$IndexSizeBytes",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndexDescription",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "index_size_bytes",
     "IndexSizeBytes",
 ,
 );
 static LOCALSECONDARYINDEXDESCRIPTION_MEMBER_ITEM_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndexDescription$ItemCount",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndexDescription",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "item_count",
     "ItemCount",
 ,
 );
 static LOCALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndexDescription$IndexArn",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndexDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "index_arn",
     "IndexArn",
 ,
 );
 static LOCALSECONDARYINDEXDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LOCALSECONDARYINDEXDESCRIPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LOCALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_NAME,
         &LOCALSECONDARYINDEXDESCRIPTION_MEMBER_KEY_SCHEMA,
         &LOCALSECONDARYINDEXDESCRIPTION_MEMBER_PROJECTION,
         &LOCALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_SIZE_BYTES,
         &LOCALSECONDARYINDEXDESCRIPTION_MEMBER_ITEM_COUNT,
         &LOCALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_ARN,
     ],
 );
 impl LocalSecondaryIndexDescription {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LOCALSECONDARYINDEXDESCRIPTION_SCHEMA;
-146
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LocalSecondaryIndexDescription {
     #[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.index_name {
             ser.write_string(&LOCALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_NAME, val)?;
-155
+        }
         if let Some(ref val) = self.key_schema {
             ser.write_list(
                 &LOCALSECONDARYINDEXDESCRIPTION_MEMBER_KEY_SCHEMA,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::KeySchemaElement::SCHEMA, item)?;
-162
+                    }
                     Ok(())
                 },
             )?;
-166
+        }
         if let Some(ref val) = self.projection {
             ser.write_struct(&LOCALSECONDARYINDEXDESCRIPTION_MEMBER_PROJECTION, val)?;
-169
+        }
         if let Some(ref val) = self.index_size_bytes {
             ser.write_long(&LOCALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_SIZE_BYTES, *val)?;
-172
+        }
         if let Some(ref val) = self.item_count {
             ser.write_long(&LOCALSECONDARYINDEXDESCRIPTION_MEMBER_ITEM_COUNT, *val)?;
-175
+        }
         if let Some(ref val) = self.index_arn {
             ser.write_string(&LOCALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_ARN, val)?;
-178
+        }
         Ok(())
-180
+    }
-181
+}
 impl LocalSecondaryIndexDescription {
     /// 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(&LOCALSECONDARYINDEXDESCRIPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LOCALSECONDARYINDEXDESCRIPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.index_name = Some(deser.read_string(member)?);
-200
+                }
                 Some(1) => {
                     builder.key_schema = 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::KeySchemaElement::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::KeySchemaElement::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-210
+                }
                 Some(2) => {
                     builder.projection = Some(crate::types::Projection::deserialize(deser)?);
-213
+                }
                 Some(3) => {
                     builder.index_size_bytes = Some(deser.read_long(member)?);
-216
+                }
                 Some(4) => {
                     builder.item_count = Some(deser.read_long(member)?);
-219
+                }
                 Some(5) => {
                     builder.index_arn = Some(deser.read_string(member)?);
-222
+                }
                 _ => {}
-224
+            }
             Ok(())
         })?;
         Ok(builder.build())
-228
+    }
-229
+}
 impl LocalSecondaryIndexDescription {
     /// 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 LocalSecondaryIndexDescription {
     /// Creates a new builder-style object to manufacture [`LocalSecondaryIndexDescription`](crate::types::LocalSecondaryIndexDescription).
     pub fn builder() -> crate::types::builders::LocalSecondaryIndexDescriptionBuilder {
         crate::types::builders::LocalSecondaryIndexDescriptionBuilder::default()
-245
+    }
-246
+}
-247
 /// A builder for [`LocalSecondaryIndexDescription`](crate::types::LocalSecondaryIndexDescription).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LocalSecondaryIndexDescriptionBuilder {
     pub(crate) index_name: ::std::option::Option<::std::string::String>,
     pub(crate) key_schema: ::std::option::Option<::std::vec::Vec<crate::types::KeySchemaElement>>,
     pub(crate) projection: ::std::option::Option<crate::types::Projection>,
     pub(crate) index_size_bytes: ::std::option::Option<i64>,
     pub(crate) item_count: ::std::option::Option<i64>,
     pub(crate) index_arn: ::std::option::Option<::std::string::String>,
-258
+}
 impl LocalSecondaryIndexDescriptionBuilder {
     /// <p>Represents the name of the local secondary index.</p>
     pub fn index_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.index_name = ::std::option::Option::Some(input.into());
         self
-264
+    }
     /// <p>Represents the name of the local secondary index.</p>
     pub fn set_index_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.index_name = input;
         self
-269
+    }
     /// <p>Represents the name of the local secondary index.</p>

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_local_secondary_index_info.rs

@@ -30,30 +193,201 @@

↥ Expand context

     /// <li>
     /// <p><code>HASH</code> - partition key</p></li>
     /// <li>
     /// <p><code>RANGE</code> - sort key</p></li>
     /// </ul><note>
     /// <p>The partition key of an item is also known as its <i>hash attribute</i>. The term "hash attribute" derives from DynamoDB's usage of an internal hash function to evenly distribute data items across partitions, based on their partition key values.</p>
     /// <p>The sort key of an item is also known as its <i>range attribute</i>. The term "range attribute" derives from the way DynamoDB stores items with the same partition key physically close together, in sorted order by the sort key value.</p>
     /// </note>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.key_schema.is_none()`.
     pub fn key_schema(&self) -> &[crate::types::KeySchemaElement] {
         self.key_schema.as_deref().unwrap_or_default()
-42
+    }
     /// <p>Represents attributes that are copied (projected) from the table into the global secondary index. These are in addition to the primary key attributes and index key attributes, which are automatically projected.</p>
     pub fn projection(&self) -> ::std::option::Option<&crate::types::Projection> {
         self.projection.as_ref()
-46
+    }
-47
+}
 static LOCALSECONDARYINDEXINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#LocalSecondaryIndexInfo",

     "com.amazonaws.dynamodb",
     "LocalSecondaryIndexInfo",
 );
 static LOCALSECONDARYINDEXINFO_MEMBER_INDEX_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndexInfo$IndexName",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndexInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "index_name",
     "IndexName",
 ,
 );
 static LOCALSECONDARYINDEXINFO_MEMBER_KEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndexInfo$KeySchema",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndexInfo",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "key_schema",
     "KeySchema",
 ,
 );
 static LOCALSECONDARYINDEXINFO_MEMBER_PROJECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#LocalSecondaryIndexInfo$Projection",
         "com.amazonaws.dynamodb",
         "LocalSecondaryIndexInfo",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "projection",
     "Projection",
 ,
 );
 static LOCALSECONDARYINDEXINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LOCALSECONDARYINDEXINFO_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LOCALSECONDARYINDEXINFO_MEMBER_INDEX_NAME,
         &LOCALSECONDARYINDEXINFO_MEMBER_KEY_SCHEMA,
         &LOCALSECONDARYINDEXINFO_MEMBER_PROJECTION,
     ],
 );
 impl LocalSecondaryIndexInfo {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LOCALSECONDARYINDEXINFO_SCHEMA;
-95
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LocalSecondaryIndexInfo {
     #[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.index_name {
             ser.write_string(&LOCALSECONDARYINDEXINFO_MEMBER_INDEX_NAME, val)?;
-104
+        }
         if let Some(ref val) = self.key_schema {
             ser.write_list(
                 &LOCALSECONDARYINDEXINFO_MEMBER_KEY_SCHEMA,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::KeySchemaElement::SCHEMA, item)?;
-111
+                    }
                     Ok(())
                 },
             )?;
-115
+        }
         if let Some(ref val) = self.projection {
             ser.write_struct(&LOCALSECONDARYINDEXINFO_MEMBER_PROJECTION, val)?;
-118
+        }
         Ok(())
-120
+    }
-121
+}
 impl LocalSecondaryIndexInfo {
     /// 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(&LOCALSECONDARYINDEXINFO_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LOCALSECONDARYINDEXINFO_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.index_name = Some(deser.read_string(member)?);
-140
+                }
                 Some(1) => {
                     builder.key_schema = 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::KeySchemaElement::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::KeySchemaElement::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-150
+                }
                 Some(2) => {
                     builder.projection = Some(crate::types::Projection::deserialize(deser)?);
-153
+                }
                 _ => {}
-155
+            }
             Ok(())
         })?;
         Ok(builder.build())
-159
+    }
-160
+}
 impl LocalSecondaryIndexInfo {
     /// 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 LocalSecondaryIndexInfo {
     /// Creates a new builder-style object to manufacture [`LocalSecondaryIndexInfo`](crate::types::LocalSecondaryIndexInfo).
     pub fn builder() -> crate::types::builders::LocalSecondaryIndexInfoBuilder {
         crate::types::builders::LocalSecondaryIndexInfoBuilder::default()
-176
+    }
-177
+}
-178
 /// A builder for [`LocalSecondaryIndexInfo`](crate::types::LocalSecondaryIndexInfo).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LocalSecondaryIndexInfoBuilder {
     pub(crate) index_name: ::std::option::Option<::std::string::String>,
     pub(crate) key_schema: ::std::option::Option<::std::vec::Vec<crate::types::KeySchemaElement>>,
     pub(crate) projection: ::std::option::Option<crate::types::Projection>,
-186
+}
 impl LocalSecondaryIndexInfoBuilder {
     /// <p>Represents the name of the local secondary index.</p>
     pub fn index_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.index_name = ::std::option::Option::Some(input.into());
         self
-192
+    }
     /// <p>Represents the name of the local secondary index.</p>
     pub fn set_index_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.index_name = input;
         self
-197
+    }
     /// <p>Represents the name of the local secondary index.</p>
     pub fn get_index_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.index_name
-201
+    }

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_on_demand_throughput.rs

@@ -8,8 +136,147 @@

↥ Expand context

     /// <p>To specify a maximum <code>OnDemandThroughput</code> on your table, set the value of <code>MaxReadRequestUnits</code> as greater than or equal to 1. To remove the maximum <code>OnDemandThroughput</code> that is currently set on your table, set the value of <code>MaxReadRequestUnits</code> to -1.</p>
     pub max_read_request_units: ::std::option::Option<i64>,
     /// <p>Maximum number of write request units for the specified table.</p>
     /// <p>To specify a maximum <code>OnDemandThroughput</code> on your table, set the value of <code>MaxWriteRequestUnits</code> as greater than or equal to 1. To remove the maximum <code>OnDemandThroughput</code> that is currently set on your table, set the value of <code>MaxWriteRequestUnits</code> to -1.</p>
     pub max_write_request_units: ::std::option::Option<i64>,
-13
+}
 impl OnDemandThroughput {
     /// <p>Maximum number of read request units for the specified table.</p>
     /// <p>To specify a maximum <code>OnDemandThroughput</code> on your table, set the value of <code>MaxReadRequestUnits</code> as greater than or equal to 1. To remove the maximum <code>OnDemandThroughput</code> that is currently set on your table, set the value of <code>MaxReadRequestUnits</code> to -1.</p>
     pub fn max_read_request_units(&self) -> ::std::option::Option<i64> {
         self.max_read_request_units
-19
+    }
     /// <p>Maximum number of write request units for the specified table.</p>
     /// <p>To specify a maximum <code>OnDemandThroughput</code> on your table, set the value of <code>MaxWriteRequestUnits</code> as greater than or equal to 1. To remove the maximum <code>OnDemandThroughput</code> that is currently set on your table, set the value of <code>MaxWriteRequestUnits</code> to -1.</p>
     pub fn max_write_request_units(&self) -> ::std::option::Option<i64> {
         self.max_write_request_units
-24
+    }
-25
+}
 static ONDEMANDTHROUGHPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#OnDemandThroughput",

     "com.amazonaws.dynamodb",
     "OnDemandThroughput",
 );
 static ONDEMANDTHROUGHPUT_MEMBER_MAX_READ_REQUEST_UNITS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#OnDemandThroughput$MaxReadRequestUnits",
         "com.amazonaws.dynamodb",
         "OnDemandThroughput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "max_read_request_units",
     "MaxReadRequestUnits",
 ,
 );
 static ONDEMANDTHROUGHPUT_MEMBER_MAX_WRITE_REQUEST_UNITS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#OnDemandThroughput$MaxWriteRequestUnits",
         "com.amazonaws.dynamodb",
         "OnDemandThroughput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "max_write_request_units",
     "MaxWriteRequestUnits",
 ,
 );
 static ONDEMANDTHROUGHPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ONDEMANDTHROUGHPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ONDEMANDTHROUGHPUT_MEMBER_MAX_READ_REQUEST_UNITS,
         &ONDEMANDTHROUGHPUT_MEMBER_MAX_WRITE_REQUEST_UNITS,
     ],
 );
 impl OnDemandThroughput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ONDEMANDTHROUGHPUT_SCHEMA;
-62
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for OnDemandThroughput {
     #[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.max_read_request_units {
             ser.write_long(&ONDEMANDTHROUGHPUT_MEMBER_MAX_READ_REQUEST_UNITS, *val)?;
-71
+        }
         if let Some(ref val) = self.max_write_request_units {
             ser.write_long(&ONDEMANDTHROUGHPUT_MEMBER_MAX_WRITE_REQUEST_UNITS, *val)?;
-74
+        }
         Ok(())
-76
+    }
-77
+}
 impl OnDemandThroughput {
     /// 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(&ONDEMANDTHROUGHPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ONDEMANDTHROUGHPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.max_read_request_units = Some(deser.read_long(member)?);
-96
+                }
                 Some(1) => {
                     builder.max_write_request_units = Some(deser.read_long(member)?);
-99
+                }
                 _ => {}
-101
+            }
             Ok(())
         })?;
         Ok(builder.build())
-105
+    }
-106
+}
 impl OnDemandThroughput {
     /// 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 OnDemandThroughput {
     /// Creates a new builder-style object to manufacture [`OnDemandThroughput`](crate::types::OnDemandThroughput).
     pub fn builder() -> crate::types::builders::OnDemandThroughputBuilder {
         crate::types::builders::OnDemandThroughputBuilder::default()
-122
+    }
-123
+}
-124
 /// A builder for [`OnDemandThroughput`](crate::types::OnDemandThroughput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct OnDemandThroughputBuilder {
     pub(crate) max_read_request_units: ::std::option::Option<i64>,
     pub(crate) max_write_request_units: ::std::option::Option<i64>,
-131
+}
 impl OnDemandThroughputBuilder {
     /// <p>Maximum number of read request units for the specified table.</p>
     /// <p>To specify a maximum <code>OnDemandThroughput</code> on your table, set the value of <code>MaxReadRequestUnits</code> as greater than or equal to 1. To remove the maximum <code>OnDemandThroughput</code> that is currently set on your table, set the value of <code>MaxReadRequestUnits</code> to -1.</p>
     pub fn max_read_request_units(mut self, input: i64) -> Self {
         self.max_read_request_units = ::std::option::Option::Some(input);
         self
-138
+    }
     /// <p>Maximum number of read request units for the specified table.</p>
     /// <p>To specify a maximum <code>OnDemandThroughput</code> on your table, set the value of <code>MaxReadRequestUnits</code> as greater than or equal to 1. To remove the maximum <code>OnDemandThroughput</code> that is currently set on your table, set the value of <code>MaxReadRequestUnits</code> to -1.</p>
     pub fn set_max_read_request_units(mut self, input: ::std::option::Option<i64>) -> Self {
         self.max_read_request_units = input;
         self
-144
+    }
     /// <p>Maximum number of read request units for the specified table.</p>
     /// <p>To specify a maximum <code>OnDemandThroughput</code> on your table, set the value of <code>MaxReadRequestUnits</code> as greater than or equal to 1. To remove the maximum <code>OnDemandThroughput</code> that is currently set on your table, set the value of <code>MaxReadRequestUnits</code> to -1.</p>
     pub fn get_max_read_request_units(&self) -> &::std::option::Option<i64> {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_on_demand_throughput_override.rs

@@ -1,1 +107,118 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Overrides the on-demand throughput settings for this replica table. If you don't specify a value for this parameter, it uses the source table's on-demand throughput settings.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct OnDemandThroughputOverride {
     /// <p>Maximum number of read request units for the specified replica table.</p>
     pub max_read_request_units: ::std::option::Option<i64>,
-9
+}
 impl OnDemandThroughputOverride {
     /// <p>Maximum number of read request units for the specified replica table.</p>
     pub fn max_read_request_units(&self) -> ::std::option::Option<i64> {
         self.max_read_request_units
-14
+    }
-15
+}
 static ONDEMANDTHROUGHPUTOVERRIDE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#OnDemandThroughputOverride",

     "com.amazonaws.dynamodb",
     "OnDemandThroughputOverride",
 );
 static ONDEMANDTHROUGHPUTOVERRIDE_MEMBER_MAX_READ_REQUEST_UNITS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#OnDemandThroughputOverride$MaxReadRequestUnits",
         "com.amazonaws.dynamodb",
         "OnDemandThroughputOverride",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "max_read_request_units",
     "MaxReadRequestUnits",
 ,
 );
 static ONDEMANDTHROUGHPUTOVERRIDE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ONDEMANDTHROUGHPUTOVERRIDE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ONDEMANDTHROUGHPUTOVERRIDE_MEMBER_MAX_READ_REQUEST_UNITS],
 );
 impl OnDemandThroughputOverride {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ONDEMANDTHROUGHPUTOVERRIDE_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for OnDemandThroughputOverride {
     #[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.max_read_request_units {
             ser.write_long(&ONDEMANDTHROUGHPUTOVERRIDE_MEMBER_MAX_READ_REQUEST_UNITS, *val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl OnDemandThroughputOverride {
     /// 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(&ONDEMANDTHROUGHPUTOVERRIDE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ONDEMANDTHROUGHPUTOVERRIDE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.max_read_request_units = Some(deser.read_long(member)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl OnDemandThroughputOverride {
     /// 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 OnDemandThroughputOverride {
     /// Creates a new builder-style object to manufacture [`OnDemandThroughputOverride`](crate::types::OnDemandThroughputOverride).
     pub fn builder() -> crate::types::builders::OnDemandThroughputOverrideBuilder {
         crate::types::builders::OnDemandThroughputOverrideBuilder::default()
-93
+    }
-94
+}
-95
 /// A builder for [`OnDemandThroughputOverride`](crate::types::OnDemandThroughputOverride).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct OnDemandThroughputOverrideBuilder {
     pub(crate) max_read_request_units: ::std::option::Option<i64>,
-101
+}
 impl OnDemandThroughputOverrideBuilder {
     /// <p>Maximum number of read request units for the specified replica table.</p>
     pub fn max_read_request_units(mut self, input: i64) -> Self {
         self.max_read_request_units = ::std::option::Option::Some(input);
         self
-107
+    }
     /// <p>Maximum number of read request units for the specified replica table.</p>
     pub fn set_max_read_request_units(mut self, input: ::std::option::Option<i64>) -> Self {
         self.max_read_request_units = input;
         self
-112
+    }
     /// <p>Maximum number of read request units for the specified replica table.</p>
     pub fn get_max_read_request_units(&self) -> &::std::option::Option<i64> {
         &self.max_read_request_units
-116
+    }
     /// Consumes the builder and constructs a [`OnDemandThroughputOverride`](crate::types::OnDemandThroughputOverride).
     pub fn build(self) -> crate::types::OnDemandThroughputOverride {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_parameterized_statement.rs

@@ -15,15 +183,192 @@

↥ Expand context

 impl ParameterizedStatement {
     /// <p>A PartiQL statement that uses parameters.</p>
     pub fn statement(&self) -> &str {
         use std::ops::Deref;
         self.statement.deref()
-20
+    }
     /// <p>The parameter values.</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 `.parameters.is_none()`.
     pub fn parameters(&self) -> &[crate::types::AttributeValue] {
         self.parameters.as_deref().unwrap_or_default()
-26
+    }
     /// <p>An optional parameter that returns the item attributes for a PartiQL <code>ParameterizedStatement</code> operation that failed a condition check.</p>
     /// <p>There is no additional cost associated with requesting a return value aside from the small network and processing overhead of receiving a larger response. No read capacity units are consumed.</p>
     pub fn return_values_on_condition_check_failure(&self) -> ::std::option::Option<&crate::types::ReturnValuesOnConditionCheckFailure> {
         self.return_values_on_condition_check_failure.as_ref()
-31
+    }
-32
+}
 static PARAMETERIZEDSTATEMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#ParameterizedStatement",

     "com.amazonaws.dynamodb",
     "ParameterizedStatement",
 );
 static PARAMETERIZEDSTATEMENT_MEMBER_STATEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ParameterizedStatement$Statement",
         "com.amazonaws.dynamodb",
         "ParameterizedStatement",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "statement",
     "Statement",
 ,
 );
 static PARAMETERIZEDSTATEMENT_MEMBER_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ParameterizedStatement$Parameters",
         "com.amazonaws.dynamodb",
         "ParameterizedStatement",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "parameters",
     "Parameters",
 ,
 );
 static PARAMETERIZEDSTATEMENT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#ParameterizedStatement$ReturnValuesOnConditionCheckFailure",
         "com.amazonaws.dynamodb",
         "ParameterizedStatement",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_values_on_condition_check_failure",
     "ReturnValuesOnConditionCheckFailure",
 ,
 );
 static PARAMETERIZEDSTATEMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PARAMETERIZEDSTATEMENT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PARAMETERIZEDSTATEMENT_MEMBER_STATEMENT,
         &PARAMETERIZEDSTATEMENT_MEMBER_PARAMETERS,
         &PARAMETERIZEDSTATEMENT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE,
     ],
 );
 impl ParameterizedStatement {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PARAMETERIZEDSTATEMENT_SCHEMA;
-80
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ParameterizedStatement {
     #[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> {
-87
+        {
             let val = &self.statement;
             ser.write_string(&PARAMETERIZEDSTATEMENT_MEMBER_STATEMENT, val)?;
-90
+        }
         if let Some(ref val) = self.parameters {
             ser.write_list(
                 &PARAMETERIZEDSTATEMENT_MEMBER_PARAMETERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_struct(crate::types::AttributeValue::SCHEMA, item)?;
-97
+                    }
                     Ok(())
                 },
             )?;
-101
+        }
         if let Some(ref val) = self.return_values_on_condition_check_failure {
             ser.write_string(&PARAMETERIZEDSTATEMENT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE, val.as_str())?;
-104
+        }
         Ok(())
-106
+    }
-107
+}
 impl ParameterizedStatement {
     /// 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(&PARAMETERIZEDSTATEMENT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PARAMETERIZEDSTATEMENT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.statement = Some(deser.read_string(member)?);
-126
+                }
                 Some(1) => {
                     builder.parameters = 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(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-136
+                }
                 Some(2) => {
                     builder.return_values_on_condition_check_failure = Some(crate::types::ReturnValuesOnConditionCheckFailure::from(
                         deser.read_string(member)?.as_str(),
                     ));
-141
+                }
                 _ => {}
-143
+            }
             Ok(())
         })?;
         builder.statement = builder.statement.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-150
+    }
-151
+}
 impl ParameterizedStatement {
     /// 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 ParameterizedStatement {
     /// Creates a new builder-style object to manufacture [`ParameterizedStatement`](crate::types::ParameterizedStatement).
     pub fn builder() -> crate::types::builders::ParameterizedStatementBuilder {
         crate::types::builders::ParameterizedStatementBuilder::default()
-167
+    }
-168
+}
-169
 /// A builder for [`ParameterizedStatement`](crate::types::ParameterizedStatement).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ParameterizedStatementBuilder {
     pub(crate) statement: ::std::option::Option<::std::string::String>,
     pub(crate) parameters: ::std::option::Option<::std::vec::Vec<crate::types::AttributeValue>>,
     pub(crate) return_values_on_condition_check_failure: ::std::option::Option<crate::types::ReturnValuesOnConditionCheckFailure>,
-177
+}
 impl ParameterizedStatementBuilder {
     /// <p>A PartiQL statement that uses parameters.</p>
     /// This field is required.
     pub fn statement(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.statement = ::std::option::Option::Some(input.into());
         self
-184
+    }
     /// <p>A PartiQL statement that uses parameters.</p>
     pub fn set_statement(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.statement = input;
         self
-189
+    }
     /// <p>A PartiQL statement that uses parameters.</p>
     pub fn get_statement(&self) -> &::std::option::Option<::std::string::String> {
         &self.statement

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_point_in_time_recovery_description.rs

@@ -28,28 +190,201 @@

↥ Expand context

     /// <p><code>DISABLED</code> - Point in time recovery is disabled.</p></li>
     /// </ul>
     pub fn point_in_time_recovery_status(&self) -> ::std::option::Option<&crate::types::PointInTimeRecoveryStatus> {
         self.point_in_time_recovery_status.as_ref()
-32
+    }
     /// <p>The number of preceding days for which continuous backups are taken and maintained. Your table data is only recoverable to any point-in-time from within the configured recovery period. This parameter is optional.</p>
     pub fn recovery_period_in_days(&self) -> ::std::option::Option<i32> {
         self.recovery_period_in_days
-36
+    }
     /// <p>Specifies the earliest point in time you can restore your table to. You can restore your table to any point in time during the last 35 days.</p>
     pub fn earliest_restorable_date_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.earliest_restorable_date_time.as_ref()
-40
+    }
     /// <p><code>LatestRestorableDateTime</code> is typically 5 minutes before the current time.</p>
     pub fn latest_restorable_date_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.latest_restorable_date_time.as_ref()
-44
+    }
-45
+}
 static POINTINTIMERECOVERYDESCRIPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb#PointInTimeRecoveryDescription",

     "com.amazonaws.dynamodb",
     "PointInTimeRecoveryDescription",
 );
 static POINTINTIMERECOVERYDESCRIPTION_MEMBER_POINT_IN_TIME_RECOVERY_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#PointInTimeRecoveryDescription$PointInTimeRecoveryStatus",
         "com.amazonaws.dynamodb",
         "PointInTimeRecoveryDescription",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "point_in_time_recovery_status",
     "PointInTimeRecoveryStatus",
 ,
 );
 static POINTINTIMERECOVERYDESCRIPTION_MEMBER_RECOVERY_PERIOD_IN_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#PointInTimeRecoveryDescription$RecoveryPeriodInDays",
         "com.amazonaws.dynamodb",
         "PointInTimeRecoveryDescription",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "recovery_period_in_days",
     "RecoveryPeriodInDays",
 ,
 );
 static POINTINTIMERECOVERYDESCRIPTION_MEMBER_EARLIEST_RESTORABLE_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#PointInTimeRecoveryDescription$EarliestRestorableDateTime",
         "com.amazonaws.dynamodb",
         "PointInTimeRecoveryDescription",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "earliest_restorable_date_time",
     "EarliestRestorableDateTime",
 ,
 );
 static POINTINTIMERECOVERYDESCRIPTION_MEMBER_LATEST_RESTORABLE_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb#PointInTimeRecoveryDescription$LatestRestorableDateTime",
         "com.amazonaws.dynamodb",
         "PointInTimeRecoveryDescription",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "latest_restorable_date_time",
     "LatestRestorableDateTime",
 ,
 );
 static POINTINTIMERECOVERYDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     POINTINTIMERECOVERYDESCRIPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &POINTINTIMERECOVERYDESCRIPTION_MEMBER_POINT_IN_TIME_RECOVERY_STATUS,
         &POINTINTIMERECOVERYDESCRIPTION_MEMBER_RECOVERY_PERIOD_IN_DAYS,
         &POINTINTIMERECOVERYDESCRIPTION_MEMBER_EARLIEST_RESTORABLE_DATE_TIME,
         &POINTINTIMERECOVERYDESCRIPTION_MEMBER_LATEST_RESTORABLE_DATE_TIME,
     ],
 );
 impl PointInTimeRecoveryDescription {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POINTINTIMERECOVERYDESCRIPTION_SCHEMA;
-104
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PointInTimeRecoveryDescription {
     #[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.point_in_time_recovery_status {
             ser.write_string(&POINTINTIMERECOVERYDESCRIPTION_MEMBER_POINT_IN_TIME_RECOVERY_STATUS, val.as_str())?;
-113
+        }
         if let Some(ref val) = self.recovery_period_in_days {
             ser.write_integer(&POINTINTIMERECOVERYDESCRIPTION_MEMBER_RECOVERY_PERIOD_IN_DAYS, *val)?;
-116
+        }
         if let Some(ref val) = self.earliest_restorable_date_time {
             ser.write_timestamp(&POINTINTIMERECOVERYDESCRIPTION_MEMBER_EARLIEST_RESTORABLE_DATE_TIME, val)?;
-119
+        }
         if let Some(ref val) = self.latest_restorable_date_time {
             ser.write_timestamp(&POINTINTIMERECOVERYDESCRIPTION_MEMBER_LATEST_RESTORABLE_DATE_TIME, val)?;
-122
+        }
         Ok(())
-124
+    }
-125
+}
 impl PointInTimeRecoveryDescription {
     /// 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(&POINTINTIMERECOVERYDESCRIPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&POINTINTIMERECOVERYDESCRIPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.point_in_time_recovery_status = Some(crate::types::PointInTimeRecoveryStatus::from(deser.read_string(member)?.as_str()));
-144
+                }
                 Some(1) => {
                     builder.recovery_period_in_days = Some(deser.read_integer(member)?);
-147
+                }
                 Some(2) => {
                     builder.earliest_restorable_date_time = Some(deser.read_timestamp(member)?);
-150
+                }
                 Some(3) => {
                     builder.latest_restorable_date_time = Some(deser.read_timestamp(member)?);
-153
+                }
                 _ => {}
-155
+            }
             Ok(())
         })?;
         Ok(builder.build())
-159
+    }
-160
+}
 impl PointInTimeRecoveryDescription {
     /// 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 PointInTimeRecoveryDescription {
     /// Creates a new builder-style object to manufacture [`PointInTimeRecoveryDescription`](crate::types::PointInTimeRecoveryDescription).
     pub fn builder() -> crate::types::builders::PointInTimeRecoveryDescriptionBuilder {
         crate::types::builders::PointInTimeRecoveryDescriptionBuilder::default()
-176
+    }
-177
+}
-178
 /// A builder for [`PointInTimeRecoveryDescription`](crate::types::PointInTimeRecoveryDescription).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PointInTimeRecoveryDescriptionBuilder {
     pub(crate) point_in_time_recovery_status: ::std::option::Option<crate::types::PointInTimeRecoveryStatus>,
     pub(crate) recovery_period_in_days: ::std::option::Option<i32>,
     pub(crate) earliest_restorable_date_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) latest_restorable_date_time: ::std::option::Option<::aws_smithy_types::DateTime>,
-187
+}
 impl PointInTimeRecoveryDescriptionBuilder {
     /// <p>The current state of point in time recovery:</p>
     /// <ul>
     /// <li>
     /// <p><code>ENABLED</code> - Point in time recovery is enabled.</p></li>
     /// <li>
     /// <p><code>DISABLED</code> - Point in time recovery is disabled.</p></li>
     /// </ul>
     pub fn point_in_time_recovery_status(mut self, input: crate::types::PointInTimeRecoveryStatus) -> Self {
         self.point_in_time_recovery_status = ::std::option::Option::Some(input);
         self
-199
+    }
     /// <p>The current state of point in time recovery:</p>
     /// <ul>

AWS SDK

Files changed: