Client Test

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/query/_query_output.rs

@@ -34,34 +249,271 @@

         self.count
-35
+    }
     /// <p>The number of items evaluated, before any <code>QueryFilter</code> is applied. A high <code>ScannedCount</code> value with few, or no, <code>Count</code> results indicates an inefficient <code>Query</code> operation. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/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
-40
+    }
     /// <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()
-46
+    }
     /// <p>The capacity units consumed by the <code>Query</code> operation. The data returned includes the total provisioned throughput consumed, along with statistics for the table and any indexes involved in the operation. <code>ConsumedCapacity</code> is only returned if the <code>ReturnConsumedCapacity</code> parameter was specified. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Provisioned Throughput</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()
-50
+    }
-51
+}
 static QUERYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#QueryOutput",

     "com.amazonaws.dynamodb.synthetic",
     "QueryOutput",
 );
 static QUERYOUTPUT_MEMBER_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryOutput$Items",
         "com.amazonaws.dynamodb.synthetic",
         "QueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "items",
     "Items",
 ,
 );
 static QUERYOUTPUT_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryOutput$Count",
         "com.amazonaws.dynamodb.synthetic",
         "QueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "count",
     "Count",
 ,
 );
 static QUERYOUTPUT_MEMBER_SCANNED_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryOutput$ScannedCount",
         "com.amazonaws.dynamodb.synthetic",
         "QueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "scanned_count",
     "ScannedCount",
 ,
 );
 static QUERYOUTPUT_MEMBER_LAST_EVALUATED_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryOutput$LastEvaluatedKey",
         "com.amazonaws.dynamodb.synthetic",
         "QueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "last_evaluated_key",
     "LastEvaluatedKey",
 ,
 );
 static QUERYOUTPUT_MEMBER_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#QueryOutput$ConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "QueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "consumed_capacity",
     "ConsumedCapacity",
 ,
 );
 static QUERYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     QUERYOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &QUERYOUTPUT_MEMBER_ITEMS,
         &QUERYOUTPUT_MEMBER_COUNT,
         &QUERYOUTPUT_MEMBER_SCANNED_COUNT,
         &QUERYOUTPUT_MEMBER_LAST_EVALUATED_KEY,
         &QUERYOUTPUT_MEMBER_CONSUMED_CAPACITY,
     ],
 );
 impl QueryOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYOUTPUT_SCHEMA;
-121
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for QueryOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.items {
             ser.write_list(&QUERYOUTPUT_MEMBER_ITEMS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for item in val {
                     todo!("schema: unsupported list element type");
                     ser.write_map(
                         &::aws_smithy_schema::prelude::DOCUMENT,
                         &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                             for (key, value) in item {
                                 ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                                 ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-+
+                            }
                             Ok(())
                         },
                     )?;
-141
+                }
                 Ok(())
             })?;
-144
+        }
-145
+        {
             let val = &self.count;
             ser.write_integer(&QUERYOUTPUT_MEMBER_COUNT, *val)?;
-148
+        }
-149
+        {
             let val = &self.scanned_count;
             ser.write_integer(&QUERYOUTPUT_MEMBER_SCANNED_COUNT, *val)?;
-152
+        }
         if let Some(ref val) = self.last_evaluated_key {
             ser.write_map(
                 &QUERYOUTPUT_MEMBER_LAST_EVALUATED_KEY,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
                         ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-160
+                    }
                     Ok(())
                 },
             )?;
-164
+        }
         if let Some(ref val) = self.consumed_capacity {
             ser.write_struct(&QUERYOUTPUT_MEMBER_CONSUMED_CAPACITY, val)?;
-167
+        }
         Ok(())
-169
+    }
-170
+}
 impl QueryOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&QUERYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&QUERYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.items = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push({
                                 let mut map = ::std::collections::HashMap::new();
                                 deser.read_map(member, &mut |key, deser| {
                                     let value = crate::types::AttributeValue::deserialize(deser)?;
                                     map.insert(key, value);
                                     Ok(())
                                 })?;
                                 map
                             });
                             Ok(())
                         })?;
                         container
                     });
-204
+                }
                 Some(1) => {
                     builder.count = Some(deser.read_integer(member)?);
-207
+                }
                 Some(2) => {
                     builder.scanned_count = Some(deser.read_integer(member)?);
-210
+                }
                 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
                     });
-220
+                }
                 Some(4) => {
                     builder.consumed_capacity = Some(crate::types::ConsumedCapacity::deserialize(deser)?);
-223
+                }
                 _ => {}
-225
+            }
             Ok(())
         })?;
         Ok(builder.build())
-229
+    }
-230
+}
 impl QueryOutput {
     /// 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 QueryOutput {
     /// Creates a new builder-style object to manufacture [`QueryOutput`](crate::operation::query::QueryOutput).
     pub fn builder() -> crate::operation::query::builders::QueryOutputBuilder {
         crate::operation::query::builders::QueryOutputBuilder::default()
-246
+    }
-247
+}
-248
 /// A builder for [`QueryOutput`](crate::operation::query::QueryOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct QueryOutputBuilder {
     pub(crate) items: ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>>,
     pub(crate) count: ::std::option::Option<i32>,
     pub(crate) scanned_count: ::std::option::Option<i32>,
     pub(crate) last_evaluated_key: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
     pub(crate) consumed_capacity: ::std::option::Option<crate::types::ConsumedCapacity>,
-258
+}
 impl QueryOutputBuilder {
     /// Appends an item to `items`.
     ///
     /// To override the contents of this collection use [`set_items`](Self::set_items).
     ///
     /// <p>An array of item attributes that match the query criteria. Each element in this array consists of an attribute name and the value for that attribute.</p>
     pub fn items(mut self, input: ::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>) -> Self {
         let mut v = self.items.unwrap_or_default();
         v.push(input);
         self.items = ::std::option::Option::Some(v);
         self
-270
+    }
     /// <p>An array of item attributes that match the query criteria. Each element in this array consists of an attribute name and the value for that attribute.</p>

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/restore_table_from_backup.rs

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

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

↧ Expand context

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

@@ -107,111 +233,416 @@

↥ Expand context

         ));
-112
         ::std::option::Option::Some(cfg.freeze())
-114
+    }
-115
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("RestoreTableFromBackup")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(RestoreTableFromBackupEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::restore_table_from_backup::RestoreTableFromBackupError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::restore_table_from_backup::RestoreTableFromBackupError,
             >::new());
-130

         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct RestoreTableFromBackupResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RestoreTableFromBackupResponseDeserializer {
     fn deserialize_nonstreaming(
         &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());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_restore_table_from_backup::de_restore_table_from_backup_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_restore_table_from_backup::de_restore_table_from_backup_http_response(status, headers, body)
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::restore_table_from_backup::RestoreTableFromBackupError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
         crate::protocol_serde::type_erase_result(parse_result)
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "BackupInUseException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::BackupInUseError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::BackupInUseError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::BackupInUseError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "BackupNotFoundException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::BackupNotFoundError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::BackupNotFoundError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::BackupNotFoundError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InternalServerError" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::InternalServerError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidEndpointException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::InvalidEndpointError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidEndpointError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidEndpointError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "LimitExceededException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::LimitExceededError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::LimitExceededError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::LimitExceededError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "TableAlreadyExistsException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::TableAlreadyExistsError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::TableAlreadyExistsError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::TableAlreadyExistsError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "TableInUseException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::TableInUseError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::TableInUseError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::TableInUseError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, RestoreTableFromBackup::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::restore_table_from_backup::RestoreTableFromBackupOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-365
+    }
-366
+}
 #[derive(Debug)]
 struct RestoreTableFromBackupRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RestoreTableFromBackupRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::restore_table_from_backup::RestoreTableFromBackupInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::restore_table_from_backup::RestoreTableFromBackupInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::restore_table_from_backup::RestoreTableFromBackupInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.RestoreTableFromBackup",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_restore_table_from_backup::ser_restore_table_from_backup_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, RestoreTableFromBackup::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-387
+    }
-388
+}
 #[derive(Debug)]
 struct RestoreTableFromBackupEndpointParamsInterceptor;
-391
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RestoreTableFromBackupEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RestoreTableFromBackupEndpointParamsInterceptor"
-395
+    }
-396

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<RestoreTableFromBackupInput>()
             .ok_or("failed to downcast to RestoreTableFromBackupInput")?;
-411
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/restore_table_from_backup/_restore_table_from_backup_input.rs

@@ -37,37 +157,157 @@

↥ Expand context

     pub fn global_secondary_index_override(&self) -> &[crate::types::GlobalSecondaryIndex] {
         self.global_secondary_index_override.as_deref().unwrap_or_default()
-39
+    }
     /// <p>List of local secondary indexes for the restored table. The indexes provided should match existing secondary indexes. You can choose to exclude some or all of the indexes at the time of restore.</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 `.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()
-45
+    }
     /// <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()
-49
+    }
     /// <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()
-53
+    }
-54
+}
 static RESTORETABLEFROMBACKUPINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupInput",

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

↧ Expand context

         &RESTORETABLEFROMBACKUPINPUT_MEMBER_LOCAL_SECONDARY_INDEX_OVERRIDE,
         &RESTORETABLEFROMBACKUPINPUT_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE,
         &RESTORETABLEFROMBACKUPINPUT_MEMBER_SSE_SPECIFICATION_OVERRIDE,
     ],
 );
 impl RestoreTableFromBackupInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTORETABLEFROMBACKUPINPUT_SCHEMA;
-146
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RestoreTableFromBackupInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.target_table_name {
             ser.write_string(&RESTORETABLEFROMBACKUPINPUT_MEMBER_TARGET_TABLE_NAME, val)?;
-155
+        }
         if let Some(ref val) = self.backup_arn {
             ser.write_string(&RESTORETABLEFROMBACKUPINPUT_MEMBER_BACKUP_ARN, val)?;

@@ -165,165 +288,295 @@

↥ Expand context

                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::GlobalSecondaryIndex::SCHEMA, item)?;
-168
+                    }
                     Ok(())
                 },
             )?;
-172
+        }
         if let Some(ref val) = self.local_secondary_index_override {
             ser.write_list(
                 &RESTORETABLEFROMBACKUPINPUT_MEMBER_LOCAL_SECONDARY_INDEX_OVERRIDE,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::LocalSecondaryIndex::SCHEMA, item)?;
-179
+                    }
                     Ok(())
                 },
             )?;
-183
+        }
         if let Some(ref val) = self.provisioned_throughput_override {

             ser.write_struct(&RESTORETABLEFROMBACKUPINPUT_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE, val)?;
-186
+        }
         if let Some(ref val) = self.sse_specification_override {
             ser.write_struct(&RESTORETABLEFROMBACKUPINPUT_MEMBER_SSE_SPECIFICATION_OVERRIDE, val)?;
-189
+        }
         Ok(())
-191
+    }
-192
+}
 impl RestoreTableFromBackupInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RESTORETABLEFROMBACKUPINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESTORETABLEFROMBACKUPINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.target_table_name = Some(deser.read_string(member)?);
-211
+                }
                 Some(1) => {
                     builder.backup_arn = Some(deser.read_string(member)?);
-214
+                }
                 Some(2) => {
                     builder.billing_mode_override = Some(crate::types::BillingMode::from(deser.read_string(member)?.as_str()));
-217
+                }
                 Some(3) => {
                     builder.global_secondary_index_override = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::GlobalSecondaryIndex::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GlobalSecondaryIndex::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-227
+                }
                 Some(4) => {
                     builder.local_secondary_index_override = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::LocalSecondaryIndex::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::LocalSecondaryIndex::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-237
+                }
                 Some(5) => {
                     builder.provisioned_throughput_override = Some(crate::types::ProvisionedThroughput::deserialize(deser)?);
-240
+                }
                 Some(6) => {
                     builder.sse_specification_override = Some(crate::types::SseSpecification::deserialize(deser)?);
-243
+                }
                 _ => {}
-245
+            }
             Ok(())
         })?;
         builder.target_table_name = builder.target_table_name.or(Some(String::new()));
         builder.backup_arn = builder.backup_arn.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-253
+    }
-254
+}
 impl RestoreTableFromBackupInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RestoreTableFromBackupInput {
     /// Creates a new builder-style object to manufacture [`RestoreTableFromBackupInput`](crate::operation::restore_table_from_backup::RestoreTableFromBackupInput).
     pub fn builder() -> crate::operation::restore_table_from_backup::builders::RestoreTableFromBackupInputBuilder {
         crate::operation::restore_table_from_backup::builders::RestoreTableFromBackupInputBuilder::default()
-270
+    }
-271
+}
-272
 /// A builder for [`RestoreTableFromBackupInput`](crate::operation::restore_table_from_backup::RestoreTableFromBackupInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/restore_table_from_backup/_restore_table_from_backup_output.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct RestoreTableFromBackupOutput {
     /// <p>The description of the table created from an existing backup.</p>
     pub table_description: ::std::option::Option<crate::types::TableDescription>,
-8
+}
 impl RestoreTableFromBackupOutput {
     /// <p>The description of the table created from an existing backup.</p>
     pub fn table_description(&self) -> ::std::option::Option<&crate::types::TableDescription> {
         self.table_description.as_ref()
-13
+    }
-14
+}
 static RESTORETABLEFROMBACKUPOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupOutput",

     "com.amazonaws.dynamodb.synthetic",
     "RestoreTableFromBackupOutput",
 );
 static RESTORETABLEFROMBACKUPOUTPUT_MEMBER_TABLE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#RestoreTableFromBackupOutput$TableDescription",
         "com.amazonaws.dynamodb.synthetic",
         "RestoreTableFromBackupOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "table_description",
     "TableDescription",
 ,
 );
 static RESTORETABLEFROMBACKUPOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESTORETABLEFROMBACKUPOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&RESTORETABLEFROMBACKUPOUTPUT_MEMBER_TABLE_DESCRIPTION],
 );
 impl RestoreTableFromBackupOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTORETABLEFROMBACKUPOUTPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RestoreTableFromBackupOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.table_description {
             ser.write_struct(&RESTORETABLEFROMBACKUPOUTPUT_MEMBER_TABLE_DESCRIPTION, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl RestoreTableFromBackupOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RESTORETABLEFROMBACKUPOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESTORETABLEFROMBACKUPOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_description = Some(crate::types::TableDescription::deserialize(deser)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl RestoreTableFromBackupOutput {
     /// 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 RestoreTableFromBackupOutput {
     /// Creates a new builder-style object to manufacture [`RestoreTableFromBackupOutput`](crate::operation::restore_table_from_backup::RestoreTableFromBackupOutput).
     pub fn builder() -> crate::operation::restore_table_from_backup::builders::RestoreTableFromBackupOutputBuilder {
         crate::operation::restore_table_from_backup::builders::RestoreTableFromBackupOutputBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`RestoreTableFromBackupOutput`](crate::operation::restore_table_from_backup::RestoreTableFromBackupOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RestoreTableFromBackupOutputBuilder {
     pub(crate) table_description: ::std::option::Option<crate::types::TableDescription>,
-100
+}
 impl RestoreTableFromBackupOutputBuilder {
     /// <p>The description of the table created from an existing backup.</p>
     pub fn table_description(mut self, input: crate::types::TableDescription) -> Self {
         self.table_description = ::std::option::Option::Some(input);
         self
-106
+    }
     /// <p>The description of the table created from an existing backup.</p>
     pub fn set_table_description(mut self, input: ::std::option::Option<crate::types::TableDescription>) -> Self {
         self.table_description = input;
         self
-111
+    }
     /// <p>The description of the table created from an existing backup.</p>
     pub fn get_table_description(&self) -> &::std::option::Option<crate::types::TableDescription> {
         &self.table_description
-115
+    }
     /// Consumes the builder and constructs a [`RestoreTableFromBackupOutput`](crate::operation::restore_table_from_backup::RestoreTableFromBackupOutput).
     pub fn build(self) -> crate::operation::restore_table_from_backup::RestoreTableFromBackupOutput {

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/restore_table_to_point_in_time.rs

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

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

↧ Expand context

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

@@ -113,119 +239,456 @@

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

         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct RestoreTableToPointInTimeResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RestoreTableToPointInTimeResponseDeserializer {
     fn deserialize_nonstreaming(
         &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());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-162
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_restore_table_to_point_in_time::de_restore_table_to_point_in_time_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_restore_table_to_point_in_time::de_restore_table_to_point_in_time_http_response(status, headers, body)
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
         crate::protocol_serde::type_erase_result(parse_result)
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InternalServerError" => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::InternalServerError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidEndpointException" => {
                     crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::InvalidEndpointError({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidEndpointError::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidEndpointError::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "InvalidRestoreTimeException" => {
                     crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::InvalidRestoreTimeError({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidRestoreTimeError::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidRestoreTimeError::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "LimitExceededException" => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::LimitExceededError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::LimitExceededError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::LimitExceededError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "PointInTimeRecoveryUnavailableException" => {
                     crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::PointInTimeRecoveryUnavailableError({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::PointInTimeRecoveryUnavailableError::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::PointInTimeRecoveryUnavailableError::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "TableAlreadyExistsException" => {
                     crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::TableAlreadyExistsError({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::TableAlreadyExistsError::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::TableAlreadyExistsError::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "TableInUseException" => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::TableInUseError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::TableInUseError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::TableInUseError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "TableNotFoundException" => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::TableNotFoundError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::TableNotFoundError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::TableNotFoundError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, RestoreTableToPointInTime::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-405
+    }
-406
+}
 #[derive(Debug)]
 struct RestoreTableToPointInTimeRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RestoreTableToPointInTimeRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.RestoreTableToPointInTime",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_restore_table_to_point_in_time::ser_restore_table_to_point_in_time_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, RestoreTableToPointInTime::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-427
+    }
-428
+}
 #[derive(Debug)]
 struct RestoreTableToPointInTimeEndpointParamsInterceptor;
-431
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RestoreTableToPointInTimeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RestoreTableToPointInTimeEndpointParamsInterceptor"
-435
+    }
-436

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<RestoreTableToPointInTimeInput>()
             .ok_or("failed to downcast to RestoreTableToPointInTimeInput")?;
-451
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/restore_table_to_point_in_time/_restore_table_to_point_in_time_input.rs

@@ -55,55 +205,205 @@

↥ Expand context

     pub fn global_secondary_index_override(&self) -> &[crate::types::GlobalSecondaryIndex] {
         self.global_secondary_index_override.as_deref().unwrap_or_default()
-57
+    }
     /// <p>List of local secondary indexes for the restored table. The indexes provided should match existing secondary indexes. You can choose to exclude some or all of the indexes at the time of restore.</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 `.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()
-63
+    }
     /// <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()
-67
+    }
     /// <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()
-71
+    }
-72
+}
 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_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_SSE_SPECIFICATION_OVERRIDE,
     ],
 );
 impl RestoreTableToPointInTimeInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTORETABLETOPOINTINTIMEINPUT_SCHEMA;
-197
+}
 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 {
             ser.write_string(&RESTORETABLETOPOINTINTIMEINPUT_MEMBER_SOURCE_TABLE_ARN, val)?;

@@ -225,225 +357,363 @@

↥ Expand context

                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::GlobalSecondaryIndex::SCHEMA, item)?;
-228
+                    }
                     Ok(())
                 },
             )?;
-232
+        }
         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)?;
-239
+                    }
                     Ok(())
                 },
             )?;
-243
+        }
         if let Some(ref val) = self.provisioned_throughput_override {

             ser.write_struct(&RESTORETABLETOPOINTINTIMEINPUT_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE, val)?;
-246
+        }
         if let Some(ref val) = self.sse_specification_override {
             ser.write_struct(&RESTORETABLETOPOINTINTIMEINPUT_MEMBER_SSE_SPECIFICATION_OVERRIDE, val)?;
-249
+        }
         Ok(())
-251
+    }
-252
+}
 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)?);
-271
+                }
                 Some(1) => {
                     builder.source_table_name = Some(deser.read_string(member)?);
-274
+                }
                 Some(2) => {
                     builder.target_table_name = Some(deser.read_string(member)?);
-277
+                }
                 Some(3) => {
                     builder.use_latest_restorable_time = Some(deser.read_boolean(member)?);
-280
+                }
                 Some(4) => {
                     builder.restore_date_time = Some(deser.read_timestamp(member)?);
-283
+                }
                 Some(5) => {
                     builder.billing_mode_override = Some(crate::types::BillingMode::from(deser.read_string(member)?.as_str()));
-286
+                }
                 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
                     });
-296
+                }
                 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
                     });
-306
+                }
                 Some(8) => {
                     builder.provisioned_throughput_override = Some(crate::types::ProvisionedThroughput::deserialize(deser)?);
-309
+                }
                 Some(9) => {
                     builder.sse_specification_override = Some(crate::types::SseSpecification::deserialize(deser)?);
-312
+                }
                 _ => {}
-314
+            }
             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() })
-321
+    }
-322
+}
 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()
-338
+    }
-339
+}
-340
 /// 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) sse_specification_override: ::std::option::Option<crate::types::SseSpecification>,
-355
+}
 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
-361
+    }
     /// <p>The DynamoDB table that will be restored. This value is an Amazon Resource Name (ARN).</p>
     pub fn set_source_table_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/restore_table_to_point_in_time/_restore_table_to_point_in_time_output.rs

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

↥ 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>,
-8
+}
 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()
-13
+    }
-14
+}
 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_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESTORETABLETOPOINTINTIMEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&RESTORETABLETOPOINTINTIMEOUTPUT_MEMBER_TABLE_DESCRIPTION],
 );
 impl RestoreTableToPointInTimeOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTORETABLETOPOINTINTIMEOUTPUT_SCHEMA;
-38
+}
 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)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 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)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl RestoreTableToPointInTimeOutput {
     /// 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 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()
-92
+    }
-93
+}
-94
 /// 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]

↧ Expand context

 pub struct RestoreTableToPointInTimeOutputBuilder {
     pub(crate) table_description: ::std::option::Option<crate::types::TableDescription>,
-100
+}
 impl RestoreTableToPointInTimeOutputBuilder {
     /// <p>Represents the properties of a table.</p>
     pub fn table_description(mut self, input: crate::types::TableDescription) -> Self {
         self.table_description = ::std::option::Option::Some(input);
         self
-106
+    }
     /// <p>Represents the properties of a table.</p>
     pub fn set_table_description(mut self, input: ::std::option::Option<crate::types::TableDescription>) -> Self {
         self.table_description = input;
         self
-111
+    }
     /// <p>Represents the properties of a table.</p>
     pub fn get_table_description(&self) -> &::std::option::Option<crate::types::TableDescription> {
         &self.table_description
-115
+    }
     /// Consumes the builder and constructs a [`RestoreTableToPointInTimeOutput`](crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeOutput).
     pub fn build(self) -> crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeOutput {

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/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,

@@ -95,99 +217,348 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("Scan", "DynamoDB"));
-100
         ::std::option::Option::Some(cfg.freeze())
-102
+    }
-103
     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());
-118

         ::std::borrow::Cow::Owned(rcb)
-120
+    }
-121
+}
-122
 #[derive(Debug)]
 struct ScanResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ScanResponseDeserializer {
     fn deserialize_nonstreaming(
         &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());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-142
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_scan::de_scan_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_scan::de_scan_http_response(status, headers, body)
             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)),
                     ))
-+
+                }
             };
         crate::protocol_serde::type_erase_result(parse_result)
             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::InvalidEndpointError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidEndpointError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidEndpointError::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::ProvisionedThroughputExceededError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ProvisionedThroughputExceededError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ProvisionedThroughputExceededError::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::ResourceNotFoundError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundError::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 {
             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))
-+
+        }
-299
+    }
-300
+}
 #[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);
-319
+    }
-320
+}
 #[derive(Debug)]
 struct ScanEndpointParamsInterceptor;
-323
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ScanEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ScanEndpointParamsInterceptor"
-327
+    }
-328

↧ 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")?;
-340
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-347
+    }
-348
+}

Client Test

Files changed: