AWS SDK

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

@@ -304,304 +524,524 @@

     /// <p>For more information on expression attribute names, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     pub fn expression_attribute_names(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.expression_attribute_names.as_ref()
-307
+    }
     /// <p>One or more values that can be substituted in an expression.</p>
     /// <p>Use the <b>:</b> (colon) character in an expression to dereference an attribute value. For example, suppose that you wanted to check whether the value of the <i>ProductStatus</i> attribute was one of the following:</p>
     /// <p><code>Available | Backordered | Discontinued</code></p>
     /// <p>You would first need to specify <code>ExpressionAttributeValues</code> as follows:</p>
     /// <p><code>{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }</code></p>
     /// <p>You could then use these values in an expression, such as this:</p>
     /// <p><code>ProductStatus IN (:avail, :back, :disc)</code></p>
     /// <p>For more information on expression attribute values, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html">Specifying Conditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     pub fn expression_attribute_values(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {
         self.expression_attribute_values.as_ref()
-320
+    }
-321
+}
 static QUERYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#QueryInput",

     "com.amazonaws.dynamodb.synthetic",
     "QueryInput",
 );
 static QUERYINPUT_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$TableName",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_name",
     "TableName",
 ,
 );
 static QUERYINPUT_MEMBER_INDEX_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$IndexName",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "index_name",
     "IndexName",
 ,
 );
 static QUERYINPUT_MEMBER_SELECT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$Select",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "select",
     "Select",
 ,
 );
 static QUERYINPUT_MEMBER_ATTRIBUTES_TO_GET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$AttributesToGet",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "attributes_to_get",
     "AttributesToGet",
 ,
 );
 static QUERYINPUT_MEMBER_LIMIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$Limit",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "limit",
     "Limit",
 ,
 );
 static QUERYINPUT_MEMBER_CONSISTENT_READ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$ConsistentRead",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "consistent_read",
     "ConsistentRead",
 ,
 );
 static QUERYINPUT_MEMBER_KEY_CONDITIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$KeyConditions",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "key_conditions",
     "KeyConditions",
 ,
 );
 static QUERYINPUT_MEMBER_QUERY_FILTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$QueryFilter",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "query_filter",
     "QueryFilter",
 ,
 );
 static QUERYINPUT_MEMBER_CONDITIONAL_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$ConditionalOperator",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "conditional_operator",
     "ConditionalOperator",
 ,
 );
 static QUERYINPUT_MEMBER_SCAN_INDEX_FORWARD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$ScanIndexForward",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "scan_index_forward",
     "ScanIndexForward",
 ,
 );
 static QUERYINPUT_MEMBER_EXCLUSIVE_START_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$ExclusiveStartKey",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "exclusive_start_key",
     "ExclusiveStartKey",
 ,
 );
 static QUERYINPUT_MEMBER_RETURN_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$ReturnConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_consumed_capacity",
     "ReturnConsumedCapacity",
 ,
 );
 static QUERYINPUT_MEMBER_PROJECTION_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$ProjectionExpression",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "projection_expression",
     "ProjectionExpression",
 ,
 );
 static QUERYINPUT_MEMBER_FILTER_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$FilterExpression",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "filter_expression",
     "FilterExpression",
 ,
 );
 static QUERYINPUT_MEMBER_KEY_CONDITION_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$KeyConditionExpression",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key_condition_expression",
     "KeyConditionExpression",
 ,
 );
 static QUERYINPUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$ExpressionAttributeNames",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expression_attribute_names",
     "ExpressionAttributeNames",
 ,
 );
 static QUERYINPUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryInput$ExpressionAttributeValues",
         "com.amazonaws.dynamodb.synthetic",
         "QueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expression_attribute_values",
     "ExpressionAttributeValues",
 ,
 );
 static QUERYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     QUERYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &QUERYINPUT_MEMBER_TABLE_NAME,
         &QUERYINPUT_MEMBER_INDEX_NAME,
         &QUERYINPUT_MEMBER_SELECT,
         &QUERYINPUT_MEMBER_ATTRIBUTES_TO_GET,

↧ Expand context

         &QUERYINPUT_MEMBER_LIMIT,
         &QUERYINPUT_MEMBER_CONSISTENT_READ,
         &QUERYINPUT_MEMBER_KEY_CONDITIONS,
         &QUERYINPUT_MEMBER_QUERY_FILTER,
         &QUERYINPUT_MEMBER_CONDITIONAL_OPERATOR,
         &QUERYINPUT_MEMBER_SCAN_INDEX_FORWARD,
         &QUERYINPUT_MEMBER_EXCLUSIVE_START_KEY,
         &QUERYINPUT_MEMBER_RETURN_CONSUMED_CAPACITY,
         &QUERYINPUT_MEMBER_PROJECTION_EXPRESSION,
         &QUERYINPUT_MEMBER_FILTER_EXPRESSION,
         &QUERYINPUT_MEMBER_KEY_CONDITION_EXPRESSION,
         &QUERYINPUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
         &QUERYINPUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES,
     ],
 );
 impl QueryInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYINPUT_SCHEMA;
-523
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for QueryInput {

@@ -562,562 +802,782 @@

↥ Expand context

                         ser.write_struct(crate::types::Condition::SCHEMA, value)?;
-563
+                    }
                     Ok(())
                 },
             )?;
-567
+        }
         if let Some(ref val) = self.query_filter {
             ser.write_map(
                 &QUERYINPUT_MEMBER_QUERY_FILTER,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::Condition::SCHEMA, value)?;
-575
+                    }
                     Ok(())
                 },
             )?;
-579
+        }
         if let Some(ref val) = self.conditional_operator {
             ser.write_string(&QUERYINPUT_MEMBER_CONDITIONAL_OPERATOR, val.as_str())?;

-582
+        }
         if let Some(ref val) = self.scan_index_forward {
             ser.write_boolean(&QUERYINPUT_MEMBER_SCAN_INDEX_FORWARD, *val)?;
-585
+        }
         if let Some(ref val) = self.exclusive_start_key {
             ser.write_map(
                 &QUERYINPUT_MEMBER_EXCLUSIVE_START_KEY,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
                         ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-593
+                    }
                     Ok(())
                 },
             )?;
-597
+        }
         if let Some(ref val) = self.return_consumed_capacity {
             ser.write_string(&QUERYINPUT_MEMBER_RETURN_CONSUMED_CAPACITY, val.as_str())?;
-600
+        }
         if let Some(ref val) = self.projection_expression {
             ser.write_string(&QUERYINPUT_MEMBER_PROJECTION_EXPRESSION, val)?;
-603
+        }
         if let Some(ref val) = self.filter_expression {
             ser.write_string(&QUERYINPUT_MEMBER_FILTER_EXPRESSION, val)?;
-606
+        }
         if let Some(ref val) = self.key_condition_expression {
             ser.write_string(&QUERYINPUT_MEMBER_KEY_CONDITION_EXPRESSION, val)?;
-609
+        }
         if let Some(ref val) = self.expression_attribute_names {
             ser.write_map(
                 &QUERYINPUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-617
+                    }
                     Ok(())
                 },
             )?;
-621
+        }
         if let Some(ref val) = self.expression_attribute_values {
             ser.write_map(
                 &QUERYINPUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
                         ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-629
+                    }
                     Ok(())
                 },
             )?;
-633
+        }
         Ok(())
-635
+    }
-636
+}
 impl QueryInput {
     /// 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(&QUERYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&QUERYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_name = Some(deser.read_string(member)?);
-655
+                }
                 Some(1) => {
                     builder.index_name = Some(deser.read_string(member)?);
-658
+                }
                 Some(2) => {
                     builder.select = Some(crate::types::Select::from(deser.read_string(member)?.as_str()));
-661
+                }
                 Some(3) => {
                     builder.attributes_to_get = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.attributes_to_get = Some(deser.read_string_list(member)?);
-664
+                }
                 Some(4) => {
                     builder.limit = Some(deser.read_integer(member)?);
-667
+                }
                 Some(5) => {
                     builder.consistent_read = Some(deser.read_boolean(member)?);
-670
+                }
                 Some(6) => {
                     builder.key_conditions = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, crate::types::Condition::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::Condition::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-680
+                }
                 Some(7) => {
                     builder.query_filter = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, crate::types::Condition::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::Condition::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-690
+                }
                 Some(8) => {
                     builder.conditional_operator = Some(crate::types::ConditionalOperator::from(deser.read_string(member)?.as_str()));
-693
+                }
                 Some(9) => {
                     builder.scan_index_forward = Some(deser.read_boolean(member)?);
-696
+                }
                 Some(10) => {
                     builder.exclusive_start_key = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-706
+                }
                 Some(11) => {
                     builder.return_consumed_capacity = Some(crate::types::ReturnConsumedCapacity::from(deser.read_string(member)?.as_str()));
-709
+                }
                 Some(12) => {
                     builder.projection_expression = Some(deser.read_string(member)?);
-712
+                }
                 Some(13) => {
                     builder.filter_expression = Some(deser.read_string(member)?);
-715
+                }
                 Some(14) => {
                     builder.key_condition_expression = Some(deser.read_string(member)?);
-718
+                }
                 Some(15) => {
                     builder.expression_attribute_names = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.expression_attribute_names = Some(deser.read_string_string_map(member)?);
-721
+                }
                 Some(16) => {
                     builder.expression_attribute_values = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-731
+                }
                 _ => {}
-733
+            }
             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() })
-740
+    }
-741
+}
 impl QueryInput {
     /// 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 QueryInput {
     /// Creates a new builder-style object to manufacture [`QueryInput`](crate::operation::query::QueryInput).
     pub fn builder() -> crate::operation::query::builders::QueryInputBuilder {
         crate::operation::query::builders::QueryInputBuilder::default()
-757
+    }
-758
+}
-759
 /// A builder for [`QueryInput`](crate::operation::query::QueryInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct QueryInputBuilder {
     pub(crate) table_name: ::std::option::Option<::std::string::String>,
     pub(crate) index_name: ::std::option::Option<::std::string::String>,
     pub(crate) select: ::std::option::Option<crate::types::Select>,
     pub(crate) attributes_to_get: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) limit: ::std::option::Option<i32>,
     pub(crate) consistent_read: ::std::option::Option<bool>,
     pub(crate) key_conditions: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::Condition>>,
     pub(crate) query_filter: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::Condition>>,
     pub(crate) conditional_operator: ::std::option::Option<crate::types::ConditionalOperator>,
     pub(crate) scan_index_forward: ::std::option::Option<bool>,
     pub(crate) exclusive_start_key: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
     pub(crate) return_consumed_capacity: ::std::option::Option<crate::types::ReturnConsumedCapacity>,
     pub(crate) projection_expression: ::std::option::Option<::std::string::String>,
     pub(crate) filter_expression: ::std::option::Option<::std::string::String>,
     pub(crate) key_condition_expression: ::std::option::Option<::std::string::String>,
     pub(crate) expression_attribute_names: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) expression_attribute_values: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
-781
+}
 impl QueryInputBuilder {

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

@@ -35,35 +238,328 @@

↥ Expand context

         self.count
-36
+    }
     /// <p>The number of items evaluated, before any <code>QueryFilter</code> is applied. A high <code>ScannedCount</code> value with few, or no, <code>Count</code> results indicates an inefficient <code>Query</code> operation. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.Count">Count and ScannedCount</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     /// <p>If you did not use a filter in the request, then <code>ScannedCount</code> is the same as <code>Count</code>.</p>
     pub fn scanned_count(&self) -> i32 {
         self.scanned_count
-41
+    }
     /// <p>The primary key of the item where the operation stopped, inclusive of the previous result set. Use this value to start a new operation, excluding this value in the new request.</p>
     /// <p>If <code>LastEvaluatedKey</code> is empty, then the "last page" of results has been processed and there is no more data to be retrieved.</p>
     /// <p>If <code>LastEvaluatedKey</code> is not empty, it does not necessarily mean that there is more data in the result set. The only way to know when you have reached the end of the result set is when <code>LastEvaluatedKey</code> is empty.</p>
     pub fn last_evaluated_key(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {
         self.last_evaluated_key.as_ref()
-47
+    }
     /// <p>The capacity units consumed by the <code>Query</code> operation. The data returned includes the total provisioned throughput consumed, along with statistics for the table and any indexes involved in the operation. <code>ConsumedCapacity</code> is only returned if the <code>ReturnConsumedCapacity</code> parameter was specified. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/read-write-operations.html#read-operation-consumption">Capacity unit consumption for read operations</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     pub fn consumed_capacity(&self) -> ::std::option::Option<&crate::types::ConsumedCapacity> {
         self.consumed_capacity.as_ref()
-51
+    }
-52
+}
 static QUERYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#QueryOutput",

     "com.amazonaws.dynamodb.synthetic",
     "QueryOutput",
 );
 static QUERYOUTPUT_MEMBER_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryOutput$Items",
         "com.amazonaws.dynamodb.synthetic",
         "QueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "items",
     "Items",
 ,
 );
 static QUERYOUTPUT_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryOutput$Count",
         "com.amazonaws.dynamodb.synthetic",
         "QueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "count",
     "Count",
 ,
 );
 static QUERYOUTPUT_MEMBER_SCANNED_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryOutput$ScannedCount",
         "com.amazonaws.dynamodb.synthetic",
         "QueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "scanned_count",
     "ScannedCount",
 ,
 );
 static QUERYOUTPUT_MEMBER_LAST_EVALUATED_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryOutput$LastEvaluatedKey",
         "com.amazonaws.dynamodb.synthetic",
         "QueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "last_evaluated_key",
     "LastEvaluatedKey",
 ,
 );
 static QUERYOUTPUT_MEMBER_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryOutput$ConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "QueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "consumed_capacity",
     "ConsumedCapacity",
 ,
 );
 static QUERYOUTPUT_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 QUERYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     QUERYOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &QUERYOUTPUT_MEMBER_ITEMS,
         &QUERYOUTPUT_MEMBER_COUNT,
         &QUERYOUTPUT_MEMBER_SCANNED_COUNT,
         &QUERYOUTPUT_MEMBER_LAST_EVALUATED_KEY,
         &QUERYOUTPUT_MEMBER_CONSUMED_CAPACITY,
         &QUERYOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl QueryOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYOUTPUT_SCHEMA;
-130
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for QueryOutput {
     #[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.items {
             ser.write_list(&QUERYOUTPUT_MEMBER_ITEMS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for item in val {
                     todo!("schema: unsupported list element type");
                     ser.write_map(
                         &::aws_smithy_schema::prelude::DOCUMENT,
                         &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                             for (key, value) in item {
                                 ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                                 ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-+
+                            }
                             Ok(())
                         },
                     )?;
-150
+                }
                 Ok(())
             })?;
-153
+        }
-154
+        {
             let val = &self.count;
             ser.write_integer(&QUERYOUTPUT_MEMBER_COUNT, *val)?;
-157
+        }
-158
+        {
             let val = &self.scanned_count;
             ser.write_integer(&QUERYOUTPUT_MEMBER_SCANNED_COUNT, *val)?;
-161
+        }
         if let Some(ref val) = self.last_evaluated_key {
             ser.write_map(
                 &QUERYOUTPUT_MEMBER_LAST_EVALUATED_KEY,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
                         ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-169
+                    }
                     Ok(())
                 },
             )?;
-173
+        }
         if let Some(ref val) = self.consumed_capacity {
             ser.write_struct(&QUERYOUTPUT_MEMBER_CONSUMED_CAPACITY, val)?;
-176
+        }
         Ok(())
-178
+    }
-179
+}
 impl QueryOutput {
     /// 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(&QUERYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&QUERYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.items = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push({
                                 let mut map = ::std::collections::HashMap::new();
                                 deser.read_map(member, &mut |key, deser| {
                                     let value = crate::types::AttributeValue::deserialize(deser)?;
                                     map.insert(key, value);
                                     Ok(())
                                 })?;
                                 map
                             });
                             Ok(())
                         })?;
                         container
                     });
-213
+                }
                 Some(1) => {
                     builder.count = Some(deser.read_integer(member)?);
-216
+                }
                 Some(2) => {
                     builder.scanned_count = Some(deser.read_integer(member)?);
-219
+                }
                 Some(3) => {
                     builder.last_evaluated_key = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(4) => {
                     builder.consumed_capacity = Some(crate::types::ConsumedCapacity::deserialize(deser)?);
-+
+                }
                 Some(5) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl QueryOutput {
     /// 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(&QUERYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.items = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push({
                                 let mut map = ::std::collections::HashMap::new();
                                 deser.read_map(member, &mut |key, deser| {
                                     let value = crate::types::AttributeValue::deserialize(deser)?;
                                     map.insert(key, value);
                                     Ok(())
                                 })?;
                                 map
                             });
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder.count = Some(deser.read_integer(member)?);
-+
+                }
                 Some(2) => {
                     builder.scanned_count = Some(deser.read_integer(member)?);
-+
+                }
                 Some(3) => {
                     builder.last_evaluated_key = Some({
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-300
+                }
                 Some(4) => {
                     builder.consumed_capacity = Some(crate::types::ConsumedCapacity::deserialize(deser)?);
-303
+                }
                 _ => {}
-305
+            }
             Ok(())
         })?;
         Ok(builder.build())

↧ Expand context

-309
+    }
-310
+}
 impl ::aws_types::request_id::RequestId for QueryOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-314
+    }
-315
+}
 impl QueryOutput {
     /// Creates a new builder-style object to manufacture [`QueryOutput`](crate::operation::query::QueryOutput).
     pub fn builder() -> crate::operation::query::builders::QueryOutputBuilder {
         crate::operation::query::builders::QueryOutputBuilder::default()
-320
+    }
-321
+}
-322
 /// A builder for [`QueryOutput`](crate::operation::query::QueryOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct QueryOutputBuilder {
     pub(crate) items: ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>>,
     pub(crate) count: ::std::option::Option<i32>,

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

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

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

@@ -118,122 +247,432 @@

↥ 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("RestoreTableFromBackup")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(RestoreTableFromBackupEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::restore_table_from_backup::RestoreTableFromBackupError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::restore_table_from_backup::RestoreTableFromBackupError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::restore_table_from_backup::RestoreTableFromBackupError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct RestoreTableFromBackupResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RestoreTableFromBackupResponseDeserializer {
     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_restore_table_from_backup::de_restore_table_from_backup_http_error(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::restore_table_from_backup::RestoreTableFromBackupError::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 {
                 "BackupInUseException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::BackupInUseException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::BackupInUseException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::BackupInUseException::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
                 }),
                 "BackupNotFoundException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::BackupNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::BackupNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::BackupNotFoundException::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
                 }),
                 "InternalServerError" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::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::restore_table_from_backup::RestoreTableFromBackupError::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::restore_table_from_backup::RestoreTableFromBackupError::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
                 }),
                 "TableAlreadyExistsException" => {
                     crate::operation::restore_table_from_backup::RestoreTableFromBackupError::TableAlreadyExistsException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::TableAlreadyExistsException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::TableAlreadyExistsException::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
                     })
-+
+                }
                 "TableInUseException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::TableInUseException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::TableInUseException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::TableInUseException::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::restore_table_from_backup::RestoreTableFromBackupError::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 {
             crate::protocol_serde::shape_restore_table_from_backup::de_restore_table_from_backup_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, RestoreTableFromBackup::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::restore_table_from_backup::RestoreTableFromBackupOutput::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))
-+
+        }
-381
+    }
-382
+}
 #[derive(Debug)]
 struct RestoreTableFromBackupRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RestoreTableFromBackupRequestSerializer {
     #[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::restore_table_from_backup::RestoreTableFromBackupInput>()
             .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::restore_table_from_backup::RestoreTableFromBackupInput,
                 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::restore_table_from_backup::RestoreTableFromBackupInput,
                 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.RestoreTableFromBackup",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_restore_table_from_backup::ser_restore_table_from_backup_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, RestoreTableFromBackup::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-403
+    }
-404
+}
 #[derive(Debug)]
 struct RestoreTableFromBackupEndpointParamsInterceptor;
-407
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RestoreTableFromBackupEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RestoreTableFromBackupEndpointParamsInterceptor"
-411
+    }
-412

↧ 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::<RestoreTableFromBackupInput>()
             .ok_or("failed to downcast to RestoreTableFromBackupInput")?;
-427
         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/restore_table_from_backup/_restore_table_from_backup_input.rs

@@ -43,43 +173,173 @@

↥ Expand context

     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.local_secondary_index_override.is_none()`.
     pub fn local_secondary_index_override(&self) -> &[crate::types::LocalSecondaryIndex] {
         self.local_secondary_index_override.as_deref().unwrap_or_default()
-47
+    }
     /// <p>Provisioned throughput settings for the restored table.</p>
     pub fn provisioned_throughput_override(&self) -> ::std::option::Option<&crate::types::ProvisionedThroughput> {
         self.provisioned_throughput_override.as_ref()
-51
+    }
     /// <p>Sets the maximum number of read and write units for the specified on-demand table. If you use this parameter, you must specify <code>MaxReadRequestUnits</code>, <code>MaxWriteRequestUnits</code>, or both.</p>
     pub fn on_demand_throughput_override(&self) -> ::std::option::Option<&crate::types::OnDemandThroughput> {
         self.on_demand_throughput_override.as_ref()
-55
+    }
     /// <p>The new server-side encryption settings for the restored table.</p>
     pub fn sse_specification_override(&self) -> ::std::option::Option<&crate::types::SseSpecification> {
         self.sse_specification_override.as_ref()
-59
+    }
-60
+}
 static RESTORETABLEFROMBACKUPINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupInput",

     "com.amazonaws.dynamodb.synthetic",
     "RestoreTableFromBackupInput",
 );
 static RESTORETABLEFROMBACKUPINPUT_MEMBER_TARGET_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupInput$TargetTableName",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableFromBackupInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "target_table_name",
     "TargetTableName",
 ,
 );
 static RESTORETABLEFROMBACKUPINPUT_MEMBER_BACKUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupInput$BackupArn",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableFromBackupInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "backup_arn",
     "BackupArn",
 ,
 );
 static RESTORETABLEFROMBACKUPINPUT_MEMBER_BILLING_MODE_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupInput$BillingModeOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableFromBackupInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "billing_mode_override",
     "BillingModeOverride",
 ,
 );
 static RESTORETABLEFROMBACKUPINPUT_MEMBER_GLOBAL_SECONDARY_INDEX_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupInput$GlobalSecondaryIndexOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableFromBackupInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "global_secondary_index_override",
     "GlobalSecondaryIndexOverride",
 ,
 );
 static RESTORETABLEFROMBACKUPINPUT_MEMBER_LOCAL_SECONDARY_INDEX_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupInput$LocalSecondaryIndexOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableFromBackupInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "local_secondary_index_override",
     "LocalSecondaryIndexOverride",
 ,
 );
 static RESTORETABLEFROMBACKUPINPUT_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupInput$ProvisionedThroughputOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableFromBackupInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "provisioned_throughput_override",
     "ProvisionedThroughputOverride",
 ,
 );
 static RESTORETABLEFROMBACKUPINPUT_MEMBER_ON_DEMAND_THROUGHPUT_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupInput$OnDemandThroughputOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableFromBackupInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "on_demand_throughput_override",
     "OnDemandThroughputOverride",
 ,
 );
 static RESTORETABLEFROMBACKUPINPUT_MEMBER_SSE_SPECIFICATION_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupInput$SSESpecificationOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableFromBackupInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "sse_specification_override",
     "SSESpecificationOverride",
 ,
 );
 static RESTORETABLEFROMBACKUPINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESTORETABLEFROMBACKUPINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RESTORETABLEFROMBACKUPINPUT_MEMBER_TARGET_TABLE_NAME,
         &RESTORETABLEFROMBACKUPINPUT_MEMBER_BACKUP_ARN,
         &RESTORETABLEFROMBACKUPINPUT_MEMBER_BILLING_MODE_OVERRIDE,
         &RESTORETABLEFROMBACKUPINPUT_MEMBER_GLOBAL_SECONDARY_INDEX_OVERRIDE,

↧ Expand context

         &RESTORETABLEFROMBACKUPINPUT_MEMBER_LOCAL_SECONDARY_INDEX_OVERRIDE,
         &RESTORETABLEFROMBACKUPINPUT_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE,
         &RESTORETABLEFROMBACKUPINPUT_MEMBER_ON_DEMAND_THROUGHPUT_OVERRIDE,
         &RESTORETABLEFROMBACKUPINPUT_MEMBER_SSE_SPECIFICATION_OVERRIDE,
     ],
 );
 impl RestoreTableFromBackupInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTORETABLEFROMBACKUPINPUT_SCHEMA;
-163
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RestoreTableFromBackupInput {
     #[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.target_table_name {
             ser.write_string(&RESTORETABLEFROMBACKUPINPUT_MEMBER_TARGET_TABLE_NAME, val)?;
-172
+        }
         if let Some(ref val) = self.backup_arn {

@@ -185,185 +311,318 @@

↥ Expand context

-185
+                    }
                     Ok(())
                 },
             )?;
-189
+        }
         if let Some(ref val) = self.local_secondary_index_override {
             ser.write_list(
                 &RESTORETABLEFROMBACKUPINPUT_MEMBER_LOCAL_SECONDARY_INDEX_OVERRIDE,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::LocalSecondaryIndex::SCHEMA, item)?;
-196
+                    }
                     Ok(())
                 },
             )?;
-200
+        }
         if let Some(ref val) = self.provisioned_throughput_override {
             ser.write_struct(&RESTORETABLEFROMBACKUPINPUT_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE, val)?;
-203
+        }
         if let Some(ref val) = self.on_demand_throughput_override {

             ser.write_struct(&RESTORETABLEFROMBACKUPINPUT_MEMBER_ON_DEMAND_THROUGHPUT_OVERRIDE, val)?;
-206
+        }
         if let Some(ref val) = self.sse_specification_override {
             ser.write_struct(&RESTORETABLEFROMBACKUPINPUT_MEMBER_SSE_SPECIFICATION_OVERRIDE, val)?;
-209
+        }
         Ok(())
-211
+    }
-212
+}
 impl RestoreTableFromBackupInput {
     /// 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(&RESTORETABLEFROMBACKUPINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESTORETABLEFROMBACKUPINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.target_table_name = Some(deser.read_string(member)?);
-231
+                }
                 Some(1) => {
                     builder.backup_arn = Some(deser.read_string(member)?);
-234
+                }
                 Some(2) => {
                     builder.billing_mode_override = Some(crate::types::BillingMode::from(deser.read_string(member)?.as_str()));
-237
+                }
                 Some(3) => {
                     builder.global_secondary_index_override = 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::GlobalSecondaryIndex::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GlobalSecondaryIndex::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-247
+                }
                 Some(4) => {
                     builder.local_secondary_index_override = 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::LocalSecondaryIndex::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::LocalSecondaryIndex::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-257
+                }
                 Some(5) => {
                     builder.provisioned_throughput_override = Some(crate::types::ProvisionedThroughput::deserialize(deser)?);
-260
+                }
                 Some(6) => {
                     builder.on_demand_throughput_override = Some(crate::types::OnDemandThroughput::deserialize(deser)?);
-263
+                }
                 Some(7) => {
                     builder.sse_specification_override = Some(crate::types::SseSpecification::deserialize(deser)?);
-266
+                }
                 _ => {}
-268
+            }
             Ok(())
         })?;
         builder.target_table_name = builder.target_table_name.or(Some(String::new()));
         builder.backup_arn = builder.backup_arn.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-276
+    }
-277
+}
 impl RestoreTableFromBackupInput {
     /// 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 RestoreTableFromBackupInput {
     /// Creates a new builder-style object to manufacture [`RestoreTableFromBackupInput`](crate::operation::restore_table_from_backup::RestoreTableFromBackupInput).
     pub fn builder() -> crate::operation::restore_table_from_backup::builders::RestoreTableFromBackupInputBuilder {
         crate::operation::restore_table_from_backup::builders::RestoreTableFromBackupInputBuilder::default()
-293
+    }
-294
+}
-295
 /// A builder for [`RestoreTableFromBackupInput`](crate::operation::restore_table_from_backup::RestoreTableFromBackupInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RestoreTableFromBackupInputBuilder {
     pub(crate) target_table_name: ::std::option::Option<::std::string::String>,
     pub(crate) backup_arn: ::std::option::Option<::std::string::String>,
     pub(crate) billing_mode_override: ::std::option::Option<crate::types::BillingMode>,
     pub(crate) global_secondary_index_override: ::std::option::Option<::std::vec::Vec<crate::types::GlobalSecondaryIndex>>,
     pub(crate) local_secondary_index_override: ::std::option::Option<::std::vec::Vec<crate::types::LocalSecondaryIndex>>,
     pub(crate) provisioned_throughput_override: ::std::option::Option<crate::types::ProvisionedThroughput>,
     pub(crate) on_demand_throughput_override: ::std::option::Option<crate::types::OnDemandThroughput>,
     pub(crate) sse_specification_override: ::std::option::Option<crate::types::SseSpecification>,
-308
+}
 impl RestoreTableFromBackupInputBuilder {
     /// <p>The name of the new table to which the backup must be restored.</p>
     /// This field is required.
     pub fn target_table_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.target_table_name = ::std::option::Option::Some(input.into());
         self
-315
+    }
     /// <p>The name of the new table to which the backup must be restored.</p>
     pub fn set_target_table_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.target_table_name = input;

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/restore_table_from_backup/_restore_table_from_backup_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 RestoreTableFromBackupOutput {
     /// <p>The description of the table created from an existing backup.</p>
     pub table_description: ::std::option::Option<crate::types::TableDescription>,
     _request_id: Option<String>,
-9
+}
 impl RestoreTableFromBackupOutput {
     /// <p>The description of the table created from an existing backup.</p>
     pub fn table_description(&self) -> ::std::option::Option<&crate::types::TableDescription> {
         self.table_description.as_ref()
-14
+    }
-15
+}
 static RESTORETABLEFROMBACKUPOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupOutput",

     "com.amazonaws.dynamodb.synthetic",
     "RestoreTableFromBackupOutput",
 );
 static RESTORETABLEFROMBACKUPOUTPUT_MEMBER_TABLE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupOutput$TableDescription",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableFromBackupOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "table_description",
     "TableDescription",
 ,
 );
 static RESTORETABLEFROMBACKUPOUTPUT_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 RESTORETABLEFROMBACKUPOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESTORETABLEFROMBACKUPOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&RESTORETABLEFROMBACKUPOUTPUT_MEMBER_TABLE_DESCRIPTION],
     &[
         &RESTORETABLEFROMBACKUPOUTPUT_MEMBER_TABLE_DESCRIPTION,
         &RESTORETABLEFROMBACKUPOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl RestoreTableFromBackupOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTORETABLEFROMBACKUPOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RestoreTableFromBackupOutput {
     #[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(&RESTORETABLEFROMBACKUPOUTPUT_MEMBER_TABLE_DESCRIPTION, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl RestoreTableFromBackupOutput {
     /// 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(&RESTORETABLEFROMBACKUPOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESTORETABLEFROMBACKUPOUTPUT_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 RestoreTableFromBackupOutput {
     /// 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(&RESTORETABLEFROMBACKUPOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_description = Some(crate::types::TableDescription::deserialize(deser)?);
-117
+                }
                 _ => {}
-119
+            }
             Ok(())
         })?;
         Ok(builder.build())
-123
+    }

↧ Expand context

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

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

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

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

@@ -124,130 +253,474 @@

↥ 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("RestoreTableToPointInTime")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(RestoreTableToPointInTimeEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError,
             >::new());
-152
         ::std::borrow::Cow::Owned(rcb)
-154
+    }
-155
+}
-156
 #[derive(Debug)]
 struct RestoreTableToPointInTimeResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RestoreTableToPointInTimeResponseDeserializer {
     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_restore_table_to_point_in_time::de_restore_table_to_point_in_time_http_error(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::restore_table_to_point_in_time::RestoreTableToPointInTimeError::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::restore_table_to_point_in_time::RestoreTableToPointInTimeError::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::restore_table_to_point_in_time::RestoreTableToPointInTimeError::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
                     })
-+
+                }
                 "InvalidRestoreTimeException" => {
                     crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::InvalidRestoreTimeException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidRestoreTimeException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidRestoreTimeException::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::restore_table_to_point_in_time::RestoreTableToPointInTimeError::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
                     })
-+
+                }
                 "PointInTimeRecoveryUnavailableException" => {
                     crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::PointInTimeRecoveryUnavailableException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::PointInTimeRecoveryUnavailableException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::PointInTimeRecoveryUnavailableException::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
                     })
-+
+                }
                 "TableAlreadyExistsException" => {
                     crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::TableAlreadyExistsException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::TableAlreadyExistsException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::TableAlreadyExistsException::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
                     })
-+
+                }
                 "TableInUseException" => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::TableInUseException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::TableInUseException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::TableInUseException::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
                 }),
                 "TableNotFoundException" => {
                     crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::TableNotFoundException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::TableNotFoundException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::TableNotFoundException::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::restore_table_to_point_in_time::RestoreTableToPointInTimeError::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 {
             crate::protocol_serde::shape_restore_table_to_point_in_time::de_restore_table_to_point_in_time_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, RestoreTableToPointInTime::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::restore_table_to_point_in_time::RestoreTableToPointInTimeOutput::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))
-+
+        }
-423
+    }
-424
+}
 #[derive(Debug)]
 struct RestoreTableToPointInTimeRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RestoreTableToPointInTimeRequestSerializer {
     #[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::restore_table_to_point_in_time::RestoreTableToPointInTimeInput>()
             .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::restore_table_to_point_in_time::RestoreTableToPointInTimeInput,
                 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::restore_table_to_point_in_time::RestoreTableToPointInTimeInput,
                 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.RestoreTableToPointInTime",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_restore_table_to_point_in_time::ser_restore_table_to_point_in_time_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, RestoreTableToPointInTime::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-445
+    }
-446
+}
 #[derive(Debug)]
 struct RestoreTableToPointInTimeEndpointParamsInterceptor;
-449
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RestoreTableToPointInTimeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RestoreTableToPointInTimeEndpointParamsInterceptor"
-453
+    }
-454

↧ 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::<RestoreTableToPointInTimeInput>()
             .ok_or("failed to downcast to RestoreTableToPointInTimeInput")?;
-469
         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()))

AWS SDK

Files changed:

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

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

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

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

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

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