AWS SDK

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

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

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

     "com.amazonaws.dynamodb.synthetic",
     "CreateTableOutput",
 );
 static CREATETABLEOUTPUT_MEMBER_TABLE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#CreateTableOutput$TableDescription",
         "com.amazonaws.dynamodb.synthetic",
         "CreateTableOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "table_description",
     "TableDescription",
 ,
 );
 static CREATETABLEOUTPUT_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 CREATETABLEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATETABLEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CREATETABLEOUTPUT_MEMBER_TABLE_DESCRIPTION],
     &[&CREATETABLEOUTPUT_MEMBER_TABLE_DESCRIPTION, &CREATETABLEOUTPUT_MEMBER__REQUEST_ID],
 );
 impl CreateTableOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATETABLEOUTPUT_SCHEMA;
-47
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateTableOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.table_description {
             ser.write_struct(&CREATETABLEOUTPUT_MEMBER_TABLE_DESCRIPTION, val)?;
-56
+        }
         Ok(())
-58
+    }
-59
+}
 impl CreateTableOutput {
     /// 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(&CREATETABLEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATETABLEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_description = Some(crate::types::TableDescription::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateTableOutput {
     /// 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(&CREATETABLEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_description = Some(crate::types::TableDescription::deserialize(deser)?);
-115
+                }
                 _ => {}
-117
+            }
             Ok(())
         })?;
         Ok(builder.build())
-121
+    }

↧ Expand context

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

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

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

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

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

↥ Expand context

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

                 crate::operation::delete_backup::DeleteBackupError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct DeleteBackupResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBackupResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_delete_backup::de_delete_backup_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_backup::de_delete_backup_http_response(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::delete_backup::DeleteBackupError::unhandled(generic)),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "BackupInUseException" => crate::operation::delete_backup::DeleteBackupError::BackupInUseException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::BackupInUseException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::BackupInUseException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "BackupNotFoundException" => crate::operation::delete_backup::DeleteBackupError::BackupNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::BackupNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::BackupNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InternalServerError" => crate::operation::delete_backup::DeleteBackupError::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::delete_backup::DeleteBackupError::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),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "LimitExceededException" => crate::operation::delete_backup::DeleteBackupError::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
                 }),
                 _ => crate::operation::delete_backup::DeleteBackupError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, DeleteBackup::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::delete_backup::DeleteBackupOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-324
+    }
-325
+}
 #[derive(Debug)]
 struct DeleteBackupRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DeleteBackupRequestSerializer {
     #[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::delete_backup::DeleteBackupInput>()
             .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::delete_backup::DeleteBackupInput,
                 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::delete_backup::DeleteBackupInput,
                 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.DeleteBackup",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_delete_backup::ser_delete_backup_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, DeleteBackup::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-346
+    }
-347
+}
 #[derive(Debug)]
 struct DeleteBackupEndpointParamsInterceptor;
-350
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteBackupEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteBackupEndpointParamsInterceptor"
-354
+    }
-355

↧ Expand context

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

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

@@ -1,1 +108,120 @@

↥ 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 DeleteBackupInput {
     /// <p>The ARN associated with the backup.</p>
     pub backup_arn: ::std::option::Option<::std::string::String>,
-8
+}
 impl DeleteBackupInput {
     /// <p>The ARN associated with the backup.</p>
     pub fn backup_arn(&self) -> ::std::option::Option<&str> {
         self.backup_arn.as_deref()
-13
+    }
-14
+}
 static DELETEBACKUPINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#DeleteBackupInput",

     "com.amazonaws.dynamodb.synthetic",
     "DeleteBackupInput",
 );
 static DELETEBACKUPINPUT_MEMBER_BACKUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteBackupInput$BackupArn",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteBackupInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "backup_arn",
     "BackupArn",
 ,
 );
 static DELETEBACKUPINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETEBACKUPINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DELETEBACKUPINPUT_MEMBER_BACKUP_ARN],
 );
 impl DeleteBackupInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEBACKUPINPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeleteBackupInput {
     #[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.backup_arn {
             ser.write_string(&DELETEBACKUPINPUT_MEMBER_BACKUP_ARN, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl DeleteBackupInput {
     /// 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(&DELETEBACKUPINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETEBACKUPINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.backup_arn = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder.backup_arn = builder.backup_arn.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-78
+    }
-79
+}
 impl DeleteBackupInput {
     /// 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 DeleteBackupInput {
     /// Creates a new builder-style object to manufacture [`DeleteBackupInput`](crate::operation::delete_backup::DeleteBackupInput).
     pub fn builder() -> crate::operation::delete_backup::builders::DeleteBackupInputBuilder {
         crate::operation::delete_backup::builders::DeleteBackupInputBuilder::default()
-95
+    }
-96
+}
-97
 /// A builder for [`DeleteBackupInput`](crate::operation::delete_backup::DeleteBackupInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeleteBackupInputBuilder {
     pub(crate) backup_arn: ::std::option::Option<::std::string::String>,
-103
+}
 impl DeleteBackupInputBuilder {
     /// <p>The ARN associated with the backup.</p>
     /// This field is required.
     pub fn backup_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.backup_arn = ::std::option::Option::Some(input.into());
         self
-110
+    }
     /// <p>The ARN associated with the backup.</p>
     pub fn set_backup_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.backup_arn = input;
         self
-115
+    }
     /// <p>The ARN associated with the backup.</p>
     pub fn get_backup_arn(&self) -> &::std::option::Option<::std::string::String> {
         &self.backup_arn
-119
+    }
     /// Consumes the builder and constructs a [`DeleteBackupInput`](crate::operation::delete_backup::DeleteBackupInput).

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/delete_backup/_delete_backup_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 DeleteBackupOutput {
     /// <p>Contains the description of the backup created for the table.</p>
     pub backup_description: ::std::option::Option<crate::types::BackupDescription>,
     _request_id: Option<String>,
-9
+}
 impl DeleteBackupOutput {
     /// <p>Contains the description of the backup created for the table.</p>
     pub fn backup_description(&self) -> ::std::option::Option<&crate::types::BackupDescription> {
         self.backup_description.as_ref()
-14
+    }
-15
+}
 static DELETEBACKUPOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#DeleteBackupOutput",

     "com.amazonaws.dynamodb.synthetic",
     "DeleteBackupOutput",
 );
 static DELETEBACKUPOUTPUT_MEMBER_BACKUP_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteBackupOutput$BackupDescription",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteBackupOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "backup_description",
     "BackupDescription",
 ,
 );
 static DELETEBACKUPOUTPUT_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 DELETEBACKUPOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETEBACKUPOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DELETEBACKUPOUTPUT_MEMBER_BACKUP_DESCRIPTION],
     &[&DELETEBACKUPOUTPUT_MEMBER_BACKUP_DESCRIPTION, &DELETEBACKUPOUTPUT_MEMBER__REQUEST_ID],
 );
 impl DeleteBackupOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEBACKUPOUTPUT_SCHEMA;
-46
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeleteBackupOutput {
     #[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.backup_description {
             ser.write_struct(&DELETEBACKUPOUTPUT_MEMBER_BACKUP_DESCRIPTION, val)?;
-55
+        }
         Ok(())
-57
+    }
-58
+}
 impl DeleteBackupOutput {
     /// 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(&DELETEBACKUPOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETEBACKUPOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.backup_description = Some(crate::types::BackupDescription::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl DeleteBackupOutput {
     /// 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(&DELETEBACKUPOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.backup_description = Some(crate::types::BackupDescription::deserialize(deser)?);
-114
+                }
                 _ => {}
-116
+            }
             Ok(())
         })?;
         Ok(builder.build())
-120
+    }

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/delete_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 `DeleteItem`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct DeleteItem;
 impl DeleteItem {
     /// Creates a new `DeleteItem`
     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::delete_item::DeleteItemInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::delete_item::DeleteItemOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::delete_item::DeleteItemInput,
     ) -> ::std::result::Result<
         crate::operation::delete_item::DeleteItemOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::delete_item::DeleteItemError,
             ::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::delete_item::DeleteItemError>()
                     .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::delete_item::DeleteItemOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -115,119 +240,495 @@

↥ Expand context

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

                 crate::operation::delete_item::DeleteItemError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct DeleteItemResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteItemResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_delete_item::de_delete_item_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_item::de_delete_item_http_response(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidEndpointException" => crate::operation::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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::delete_item::DeleteItemError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, DeleteItem::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::delete_item::DeleteItemOutput::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))
-+
+        }
-446
+    }
-447
+}
 #[derive(Debug)]
 struct DeleteItemRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DeleteItemRequestSerializer {
     #[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::delete_item::DeleteItemInput>().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::delete_item::DeleteItemInput,
                 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::delete_item::DeleteItemInput,
                 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.DeleteItem",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_delete_item::ser_delete_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, DeleteItem::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-466
+    }
-467
+}
 #[derive(Debug)]
 struct DeleteItemEndpointParamsInterceptor;
-470
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteItemEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteItemEndpointParamsInterceptor"
-474
+    }
-475

↧ 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::<DeleteItemInput>()
             .ok_or("failed to downcast to DeleteItemInput")?;
-490
         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/delete_item/_delete_item_input.rs

@@ -188,188 +550,544 @@

↥ 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()
-199
+    }
     /// <p>An optional parameter that returns the item attributes for a <code>DeleteItem</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()
-204
+    }
-205
+}
 static DELETEITEMINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#DeleteItemInput",

     "com.amazonaws.dynamodb.synthetic",
     "DeleteItemInput",
 );
 static DELETEITEMINPUT_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemInput$TableName",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "table_name",
     "TableName",
 ,
 );
 static DELETEITEMINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemInput$Key",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "key",
     "Key",
 ,
 );
 static DELETEITEMINPUT_MEMBER_EXPECTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemInput$Expected",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expected",
     "Expected",
 ,
 );
 static DELETEITEMINPUT_MEMBER_CONDITIONAL_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemInput$ConditionalOperator",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "conditional_operator",
     "ConditionalOperator",
 ,
 );
 static DELETEITEMINPUT_MEMBER_RETURN_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemInput$ReturnValues",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_values",
     "ReturnValues",
 ,
 );
 static DELETEITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemInput$ReturnConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_consumed_capacity",
     "ReturnConsumedCapacity",
 ,
 );
 static DELETEITEMINPUT_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#DeleteItemInput$ReturnItemCollectionMetrics",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_item_collection_metrics",
     "ReturnItemCollectionMetrics",
 ,
 );
 static DELETEITEMINPUT_MEMBER_CONDITION_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemInput$ConditionExpression",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "condition_expression",
     "ConditionExpression",
 ,
 );
 static DELETEITEMINPUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemInput$ExpressionAttributeNames",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expression_attribute_names",
     "ExpressionAttributeNames",
 ,
 );
 static DELETEITEMINPUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemInput$ExpressionAttributeValues",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "expression_attribute_values",
     "ExpressionAttributeValues",
 ,
 );
 static DELETEITEMINPUT_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#DeleteItemInput$ReturnValuesOnConditionCheckFailure",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_values_on_condition_check_failure",
     "ReturnValuesOnConditionCheckFailure",
 ,
 );
 static DELETEITEMINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETEITEMINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DELETEITEMINPUT_MEMBER_TABLE_NAME,
         &DELETEITEMINPUT_MEMBER_KEY,
         &DELETEITEMINPUT_MEMBER_EXPECTED,
         &DELETEITEMINPUT_MEMBER_CONDITIONAL_OPERATOR,
         &DELETEITEMINPUT_MEMBER_RETURN_VALUES,
         &DELETEITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY,
         &DELETEITEMINPUT_MEMBER_RETURN_ITEM_COLLECTION_METRICS,
         &DELETEITEMINPUT_MEMBER_CONDITION_EXPRESSION,
         &DELETEITEMINPUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
         &DELETEITEMINPUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES,
         &DELETEITEMINPUT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE,
     ],
 );
 impl DeleteItemInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEITEMINPUT_SCHEMA;
-341
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeleteItemInput {
     #[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(&DELETEITEMINPUT_MEMBER_TABLE_NAME, val)?;
-350
+        }
         if let Some(ref val) = self.key {
             ser.write_map(
                 &DELETEITEMINPUT_MEMBER_KEY,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
                         ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-358
+                    }
                     Ok(())
                 },
             )?;
-362
+        }
         if let Some(ref val) = self.expected {
             ser.write_map(
                 &DELETEITEMINPUT_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)?;
-370
+                    }
                     Ok(())
                 },
             )?;
-374
+        }
         if let Some(ref val) = self.conditional_operator {
             ser.write_string(&DELETEITEMINPUT_MEMBER_CONDITIONAL_OPERATOR, val.as_str())?;
-377
+        }
         if let Some(ref val) = self.return_values {
             ser.write_string(&DELETEITEMINPUT_MEMBER_RETURN_VALUES, val.as_str())?;
-380
+        }
         if let Some(ref val) = self.return_consumed_capacity {
             ser.write_string(&DELETEITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY, val.as_str())?;
-383
+        }
         if let Some(ref val) = self.return_item_collection_metrics {
             ser.write_string(&DELETEITEMINPUT_MEMBER_RETURN_ITEM_COLLECTION_METRICS, val.as_str())?;
-386
+        }
         if let Some(ref val) = self.condition_expression {
             ser.write_string(&DELETEITEMINPUT_MEMBER_CONDITION_EXPRESSION, val)?;
-389
+        }
         if let Some(ref val) = self.expression_attribute_names {
             ser.write_map(
                 &DELETEITEMINPUT_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)?;
-397
+                    }
                     Ok(())
                 },
             )?;
-401
+        }
         if let Some(ref val) = self.expression_attribute_values {
             ser.write_map(
                 &DELETEITEMINPUT_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)?;
-409
+                    }
                     Ok(())
                 },
             )?;
-413
+        }
         if let Some(ref val) = self.return_values_on_condition_check_failure {
             ser.write_string(&DELETEITEMINPUT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE, val.as_str())?;
-416
+        }
         Ok(())
-418
+    }
-419
+}
 impl DeleteItemInput {
     /// 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(&DELETEITEMINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETEITEMINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.table_name = Some(deser.read_string(member)?);
-438
+                }
                 Some(1) => {
                     builder.key = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-448
+                }
                 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
                     });
-458
+                }
                 Some(3) => {
                     builder.conditional_operator = Some(crate::types::ConditionalOperator::from(deser.read_string(member)?.as_str()));
-461
+                }
                 Some(4) => {
                     builder.return_values = Some(crate::types::ReturnValue::from(deser.read_string(member)?.as_str()));
-464
+                }
                 Some(5) => {
                     builder.return_consumed_capacity = Some(crate::types::ReturnConsumedCapacity::from(deser.read_string(member)?.as_str()));
-467
+                }
                 Some(6) => {
                     builder.return_item_collection_metrics =
                         Some(crate::types::ReturnItemCollectionMetrics::from(deser.read_string(member)?.as_str()));
-471
+                }
                 Some(7) => {
                     builder.condition_expression = Some(deser.read_string(member)?);
-474
+                }
                 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)?);
-477
+                }
                 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
                     });
-487
+                }
                 Some(10) => {
                     builder.return_values_on_condition_check_failure = Some(crate::types::ReturnValuesOnConditionCheckFailure::from(
                         deser.read_string(member)?.as_str(),
                     ));
-492
+                }
                 _ => {}
-494
+            }
             Ok(())
         })?;
         builder.table_name = builder.table_name.or(Some(String::new()));
         builder.key = builder.key.or(Some(::std::collections::HashMap::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-502
+    }
-503
+}
 impl DeleteItemInput {
     /// 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 DeleteItemInput {
     /// Creates a new builder-style object to manufacture [`DeleteItemInput`](crate::operation::delete_item::DeleteItemInput).
     pub fn builder() -> crate::operation::delete_item::builders::DeleteItemInputBuilder {
         crate::operation::delete_item::builders::DeleteItemInputBuilder::default()
-519
+    }
-520
+}
-521
 /// A builder for [`DeleteItemInput`](crate::operation::delete_item::DeleteItemInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeleteItemInputBuilder {
     pub(crate) table_name: ::std::option::Option<::std::string::String>,
     pub(crate) key: ::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) conditional_operator: ::std::option::Option<crate::types::ConditionalOperator>,
     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) 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>,
-537
+}
 impl DeleteItemInputBuilder {
     /// <p>The name of the table from which to delete 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
-544
+    }

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

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

↥ Expand context

-27
+    }
     /// <p>The capacity units consumed by the <code>DeleteItem</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/provisioned-capacity-mode.html">Provisioned capacity mode</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>DeleteItem</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 DELETEITEMOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#DeleteItemOutput",

     "com.amazonaws.dynamodb.synthetic",
     "DeleteItemOutput",
 );
 static DELETEITEMOUTPUT_MEMBER_ATTRIBUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemOutput$Attributes",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "attributes",
     "Attributes",
 ,
 );
 static DELETEITEMOUTPUT_MEMBER_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemOutput$ConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "consumed_capacity",
     "ConsumedCapacity",
 ,
 );
 static DELETEITEMOUTPUT_MEMBER_ITEM_COLLECTION_METRICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#DeleteItemOutput$ItemCollectionMetrics",
         "com.amazonaws.dynamodb.synthetic",
         "DeleteItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "item_collection_metrics",
     "ItemCollectionMetrics",
 ,
 );
 static DELETEITEMOUTPUT_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 DELETEITEMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DELETEITEMOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DELETEITEMOUTPUT_MEMBER_ATTRIBUTES,
         &DELETEITEMOUTPUT_MEMBER_CONSUMED_CAPACITY,
         &DELETEITEMOUTPUT_MEMBER_ITEM_COLLECTION_METRICS,
         &DELETEITEMOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl DeleteItemOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEITEMOUTPUT_SCHEMA;
-100
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeleteItemOutput {
     #[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(
                 &DELETEITEMOUTPUT_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(&DELETEITEMOUTPUT_MEMBER_CONSUMED_CAPACITY, val)?;
-121
+        }
         if let Some(ref val) = self.item_collection_metrics {
             ser.write_struct(&DELETEITEMOUTPUT_MEMBER_ITEM_COLLECTION_METRICS, val)?;
-124
+        }
         Ok(())
-126
+    }
-127
+}
 impl DeleteItemOutput {
     /// 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(&DELETEITEMOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DELETEITEMOUTPUT_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 DeleteItemOutput {
     /// 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(&DELETEITEMOUTPUT_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 DeleteItemOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-220
+    }
-221
+}
 impl DeleteItemOutput {
     /// Creates a new builder-style object to manufacture [`DeleteItemOutput`](crate::operation::delete_item::DeleteItemOutput).
     pub fn builder() -> crate::operation::delete_item::builders::DeleteItemOutputBuilder {
         crate::operation::delete_item::builders::DeleteItemOutputBuilder::default()
-226
+    }
-227
+}
-228
 /// A builder for [`DeleteItemOutput`](crate::operation::delete_item::DeleteItemOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/delete_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 `DeleteResourcePolicy`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct DeleteResourcePolicy;
 impl DeleteResourcePolicy {
     /// Creates a new `DeleteResourcePolicy`
     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::delete_resource_policy::DeleteResourcePolicyInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::delete_resource_policy::DeleteResourcePolicyOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::delete_resource_policy::DeleteResourcePolicyInput,
     ) -> ::std::result::Result<
         crate::operation::delete_resource_policy::DeleteResourcePolicyOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::delete_resource_policy::DeleteResourcePolicyError,
             ::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::delete_resource_policy::DeleteResourcePolicyError>()
                     .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::delete_resource_policy::DeleteResourcePolicyOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -118,122 +247,406 @@

↥ Expand context

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

                 crate::operation::delete_resource_policy::DeleteResourcePolicyError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct DeleteResourcePolicyResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteResourcePolicyResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_delete_resource_policy::de_delete_resource_policy_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_resource_policy::de_delete_resource_policy_http_response(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::delete_resource_policy::DeleteResourcePolicyError::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::delete_resource_policy::DeleteResourcePolicyError::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::delete_resource_policy::DeleteResourcePolicyError::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::delete_resource_policy::DeleteResourcePolicyError::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),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "PolicyNotFoundException" => crate::operation::delete_resource_policy::DeleteResourcePolicyError::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::delete_resource_policy::DeleteResourcePolicyError::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::delete_resource_policy::DeleteResourcePolicyError::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::delete_resource_policy::DeleteResourcePolicyError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, DeleteResourcePolicy::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::delete_resource_policy::DeleteResourcePolicyOutput::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 DeleteResourcePolicyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DeleteResourcePolicyRequestSerializer {
     #[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::delete_resource_policy::DeleteResourcePolicyInput>()
             .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::delete_resource_policy::DeleteResourcePolicyInput,
                 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::delete_resource_policy::DeleteResourcePolicyInput,
                 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.DeleteResourcePolicy",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_delete_resource_policy::ser_delete_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);
--
+        }
         ::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, DeleteResourcePolicy::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-377
+    }
-378
+}
 #[derive(Debug)]
 struct DeleteResourcePolicyEndpointParamsInterceptor;
-381
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteResourcePolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteResourcePolicyEndpointParamsInterceptor"
-385
+    }
-386

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

AWS SDK

Files changed: