AWS SDK

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/update_table/_update_table_input.rs

@@ -152,152 +342,342 @@

     /// <p><code>Delete</code> - remove a witness from the global table.</p></li>
     /// </ul>
     /// <p>You can create or delete only one witness per <code>UpdateTable</code> operation.</p>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_HowItWorks.html#V2globaltables_HowItWorks.consistency-modes">Multi-Region strong consistency (MRSC)</a> in the Amazon DynamoDB Developer Guide</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 `.global_table_witness_updates.is_none()`.
     pub fn global_table_witness_updates(&self) -> &[crate::types::GlobalTableWitnessGroupUpdate] {
         self.global_table_witness_updates.as_deref().unwrap_or_default()
-160
+    }
     /// <p>Updates the maximum number of read and write units for the specified table in on-demand capacity mode. If you use this parameter, you must specify <code>MaxReadRequestUnits</code>, <code>MaxWriteRequestUnits</code>, or both.</p>
     pub fn on_demand_throughput(&self) -> ::std::option::Option<&crate::types::OnDemandThroughput> {
         self.on_demand_throughput.as_ref()
-164
+    }
     /// <p>Represents the warm throughput (in read units per second and write units per second) for updating a table.</p>
     pub fn warm_throughput(&self) -> ::std::option::Option<&crate::types::WarmThroughput> {
         self.warm_throughput.as_ref()
-168
+    }
-169
+}
 static UPDATETABLEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#UpdateTableInput",

     "com.amazonaws.dynamodb.synthetic",
     "UpdateTableInput",
 );
 static UPDATETABLEINPUT_MEMBER_ATTRIBUTE_DEFINITIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$AttributeDefinitions",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "attribute_definitions",
     "AttributeDefinitions",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$TableName",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_name",
     "TableName",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_BILLING_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$BillingMode",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "billing_mode",
     "BillingMode",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_PROVISIONED_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$ProvisionedThroughput",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "provisioned_throughput",
     "ProvisionedThroughput",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_GLOBAL_SECONDARY_INDEX_UPDATES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$GlobalSecondaryIndexUpdates",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "global_secondary_index_updates",
     "GlobalSecondaryIndexUpdates",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_STREAM_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$StreamSpecification",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "stream_specification",
     "StreamSpecification",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_SSE_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$SSESpecification",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "sse_specification",
     "SSESpecification",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_REPLICA_UPDATES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$ReplicaUpdates",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "replica_updates",
     "ReplicaUpdates",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_TABLE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$TableClass",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_class",
     "TableClass",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_DELETION_PROTECTION_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$DeletionProtectionEnabled",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "deletion_protection_enabled",
     "DeletionProtectionEnabled",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_MULTI_REGION_CONSISTENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$MultiRegionConsistency",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "multi_region_consistency",
     "MultiRegionConsistency",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_GLOBAL_TABLE_WITNESS_UPDATES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$GlobalTableWitnessUpdates",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "global_table_witness_updates",
     "GlobalTableWitnessUpdates",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_ON_DEMAND_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$OnDemandThroughput",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "on_demand_throughput",
     "OnDemandThroughput",
 ,
 );
 static UPDATETABLEINPUT_MEMBER_WARM_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableInput$WarmThroughput",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "warm_throughput",
     "WarmThroughput",
 ,
 );
 static UPDATETABLEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATETABLEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPDATETABLEINPUT_MEMBER_ATTRIBUTE_DEFINITIONS,
         &UPDATETABLEINPUT_MEMBER_TABLE_NAME,
         &UPDATETABLEINPUT_MEMBER_BILLING_MODE,
         &UPDATETABLEINPUT_MEMBER_PROVISIONED_THROUGHPUT,

↧ Expand context

         &UPDATETABLEINPUT_MEMBER_GLOBAL_SECONDARY_INDEX_UPDATES,
         &UPDATETABLEINPUT_MEMBER_STREAM_SPECIFICATION,
         &UPDATETABLEINPUT_MEMBER_SSE_SPECIFICATION,
         &UPDATETABLEINPUT_MEMBER_REPLICA_UPDATES,
         &UPDATETABLEINPUT_MEMBER_TABLE_CLASS,
         &UPDATETABLEINPUT_MEMBER_DELETION_PROTECTION_ENABLED,
         &UPDATETABLEINPUT_MEMBER_MULTI_REGION_CONSISTENCY,
         &UPDATETABLEINPUT_MEMBER_GLOBAL_TABLE_WITNESS_UPDATES,
         &UPDATETABLEINPUT_MEMBER_ON_DEMAND_THROUGHPUT,
         &UPDATETABLEINPUT_MEMBER_WARM_THROUGHPUT,
     ],
 );
 impl UpdateTableInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATETABLEINPUT_SCHEMA;
-338
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateTableInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

@@ -394,394 +558,558 @@

↥ Expand context

             ser.write_string(&UPDATETABLEINPUT_MEMBER_TABLE_CLASS, val.as_str())?;
-395
+        }
         if let Some(ref val) = self.deletion_protection_enabled {
             ser.write_boolean(&UPDATETABLEINPUT_MEMBER_DELETION_PROTECTION_ENABLED, *val)?;
-398
+        }
         if let Some(ref val) = self.multi_region_consistency {
             ser.write_string(&UPDATETABLEINPUT_MEMBER_MULTI_REGION_CONSISTENCY, val.as_str())?;
-401
+        }
         if let Some(ref val) = self.global_table_witness_updates {
             ser.write_list(
                 &UPDATETABLEINPUT_MEMBER_GLOBAL_TABLE_WITNESS_UPDATES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::GlobalTableWitnessGroupUpdate::SCHEMA, item)?;
-408
+                    }
                     Ok(())
                 },
             )?;
-412
+        }
         if let Some(ref val) = self.on_demand_throughput {

             ser.write_struct(&UPDATETABLEINPUT_MEMBER_ON_DEMAND_THROUGHPUT, val)?;
-415
+        }
         if let Some(ref val) = self.warm_throughput {
             ser.write_struct(&UPDATETABLEINPUT_MEMBER_WARM_THROUGHPUT, val)?;
-418
+        }
         Ok(())
-420
+    }
-421
+}
 impl UpdateTableInput {
     /// 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(&UPDATETABLEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATETABLEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.attribute_definitions = 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::AttributeDefinition::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::AttributeDefinition::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-447
+                }
                 Some(1) => {
                     builder.table_name = Some(deser.read_string(member)?);
-450
+                }
                 Some(2) => {
                     builder.billing_mode = Some(crate::types::BillingMode::from(deser.read_string(member)?.as_str()));
-453
+                }
                 Some(3) => {
                     builder.provisioned_throughput = Some(crate::types::ProvisionedThroughput::deserialize(deser)?);
-456
+                }
                 Some(4) => {
                     builder.global_secondary_index_updates = 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::GlobalSecondaryIndexUpdate::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GlobalSecondaryIndexUpdate::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-466
+                }
                 Some(5) => {
                     builder.stream_specification = Some(crate::types::StreamSpecification::deserialize(deser)?);
-469
+                }
                 Some(6) => {
                     builder.sse_specification = Some(crate::types::SseSpecification::deserialize(deser)?);
-472
+                }
                 Some(7) => {
                     builder.replica_updates = 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::ReplicationGroupUpdate::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ReplicationGroupUpdate::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-482
+                }
                 Some(8) => {
                     builder.table_class = Some(crate::types::TableClass::from(deser.read_string(member)?.as_str()));
-485
+                }
                 Some(9) => {
                     builder.deletion_protection_enabled = Some(deser.read_boolean(member)?);
-488
+                }
                 Some(10) => {
                     builder.multi_region_consistency = Some(crate::types::MultiRegionConsistency::from(deser.read_string(member)?.as_str()));
-491
+                }
                 Some(11) => {
                     builder.global_table_witness_updates = 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::GlobalTableWitnessGroupUpdate::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GlobalTableWitnessGroupUpdate::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-501
+                }
                 Some(12) => {
                     builder.on_demand_throughput = Some(crate::types::OnDemandThroughput::deserialize(deser)?);
-504
+                }
                 Some(13) => {
                     builder.warm_throughput = Some(crate::types::WarmThroughput::deserialize(deser)?);
-507
+                }
                 _ => {}
-509
+            }
             Ok(())
         })?;
         builder.table_name = builder.table_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-516
+    }
-517
+}
 impl UpdateTableInput {
     /// 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 UpdateTableInput {
     /// Creates a new builder-style object to manufacture [`UpdateTableInput`](crate::operation::update_table::UpdateTableInput).
     pub fn builder() -> crate::operation::update_table::builders::UpdateTableInputBuilder {
         crate::operation::update_table::builders::UpdateTableInputBuilder::default()
-533
+    }
-534
+}
-535
 /// A builder for [`UpdateTableInput`](crate::operation::update_table::UpdateTableInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UpdateTableInputBuilder {
     pub(crate) attribute_definitions: ::std::option::Option<::std::vec::Vec<crate::types::AttributeDefinition>>,
     pub(crate) table_name: ::std::option::Option<::std::string::String>,
     pub(crate) billing_mode: ::std::option::Option<crate::types::BillingMode>,
     pub(crate) provisioned_throughput: ::std::option::Option<crate::types::ProvisionedThroughput>,
     pub(crate) global_secondary_index_updates: ::std::option::Option<::std::vec::Vec<crate::types::GlobalSecondaryIndexUpdate>>,
     pub(crate) stream_specification: ::std::option::Option<crate::types::StreamSpecification>,
     pub(crate) sse_specification: ::std::option::Option<crate::types::SseSpecification>,
     pub(crate) replica_updates: ::std::option::Option<::std::vec::Vec<crate::types::ReplicationGroupUpdate>>,
     pub(crate) table_class: ::std::option::Option<crate::types::TableClass>,
     pub(crate) deletion_protection_enabled: ::std::option::Option<bool>,
     pub(crate) multi_region_consistency: ::std::option::Option<crate::types::MultiRegionConsistency>,
     pub(crate) global_table_witness_updates: ::std::option::Option<::std::vec::Vec<crate::types::GlobalTableWitnessGroupUpdate>>,
     pub(crate) on_demand_throughput: ::std::option::Option<crate::types::OnDemandThroughput>,
     pub(crate) warm_throughput: ::std::option::Option<crate::types::WarmThroughput>,
-554
+}
 impl UpdateTableInputBuilder {
     /// Appends an item to `attribute_definitions`.
     ///
     /// To override the contents of this collection use [`set_attribute_definitions`](Self::set_attribute_definitions).

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/update_table/_update_table_output.rs

@@ -1,1 +97,141 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Represents the output of an <code>UpdateTable</code> operation.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UpdateTableOutput {
     /// <p>Represents the properties of the table.</p>
     pub table_description: ::std::option::Option<crate::types::TableDescription>,
     _request_id: Option<String>,
-10
+}
 impl UpdateTableOutput {
     /// <p>Represents the properties of the table.</p>
     pub fn table_description(&self) -> ::std::option::Option<&crate::types::TableDescription> {
         self.table_description.as_ref()
-15
+    }
-16
+}
 static UPDATETABLEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#UpdateTableOutput",

     "com.amazonaws.dynamodb.synthetic",
     "UpdateTableOutput",
 );
 static UPDATETABLEOUTPUT_MEMBER_TABLE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableOutput$TableDescription",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "table_description",
     "TableDescription",
 ,
 );
 static UPDATETABLEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static UPDATETABLEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATETABLEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UPDATETABLEOUTPUT_MEMBER_TABLE_DESCRIPTION],
     &[&UPDATETABLEOUTPUT_MEMBER_TABLE_DESCRIPTION, &UPDATETABLEOUTPUT_MEMBER__REQUEST_ID],
 );
 impl UpdateTableOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATETABLEOUTPUT_SCHEMA;
-47
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateTableOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.table_description {
             ser.write_struct(&UPDATETABLEOUTPUT_MEMBER_TABLE_DESCRIPTION, val)?;
-56
+        }
         Ok(())
-58
+    }
-59
+}
 impl UpdateTableOutput {
     /// 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(&UPDATETABLEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATETABLEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_description = Some(crate::types::TableDescription::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl UpdateTableOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UPDATETABLEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_description = Some(crate::types::TableDescription::deserialize(deser)?);
-115
+                }
                 _ => {}
-117
+            }
             Ok(())
         })?;
         Ok(builder.build())
-121
+    }

↧ Expand context

-122
+}
 impl ::aws_types::request_id::RequestId for UpdateTableOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-126
+    }
-127
+}
 impl UpdateTableOutput {
     /// Creates a new builder-style object to manufacture [`UpdateTableOutput`](crate::operation::update_table::UpdateTableOutput).
     pub fn builder() -> crate::operation::update_table::builders::UpdateTableOutputBuilder {
         crate::operation::update_table::builders::UpdateTableOutputBuilder::default()
-132
+    }
-133
+}
-134
 /// A builder for [`UpdateTableOutput`](crate::operation::update_table::UpdateTableOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UpdateTableOutputBuilder {
     pub(crate) table_description: ::std::option::Option<crate::types::TableDescription>,
     _request_id: Option<String>,
-141
+}

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/update_table_replica_auto_scaling.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `UpdateTableReplicaAutoScaling`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UpdateTableReplicaAutoScaling;
 impl UpdateTableReplicaAutoScaling {
     /// Creates a new `UpdateTableReplicaAutoScaling`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingInput,
     ) -> ::std::result::Result<
         crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -124,130 +253,374 @@

↥ Expand context

         });
-131
         ::std::option::Option::Some(cfg.freeze())
-133
+    }
-134
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("UpdateTableReplicaAutoScaling")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UpdateTableReplicaAutoScalingEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError,
             >::new());
-152
         ::std::borrow::Cow::Owned(rcb)
-154
+    }
-155
+}
-156
 #[derive(Debug)]
 struct UpdateTableReplicaAutoScalingResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateTableReplicaAutoScalingResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_update_table_replica_auto_scaling::de_update_table_replica_auto_scaling_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_update_table_replica_auto_scaling::de_update_table_replica_auto_scaling_http_response(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InternalServerError" => {
                     crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::InternalServerError({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InternalServerError::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InternalServerError::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "LimitExceededException" => {
                     crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::LimitExceededException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::LimitExceededException::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "ResourceInUseException" => {
                     crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::ResourceInUseException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::ResourceInUseException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::ResourceInUseException::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
         crate::protocol_serde::type_erase_result(parse_result)
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "ResourceNotFoundException" => {
                     crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::ResourceNotFoundException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 _ => crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, UpdateTableReplicaAutoScaling::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-323
+    }
-324
+}
 #[derive(Debug)]
 struct UpdateTableReplicaAutoScalingRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateTableReplicaAutoScalingRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UpdateTableReplicaAutoScaling",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_update_table_replica_auto_scaling::ser_update_table_replica_auto_scaling_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, UpdateTableReplicaAutoScaling::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-345
+    }
-346
+}
 #[derive(Debug)]
 struct UpdateTableReplicaAutoScalingEndpointParamsInterceptor;
-349
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTableReplicaAutoScalingEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateTableReplicaAutoScalingEndpointParamsInterceptor"
-353
+    }
-354

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UpdateTableReplicaAutoScalingInput>()
             .ok_or("failed to downcast to UpdateTableReplicaAutoScalingInput")?;
-369
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/update_table_replica_auto_scaling/_update_table_replica_auto_scaling_input.rs

@@ -20,20 +224,230 @@

↥ Expand context

         self.global_secondary_index_updates.as_deref().unwrap_or_default()
-21
+    }
     /// <p>The name of the global table to be updated. You can also provide the Amazon Resource Name (ARN) of the table in this parameter.</p>
     pub fn table_name(&self) -> ::std::option::Option<&str> {
         self.table_name.as_deref()
-25
+    }
     /// <p>Represents the auto scaling settings to be modified for a global table or global secondary index.</p>
     pub fn provisioned_write_capacity_auto_scaling_update(&self) -> ::std::option::Option<&crate::types::AutoScalingSettingsUpdate> {
         self.provisioned_write_capacity_auto_scaling_update.as_ref()
-29
+    }
     /// <p>Represents the auto scaling settings of replicas of the table that will be modified.</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 `.replica_updates.is_none()`.
     pub fn replica_updates(&self) -> &[crate::types::ReplicaAutoScalingUpdate] {
         self.replica_updates.as_deref().unwrap_or_default()
-35
+    }
-36
+}
 static UPDATETABLEREPLICAAUTOSCALINGINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#UpdateTableReplicaAutoScalingInput",
     "com.amazonaws.dynamodb.synthetic",

     "UpdateTableReplicaAutoScalingInput",
 );
 static UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_GLOBAL_SECONDARY_INDEX_UPDATES: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.dynamodb.synthetic#UpdateTableReplicaAutoScalingInput$GlobalSecondaryIndexUpdates",
             "com.amazonaws.dynamodb.synthetic",
             "UpdateTableReplicaAutoScalingInput",
         ),
         ::aws_smithy_schema::ShapeType::List,
         "global_secondary_index_updates",
         "GlobalSecondaryIndexUpdates",
 ,
     );
 static UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableReplicaAutoScalingInput$TableName",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableReplicaAutoScalingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_name",
     "TableName",
 ,
 );
 static UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_UPDATE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.dynamodb.synthetic#UpdateTableReplicaAutoScalingInput$ProvisionedWriteCapacityAutoScalingUpdate",
             "com.amazonaws.dynamodb.synthetic",
             "UpdateTableReplicaAutoScalingInput",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "provisioned_write_capacity_auto_scaling_update",
         "ProvisionedWriteCapacityAutoScalingUpdate",
 ,
     );
 static UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_REPLICA_UPDATES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTableReplicaAutoScalingInput$ReplicaUpdates",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTableReplicaAutoScalingInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "replica_updates",
     "ReplicaUpdates",
 ,
 );
 static UPDATETABLEREPLICAAUTOSCALINGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATETABLEREPLICAAUTOSCALINGINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_GLOBAL_SECONDARY_INDEX_UPDATES,
         &UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_TABLE_NAME,
         &UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_UPDATE,
         &UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_REPLICA_UPDATES,
     ],
 );
 impl UpdateTableReplicaAutoScalingInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATETABLEREPLICAAUTOSCALINGINPUT_SCHEMA;
-97
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateTableReplicaAutoScalingInput {
     #[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.global_secondary_index_updates {
             ser.write_list(
                 &UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_GLOBAL_SECONDARY_INDEX_UPDATES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::GlobalSecondaryIndexAutoScalingUpdate::SCHEMA, item)?;
-110
+                    }
                     Ok(())
                 },
             )?;
-114
+        }
         if let Some(ref val) = self.table_name {
             ser.write_string(&UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_TABLE_NAME, val)?;
-117
+        }
         if let Some(ref val) = self.provisioned_write_capacity_auto_scaling_update {
             ser.write_struct(
                 &UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_UPDATE,
                 val,
             )?;
-123
+        }
         if let Some(ref val) = self.replica_updates {
             ser.write_list(
                 &UPDATETABLEREPLICAAUTOSCALINGINPUT_MEMBER_REPLICA_UPDATES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ReplicaAutoScalingUpdate::SCHEMA, item)?;
-130
+                    }
                     Ok(())
                 },
             )?;
-134
+        }
         Ok(())
-136
+    }
-137
+}
 impl UpdateTableReplicaAutoScalingInput {
     /// 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(&UPDATETABLEREPLICAAUTOSCALINGINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATETABLEREPLICAAUTOSCALINGINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.global_secondary_index_updates = 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::GlobalSecondaryIndexAutoScalingUpdate::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GlobalSecondaryIndexAutoScalingUpdate::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-163
+                }
                 Some(1) => {
                     builder.table_name = Some(deser.read_string(member)?);
-166
+                }
                 Some(2) => {
                     builder.provisioned_write_capacity_auto_scaling_update = Some(crate::types::AutoScalingSettingsUpdate::deserialize(deser)?);
-169
+                }
                 Some(3) => {
                     builder.replica_updates = 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::ReplicaAutoScalingUpdate::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ReplicaAutoScalingUpdate::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-179
+                }
                 _ => {}
-181
+            }
             Ok(())
         })?;
         builder.table_name = builder.table_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-188
+    }
-189
+}
 impl UpdateTableReplicaAutoScalingInput {
     /// 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 UpdateTableReplicaAutoScalingInput {
     /// Creates a new builder-style object to manufacture [`UpdateTableReplicaAutoScalingInput`](crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingInput).
     pub fn builder() -> crate::operation::update_table_replica_auto_scaling::builders::UpdateTableReplicaAutoScalingInputBuilder {
         crate::operation::update_table_replica_auto_scaling::builders::UpdateTableReplicaAutoScalingInputBuilder::default()
-205
+    }
-206
+}
-207
 /// A builder for [`UpdateTableReplicaAutoScalingInput`](crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UpdateTableReplicaAutoScalingInputBuilder {
     pub(crate) global_secondary_index_updates: ::std::option::Option<::std::vec::Vec<crate::types::GlobalSecondaryIndexAutoScalingUpdate>>,
     pub(crate) table_name: ::std::option::Option<::std::string::String>,
     pub(crate) provisioned_write_capacity_auto_scaling_update: ::std::option::Option<crate::types::AutoScalingSettingsUpdate>,
     pub(crate) replica_updates: ::std::option::Option<::std::vec::Vec<crate::types::ReplicaAutoScalingUpdate>>,
-216
+}
 impl UpdateTableReplicaAutoScalingInputBuilder {
     /// Appends an item to `global_secondary_index_updates`.
     ///
     /// To override the contents of this collection use [`set_global_secondary_index_updates`](Self::set_global_secondary_index_updates).
     ///
     /// <p>Represents the auto scaling settings of the global secondary indexes of the replica to be updated.</p>
     pub fn global_secondary_index_updates(mut self, input: crate::types::GlobalSecondaryIndexAutoScalingUpdate) -> Self {
         let mut v = self.global_secondary_index_updates.unwrap_or_default();
         v.push(input);
         self.global_secondary_index_updates = ::std::option::Option::Some(v);
         self
-228
+    }
     /// <p>Represents the auto scaling settings of the global secondary indexes of the replica to be updated.</p>
     pub fn set_global_secondary_index_updates(

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/update_table_replica_auto_scaling/_update_table_replica_auto_scaling_output.rs

@@ -1,1 +97,144 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UpdateTableReplicaAutoScalingOutput {
     /// <p>Returns information about the auto scaling settings of a table with replicas.</p>
     pub table_auto_scaling_description: ::std::option::Option<crate::types::TableAutoScalingDescription>,
     _request_id: Option<String>,
-9
+}
 impl UpdateTableReplicaAutoScalingOutput {
     /// <p>Returns information about the auto scaling settings of a table with replicas.</p>
     pub fn table_auto_scaling_description(&self) -> ::std::option::Option<&crate::types::TableAutoScalingDescription> {
         self.table_auto_scaling_description.as_ref()
-14
+    }
-15
+}
 static UPDATETABLEREPLICAAUTOSCALINGOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#UpdateTableReplicaAutoScalingOutput",
     "com.amazonaws.dynamodb.synthetic",

     "UpdateTableReplicaAutoScalingOutput",
 );
 static UPDATETABLEREPLICAAUTOSCALINGOUTPUT_MEMBER_TABLE_AUTO_SCALING_DESCRIPTION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.dynamodb.synthetic#UpdateTableReplicaAutoScalingOutput$TableAutoScalingDescription",
             "com.amazonaws.dynamodb.synthetic",
             "UpdateTableReplicaAutoScalingOutput",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "table_auto_scaling_description",
         "TableAutoScalingDescription",
 ,
     );
 static UPDATETABLEREPLICAAUTOSCALINGOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static UPDATETABLEREPLICAAUTOSCALINGOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATETABLEREPLICAAUTOSCALINGOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UPDATETABLEREPLICAAUTOSCALINGOUTPUT_MEMBER_TABLE_AUTO_SCALING_DESCRIPTION],
     &[
         &UPDATETABLEREPLICAAUTOSCALINGOUTPUT_MEMBER_TABLE_AUTO_SCALING_DESCRIPTION,
         &UPDATETABLEREPLICAAUTOSCALINGOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl UpdateTableReplicaAutoScalingOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATETABLEREPLICAAUTOSCALINGOUTPUT_SCHEMA;
-50
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateTableReplicaAutoScalingOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.table_auto_scaling_description {
             ser.write_struct(&UPDATETABLEREPLICAAUTOSCALINGOUTPUT_MEMBER_TABLE_AUTO_SCALING_DESCRIPTION, val)?;
-59
+        }
         Ok(())
-61
+    }
-62
+}
 impl UpdateTableReplicaAutoScalingOutput {
     /// 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(&UPDATETABLEREPLICAAUTOSCALINGOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATETABLEREPLICAAUTOSCALINGOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_auto_scaling_description = Some(crate::types::TableAutoScalingDescription::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl UpdateTableReplicaAutoScalingOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UPDATETABLEREPLICAAUTOSCALINGOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_auto_scaling_description = Some(crate::types::TableAutoScalingDescription::deserialize(deser)?);
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         Ok(builder.build())
-124
+    }

↧ Expand context

-125
+}
 impl ::aws_types::request_id::RequestId for UpdateTableReplicaAutoScalingOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-129
+    }
-130
+}
 impl UpdateTableReplicaAutoScalingOutput {
     /// Creates a new builder-style object to manufacture [`UpdateTableReplicaAutoScalingOutput`](crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingOutput).
     pub fn builder() -> crate::operation::update_table_replica_auto_scaling::builders::UpdateTableReplicaAutoScalingOutputBuilder {
         crate::operation::update_table_replica_auto_scaling::builders::UpdateTableReplicaAutoScalingOutputBuilder::default()
-135
+    }
-136
+}
-137
 /// A builder for [`UpdateTableReplicaAutoScalingOutput`](crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UpdateTableReplicaAutoScalingOutputBuilder {
     pub(crate) table_auto_scaling_description: ::std::option::Option<crate::types::TableAutoScalingDescription>,
     _request_id: Option<String>,
-144
+}

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/update_time_to_live.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `UpdateTimeToLive`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UpdateTimeToLive;
 impl UpdateTimeToLive {
     /// Creates a new `UpdateTimeToLive`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::update_time_to_live::UpdateTimeToLiveInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::update_time_to_live::UpdateTimeToLiveOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::update_time_to_live::UpdateTimeToLiveInput,
     ) -> ::std::result::Result<
         crate::operation::update_time_to_live::UpdateTimeToLiveOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::update_time_to_live::UpdateTimeToLiveError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::update_time_to_live::UpdateTimeToLiveError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::update_time_to_live::UpdateTimeToLiveOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -118,122 +245,382 @@

↥ Expand context

         });
-123
         ::std::option::Option::Some(cfg.freeze())
-125
+    }
-126
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("UpdateTimeToLive")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UpdateTimeToLiveEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::update_time_to_live::UpdateTimeToLiveError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::update_time_to_live::UpdateTimeToLiveError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::update_time_to_live::UpdateTimeToLiveError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct UpdateTimeToLiveResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateTimeToLiveResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_update_time_to_live::de_update_time_to_live_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_update_time_to_live::de_update_time_to_live_http_response(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::update_time_to_live::UpdateTimeToLiveError::unhandled(
                             generic,
                         )),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InternalServerError" => crate::operation::update_time_to_live::UpdateTimeToLiveError::InternalServerError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidEndpointException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::InvalidEndpointException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidEndpointException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidEndpointException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "LimitExceededException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::LimitExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::LimitExceededException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceInUseException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::ResourceInUseException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceInUseException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceInUseException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::update_time_to_live::UpdateTimeToLiveError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, UpdateTimeToLive::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::update_time_to_live::UpdateTimeToLiveOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-331
+    }
-332
+}
 #[derive(Debug)]
 struct UpdateTimeToLiveRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateTimeToLiveRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::update_time_to_live::UpdateTimeToLiveInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::update_time_to_live::UpdateTimeToLiveInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_time_to_live::UpdateTimeToLiveInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.UpdateTimeToLive",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_time_to_live::ser_update_time_to_live_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, UpdateTimeToLive::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-353
+    }
-354
+}
 #[derive(Debug)]
 struct UpdateTimeToLiveEndpointParamsInterceptor;
-357
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTimeToLiveEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateTimeToLiveEndpointParamsInterceptor"
-361
+    }
-362

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UpdateTimeToLiveInput>()
             .ok_or("failed to downcast to UpdateTimeToLiveInput")?;
-377
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/update_time_to_live/_update_time_to_live_input.rs

@@ -4,4 +134,146 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UpdateTimeToLiveInput {
     /// <p>The name of the table to be configured. You can also provide the Amazon Resource Name (ARN) of the table in this parameter.</p>
     pub table_name: ::std::option::Option<::std::string::String>,
     /// <p>Represents the settings used to enable or disable Time to Live for the specified table.</p>
     pub time_to_live_specification: ::std::option::Option<crate::types::TimeToLiveSpecification>,
-11
+}
 impl UpdateTimeToLiveInput {
     /// <p>The name of the table to be configured. You can also provide the Amazon Resource Name (ARN) of the table in this parameter.</p>
     pub fn table_name(&self) -> ::std::option::Option<&str> {
         self.table_name.as_deref()
-16
+    }
     /// <p>Represents the settings used to enable or disable Time to Live for the specified table.</p>
     pub fn time_to_live_specification(&self) -> ::std::option::Option<&crate::types::TimeToLiveSpecification> {
         self.time_to_live_specification.as_ref()
-20
+    }
-21
+}
 static UPDATETIMETOLIVEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#UpdateTimeToLiveInput",

     "com.amazonaws.dynamodb.synthetic",
     "UpdateTimeToLiveInput",
 );
 static UPDATETIMETOLIVEINPUT_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTimeToLiveInput$TableName",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTimeToLiveInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_name",
     "TableName",
 ,
 );
 static UPDATETIMETOLIVEINPUT_MEMBER_TIME_TO_LIVE_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTimeToLiveInput$TimeToLiveSpecification",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTimeToLiveInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "time_to_live_specification",
     "TimeToLiveSpecification",
 ,
 );
 static UPDATETIMETOLIVEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATETIMETOLIVEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPDATETIMETOLIVEINPUT_MEMBER_TABLE_NAME,
         &UPDATETIMETOLIVEINPUT_MEMBER_TIME_TO_LIVE_SPECIFICATION,
     ],
 );
 impl UpdateTimeToLiveInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATETIMETOLIVEINPUT_SCHEMA;
-58
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateTimeToLiveInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.table_name {
             ser.write_string(&UPDATETIMETOLIVEINPUT_MEMBER_TABLE_NAME, val)?;
-67
+        }
         if let Some(ref val) = self.time_to_live_specification {
             ser.write_struct(&UPDATETIMETOLIVEINPUT_MEMBER_TIME_TO_LIVE_SPECIFICATION, val)?;
-70
+        }
         Ok(())
-72
+    }
-73
+}
 impl UpdateTimeToLiveInput {
     /// 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(&UPDATETIMETOLIVEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATETIMETOLIVEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_name = Some(deser.read_string(member)?);
-92
+                }
                 Some(1) => {
                     builder.time_to_live_specification = Some(crate::types::TimeToLiveSpecification::deserialize(deser)?);
-95
+                }
                 _ => {}
-97
+            }
             Ok(())
         })?;
         builder.table_name = builder.table_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-104
+    }
-105
+}
 impl UpdateTimeToLiveInput {
     /// 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 UpdateTimeToLiveInput {
     /// Creates a new builder-style object to manufacture [`UpdateTimeToLiveInput`](crate::operation::update_time_to_live::UpdateTimeToLiveInput).
     pub fn builder() -> crate::operation::update_time_to_live::builders::UpdateTimeToLiveInputBuilder {
         crate::operation::update_time_to_live::builders::UpdateTimeToLiveInputBuilder::default()
-121
+    }
-122
+}
-123
 /// A builder for [`UpdateTimeToLiveInput`](crate::operation::update_time_to_live::UpdateTimeToLiveInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UpdateTimeToLiveInputBuilder {
     pub(crate) table_name: ::std::option::Option<::std::string::String>,
     pub(crate) time_to_live_specification: ::std::option::Option<crate::types::TimeToLiveSpecification>,
-130
+}
 impl UpdateTimeToLiveInputBuilder {
     /// <p>The name of the table to be configured. You can also provide the Amazon Resource Name (ARN) of the table in this parameter.</p>
     /// This field is required.
     pub fn table_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.table_name = ::std::option::Option::Some(input.into());
         self
-137
+    }
     /// <p>The name of the table to be configured. You can also provide the Amazon Resource Name (ARN) of the table in this parameter.</p>
     pub fn set_table_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.table_name = input;
         self
-142
+    }
     /// <p>The name of the table to be configured. You can also provide the Amazon Resource Name (ARN) of the table in this parameter.</p>
     pub fn get_table_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.table_name
-146
+    }

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/update_time_to_live/_update_time_to_live_output.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UpdateTimeToLiveOutput {
     /// <p>Represents the output of an <code>UpdateTimeToLive</code> operation.</p>
     pub time_to_live_specification: ::std::option::Option<crate::types::TimeToLiveSpecification>,
     _request_id: Option<String>,
-9
+}
 impl UpdateTimeToLiveOutput {
     /// <p>Represents the output of an <code>UpdateTimeToLive</code> operation.</p>
     pub fn time_to_live_specification(&self) -> ::std::option::Option<&crate::types::TimeToLiveSpecification> {
         self.time_to_live_specification.as_ref()
-14
+    }
-15
+}
 static UPDATETIMETOLIVEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#UpdateTimeToLiveOutput",

     "com.amazonaws.dynamodb.synthetic",
     "UpdateTimeToLiveOutput",
 );
 static UPDATETIMETOLIVEOUTPUT_MEMBER_TIME_TO_LIVE_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#UpdateTimeToLiveOutput$TimeToLiveSpecification",
         "com.amazonaws.dynamodb.synthetic",
         "UpdateTimeToLiveOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "time_to_live_specification",
     "TimeToLiveSpecification",
 ,
 );
 static UPDATETIMETOLIVEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static UPDATETIMETOLIVEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATETIMETOLIVEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UPDATETIMETOLIVEOUTPUT_MEMBER_TIME_TO_LIVE_SPECIFICATION],
     &[
         &UPDATETIMETOLIVEOUTPUT_MEMBER_TIME_TO_LIVE_SPECIFICATION,
         &UPDATETIMETOLIVEOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl UpdateTimeToLiveOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATETIMETOLIVEOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateTimeToLiveOutput {
     #[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.time_to_live_specification {
             ser.write_struct(&UPDATETIMETOLIVEOUTPUT_MEMBER_TIME_TO_LIVE_SPECIFICATION, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl UpdateTimeToLiveOutput {
     /// 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(&UPDATETIMETOLIVEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATETIMETOLIVEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.time_to_live_specification = Some(crate::types::TimeToLiveSpecification::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl UpdateTimeToLiveOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UPDATETIMETOLIVEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.time_to_live_specification = Some(crate::types::TimeToLiveSpecification::deserialize(deser)?);
-117
+                }
                 _ => {}
-119
+            }
             Ok(())
         })?;
         Ok(builder.build())
-123
+    }

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde.rs

@@ -1,1 +662,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn type_erase_result<O, E>(
     result: ::std::result::Result<O, E>,
 ) -> ::std::result::Result<
     ::aws_smithy_runtime_api::client::interceptors::context::Output,
     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError<::aws_smithy_runtime_api::client::interceptors::context::Error>,
--
+>
 where
     O: ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
     E: ::std::error::Error + std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
--
+{
     result
         .map(|output| ::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         .map_err(|error| ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(error))
         .map_err(::std::convert::Into::into)
--
+}
--
 pub fn parse_http_error_metadata(
     _response_status: u16,
     response_headers: &::aws_smithy_runtime_api::http::Headers,
     response_body: &[u8],
 ) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     crate::json_errors::parse_error_metadata(response_body, response_headers)
-8
+}
--
 pub(crate) mod shape_batch_execute_statement;
--
 pub(crate) mod shape_batch_get_item;
--
 pub(crate) mod shape_batch_write_item;
--
 pub(crate) mod shape_create_backup;
--
 pub(crate) mod shape_create_global_table;
--
 pub(crate) mod shape_create_table;
--
 pub(crate) mod shape_delete_backup;
--
 pub(crate) mod shape_delete_item;
--
 pub(crate) mod shape_delete_resource_policy;
--
 pub(crate) mod shape_delete_table;
--
 pub(crate) mod shape_describe_backup;
--
 pub(crate) mod shape_describe_continuous_backups;
--
 pub(crate) mod shape_describe_contributor_insights;
--
 pub(crate) mod shape_describe_endpoints;
--
 pub(crate) mod shape_describe_export;
--
 pub(crate) mod shape_describe_global_table;
--
 pub(crate) mod shape_describe_global_table_settings;
--
 pub(crate) mod shape_describe_import;
--
 pub(crate) mod shape_describe_kinesis_streaming_destination;
--
 pub(crate) mod shape_describe_limits;
--
 pub(crate) mod shape_describe_table;
--
 pub(crate) mod shape_describe_table_replica_auto_scaling;
--
 pub(crate) mod shape_describe_time_to_live;
--
 pub(crate) mod shape_disable_kinesis_streaming_destination;
--
 pub(crate) mod shape_enable_kinesis_streaming_destination;
--
 pub(crate) mod shape_execute_statement;
--
 pub(crate) mod shape_execute_transaction;
--
 pub(crate) mod shape_export_table_to_point_in_time;
--
 pub(crate) mod shape_get_item;
--
 pub(crate) mod shape_get_resource_policy;
--
 pub(crate) mod shape_import_table;
--
 pub(crate) mod shape_list_backups;
--
 pub(crate) mod shape_list_contributor_insights;
--
 pub(crate) mod shape_list_exports;
--
 pub(crate) mod shape_list_global_tables;
--
 pub(crate) mod shape_list_imports;
--
 pub(crate) mod shape_list_tables;
--
 pub(crate) mod shape_list_tags_of_resource;
--
 pub(crate) mod shape_put_item;
--
 pub(crate) mod shape_put_resource_policy;
--
 pub(crate) mod shape_query;
--
 pub(crate) mod shape_restore_table_from_backup;
--
 pub(crate) mod shape_restore_table_to_point_in_time;
--
 pub(crate) mod shape_scan;
--
 pub(crate) mod shape_tag_resource;
--
 pub(crate) mod shape_transact_get_items;
--
 pub(crate) mod shape_transact_write_items;
--
 pub(crate) mod shape_untag_resource;
--
 pub(crate) mod shape_update_continuous_backups;
--
 pub(crate) mod shape_update_contributor_insights;
--
 pub(crate) mod shape_update_global_table;
--
 pub(crate) mod shape_update_global_table_settings;
--
 pub(crate) mod shape_update_item;
--
 pub(crate) mod shape_update_kinesis_streaming_destination;
--
 pub(crate) mod shape_update_table;
--
 pub(crate) mod shape_update_table_replica_auto_scaling;
--
 pub(crate) mod shape_update_time_to_live;
--
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
--
+    }
--
+}
--
 pub(crate) mod shape_backup_in_use_exception;
--
 pub(crate) mod shape_backup_not_found_exception;
--
 pub(crate) mod shape_batch_execute_statement_input;
--
 pub(crate) mod shape_batch_get_item_input;
--
 pub(crate) mod shape_batch_write_item_input;
--
 pub(crate) mod shape_conditional_check_failed_exception;
--
 pub(crate) mod shape_continuous_backups_unavailable_exception;
--
 pub(crate) mod shape_create_backup_input;
--
 pub(crate) mod shape_create_global_table_input;
--
 pub(crate) mod shape_create_table_input;
--
 pub(crate) mod shape_delete_backup_input;
--
 pub(crate) mod shape_delete_item_input;
--
 pub(crate) mod shape_delete_resource_policy_input;
--
 pub(crate) mod shape_delete_table_input;
--
 pub(crate) mod shape_describe_backup_input;
--
 pub(crate) mod shape_describe_continuous_backups_input;
--
 pub(crate) mod shape_describe_contributor_insights_input;
--
 pub(crate) mod shape_describe_export_input;
--
 pub(crate) mod shape_describe_global_table_input;
--
 pub(crate) mod shape_describe_global_table_settings_input;
--
 pub(crate) mod shape_describe_import_input;
--
 pub(crate) mod shape_describe_kinesis_streaming_destination_input;
--
 pub(crate) mod shape_describe_table_input;
--
 pub(crate) mod shape_describe_table_replica_auto_scaling_input;
--
 pub(crate) mod shape_describe_time_to_live_input;
--
 pub(crate) mod shape_disable_kinesis_streaming_destination_input;
--
 pub(crate) mod shape_duplicate_item_exception;
--
 pub(crate) mod shape_enable_kinesis_streaming_destination_input;
--
 pub(crate) mod shape_execute_statement_input;
--
 pub(crate) mod shape_execute_transaction_input;
--
 pub(crate) mod shape_export_conflict_exception;
--
 pub(crate) mod shape_export_not_found_exception;
--
 pub(crate) mod shape_export_table_to_point_in_time_input;
--
 pub(crate) mod shape_get_item_input;
--
 pub(crate) mod shape_get_resource_policy_input;
--
 pub(crate) mod shape_global_table_already_exists_exception;
--
 pub(crate) mod shape_global_table_not_found_exception;
--
 pub(crate) mod shape_idempotent_parameter_mismatch_exception;
--
 pub(crate) mod shape_import_conflict_exception;
--
 pub(crate) mod shape_import_not_found_exception;
--
 pub(crate) mod shape_import_table_input;
--
 pub(crate) mod shape_index_not_found_exception;
--
 pub(crate) mod shape_internal_server_error;
--
 pub(crate) mod shape_invalid_endpoint_exception;
--
 pub(crate) mod shape_invalid_export_time_exception;
--
 pub(crate) mod shape_invalid_restore_time_exception;
--
 pub(crate) mod shape_item_collection_size_limit_exceeded_exception;
--
 pub(crate) mod shape_limit_exceeded_exception;
--
 pub(crate) mod shape_list_backups_input;
--
 pub(crate) mod shape_list_contributor_insights_input;
--
 pub(crate) mod shape_list_exports_input;
--
 pub(crate) mod shape_list_global_tables_input;
--
 pub(crate) mod shape_list_imports_input;
--
 pub(crate) mod shape_list_tables_input;
--
 pub(crate) mod shape_list_tags_of_resource_input;
--
 pub(crate) mod shape_point_in_time_recovery_unavailable_exception;
--
 pub(crate) mod shape_policy_not_found_exception;
--
 pub(crate) mod shape_provisioned_throughput_exceeded_exception;
--
 pub(crate) mod shape_put_item_input;
--
 pub(crate) mod shape_put_resource_policy_input;
--
 pub(crate) mod shape_query_input;
--
 pub(crate) mod shape_replica_already_exists_exception;
--
 pub(crate) mod shape_replica_not_found_exception;
--
 pub(crate) mod shape_replicated_write_conflict_exception;
--
 pub(crate) mod shape_request_limit_exceeded;
--
 pub(crate) mod shape_resource_in_use_exception;
--
 pub(crate) mod shape_resource_not_found_exception;
--
 pub(crate) mod shape_restore_table_from_backup_input;
--
 pub(crate) mod shape_restore_table_to_point_in_time_input;
--
 pub(crate) mod shape_scan_input;
--
 pub(crate) mod shape_table_already_exists_exception;
--
 pub(crate) mod shape_table_in_use_exception;
--
 pub(crate) mod shape_table_not_found_exception;
--
 pub(crate) mod shape_tag_resource_input;
--
 pub(crate) mod shape_throttling_exception;
--
 pub(crate) mod shape_transact_get_items_input;
--
 pub(crate) mod shape_transact_write_items_input;
--
 pub(crate) mod shape_transaction_canceled_exception;
--
 pub(crate) mod shape_transaction_conflict_exception;
--
 pub(crate) mod shape_transaction_in_progress_exception;
--
 pub(crate) mod shape_untag_resource_input;
--
 pub(crate) mod shape_update_continuous_backups_input;
--
 pub(crate) mod shape_update_contributor_insights_input;
--
 pub(crate) mod shape_update_global_table_input;
--
 pub(crate) mod shape_update_global_table_settings_input;
--
 pub(crate) mod shape_update_item_input;
--
 pub(crate) mod shape_update_kinesis_streaming_destination_input;
--
 pub(crate) mod shape_update_table_input;
--
 pub(crate) mod shape_update_table_replica_auto_scaling_input;
--
 pub(crate) mod shape_update_time_to_live_input;
--
 pub(crate) mod shape_attribute_definition;
--
 pub(crate) mod shape_attribute_map;
--
 pub(crate) mod shape_attribute_value;
--
 pub(crate) mod shape_attribute_value_update;
--
 pub(crate) mod shape_auto_scaling_settings_update;
--
 pub(crate) mod shape_backup_description;
--
 pub(crate) mod shape_backup_details;
--
 pub(crate) mod shape_backup_summaries;
--
 pub(crate) mod shape_batch_get_request_map;
--
 pub(crate) mod shape_batch_get_response_map;
--
 pub(crate) mod shape_batch_statement_request;
--
 pub(crate) mod shape_batch_write_item_request_map;
--
 pub(crate) mod shape_cancellation_reason_list;
--
 pub(crate) mod shape_condition;
--
 pub(crate) mod shape_consumed_capacity;
--
 pub(crate) mod shape_consumed_capacity_multiple;
--
 pub(crate) mod shape_continuous_backups_description;
--
 pub(crate) mod shape_contributor_insights_rule_list;
--
 pub(crate) mod shape_contributor_insights_summaries;
--
 pub(crate) mod shape_enable_kinesis_streaming_configuration;
--
 pub(crate) mod shape_endpoints;
--
 pub(crate) mod shape_expected_attribute_value;
--
 pub(crate) mod shape_export_description;
--
 pub(crate) mod shape_export_summaries;
--
 pub(crate) mod shape_failure_exception;
--
 pub(crate) mod shape_global_secondary_index;
--
 pub(crate) mod shape_global_secondary_index_auto_scaling_update;
--
 pub(crate) mod shape_global_secondary_index_update;
--
 pub(crate) mod shape_global_table_description;
--
 pub(crate) mod shape_global_table_global_secondary_index_settings_update;
--
 pub(crate) mod shape_global_table_list;
--
 pub(crate) mod shape_global_table_witness_group_update;
--
 pub(crate) mod shape_import_summary_list;
--
 pub(crate) mod shape_import_table_description;
--
 pub(crate) mod shape_incremental_export_specification;
--
 pub(crate) mod shape_input_format_options;
--
 pub(crate) mod shape_item_collection_metrics;
--
 pub(crate) mod shape_item_collection_metrics_per_table;
--
 pub(crate) mod shape_item_list;
--
 pub(crate) mod shape_item_response_list;
--
 pub(crate) mod shape_key;
--
 pub(crate) mod shape_key_schema_element;
--
 pub(crate) mod shape_keys_and_attributes;
--
 pub(crate) mod shape_kinesis_data_stream_destinations;
--
 pub(crate) mod shape_local_secondary_index;
--
 pub(crate) mod shape_on_demand_throughput;
--
 pub(crate) mod shape_parameterized_statement;
--
 pub(crate) mod shape_parti_ql_batch_response;
--
 pub(crate) mod shape_point_in_time_recovery_specification;
--
 pub(crate) mod shape_provisioned_throughput;
--
 pub(crate) mod shape_replica;
--
 pub(crate) mod shape_replica_auto_scaling_update;
--
 pub(crate) mod shape_replica_settings_description_list;
--
 pub(crate) mod shape_replica_settings_update;
--
 pub(crate) mod shape_replica_update;
--
 pub(crate) mod shape_replication_group_update;
--
 pub(crate) mod shape_s3_bucket_source;
--
 pub(crate) mod shape_sse_specification;
--
 pub(crate) mod shape_stream_specification;
--
 pub(crate) mod shape_table_auto_scaling_description;
--
 pub(crate) mod shape_table_creation_parameters;
--
 pub(crate) mod shape_table_description;
--
 pub(crate) mod shape_table_name_list;
--
 pub(crate) mod shape_tag;
--
 pub(crate) mod shape_tag_list;
--
 pub(crate) mod shape_throttling_reason_list;
--
 pub(crate) mod shape_time_to_live_description;
--
 pub(crate) mod shape_time_to_live_specification;
--
 pub(crate) mod shape_transact_get_item;
--
 pub(crate) mod shape_transact_write_item;
--
 pub(crate) mod shape_update_kinesis_streaming_configuration;
--
 pub(crate) mod shape_warm_throughput;
--
 pub(crate) mod shape_write_request;
--
 pub(crate) mod shape_archival_summary;
--
 pub(crate) mod shape_attribute_definitions;
--
 pub(crate) mod shape_auto_scaling_policy_update;
--
 pub(crate) mod shape_backup_summary;
--
 pub(crate) mod shape_batch_statement_response;
--
 pub(crate) mod shape_billing_mode_summary;
--
 pub(crate) mod shape_cancellation_reason;
--
 pub(crate) mod shape_capacity;
--
 pub(crate) mod shape_condition_check;
--
 pub(crate) mod shape_contributor_insights_summary;
--
 pub(crate) mod shape_create_global_secondary_index_action;
--
 pub(crate) mod shape_create_global_table_witness_group_member_action;
--
 pub(crate) mod shape_create_replica_action;
--
 pub(crate) mod shape_create_replication_group_member_action;
--
 pub(crate) mod shape_csv_options;
--
 pub(crate) mod shape_delete;
--
 pub(crate) mod shape_delete_global_secondary_index_action;
--
 pub(crate) mod shape_delete_global_table_witness_group_member_action;
--
 pub(crate) mod shape_delete_replica_action;
--
 pub(crate) mod shape_delete_replication_group_member_action;
--
 pub(crate) mod shape_delete_request;
--
 pub(crate) mod shape_endpoint;
--
 pub(crate) mod shape_export_summary;
--
 pub(crate) mod shape_get;
--
 pub(crate) mod shape_global_secondary_index_description_list;
--
 pub(crate) mod shape_global_table;
--
 pub(crate) mod shape_global_table_witness_description_list;
--
 pub(crate) mod shape_import_summary;
--
 pub(crate) mod shape_item_collection_key_attribute_map;
--
 pub(crate) mod shape_item_collection_metrics_multiple;
--
 pub(crate) mod shape_item_collection_size_estimate_range;
--
 pub(crate) mod shape_item_response;
--
 pub(crate) mod shape_key_schema;
--
 pub(crate) mod shape_kinesis_data_stream_destination;
--
 pub(crate) mod shape_local_secondary_index_description_list;
--
 pub(crate) mod shape_point_in_time_recovery_description;
--
 pub(crate) mod shape_projection;
--
 pub(crate) mod shape_provisioned_throughput_description;
--
 pub(crate) mod shape_put;
--
 pub(crate) mod shape_put_request;
--
 pub(crate) mod shape_replica_auto_scaling_description_list;
--
 pub(crate) mod shape_replica_description_list;
--
 pub(crate) mod shape_replica_global_secondary_index_auto_scaling_update;
--
 pub(crate) mod shape_replica_global_secondary_index_settings_update;
--
 pub(crate) mod shape_replica_settings_description;
--
 pub(crate) mod shape_restore_summary;
--
 pub(crate) mod shape_secondary_indexes_capacity_map;
--
 pub(crate) mod shape_source_table_details;
--
 pub(crate) mod shape_source_table_feature_details;
--
 pub(crate) mod shape_sse_description;
--
 pub(crate) mod shape_table_class_summary;
--
 pub(crate) mod shape_table_warm_throughput_description;
--
 pub(crate) mod shape_throttling_reason;
--
 pub(crate) mod shape_update;
--
 pub(crate) mod shape_update_global_secondary_index_action;
--
 pub(crate) mod shape_update_replication_group_member_action;
--
 pub(crate) mod shape_write_requests;
--
 pub(crate) mod shape_attribute_name_list;
--
 pub(crate) mod shape_auto_scaling_settings_description;
--
 pub(crate) mod shape_auto_scaling_target_tracking_scaling_policy_configuration_update;
--
 pub(crate) mod shape_batch_statement_error;
--
 pub(crate) mod shape_binary_set_attribute_value;
--
 pub(crate) mod shape_expression_attribute_name_map;
--
 pub(crate) mod shape_global_secondary_index_description;
--
 pub(crate) mod shape_global_secondary_index_list;
--
 pub(crate) mod shape_global_secondary_indexes;
--
 pub(crate) mod shape_global_table_witness_description;
--
 pub(crate) mod shape_key_list;
--
 pub(crate) mod shape_list_attribute_value;
--
 pub(crate) mod shape_local_secondary_index_description;
--
 pub(crate) mod shape_local_secondary_indexes;
--
 pub(crate) mod shape_map_attribute_value;
--
 pub(crate) mod shape_number_set_attribute_value;
--
 pub(crate) mod shape_on_demand_throughput_override;
--
 pub(crate) mod shape_provisioned_throughput_override;
--
 pub(crate) mod shape_replica_auto_scaling_description;
--
 pub(crate) mod shape_replica_description;
--
 pub(crate) mod shape_replica_global_secondary_index;
--
 pub(crate) mod shape_replica_global_secondary_index_settings_description_list;
--
 pub(crate) mod shape_replica_list;
--
 pub(crate) mod shape_string_set_attribute_value;
--
 pub(crate) mod shape_auto_scaling_policy_description_list;
--
 pub(crate) mod shape_csv_header_list;
--
 pub(crate) mod shape_global_secondary_index_info;
--
 pub(crate) mod shape_global_secondary_index_warm_throughput_description;
--
 pub(crate) mod shape_local_secondary_index_info;
--
 pub(crate) mod shape_replica_global_secondary_index_auto_scaling_description_list;
--
 pub(crate) mod shape_replica_global_secondary_index_description_list;
--
 pub(crate) mod shape_replica_global_secondary_index_settings_description;
--
 pub(crate) mod shape_auto_scaling_policy_description;
--
 pub(crate) mod shape_non_key_attribute_name_list;
--
 pub(crate) mod shape_put_item_input_attribute_map;
--
 pub(crate) mod shape_replica_global_secondary_index_auto_scaling_description;
--
 pub(crate) mod shape_replica_global_secondary_index_description;
--
 pub(crate) mod shape_auto_scaling_target_tracking_scaling_policy_configuration_description;

AWS SDK

Files changed: