AWS SDK

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

@@ -61,61 +221,221 @@

     ///
     /// 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()
-65
+    }
     /// <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()
-69
+    }
     /// <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()
-73
+    }
     /// <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()
-77
+    }
-78
+}
 static RESTORETABLETOPOINTINTIMEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeInput",

     "com.amazonaws.dynamodb.synthetic",
     "RestoreTableToPointInTimeInput",
 );
 static RESTORETABLETOPOINTINTIMEINPUT_MEMBER_SOURCE_TABLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeInput$SourceTableArn",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "source_table_arn",
     "SourceTableArn",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_MEMBER_SOURCE_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeInput$SourceTableName",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "source_table_name",
     "SourceTableName",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_MEMBER_TARGET_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeInput$TargetTableName",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "target_table_name",
     "TargetTableName",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_MEMBER_USE_LATEST_RESTORABLE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeInput$UseLatestRestorableTime",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "use_latest_restorable_time",
     "UseLatestRestorableTime",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_MEMBER_RESTORE_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeInput$RestoreDateTime",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "restore_date_time",
     "RestoreDateTime",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_MEMBER_BILLING_MODE_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeInput$BillingModeOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "billing_mode_override",
     "BillingModeOverride",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_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#RestoreTableToPointInTimeInput$GlobalSecondaryIndexOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "global_secondary_index_override",
     "GlobalSecondaryIndexOverride",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_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#RestoreTableToPointInTimeInput$LocalSecondaryIndexOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "local_secondary_index_override",
     "LocalSecondaryIndexOverride",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeInput$ProvisionedThroughputOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "provisioned_throughput_override",
     "ProvisionedThroughputOverride",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_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#RestoreTableToPointInTimeInput$OnDemandThroughputOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "on_demand_throughput_override",
     "OnDemandThroughputOverride",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_MEMBER_SSE_SPECIFICATION_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeInput$SSESpecificationOverride",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "sse_specification_override",
     "SSESpecificationOverride",
 ,
 );
 static RESTORETABLETOPOINTINTIMEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESTORETABLETOPOINTINTIMEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_SOURCE_TABLE_ARN,
         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_SOURCE_TABLE_NAME,
         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_TARGET_TABLE_NAME,
         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_USE_LATEST_RESTORABLE_TIME,

↧ Expand context

         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_RESTORE_DATE_TIME,
         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_BILLING_MODE_OVERRIDE,
         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_GLOBAL_SECONDARY_INDEX_OVERRIDE,
         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_LOCAL_SECONDARY_INDEX_OVERRIDE,
         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE,
         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_ON_DEMAND_THROUGHPUT_OVERRIDE,
         &RESTORETABLETOPOINTINTIMEINPUT_MEMBER_SSE_SPECIFICATION_OVERRIDE,
     ],
 );
 impl RestoreTableToPointInTimeInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTORETABLETOPOINTINTIMEINPUT_SCHEMA;
-214
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RestoreTableToPointInTimeInput {
     #[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.source_table_arn {

@@ -245,245 +380,386 @@

↥ Expand context

-245
+                    }
                     Ok(())
                 },
             )?;
-249
+        }
         if let Some(ref val) = self.local_secondary_index_override {
             ser.write_list(
                 &RESTORETABLETOPOINTINTIMEINPUT_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)?;
-256
+                    }
                     Ok(())
                 },
             )?;
-260
+        }
         if let Some(ref val) = self.provisioned_throughput_override {
             ser.write_struct(&RESTORETABLETOPOINTINTIMEINPUT_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE, val)?;
-263
+        }
         if let Some(ref val) = self.on_demand_throughput_override {

             ser.write_struct(&RESTORETABLETOPOINTINTIMEINPUT_MEMBER_ON_DEMAND_THROUGHPUT_OVERRIDE, val)?;
-266
+        }
         if let Some(ref val) = self.sse_specification_override {
             ser.write_struct(&RESTORETABLETOPOINTINTIMEINPUT_MEMBER_SSE_SPECIFICATION_OVERRIDE, val)?;
-269
+        }
         Ok(())
-271
+    }
-272
+}
 impl RestoreTableToPointInTimeInput {
     /// 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(&RESTORETABLETOPOINTINTIMEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESTORETABLETOPOINTINTIMEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.source_table_arn = Some(deser.read_string(member)?);
-291
+                }
                 Some(1) => {
                     builder.source_table_name = Some(deser.read_string(member)?);
-294
+                }
                 Some(2) => {
                     builder.target_table_name = Some(deser.read_string(member)?);
-297
+                }
                 Some(3) => {
                     builder.use_latest_restorable_time = Some(deser.read_boolean(member)?);
-300
+                }
                 Some(4) => {
                     builder.restore_date_time = Some(deser.read_timestamp(member)?);
-303
+                }
                 Some(5) => {
                     builder.billing_mode_override = Some(crate::types::BillingMode::from(deser.read_string(member)?.as_str()));
-306
+                }
                 Some(6) => {
                     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
                     });
-316
+                }
                 Some(7) => {
                     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
                     });
-326
+                }
                 Some(8) => {
                     builder.provisioned_throughput_override = Some(crate::types::ProvisionedThroughput::deserialize(deser)?);
-329
+                }
                 Some(9) => {
                     builder.on_demand_throughput_override = Some(crate::types::OnDemandThroughput::deserialize(deser)?);
-332
+                }
                 Some(10) => {
                     builder.sse_specification_override = Some(crate::types::SseSpecification::deserialize(deser)?);
-335
+                }
                 _ => {}
-337
+            }
             Ok(())
         })?;
         builder.target_table_name = builder.target_table_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-344
+    }
-345
+}
 impl RestoreTableToPointInTimeInput {
     /// 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 RestoreTableToPointInTimeInput {
     /// Creates a new builder-style object to manufacture [`RestoreTableToPointInTimeInput`](crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeInput).
     pub fn builder() -> crate::operation::restore_table_to_point_in_time::builders::RestoreTableToPointInTimeInputBuilder {
         crate::operation::restore_table_to_point_in_time::builders::RestoreTableToPointInTimeInputBuilder::default()
-361
+    }
-362
+}
-363
 /// A builder for [`RestoreTableToPointInTimeInput`](crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RestoreTableToPointInTimeInputBuilder {
     pub(crate) source_table_arn: ::std::option::Option<::std::string::String>,
     pub(crate) source_table_name: ::std::option::Option<::std::string::String>,
     pub(crate) target_table_name: ::std::option::Option<::std::string::String>,
     pub(crate) use_latest_restorable_time: ::std::option::Option<bool>,
     pub(crate) restore_date_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     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>,
-379
+}
 impl RestoreTableToPointInTimeInputBuilder {
     /// <p>The DynamoDB table that will be restored. This value is an Amazon Resource Name (ARN).</p>
     pub fn source_table_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.source_table_arn = ::std::option::Option::Some(input.into());
         self
-385
+    }
     /// <p>The DynamoDB table that will be restored. This value is an Amazon Resource Name (ARN).</p>

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/restore_table_to_point_in_time/_restore_table_to_point_in_time_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 RestoreTableToPointInTimeOutput {
     /// <p>Represents the properties of a table.</p>
     pub table_description: ::std::option::Option<crate::types::TableDescription>,
     _request_id: Option<String>,
-9
+}
 impl RestoreTableToPointInTimeOutput {
     /// <p>Represents the properties of a table.</p>
     pub fn table_description(&self) -> ::std::option::Option<&crate::types::TableDescription> {
         self.table_description.as_ref()
-14
+    }
-15
+}
 static RESTORETABLETOPOINTINTIMEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeOutput",

     "com.amazonaws.dynamodb.synthetic",
     "RestoreTableToPointInTimeOutput",
 );
 static RESTORETABLETOPOINTINTIMEOUTPUT_MEMBER_TABLE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableToPointInTimeOutput$TableDescription",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableToPointInTimeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "table_description",
     "TableDescription",
 ,
 );
 static RESTORETABLETOPOINTINTIMEOUTPUT_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 RESTORETABLETOPOINTINTIMEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESTORETABLETOPOINTINTIMEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&RESTORETABLETOPOINTINTIMEOUTPUT_MEMBER_TABLE_DESCRIPTION],
     &[
         &RESTORETABLETOPOINTINTIMEOUTPUT_MEMBER_TABLE_DESCRIPTION,
         &RESTORETABLETOPOINTINTIMEOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl RestoreTableToPointInTimeOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTORETABLETOPOINTINTIMEOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RestoreTableToPointInTimeOutput {
     #[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(&RESTORETABLETOPOINTINTIMEOUTPUT_MEMBER_TABLE_DESCRIPTION, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl RestoreTableToPointInTimeOutput {
     /// 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(&RESTORETABLETOPOINTINTIMEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESTORETABLETOPOINTINTIMEOUTPUT_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 RestoreTableToPointInTimeOutput {
     /// 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(&RESTORETABLETOPOINTINTIMEOUTPUT_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 RestoreTableToPointInTimeOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-128
+    }
-129
+}
 impl RestoreTableToPointInTimeOutput {
     /// Creates a new builder-style object to manufacture [`RestoreTableToPointInTimeOutput`](crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeOutput).
     pub fn builder() -> crate::operation::restore_table_to_point_in_time::builders::RestoreTableToPointInTimeOutputBuilder {
         crate::operation::restore_table_to_point_in_time::builders::RestoreTableToPointInTimeOutputBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`RestoreTableToPointInTimeOutput`](crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct RestoreTableToPointInTimeOutputBuilder {
     pub(crate) table_description: ::std::option::Option<crate::types::TableDescription>,
     _request_id: Option<String>,
-143
+}

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `Scan`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct Scan;
 impl Scan {
     /// Creates a new `Scan`
     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::scan::ScanInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::scan::ScanOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::scan::ScanInput,
     ) -> ::std::result::Result<
         crate::operation::scan::ScanOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::scan::ScanError,
             ::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::scan::ScanError>().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::scan::ScanOutput>().expect("correct output type"))
-34
+    }
-35
     pub(crate) async fn orchestrate_with_stop_point(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::scan::ScanInput,
         stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,
     ) -> ::std::result::Result<
         ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,
         ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

@@ -106,110 +231,386 @@

↥ Expand context

         });
-111
         ::std::option::Option::Some(cfg.freeze())
-113
+    }
-114
     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("Scan")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ScanEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::scan::ScanError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::scan::ScanError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::scan::ScanError,
             >::new());
-132
         ::std::borrow::Cow::Owned(rcb)
-134
+    }
-135
+}
-136
 #[derive(Debug)]
 struct ScanResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ScanResponseDeserializer {
     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_scan::de_scan_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::scan::ScanError::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::scan::ScanError::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::scan::ScanError::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
                 }),
                 "ProvisionedThroughputExceededException" => crate::operation::scan::ScanError::ProvisionedThroughputExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ProvisionedThroughputExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ProvisionedThroughputExceededException::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
                 }),
                 "RequestLimitExceeded" => crate::operation::scan::ScanError::RequestLimitExceeded({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestLimitExceeded::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestLimitExceeded::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
                 }),
                 "ResourceNotFoundException" => crate::operation::scan::ScanError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ThrottlingException" => crate::operation::scan::ScanError::ThrottlingException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ThrottlingException::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::scan::ScanError::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_scan::de_scan_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, Scan::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::scan::ScanOutput::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))
-+
+        }
-337
+    }
-338
+}
 #[derive(Debug)]
 struct ScanRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ScanRequestSerializer {
     #[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::scan::ScanInput>().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::scan::ScanInput,
                 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::scan::ScanInput,
                 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.Scan",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_scan::ser_scan_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, Scan::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-357
+    }
-358
+}
 #[derive(Debug)]
 struct ScanEndpointParamsInterceptor;
-361
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ScanEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ScanEndpointParamsInterceptor"
-365
+    }
-366

↧ 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::<ScanInput>().ok_or("failed to downcast to ScanInput")?;
-378
         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()))
             .set_account_id_endpoint_mode(::std::option::Option::Some(
                 cfg.load::<::aws_types::endpoint_config::AccountIdEndpointMode>()
                     .cloned()

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

@@ -250,250 +460,460 @@

↥ Expand context

     pub fn expression_attribute_values(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {
         self.expression_attribute_values.as_ref()
-254
+    }
     /// <p>A Boolean value that determines the read consistency model during the scan:</p>
     /// <ul>
     /// <li>
     /// <p>If <code>ConsistentRead</code> is <code>false</code>, then the data returned from <code>Scan</code> might not contain the results from other recently completed write operations (<code>PutItem</code>, <code>UpdateItem</code>, or <code>DeleteItem</code>).</p></li>
     /// <li>
     /// <p>If <code>ConsistentRead</code> is <code>true</code>, then all of the write operations that completed before the <code>Scan</code> began are guaranteed to be contained in the <code>Scan</code> response.</p></li>
     /// </ul>
     /// <p>The default setting for <code>ConsistentRead</code> is <code>false</code>.</p>
     /// <p>The <code>ConsistentRead</code> parameter is not supported on global secondary indexes. If you scan a global secondary index with <code>ConsistentRead</code> set to true, you will receive a <code>ValidationException</code>.</p>
     pub fn consistent_read(&self) -> ::std::option::Option<bool> {
         self.consistent_read
-266
+    }
-267
+}
 static SCANINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#ScanInput",

     "com.amazonaws.dynamodb.synthetic",
     "ScanInput",
 );
 static SCANINPUT_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$TableName",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_name",
     "TableName",
 ,
 );
 static SCANINPUT_MEMBER_INDEX_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$IndexName",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "index_name",
     "IndexName",
 ,
 );
 static SCANINPUT_MEMBER_ATTRIBUTES_TO_GET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$AttributesToGet",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "attributes_to_get",
     "AttributesToGet",
 ,
 );
 static SCANINPUT_MEMBER_LIMIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$Limit",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "limit",
     "Limit",
 ,
 );
 static SCANINPUT_MEMBER_SELECT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$Select",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "select",
     "Select",
 ,
 );
 static SCANINPUT_MEMBER_SCAN_FILTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$ScanFilter",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "scan_filter",
     "ScanFilter",
 ,
 );
 static SCANINPUT_MEMBER_CONDITIONAL_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$ConditionalOperator",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "conditional_operator",
     "ConditionalOperator",
 ,
 );
 static SCANINPUT_MEMBER_EXCLUSIVE_START_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$ExclusiveStartKey",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "exclusive_start_key",
     "ExclusiveStartKey",
 ,
 );
 static SCANINPUT_MEMBER_RETURN_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$ReturnConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_consumed_capacity",
     "ReturnConsumedCapacity",
 ,
 );
 static SCANINPUT_MEMBER_TOTAL_SEGMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$TotalSegments",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "total_segments",
     "TotalSegments",
 ,
 );
 static SCANINPUT_MEMBER_SEGMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$Segment",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "segment",
     "Segment",
 ,
 );
 static SCANINPUT_MEMBER_PROJECTION_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$ProjectionExpression",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "projection_expression",
     "ProjectionExpression",
 ,
 );
 static SCANINPUT_MEMBER_FILTER_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$FilterExpression",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "filter_expression",
     "FilterExpression",
 ,
 );
 static SCANINPUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$ExpressionAttributeNames",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expression_attribute_names",
     "ExpressionAttributeNames",
 ,
 );
 static SCANINPUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$ExpressionAttributeValues",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expression_attribute_values",
     "ExpressionAttributeValues",
 ,
 );
 static SCANINPUT_MEMBER_CONSISTENT_READ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanInput$ConsistentRead",
         "com.amazonaws.dynamodb.synthetic",
         "ScanInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "consistent_read",
     "ConsistentRead",
 ,
 );
 static SCANINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SCANINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SCANINPUT_MEMBER_TABLE_NAME,
         &SCANINPUT_MEMBER_INDEX_NAME,
         &SCANINPUT_MEMBER_ATTRIBUTES_TO_GET,
         &SCANINPUT_MEMBER_LIMIT,

↧ Expand context

         &SCANINPUT_MEMBER_SELECT,
         &SCANINPUT_MEMBER_SCAN_FILTER,
         &SCANINPUT_MEMBER_CONDITIONAL_OPERATOR,
         &SCANINPUT_MEMBER_EXCLUSIVE_START_KEY,
         &SCANINPUT_MEMBER_RETURN_CONSUMED_CAPACITY,
         &SCANINPUT_MEMBER_TOTAL_SEGMENTS,
         &SCANINPUT_MEMBER_SEGMENT,
         &SCANINPUT_MEMBER_PROJECTION_EXPRESSION,
         &SCANINPUT_MEMBER_FILTER_EXPRESSION,
         &SCANINPUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
         &SCANINPUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES,
         &SCANINPUT_MEMBER_CONSISTENT_READ,
     ],
 );
 impl ScanInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SCANINPUT_SCHEMA;
-458
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ScanInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]

@@ -479,479 +712,695 @@

↥ Expand context

                 },
             )?;
-481
+        }
         if let Some(ref val) = self.limit {
             ser.write_integer(&SCANINPUT_MEMBER_LIMIT, *val)?;
-484
+        }
         if let Some(ref val) = self.select {
             ser.write_string(&SCANINPUT_MEMBER_SELECT, val.as_str())?;
-487
+        }
         if let Some(ref val) = self.scan_filter {
             ser.write_map(
                 &SCANINPUT_MEMBER_SCAN_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)?;
-495
+                    }
                     Ok(())
                 },
             )?;

-499
+        }
         if let Some(ref val) = self.conditional_operator {
             ser.write_string(&SCANINPUT_MEMBER_CONDITIONAL_OPERATOR, val.as_str())?;
-502
+        }
         if let Some(ref val) = self.exclusive_start_key {
             ser.write_map(
                 &SCANINPUT_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)?;
-510
+                    }
                     Ok(())
                 },
             )?;
-514
+        }
         if let Some(ref val) = self.return_consumed_capacity {
             ser.write_string(&SCANINPUT_MEMBER_RETURN_CONSUMED_CAPACITY, val.as_str())?;
-517
+        }
         if let Some(ref val) = self.total_segments {
             ser.write_integer(&SCANINPUT_MEMBER_TOTAL_SEGMENTS, *val)?;
-520
+        }
         if let Some(ref val) = self.segment {
             ser.write_integer(&SCANINPUT_MEMBER_SEGMENT, *val)?;
-523
+        }
         if let Some(ref val) = self.projection_expression {
             ser.write_string(&SCANINPUT_MEMBER_PROJECTION_EXPRESSION, val)?;
-526
+        }
         if let Some(ref val) = self.filter_expression {
             ser.write_string(&SCANINPUT_MEMBER_FILTER_EXPRESSION, val)?;
-529
+        }
         if let Some(ref val) = self.expression_attribute_names {
             ser.write_map(
                 &SCANINPUT_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)?;
-537
+                    }
                     Ok(())
                 },
             )?;
-541
+        }
         if let Some(ref val) = self.expression_attribute_values {
             ser.write_map(
                 &SCANINPUT_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)?;
-549
+                    }
                     Ok(())
                 },
             )?;
-553
+        }
         if let Some(ref val) = self.consistent_read {
             ser.write_boolean(&SCANINPUT_MEMBER_CONSISTENT_READ, *val)?;
-556
+        }
         Ok(())
-558
+    }
-559
+}
 impl ScanInput {
     /// 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(&SCANINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SCANINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_name = Some(deser.read_string(member)?);
-578
+                }
                 Some(1) => {
                     builder.index_name = Some(deser.read_string(member)?);
-581
+                }
                 Some(2) => {
                     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)?);
-584
+                }
                 Some(3) => {
                     builder.limit = Some(deser.read_integer(member)?);
-587
+                }
                 Some(4) => {
                     builder.select = Some(crate::types::Select::from(deser.read_string(member)?.as_str()));
-590
+                }
                 Some(5) => {
                     builder.scan_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
                     });
-600
+                }
                 Some(6) => {
                     builder.conditional_operator = Some(crate::types::ConditionalOperator::from(deser.read_string(member)?.as_str()));
-603
+                }
                 Some(7) => {
                     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
                     });
-613
+                }
                 Some(8) => {
                     builder.return_consumed_capacity = Some(crate::types::ReturnConsumedCapacity::from(deser.read_string(member)?.as_str()));
-616
+                }
                 Some(9) => {
                     builder.total_segments = Some(deser.read_integer(member)?);
-619
+                }
                 Some(10) => {
                     builder.segment = Some(deser.read_integer(member)?);
-622
+                }
                 Some(11) => {
                     builder.projection_expression = Some(deser.read_string(member)?);
-625
+                }
                 Some(12) => {
                     builder.filter_expression = Some(deser.read_string(member)?);
-628
+                }
                 Some(13) => {
                     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)?);
-631
+                }
                 Some(14) => {
                     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
                     });
-641
+                }
                 Some(15) => {
                     builder.consistent_read = Some(deser.read_boolean(member)?);
-644
+                }
                 _ => {}
-646
+            }
             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() })
-653
+    }
-654
+}
 impl ScanInput {
     /// 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 ScanInput {
     /// Creates a new builder-style object to manufacture [`ScanInput`](crate::operation::scan::ScanInput).
     pub fn builder() -> crate::operation::scan::builders::ScanInputBuilder {
         crate::operation::scan::builders::ScanInputBuilder::default()
-670
+    }
-671
+}
-672
 /// A builder for [`ScanInput`](crate::operation::scan::ScanInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ScanInputBuilder {
     pub(crate) table_name: ::std::option::Option<::std::string::String>,
     pub(crate) index_name: ::std::option::Option<::std::string::String>,
     pub(crate) attributes_to_get: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) limit: ::std::option::Option<i32>,
     pub(crate) select: ::std::option::Option<crate::types::Select>,
     pub(crate) scan_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) 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) total_segments: ::std::option::Option<i32>,
     pub(crate) segment: ::std::option::Option<i32>,
     pub(crate) projection_expression: ::std::option::Option<::std::string::String>,
     pub(crate) filter_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>>,
     pub(crate) consistent_read: ::std::option::Option<bool>,
-693
+}
 impl ScanInputBuilder {
     /// <p>The name of the table containing the requested items or if you provide <code>IndexName</code>, the name of the table to which that index belongs.</p>

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

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

↥ Expand context

         self.count
-36
+    }
     /// <p>The number of items evaluated, before any <code>ScanFilter</code> is applied. A high <code>ScannedCount</code> value with few, or no, <code>Count</code> results indicates an inefficient <code>Scan</code> operation. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#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>Scan</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 SCANOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#ScanOutput",

     "com.amazonaws.dynamodb.synthetic",
     "ScanOutput",
 );
 static SCANOUTPUT_MEMBER_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanOutput$Items",
         "com.amazonaws.dynamodb.synthetic",
         "ScanOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "items",
     "Items",
 ,
 );
 static SCANOUTPUT_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanOutput$Count",
         "com.amazonaws.dynamodb.synthetic",
         "ScanOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "count",
     "Count",
 ,
 );
 static SCANOUTPUT_MEMBER_SCANNED_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanOutput$ScannedCount",
         "com.amazonaws.dynamodb.synthetic",
         "ScanOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "scanned_count",
     "ScannedCount",
 ,
 );
 static SCANOUTPUT_MEMBER_LAST_EVALUATED_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanOutput$LastEvaluatedKey",
         "com.amazonaws.dynamodb.synthetic",
         "ScanOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "last_evaluated_key",
     "LastEvaluatedKey",
 ,
 );
 static SCANOUTPUT_MEMBER_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#ScanOutput$ConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "ScanOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "consumed_capacity",
     "ConsumedCapacity",
 ,
 );
 static SCANOUTPUT_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 SCANOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SCANOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SCANOUTPUT_MEMBER_ITEMS,
         &SCANOUTPUT_MEMBER_COUNT,
         &SCANOUTPUT_MEMBER_SCANNED_COUNT,
         &SCANOUTPUT_MEMBER_LAST_EVALUATED_KEY,
         &SCANOUTPUT_MEMBER_CONSUMED_CAPACITY,
         &SCANOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ScanOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SCANOUTPUT_SCHEMA;
-130
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ScanOutput {
     #[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(&SCANOUTPUT_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(&SCANOUTPUT_MEMBER_COUNT, *val)?;
-157
+        }
-158
+        {
             let val = &self.scanned_count;
             ser.write_integer(&SCANOUTPUT_MEMBER_SCANNED_COUNT, *val)?;
-161
+        }
         if let Some(ref val) = self.last_evaluated_key {
             ser.write_map(
                 &SCANOUTPUT_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(&SCANOUTPUT_MEMBER_CONSUMED_CAPACITY, val)?;
-176
+        }
         Ok(())
-178
+    }
-179
+}
 impl ScanOutput {
     /// 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(&SCANOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SCANOUTPUT_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 ScanOutput {
     /// 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(&SCANOUTPUT_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 ScanOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-314
+    }
-315
+}
 impl ScanOutput {
     /// Creates a new builder-style object to manufacture [`ScanOutput`](crate::operation::scan::ScanOutput).
     pub fn builder() -> crate::operation::scan::builders::ScanOutputBuilder {
         crate::operation::scan::builders::ScanOutputBuilder::default()
-320
+    }
-321
+}
-322
 /// A builder for [`ScanOutput`](crate::operation::scan::ScanOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ScanOutputBuilder {
     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/tag_resource.rs

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

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

@@ -115,119 +242,375 @@

↥ Expand context

         });
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     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("TagResource")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(TagResourceEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::tag_resource::TagResourceError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::tag_resource::TagResourceError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::tag_resource::TagResourceError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct TagResourceResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TagResourceResponseDeserializer {
     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_tag_resource::de_tag_resource_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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::LimitExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::LimitExceededException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceInUseException" => crate::operation::tag_resource::TagResourceError::ResourceInUseException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceInUseException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceInUseException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::tag_resource::TagResourceError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::tag_resource::TagResourceError::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_tag_resource::de_tag_resource_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, TagResource::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::tag_resource::TagResourceOutput::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))
-+
+        }
-324
+    }
-325
+}
 #[derive(Debug)]
 struct TagResourceRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TagResourceRequestSerializer {
     #[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::tag_resource::TagResourceInput>()
             .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::tag_resource::TagResourceInput,
                 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::tag_resource::TagResourceInput,
                 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.TagResource",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_tag_resource::ser_tag_resource_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, TagResource::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-346
+    }
-347
+}
 #[derive(Debug)]
 struct TagResourceEndpointParamsInterceptor;
-350
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TagResourceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TagResourceEndpointParamsInterceptor"
-354
+    }
-355

↧ 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::<TagResourceInput>()
             .ok_or("failed to downcast to TagResourceInput")?;
-370
         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/tag_resource/_tag_resource_input.rs

@@ -5,5 +150,160 @@

↥ Expand context

 pub struct TagResourceInput {
     /// <p>Identifies the Amazon DynamoDB resource to which tags should be added. This value is an Amazon Resource Name (ARN).</p>
     pub resource_arn: ::std::option::Option<::std::string::String>,
     /// <p>The tags to be assigned to the Amazon DynamoDB resource.</p>
     pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-10
+}
 impl TagResourceInput {
     /// <p>Identifies the Amazon DynamoDB resource to which tags should be added. This value is an Amazon Resource Name (ARN).</p>
     pub fn resource_arn(&self) -> ::std::option::Option<&str> {
         self.resource_arn.as_deref()
-15
+    }
     /// <p>The tags to be assigned to the Amazon DynamoDB resource.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-21
+    }
-22
+}
 static TAGRESOURCEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#TagResourceInput",

     "com.amazonaws.dynamodb.synthetic",
     "TagResourceInput",
 );
 static TAGRESOURCEINPUT_MEMBER_RESOURCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#TagResourceInput$ResourceArn",
         "com.amazonaws.dynamodb.synthetic",
         "TagResourceInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_arn",
     "ResourceArn",
 ,
 );
 static TAGRESOURCEINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#TagResourceInput$Tags",
         "com.amazonaws.dynamodb.synthetic",
         "TagResourceInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
 );
 static TAGRESOURCEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TAGRESOURCEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&TAGRESOURCEINPUT_MEMBER_RESOURCE_ARN, &TAGRESOURCEINPUT_MEMBER_TAGS],
 );
 impl TagResourceInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TAGRESOURCEINPUT_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TagResourceInput {
     #[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.resource_arn {
             ser.write_string(&TAGRESOURCEINPUT_MEMBER_RESOURCE_ARN, val)?;
-65
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &TAGRESOURCEINPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-72
+                    }
                     Ok(())
                 },
             )?;
-76
+        }
         Ok(())
-78
+    }
-79
+}
 impl TagResourceInput {
     /// 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(&TAGRESOURCEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TAGRESOURCEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_arn = Some(deser.read_string(member)?);
-98
+                }
                 Some(1) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-108
+                }
                 _ => {}
-110
+            }
             Ok(())
         })?;
         builder.resource_arn = builder.resource_arn.or(Some(String::new()));
         builder.tags = builder.tags.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-118
+    }
-119
+}
 impl TagResourceInput {
     /// 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 TagResourceInput {
     /// Creates a new builder-style object to manufacture [`TagResourceInput`](crate::operation::tag_resource::TagResourceInput).
     pub fn builder() -> crate::operation::tag_resource::builders::TagResourceInputBuilder {
         crate::operation::tag_resource::builders::TagResourceInputBuilder::default()
-135
+    }
-136
+}
-137
 /// A builder for [`TagResourceInput`](crate::operation::tag_resource::TagResourceInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct TagResourceInputBuilder {
     pub(crate) resource_arn: ::std::option::Option<::std::string::String>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-144
+}
 impl TagResourceInputBuilder {
     /// <p>Identifies the Amazon DynamoDB resource to which tags should be added. This value is an Amazon Resource Name (ARN).</p>
     /// This field is required.
     pub fn resource_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.resource_arn = ::std::option::Option::Some(input.into());
         self
-151
+    }
     /// <p>Identifies the Amazon DynamoDB resource to which tags should be added. This value is an Amazon Resource Name (ARN).</p>
     pub fn set_resource_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.resource_arn = input;
         self
-156
+    }
     /// <p>Identifies the Amazon DynamoDB resource to which tags should be added. This value is an Amazon Resource Name (ARN).</p>
     pub fn get_resource_arn(&self) -> &::std::option::Option<::std::string::String> {
         &self.resource_arn
-160
+    }

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

@@ -1,1 +80,111 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct TagResourceOutput {
     _request_id: Option<String>,
-7
+}
 static TAGRESOURCEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#TagResourceOutput",
     "com.amazonaws.dynamodb.synthetic",
     "TagResourceOutput",
 );
 static TAGRESOURCEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(TAGRESOURCEOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static TAGRESOURCEOUTPUT_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 TAGRESOURCEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TAGRESOURCEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&TAGRESOURCEOUTPUT_MEMBER__REQUEST_ID],
 );
 impl TagResourceOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TAGRESOURCEOUTPUT_SCHEMA;
-28
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TagResourceOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-36
+    }
-37
+}
 impl TagResourceOutput {
     /// 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(&TAGRESOURCEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TAGRESOURCEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-58
+            }
             Ok(())
         })?;
         Ok(builder.build())
-62
+    }
-63
+}
 impl TagResourceOutput {
     /// 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());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for TagResourceOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-85
+    }
-86
+}
 impl TagResourceOutput {
     /// Creates a new builder-style object to manufacture [`TagResourceOutput`](crate::operation::tag_resource::TagResourceOutput).
     pub fn builder() -> crate::operation::tag_resource::builders::TagResourceOutputBuilder {
         crate::operation::tag_resource::builders::TagResourceOutputBuilder::default()
-91
+    }

↧ Expand context

-92
+}
-93
 /// A builder for [`TagResourceOutput`](crate::operation::tag_resource::TagResourceOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct TagResourceOutputBuilder {
     _request_id: Option<String>,
-99
+}
 impl TagResourceOutputBuilder {
     pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         self._request_id = Some(request_id.into());
         self
-104
+    }
-105
     pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         self._request_id = request_id;
         self
-109
+    }
     /// Consumes the builder and constructs a [`TagResourceOutput`](crate::operation::tag_resource::TagResourceOutput).
     pub fn build(self) -> crate::operation::tag_resource::TagResourceOutput {

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

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

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

@@ -118,122 +245,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("TransactGetItems")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(TransactGetItemsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::transact_get_items::TransactGetItemsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::transact_get_items::TransactGetItemsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::transact_get_items::TransactGetItemsError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct TransactGetItemsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TransactGetItemsResponseDeserializer {
     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_transact_get_items::de_transact_get_items_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::transact_get_items::TransactGetItemsError::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::transact_get_items::TransactGetItemsError::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::transact_get_items::TransactGetItemsError::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
                 }),
                 "ProvisionedThroughputExceededException" => {
                     crate::operation::transact_get_items::TransactGetItemsError::ProvisionedThroughputExceededException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::ProvisionedThroughputExceededException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::ProvisionedThroughputExceededException::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
                     })
-+
+                }
                 "RequestLimitExceeded" => crate::operation::transact_get_items::TransactGetItemsError::RequestLimitExceeded({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestLimitExceeded::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestLimitExceeded::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
                 }),
                 "ResourceNotFoundException" => crate::operation::transact_get_items::TransactGetItemsError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ThrottlingException" => crate::operation::transact_get_items::TransactGetItemsError::ThrottlingException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ThrottlingException::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
                 }),
                 "TransactionCanceledException" => crate::operation::transact_get_items::TransactGetItemsError::TransactionCanceledException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::TransactionCanceledException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::TransactionCanceledException::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::transact_get_items::TransactGetItemsError::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_transact_get_items::de_transact_get_items_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, TransactGetItems::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::transact_get_items::TransactGetItemsOutput::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 TransactGetItemsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TransactGetItemsRequestSerializer {
     #[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::transact_get_items::TransactGetItemsInput>()
             .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::transact_get_items::TransactGetItemsInput,
                 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::transact_get_items::TransactGetItemsInput,
                 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.TransactGetItems",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_transact_get_items::ser_transact_get_items_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, TransactGetItems::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-403
+    }
-404
+}
 #[derive(Debug)]
 struct TransactGetItemsEndpointParamsInterceptor;
-407
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TransactGetItemsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TransactGetItemsEndpointParamsInterceptor"
-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::<TransactGetItemsInput>()
             .ok_or("failed to downcast to TransactGetItemsInput")?;
-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()))

1 1	`// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2	`#[allow(missing_docs)] // documentation missing in model`

AWS SDK

Files changed: