AWS SDK

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

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

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

@@ -114,118 +236,487 @@

↥ Expand context

-118
+    }
-119
     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("PutItem")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutItemEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_item::PutItemError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_item::PutItemError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::put_item::PutItemError,
             >::new());
-137

         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct PutItemResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutItemResponseDeserializer {
     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());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_put_item::de_put_item_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::put_item::PutItemError::unhandled(generic)),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "ConditionalCheckFailedException" => crate::operation::put_item::PutItemError::ConditionalCheckFailedException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ConditionalCheckFailedException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ConditionalCheckFailedException::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::put_item::PutItemError::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::put_item::PutItemError::InvalidEndpointException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidEndpointException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidEndpointException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ItemCollectionSizeLimitExceededException" => crate::operation::put_item::PutItemError::ItemCollectionSizeLimitExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ItemCollectionSizeLimitExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ItemCollectionSizeLimitExceededException::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::put_item::PutItemError::ProvisionedThroughputExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ProvisionedThroughputExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ProvisionedThroughputExceededException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ReplicatedWriteConflictException" => crate::operation::put_item::PutItemError::ReplicatedWriteConflictException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ReplicatedWriteConflictException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ReplicatedWriteConflictException::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::put_item::PutItemError::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::put_item::PutItemError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ThrottlingException" => crate::operation::put_item::PutItemError::ThrottlingException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ThrottlingException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "TransactionConflictException" => crate::operation::put_item::PutItemError::TransactionConflictException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::TransactionConflictException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::TransactionConflictException::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::put_item::PutItemError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_put_item::de_put_item_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, PutItem::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::put_item::PutItemOutput::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))
-+
+        }
-438
+    }
-439
+}
 #[derive(Debug)]
 struct PutItemRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutItemRequestSerializer {
     #[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::put_item::PutItemInput>().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::put_item::PutItemInput,
                 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::put_item::PutItemInput,
                 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.PutItem",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_item::ser_put_item_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, PutItem::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-458
+    }
-459
+}
 #[derive(Debug)]
 struct PutItemEndpointParamsInterceptor;
-462
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutItemEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutItemEndpointParamsInterceptor"
-466
+    }
-467

↧ 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::<PutItemInput>()
             .ok_or("failed to downcast to PutItemInput")?;
-482
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

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

@@ -198,198 +557,551 @@

↥ Expand context

     /// <p>Use the <b>:</b> (colon) character in an expression to dereference an attribute value. For example, suppose that you wanted to check whether the value of the <i>ProductStatus</i> attribute was one of the following:</p>
     /// <p><code>Available | Backordered | Discontinued</code></p>
     /// <p>You would first need to specify <code>ExpressionAttributeValues</code> as follows:</p>
     /// <p><code>{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }</code></p>
     /// <p>You could then use these values in an expression, such as this:</p>
     /// <p><code>ProductStatus IN (:avail, :back, :disc)</code></p>
     /// <p>For more information on expression attribute values, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html">Condition Expressions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     pub fn expression_attribute_values(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {
         self.expression_attribute_values.as_ref()
-209
+    }
     /// <p>An optional parameter that returns the item attributes for a <code>PutItem</code> operation that failed a condition check.</p>
     /// <p>There is no additional cost associated with requesting a return value aside from the small network and processing overhead of receiving a larger response. No read capacity units are consumed.</p>
     pub fn return_values_on_condition_check_failure(&self) -> ::std::option::Option<&crate::types::ReturnValuesOnConditionCheckFailure> {
         self.return_values_on_condition_check_failure.as_ref()
-214
+    }
-215
+}
 static PUTITEMINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#PutItemInput",

     "com.amazonaws.dynamodb.synthetic",
     "PutItemInput",
 );
 static PUTITEMINPUT_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$TableName",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_name",
     "TableName",
 ,
 );
 static PUTITEMINPUT_MEMBER_ITEM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$Item",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "item",
     "Item",
 ,
 );
 static PUTITEMINPUT_MEMBER_EXPECTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$Expected",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expected",
     "Expected",
 ,
 );
 static PUTITEMINPUT_MEMBER_RETURN_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$ReturnValues",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_values",
     "ReturnValues",
 ,
 );
 static PUTITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$ReturnConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_consumed_capacity",
     "ReturnConsumedCapacity",
 ,
 );
 static PUTITEMINPUT_MEMBER_RETURN_ITEM_COLLECTION_METRICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$ReturnItemCollectionMetrics",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_item_collection_metrics",
     "ReturnItemCollectionMetrics",
 ,
 );
 static PUTITEMINPUT_MEMBER_CONDITIONAL_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$ConditionalOperator",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "conditional_operator",
     "ConditionalOperator",
 ,
 );
 static PUTITEMINPUT_MEMBER_CONDITION_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$ConditionExpression",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "condition_expression",
     "ConditionExpression",
 ,
 );
 static PUTITEMINPUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$ExpressionAttributeNames",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expression_attribute_names",
     "ExpressionAttributeNames",
 ,
 );
 static PUTITEMINPUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$ExpressionAttributeValues",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expression_attribute_values",
     "ExpressionAttributeValues",
 ,
 );
 static PUTITEMINPUT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemInput$ReturnValuesOnConditionCheckFailure",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_values_on_condition_check_failure",
     "ReturnValuesOnConditionCheckFailure",
 ,
 );
 static PUTITEMINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTITEMINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTITEMINPUT_MEMBER_TABLE_NAME,
         &PUTITEMINPUT_MEMBER_ITEM,
         &PUTITEMINPUT_MEMBER_EXPECTED,
         &PUTITEMINPUT_MEMBER_RETURN_VALUES,
         &PUTITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY,
         &PUTITEMINPUT_MEMBER_RETURN_ITEM_COLLECTION_METRICS,
         &PUTITEMINPUT_MEMBER_CONDITIONAL_OPERATOR,
         &PUTITEMINPUT_MEMBER_CONDITION_EXPRESSION,
         &PUTITEMINPUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
         &PUTITEMINPUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES,
         &PUTITEMINPUT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE,
     ],
 );
 impl PutItemInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTITEMINPUT_SCHEMA;
-351
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutItemInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.table_name {
             ser.write_string(&PUTITEMINPUT_MEMBER_TABLE_NAME, val)?;
-360
+        }
         if let Some(ref val) = self.item {
             ser.write_map(&PUTITEMINPUT_MEMBER_ITEM, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for (key, value) in val {
                     ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                     todo!("schema: unsupported map value type");
                     ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-366
+                }
                 Ok(())
             })?;
-369
+        }
         if let Some(ref val) = self.expected {
             ser.write_map(
                 &PUTITEMINPUT_MEMBER_EXPECTED,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::ExpectedAttributeValue::SCHEMA, value)?;
-377
+                    }
                     Ok(())
                 },
             )?;
-381
+        }
         if let Some(ref val) = self.return_values {
             ser.write_string(&PUTITEMINPUT_MEMBER_RETURN_VALUES, val.as_str())?;
-384
+        }
         if let Some(ref val) = self.return_consumed_capacity {
             ser.write_string(&PUTITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY, val.as_str())?;
-387
+        }
         if let Some(ref val) = self.return_item_collection_metrics {
             ser.write_string(&PUTITEMINPUT_MEMBER_RETURN_ITEM_COLLECTION_METRICS, val.as_str())?;
-390
+        }
         if let Some(ref val) = self.conditional_operator {
             ser.write_string(&PUTITEMINPUT_MEMBER_CONDITIONAL_OPERATOR, val.as_str())?;
-393
+        }
         if let Some(ref val) = self.condition_expression {
             ser.write_string(&PUTITEMINPUT_MEMBER_CONDITION_EXPRESSION, val)?;
-396
+        }
         if let Some(ref val) = self.expression_attribute_names {
             ser.write_map(
                 &PUTITEMINPUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-404
+                    }
                     Ok(())
                 },
             )?;
-408
+        }
         if let Some(ref val) = self.expression_attribute_values {
             ser.write_map(
                 &PUTITEMINPUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
                         ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-416
+                    }
                     Ok(())
                 },
             )?;
-420
+        }
         if let Some(ref val) = self.return_values_on_condition_check_failure {
             ser.write_string(&PUTITEMINPUT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE, val.as_str())?;
-423
+        }
         Ok(())
-425
+    }
-426
+}
 impl PutItemInput {
     /// 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(&PUTITEMINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTITEMINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_name = Some(deser.read_string(member)?);
-445
+                }
                 Some(1) => {
                     builder.item = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-455
+                }
                 Some(2) => {
                     builder.expected = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, crate::types::ExpectedAttributeValue::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::ExpectedAttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-465
+                }
                 Some(3) => {
                     builder.return_values = Some(crate::types::ReturnValue::from(deser.read_string(member)?.as_str()));
-468
+                }
                 Some(4) => {
                     builder.return_consumed_capacity = Some(crate::types::ReturnConsumedCapacity::from(deser.read_string(member)?.as_str()));
-471
+                }
                 Some(5) => {
                     builder.return_item_collection_metrics =
                         Some(crate::types::ReturnItemCollectionMetrics::from(deser.read_string(member)?.as_str()));
-475
+                }
                 Some(6) => {
                     builder.conditional_operator = Some(crate::types::ConditionalOperator::from(deser.read_string(member)?.as_str()));
-478
+                }
                 Some(7) => {
                     builder.condition_expression = Some(deser.read_string(member)?);
-481
+                }
                 Some(8) => {
                     builder.expression_attribute_names = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.expression_attribute_names = Some(deser.read_string_string_map(member)?);
-484
+                }
                 Some(9) => {
                     builder.expression_attribute_values = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-494
+                }
                 Some(10) => {
                     builder.return_values_on_condition_check_failure = Some(crate::types::ReturnValuesOnConditionCheckFailure::from(
                         deser.read_string(member)?.as_str(),
                     ));
-499
+                }
                 _ => {}
-501
+            }
             Ok(())
         })?;
         builder.table_name = builder.table_name.or(Some(String::new()));
         builder.item = builder.item.or(Some(::std::collections::HashMap::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-509
+    }
-510
+}
 impl PutItemInput {
     /// 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 PutItemInput {
     /// Creates a new builder-style object to manufacture [`PutItemInput`](crate::operation::put_item::PutItemInput).
     pub fn builder() -> crate::operation::put_item::builders::PutItemInputBuilder {
         crate::operation::put_item::builders::PutItemInputBuilder::default()
-526
+    }
-527
+}
-528
 /// A builder for [`PutItemInput`](crate::operation::put_item::PutItemInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PutItemInputBuilder {
     pub(crate) table_name: ::std::option::Option<::std::string::String>,
     pub(crate) item: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
     pub(crate) expected: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::ExpectedAttributeValue>>,
     pub(crate) return_values: ::std::option::Option<crate::types::ReturnValue>,
     pub(crate) return_consumed_capacity: ::std::option::Option<crate::types::ReturnConsumedCapacity>,
     pub(crate) return_item_collection_metrics: ::std::option::Option<crate::types::ReturnItemCollectionMetrics>,
     pub(crate) conditional_operator: ::std::option::Option<crate::types::ConditionalOperator>,
     pub(crate) condition_expression: ::std::option::Option<::std::string::String>,
     pub(crate) expression_attribute_names: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) expression_attribute_values: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
     pub(crate) return_values_on_condition_check_failure: ::std::option::Option<crate::types::ReturnValuesOnConditionCheckFailure>,
-544
+}
 impl PutItemInputBuilder {
     /// <p>The name of the table to contain the item. You can also provide the Amazon Resource Name (ARN) of the table in this parameter.</p>
     /// This field is required.
     pub fn table_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.table_name = ::std::option::Option::Some(input.into());
         self
-551
+    }

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

@@ -27,27 +176,231 @@

↥ Expand context

-27
+    }
     /// <p>The capacity units consumed by the <code>PutItem</code> operation. The data returned includes the total provisioned throughput consumed, along with statistics for the table and any indexes involved in the operation. <code>ConsumedCapacity</code> is only returned if the <code>ReturnConsumedCapacity</code> parameter was specified. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/read-write-operations.html#write-operation-consumption">Capacity unity consumption for write operations</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     pub fn consumed_capacity(&self) -> ::std::option::Option<&crate::types::ConsumedCapacity> {
         self.consumed_capacity.as_ref()
-31
+    }
     /// <p>Information about item collections, if any, that were affected by the <code>PutItem</code> operation. <code>ItemCollectionMetrics</code> is only returned if the <code>ReturnItemCollectionMetrics</code> parameter was specified. If the table does not have any local secondary indexes, this information is not returned in the response.</p>
     /// <p>Each <code>ItemCollectionMetrics</code> element consists of:</p>
     /// <ul>
     /// <li>
     /// <p><code>ItemCollectionKey</code> - The partition key value of the item collection. This is the same as the partition key value of the item itself.</p></li>
     /// <li>
     /// <p><code>SizeEstimateRangeGB</code> - An estimate of item collection size, in gigabytes. This value is a two-element array containing a lower bound and an upper bound for the estimate. The estimate includes the size of all the items in the table, plus the size of all attributes projected into all of the local secondary indexes on that table. Use this estimate to measure whether a local secondary index is approaching its size limit.</p>
     /// <p>The estimate is subject to change over time; therefore, do not rely on the precision or accuracy of the estimate.</p></li>
     /// </ul>
     pub fn item_collection_metrics(&self) -> ::std::option::Option<&crate::types::ItemCollectionMetrics> {
         self.item_collection_metrics.as_ref()
-43
+    }
-44
+}
 static PUTITEMOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#PutItemOutput",

     "com.amazonaws.dynamodb.synthetic",
     "PutItemOutput",
 );
 static PUTITEMOUTPUT_MEMBER_ATTRIBUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemOutput$Attributes",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "attributes",
     "Attributes",
 ,
 );
 static PUTITEMOUTPUT_MEMBER_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemOutput$ConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "consumed_capacity",
     "ConsumedCapacity",
 ,
 );
 static PUTITEMOUTPUT_MEMBER_ITEM_COLLECTION_METRICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutItemOutput$ItemCollectionMetrics",
         "com.amazonaws.dynamodb.synthetic",
         "PutItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "item_collection_metrics",
     "ItemCollectionMetrics",
 ,
 );
 static PUTITEMOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static PUTITEMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTITEMOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTITEMOUTPUT_MEMBER_ATTRIBUTES,
         &PUTITEMOUTPUT_MEMBER_CONSUMED_CAPACITY,
         &PUTITEMOUTPUT_MEMBER_ITEM_COLLECTION_METRICS,
         &PUTITEMOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl PutItemOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTITEMOUTPUT_SCHEMA;
-100
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutItemOutput {
     #[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.attributes {
             ser.write_map(
                 &PUTITEMOUTPUT_MEMBER_ATTRIBUTES,
                 &|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)?;
-114
+                    }
                     Ok(())
                 },
             )?;
-118
+        }
         if let Some(ref val) = self.consumed_capacity {
             ser.write_struct(&PUTITEMOUTPUT_MEMBER_CONSUMED_CAPACITY, val)?;
-121
+        }
         if let Some(ref val) = self.item_collection_metrics {
             ser.write_struct(&PUTITEMOUTPUT_MEMBER_ITEM_COLLECTION_METRICS, val)?;
-124
+        }
         Ok(())
-126
+    }
-127
+}
 impl PutItemOutput {
     /// 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(&PUTITEMOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTITEMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.attributes = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder.consumed_capacity = Some(crate::types::ConsumedCapacity::deserialize(deser)?);
-+
+                }
                 Some(2) => {
                     builder.item_collection_metrics = Some(crate::types::ItemCollectionMetrics::deserialize(deser)?);
-+
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl PutItemOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PUTITEMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.attributes = Some({
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-203
+                }
                 Some(1) => {
                     builder.consumed_capacity = Some(crate::types::ConsumedCapacity::deserialize(deser)?);
-206
+                }
                 Some(2) => {
                     builder.item_collection_metrics = Some(crate::types::ItemCollectionMetrics::deserialize(deser)?);
-209
+                }
                 _ => {}
-211
+            }

↧ Expand context

             Ok(())
         })?;
         Ok(builder.build())
-215
+    }
-216
+}
 impl ::aws_types::request_id::RequestId for PutItemOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-220
+    }
-221
+}
 impl PutItemOutput {
     /// Creates a new builder-style object to manufacture [`PutItemOutput`](crate::operation::put_item::PutItemOutput).
     pub fn builder() -> crate::operation::put_item::builders::PutItemOutputBuilder {
         crate::operation::put_item::builders::PutItemOutputBuilder::default()
-226
+    }
-227
+}
-228
 /// A builder for [`PutItemOutput`](crate::operation::put_item::PutItemOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

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

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

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

@@ -121,125 +245,436 @@

↥ Expand context

-125
+    }
-126
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutResourcePolicy")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutResourcePolicyEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_resource_policy::PutResourcePolicyError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_resource_policy::PutResourcePolicyError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::put_resource_policy::PutResourcePolicyError,
             >::new());
-144

         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct PutResourcePolicyResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutResourcePolicyResponseDeserializer {
     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());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_put_resource_policy::de_put_resource_policy_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::put_resource_policy::PutResourcePolicyError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InternalServerError" => crate::operation::put_resource_policy::PutResourcePolicyError::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::put_resource_policy::PutResourcePolicyError::InvalidEndpointException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidEndpointException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidEndpointException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "LimitExceededException" => crate::operation::put_resource_policy::PutResourcePolicyError::LimitExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::LimitExceededException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "PolicyNotFoundException" => crate::operation::put_resource_policy::PutResourcePolicyError::PolicyNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::PolicyNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::PolicyNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceInUseException" => crate::operation::put_resource_policy::PutResourcePolicyError::ResourceInUseException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceInUseException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceInUseException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::put_resource_policy::PutResourcePolicyError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::put_resource_policy::PutResourcePolicyError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_put_resource_policy::de_put_resource_policy_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, PutResourcePolicy::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::put_resource_policy::PutResourcePolicyOutput::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))
-+
+        }
-355
+    }
-356
+}
 #[derive(Debug)]
 struct PutResourcePolicyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutResourcePolicyRequestSerializer {
     #[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::put_resource_policy::PutResourcePolicyInput>()
             .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::put_resource_policy::PutResourcePolicyInput,
                 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::put_resource_policy::PutResourcePolicyInput,
                 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 protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, PutResourcePolicy::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.confirm_remove_self_resource_access {
                     request.headers_mut().insert("x-amz-confirm-remove-self-resource-access", val.to_string());
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-+
+                }
                 request.set_uri(uri.as_str()).expect("valid URI");
-397
+            }
             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.PutResourcePolicy",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_resource_policy::ser_put_resource_policy_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);
-+
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, PutResourcePolicy::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-406
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-407
+    }
-408
+}
 #[derive(Debug)]
 struct PutResourcePolicyEndpointParamsInterceptor;
-411
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutResourcePolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutResourcePolicyEndpointParamsInterceptor"
-415
+    }
-416

↧ 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::<PutResourcePolicyInput>()
             .ok_or("failed to downcast to PutResourcePolicyInput")?;
-431
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

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

@@ -37,37 +197,242 @@

↥ Expand context

     /// <p>Within a resource-based policy, if the action for a DynamoDB service-linked role (SLR) to replicate data for a global table is denied, adding or deleting a replica will fail with an error.</p></li>
     /// </ul>
     /// <p>For a full list of all considerations that apply while attaching a resource-based policy, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-considerations.html">Resource-based policy considerations</a>.</p>
     pub fn policy(&self) -> ::std::option::Option<&str> {
         self.policy.as_deref()
-42
+    }
     /// <p>A string value that you can use to conditionally update your policy. You can provide the revision ID of your existing policy to make mutating requests against that policy.</p><note>
     /// <p>When you provide an expected revision ID, if the revision ID of the existing policy on the resource doesn't match or if there's no policy attached to the resource, your request will be rejected with a <code>PolicyNotFoundException</code>.</p>
     /// </note>
     /// <p>To conditionally attach a policy when no policy exists for the resource, specify <code>NO_POLICY</code> for the revision ID.</p>
     pub fn expected_revision_id(&self) -> ::std::option::Option<&str> {
         self.expected_revision_id.as_deref()
-49
+    }
     /// <p>Set this parameter to <code>true</code> to confirm that you want to remove your permissions to change the policy of this resource in the future.</p>
     pub fn confirm_remove_self_resource_access(&self) -> ::std::option::Option<bool> {
         self.confirm_remove_self_resource_access
-53
+    }
-54
+}
 static PUTRESOURCEPOLICYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#PutResourcePolicyInput",

     "com.amazonaws.dynamodb.synthetic",
     "PutResourcePolicyInput",
 );
 static PUTRESOURCEPOLICYINPUT_MEMBER_RESOURCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutResourcePolicyInput$ResourceArn",
         "com.amazonaws.dynamodb.synthetic",
         "PutResourcePolicyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_arn",
     "ResourceArn",
 ,
 );
 static PUTRESOURCEPOLICYINPUT_MEMBER_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutResourcePolicyInput$Policy",
         "com.amazonaws.dynamodb.synthetic",
         "PutResourcePolicyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "policy",
     "Policy",
 ,
 );
 static PUTRESOURCEPOLICYINPUT_MEMBER_EXPECTED_REVISION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutResourcePolicyInput$ExpectedRevisionId",
         "com.amazonaws.dynamodb.synthetic",
         "PutResourcePolicyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "expected_revision_id",
     "ExpectedRevisionId",
 ,
 );
 static PUTRESOURCEPOLICYINPUT_MEMBER_CONFIRM_REMOVE_SELF_RESOURCE_ACCESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#PutResourcePolicyInput$ConfirmRemoveSelfResourceAccess",
         "com.amazonaws.dynamodb.synthetic",
         "PutResourcePolicyInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "confirm_remove_self_resource_access",
     "ConfirmRemoveSelfResourceAccess",
 ,
-99
+)
 .with_http_header("x-amz-confirm-remove-self-resource-access");
 static PUTRESOURCEPOLICYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTRESOURCEPOLICYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTRESOURCEPOLICYINPUT_MEMBER_RESOURCE_ARN,
         &PUTRESOURCEPOLICYINPUT_MEMBER_POLICY,
         &PUTRESOURCEPOLICYINPUT_MEMBER_EXPECTED_REVISION_ID,
         &PUTRESOURCEPOLICYINPUT_MEMBER_CONFIRM_REMOVE_SELF_RESOURCE_ACCESS,
     ],
 );
 impl PutResourcePolicyInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTRESOURCEPOLICYINPUT_SCHEMA;
-114
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutResourcePolicyInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.resource_arn {
             ser.write_string(&PUTRESOURCEPOLICYINPUT_MEMBER_RESOURCE_ARN, val)?;
-123
+        }
         if let Some(ref val) = self.policy {
             ser.write_string(&PUTRESOURCEPOLICYINPUT_MEMBER_POLICY, val)?;
-126
+        }
         if let Some(ref val) = self.expected_revision_id {
             ser.write_string(&PUTRESOURCEPOLICYINPUT_MEMBER_EXPECTED_REVISION_ID, val)?;
-129
+        }
         if let Some(ref val) = self.confirm_remove_self_resource_access {
             ser.write_boolean(&PUTRESOURCEPOLICYINPUT_MEMBER_CONFIRM_REMOVE_SELF_RESOURCE_ACCESS, *val)?;
-132
+        }
         Ok(())
-134
+    }
-135
+}
 impl PutResourcePolicyInput {
     /// 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(&PUTRESOURCEPOLICYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTRESOURCEPOLICYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_arn = Some(deser.read_string(member)?);
-154
+                }
                 Some(1) => {
                     builder.policy = Some(deser.read_string(member)?);
-157
+                }
                 Some(2) => {
                     builder.expected_revision_id = Some(deser.read_string(member)?);
-160
+                }
                 Some(3) => {
                     builder.confirm_remove_self_resource_access = Some(deser.read_boolean(member)?);
-163
+                }
                 _ => {}
-165
+            }
             Ok(())
         })?;
         builder.resource_arn = builder.resource_arn.or(Some(String::new()));
         builder.policy = builder.policy.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutResourcePolicyInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-confirm-remove-self-resource-access") {
             builder.confirm_remove_self_resource_access = val.parse::<bool>().ok();
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PUTRESOURCEPOLICYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_arn = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.policy = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.expected_revision_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-216
+    }
-217
+}
 impl PutResourcePolicyInput {
     /// Creates a new builder-style object to manufacture [`PutResourcePolicyInput`](crate::operation::put_resource_policy::PutResourcePolicyInput).
     pub fn builder() -> crate::operation::put_resource_policy::builders::PutResourcePolicyInputBuilder {
         crate::operation::put_resource_policy::builders::PutResourcePolicyInputBuilder::default()
-222
+    }

↧ Expand context

-223
+}
-224
 /// A builder for [`PutResourcePolicyInput`](crate::operation::put_resource_policy::PutResourcePolicyInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutResourcePolicyInputBuilder {
     pub(crate) resource_arn: ::std::option::Option<::std::string::String>,
     pub(crate) policy: ::std::option::Option<::std::string::String>,
     pub(crate) expected_revision_id: ::std::option::Option<::std::string::String>,
     pub(crate) confirm_remove_self_resource_access: ::std::option::Option<bool>,
-233
+}
 impl PutResourcePolicyInputBuilder {
     /// <p>The Amazon Resource Name (ARN) of the DynamoDB resource to which the policy will be attached. The resources you can specify include tables and streams.</p>
     /// <p>You can control index permissions using the base table's policy. To specify the same permission level for your table and its indexes, you can provide both the table and index Amazon Resource Name (ARN)s in the <code>Resource</code> field of a given <code>Statement</code> in your policy document. Alternatively, to specify different permissions for your table, indexes, or both, you can define multiple <code>Statement</code> fields in your policy document.</p>
     /// This field is required.
     pub fn resource_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.resource_arn = ::std::option::Option::Some(input.into());
         self
-241
+    }
     /// <p>The Amazon Resource Name (ARN) of the DynamoDB resource to which the policy will be attached. The resources you can specify include tables and streams.</p>

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

@@ -1,1 +96,140 @@

↥ 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 PutResourcePolicyOutput {
     /// <p>A unique string that represents the revision ID of the policy. If you're comparing revision IDs, make sure to always use string comparison logic.</p>
     pub revision_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-9
+}
 impl PutResourcePolicyOutput {
     /// <p>A unique string that represents the revision ID of the policy. If you're comparing revision IDs, make sure to always use string comparison logic.</p>
     pub fn revision_id(&self) -> ::std::option::Option<&str> {
         self.revision_id.as_deref()
-14
+    }
-15
+}
 static PUTRESOURCEPOLICYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#PutResourcePolicyOutput",

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

↧ Expand context

-121
+}
 impl ::aws_types::request_id::RequestId for PutResourcePolicyOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-125
+    }
-126
+}
 impl PutResourcePolicyOutput {
     /// Creates a new builder-style object to manufacture [`PutResourcePolicyOutput`](crate::operation::put_resource_policy::PutResourcePolicyOutput).
     pub fn builder() -> crate::operation::put_resource_policy::builders::PutResourcePolicyOutputBuilder {
         crate::operation::put_resource_policy::builders::PutResourcePolicyOutputBuilder::default()
-131
+    }
-132
+}
-133
 /// A builder for [`PutResourcePolicyOutput`](crate::operation::put_resource_policy::PutResourcePolicyOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutResourcePolicyOutputBuilder {
     pub(crate) revision_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-140
+}

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

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

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

@@ -109,113 +231,386 @@

↥ Expand context

-113
+    }
-114
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("Query")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(QueryEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::query::QueryError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::query::QueryError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::query::QueryError,
             >::new());
-132

         ::std::borrow::Cow::Owned(rcb)
-134
+    }
-135
+}
-136
 #[derive(Debug)]
 struct QueryResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for QueryResponseDeserializer {
     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());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_query::de_query_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::query::QueryError::unhandled(generic)),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InternalServerError" => crate::operation::query::QueryError::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::query::QueryError::InvalidEndpointException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidEndpointException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidEndpointException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ProvisionedThroughputExceededException" => crate::operation::query::QueryError::ProvisionedThroughputExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ProvisionedThroughputExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ProvisionedThroughputExceededException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "RequestLimitExceeded" => crate::operation::query::QueryError::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::query::QueryError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ThrottlingException" => crate::operation::query::QueryError::ThrottlingException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ThrottlingException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::query::QueryError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_query::de_query_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, Query::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::query::QueryOutput::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body)
                     .map_err(|e| {
                         ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(
                             e,
                         ))
                     })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-337
+    }
-338
+}
 #[derive(Debug)]
 struct QueryRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for QueryRequestSerializer {
     #[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::query::QueryInput>().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::query::QueryInput,
                 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::query::QueryInput,
                 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.Query",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_query::ser_query_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, Query::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-357
+    }
-358
+}
 #[derive(Debug)]
 struct QueryEndpointParamsInterceptor;
-361
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryEndpointParamsInterceptor"
-365
+    }
-366

↧ Expand context

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

AWS SDK

Files changed:

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

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

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

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

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

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

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