AWS SDK

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/create_grant.rs

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

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

@@ -115,119 +242,471 @@

↥ 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("CreateGrant")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateGrantEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_grant::CreateGrantError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_grant::CreateGrantError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::create_grant::CreateGrantError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct CreateGrantResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateGrantResponseDeserializer {
     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_create_grant::de_create_grant_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::create_grant::CreateGrantError::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 {
                 "DependencyTimeoutException" => crate::operation::create_grant::CreateGrantError::DependencyTimeoutException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::DependencyTimeoutException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::DependencyTimeoutException::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
                 }),
                 "DisabledException" => crate::operation::create_grant::CreateGrantError::DisabledException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::DisabledException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::DisabledException::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
                 }),
                 "DryRunOperationException" => crate::operation::create_grant::CreateGrantError::DryRunOperationException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::DryRunOperationException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::DryRunOperationException::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
                 }),
                 "InvalidArnException" => crate::operation::create_grant::CreateGrantError::InvalidArnException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidArnException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidArnException::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
                 }),
                 "InvalidGrantTokenException" => crate::operation::create_grant::CreateGrantError::InvalidGrantTokenException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidGrantTokenException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidGrantTokenException::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
                 }),
                 "KMSInternalException" => crate::operation::create_grant::CreateGrantError::KmsInternalException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::KmsInternalException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::KmsInternalException::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
                 }),
                 "KMSInvalidStateException" => crate::operation::create_grant::CreateGrantError::KmsInvalidStateException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::KmsInvalidStateException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::KmsInvalidStateException::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::create_grant::CreateGrantError::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
                 }),
                 "NotFoundException" => crate::operation::create_grant::CreateGrantError::NotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::NotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::NotFoundException::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::create_grant::CreateGrantError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_create_grant::de_create_grant_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, CreateGrant::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::create_grant::CreateGrantOutput::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))
-+
+        }
-420
+    }
-421
+}
 #[derive(Debug)]
 struct CreateGrantRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateGrantRequestSerializer {
     #[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::create_grant::CreateGrantInput>()
             .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::create_grant::CreateGrantInput,
                 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::create_grant::CreateGrantInput,
                 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.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "TrentService.CreateGrant",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_grant::ser_create_grant_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, CreateGrant::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-442
+    }
-443
+}
 #[derive(Debug)]
 struct CreateGrantEndpointParamsInterceptor;
-446
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateGrantEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CreateGrantEndpointParamsInterceptor"
-450
+    }
-451

↧ 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::<CreateGrantInput>()
             .ok_or("failed to downcast to CreateGrantInput")?;
-466
         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/kms/src/operation/create_grant/_create_grant_input.rs

@@ -93,93 +223,223 @@

↥ Expand context

     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.grant_tokens.is_none()`.
     pub fn grant_tokens(&self) -> &[::std::string::String] {
         self.grant_tokens.as_deref().unwrap_or_default()
-96
+    }
     /// <p>A friendly name for the grant. Use this value to prevent the unintended creation of duplicate grants when retrying this request.</p><important>
     /// <p>Do not include confidential or sensitive information in this field. This field may be displayed in plaintext in CloudTrail logs and other output.</p>
     /// </important>
     /// <p>When this value is absent, all <code>CreateGrant</code> requests result in a new grant with a unique <code>GrantId</code> even if all the supplied parameters are identical. This can result in unintended duplicates when you retry the <code>CreateGrant</code> request.</p>
     /// <p>When this value is present, you can retry a <code>CreateGrant</code> request with identical parameters; if the grant already exists, the original <code>GrantId</code> is returned without creating a new grant. Note that the returned grant token is unique with every <code>CreateGrant</code> request, even when a duplicate <code>GrantId</code> is returned. All grant tokens for the same grant ID can be used interchangeably.</p>
     pub fn name(&self) -> ::std::option::Option<&str> {
         self.name.as_deref()
-104
+    }
     /// <p>Checks if your request will succeed. <code>DryRun</code> is an optional parameter.</p>
     /// <p>To learn more about how to use this parameter, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/testing-permissions.html">Testing your permissions</a> in the <i>Key Management Service Developer Guide</i>.</p>
     pub fn dry_run(&self) -> ::std::option::Option<bool> {
         self.dry_run
-109
+    }
-110
+}
 static CREATEGRANTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.kms.synthetic#CreateGrantInput",

     "com.amazonaws.kms.synthetic",
     "CreateGrantInput",
 );
 static CREATEGRANTINPUT_MEMBER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateGrantInput$KeyId",
         "com.amazonaws.kms.synthetic",
         "CreateGrantInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key_id",
     "KeyId",
 ,
 );
 static CREATEGRANTINPUT_MEMBER_GRANTEE_PRINCIPAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateGrantInput$GranteePrincipal",
         "com.amazonaws.kms.synthetic",
         "CreateGrantInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grantee_principal",
     "GranteePrincipal",
 ,
 );
 static CREATEGRANTINPUT_MEMBER_RETIRING_PRINCIPAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateGrantInput$RetiringPrincipal",
         "com.amazonaws.kms.synthetic",
         "CreateGrantInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "retiring_principal",
     "RetiringPrincipal",
 ,
 );
 static CREATEGRANTINPUT_MEMBER_OPERATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateGrantInput$Operations",
         "com.amazonaws.kms.synthetic",
         "CreateGrantInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "operations",
     "Operations",
 ,
 );
 static CREATEGRANTINPUT_MEMBER_CONSTRAINTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateGrantInput$Constraints",
         "com.amazonaws.kms.synthetic",
         "CreateGrantInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "constraints",
     "Constraints",
 ,
 );
 static CREATEGRANTINPUT_MEMBER_GRANT_TOKENS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateGrantInput$GrantTokens",
         "com.amazonaws.kms.synthetic",
         "CreateGrantInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "grant_tokens",
     "GrantTokens",
 ,
 );
 static CREATEGRANTINPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateGrantInput$Name",
         "com.amazonaws.kms.synthetic",
         "CreateGrantInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
 );
 static CREATEGRANTINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateGrantInput$DryRun",
         "com.amazonaws.kms.synthetic",
         "CreateGrantInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static CREATEGRANTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEGRANTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEGRANTINPUT_MEMBER_KEY_ID,
         &CREATEGRANTINPUT_MEMBER_GRANTEE_PRINCIPAL,
         &CREATEGRANTINPUT_MEMBER_RETIRING_PRINCIPAL,
         &CREATEGRANTINPUT_MEMBER_OPERATIONS,

↧ Expand context

         &CREATEGRANTINPUT_MEMBER_CONSTRAINTS,
         &CREATEGRANTINPUT_MEMBER_GRANT_TOKENS,
         &CREATEGRANTINPUT_MEMBER_NAME,
         &CREATEGRANTINPUT_MEMBER_DRY_RUN,
     ],
 );
 impl CreateGrantInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEGRANTINPUT_SCHEMA;
-213
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateGrantInput {
     #[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.key_id {
             ser.write_string(&CREATEGRANTINPUT_MEMBER_KEY_ID, val)?;
-222
+        }
         if let Some(ref val) = self.grantee_principal {

@@ -235,235 +361,362 @@

↥ Expand context

-235
+                    }
                     Ok(())
                 },
             )?;
-239
+        }
         if let Some(ref val) = self.constraints {
             ser.write_struct(&CREATEGRANTINPUT_MEMBER_CONSTRAINTS, val)?;
-242
+        }
         if let Some(ref val) = self.grant_tokens {
             ser.write_list(
                 &CREATEGRANTINPUT_MEMBER_GRANT_TOKENS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-249
+                    }
                     Ok(())
                 },
             )?;
-253
+        }
         if let Some(ref val) = self.name {

             ser.write_string(&CREATEGRANTINPUT_MEMBER_NAME, val)?;
-256
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&CREATEGRANTINPUT_MEMBER_DRY_RUN, *val)?;
-259
+        }
         Ok(())
-261
+    }
-262
+}
 impl CreateGrantInput {
     /// 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(&CREATEGRANTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEGRANTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.key_id = Some(deser.read_string(member)?);
-281
+                }
                 Some(1) => {
                     builder.grantee_principal = Some(deser.read_string(member)?);
-284
+                }
                 Some(2) => {
                     builder.retiring_principal = Some(deser.read_string(member)?);
-287
+                }
                 Some(3) => {
                     builder.operations = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::GrantOperation::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GrantOperation::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-297
+                }
                 Some(4) => {
                     builder.constraints = Some(crate::types::GrantConstraints::deserialize(deser)?);
-300
+                }
                 Some(5) => {
                     builder.grant_tokens = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.grant_tokens = Some(deser.read_string_list(member)?);
-303
+                }
                 Some(6) => {
                     builder.name = Some(deser.read_string(member)?);
-306
+                }
                 Some(7) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-309
+                }
                 _ => {}
-311
+            }
             Ok(())
         })?;
         builder.key_id = builder.key_id.or(Some(String::new()));
         builder.grantee_principal = builder.grantee_principal.or(Some(String::new()));
         builder.operations = builder.operations.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-320
+    }
-321
+}
 impl CreateGrantInput {
     /// 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 CreateGrantInput {
     /// Creates a new builder-style object to manufacture [`CreateGrantInput`](crate::operation::create_grant::CreateGrantInput).
     pub fn builder() -> crate::operation::create_grant::builders::CreateGrantInputBuilder {
         crate::operation::create_grant::builders::CreateGrantInputBuilder::default()
-337
+    }
-338
+}
-339
 /// A builder for [`CreateGrantInput`](crate::operation::create_grant::CreateGrantInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateGrantInputBuilder {
     pub(crate) key_id: ::std::option::Option<::std::string::String>,
     pub(crate) grantee_principal: ::std::option::Option<::std::string::String>,
     pub(crate) retiring_principal: ::std::option::Option<::std::string::String>,
     pub(crate) operations: ::std::option::Option<::std::vec::Vec<crate::types::GrantOperation>>,
     pub(crate) constraints: ::std::option::Option<crate::types::GrantConstraints>,
     pub(crate) grant_tokens: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) dry_run: ::std::option::Option<bool>,
-352
+}
 impl CreateGrantInputBuilder {
     /// <p>Identifies the KMS key for the grant. The grant gives principals permission to use this KMS key.</p>
     /// <p>Specify the key ID or key ARN of the KMS key. To specify a KMS key in a different Amazon Web Services account, you must use the key ARN.</p>
     /// <p>For example:</p>
     /// <ul>
     /// <li>
     /// <p>Key ID: <code>1234abcd-12ab-34cd-56ef-1234567890ab</code></p></li>
     /// <li>
     /// <p>Key ARN: <code>arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab</code></p></li>
     /// </ul>

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/create_grant/_create_grant_output.rs

@@ -8,8 +119,170 @@

↥ Expand context

     pub grant_token: ::std::option::Option<::std::string::String>,
     /// <p>The unique identifier for the grant.</p>
     /// <p>You can use the <code>GrantId</code> in a <code>ListGrants</code>, <code>RetireGrant</code>, or <code>RevokeGrant</code> operation.</p>
     pub grant_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-13
+}
 impl CreateGrantOutput {
     /// <p>The grant token.</p>
     /// <p>Use a grant token when your permission to call this operation comes from a new grant that has not yet achieved <i>eventual consistency</i>. For more information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#grant_token">Grant token</a> and <a href="https://docs.aws.amazon.com/kms/latest/developerguide/using-grant-token.html">Using a grant token</a> in the <i>Key Management Service Developer Guide</i>.</p>
     pub fn grant_token(&self) -> ::std::option::Option<&str> {
         self.grant_token.as_deref()
-19
+    }
     /// <p>The unique identifier for the grant.</p>
     /// <p>You can use the <code>GrantId</code> in a <code>ListGrants</code>, <code>RetireGrant</code>, or <code>RevokeGrant</code> operation.</p>
     pub fn grant_id(&self) -> ::std::option::Option<&str> {
         self.grant_id.as_deref()
-24
+    }
-25
+}
 static CREATEGRANTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.kms.synthetic#CreateGrantOutput",

     "com.amazonaws.kms.synthetic",
     "CreateGrantOutput",
 );
 static CREATEGRANTOUTPUT_MEMBER_GRANT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateGrantOutput$GrantToken",
         "com.amazonaws.kms.synthetic",
         "CreateGrantOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_token",
     "GrantToken",
 ,
 );
 static CREATEGRANTOUTPUT_MEMBER_GRANT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateGrantOutput$GrantId",
         "com.amazonaws.kms.synthetic",
         "CreateGrantOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "grant_id",
     "GrantId",
 ,
 );
 static CREATEGRANTOUTPUT_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 CREATEGRANTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEGRANTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CREATEGRANTOUTPUT_MEMBER_GRANT_TOKEN, &CREATEGRANTOUTPUT_MEMBER_GRANT_ID],
     &[
         &CREATEGRANTOUTPUT_MEMBER_GRANT_TOKEN,
         &CREATEGRANTOUTPUT_MEMBER_GRANT_ID,
         &CREATEGRANTOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateGrantOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEGRANTOUTPUT_SCHEMA;
-70
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateGrantOutput {
     #[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.grant_token {
             ser.write_string(&CREATEGRANTOUTPUT_MEMBER_GRANT_TOKEN, val)?;
-79
+        }
         if let Some(ref val) = self.grant_id {
             ser.write_string(&CREATEGRANTOUTPUT_MEMBER_GRANT_ID, val)?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl CreateGrantOutput {
     /// 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(&CREATEGRANTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.grant_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.grant_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateGrantOutput {
     /// 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(&CREATEGRANTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEGRANTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.grant_token = Some(deser.read_string(member)?);
-144
+                }
                 Some(1) => {
                     builder.grant_id = Some(deser.read_string(member)?);
-147
+                }
                 _ => {}
-149
+            }
             Ok(())

↧ Expand context

         })?;
         Ok(builder.build())
-153
+    }
-154
+}
 impl ::aws_types::request_id::RequestId for CreateGrantOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-158
+    }
-159
+}
 impl CreateGrantOutput {
     /// Creates a new builder-style object to manufacture [`CreateGrantOutput`](crate::operation::create_grant::CreateGrantOutput).
     pub fn builder() -> crate::operation::create_grant::builders::CreateGrantOutputBuilder {
         crate::operation::create_grant::builders::CreateGrantOutputBuilder::default()
-164
+    }
-165
+}
-166
 /// A builder for [`CreateGrantOutput`](crate::operation::create_grant::CreateGrantOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateGrantOutputBuilder {

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/create_key.rs

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

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

@@ -115,119 +240,567 @@

↥ 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("CreateKey")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateKeyEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_key::CreateKeyError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_key::CreateKeyError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::create_key::CreateKeyError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct CreateKeyResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateKeyResponseDeserializer {
     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_create_key::de_create_key_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::create_key::CreateKeyError::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 {
                 "CloudHsmClusterInvalidConfigurationException" => {
                     crate::operation::create_key::CreateKeyError::CloudHsmClusterInvalidConfigurationException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::CloudHsmClusterInvalidConfigurationException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::CloudHsmClusterInvalidConfigurationException::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
                     })
-+
+                }
                 "CustomKeyStoreInvalidStateException" => crate::operation::create_key::CreateKeyError::CustomKeyStoreInvalidStateException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::CustomKeyStoreInvalidStateException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::CustomKeyStoreInvalidStateException::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
                 }),
                 "CustomKeyStoreNotFoundException" => crate::operation::create_key::CreateKeyError::CustomKeyStoreNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::CustomKeyStoreNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::CustomKeyStoreNotFoundException::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
                 }),
                 "DependencyTimeoutException" => crate::operation::create_key::CreateKeyError::DependencyTimeoutException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::DependencyTimeoutException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::DependencyTimeoutException::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
                 }),
                 "InvalidArnException" => crate::operation::create_key::CreateKeyError::InvalidArnException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidArnException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidArnException::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
                 }),
                 "KMSInternalException" => crate::operation::create_key::CreateKeyError::KmsInternalException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::KmsInternalException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::KmsInternalException::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::create_key::CreateKeyError::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
                 }),
                 "MalformedPolicyDocumentException" => crate::operation::create_key::CreateKeyError::MalformedPolicyDocumentException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::MalformedPolicyDocumentException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::MalformedPolicyDocumentException::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
                 }),
                 "TagException" => crate::operation::create_key::CreateKeyError::TagException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::TagException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::TagException::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
                 }),
                 "UnsupportedOperationException" => crate::operation::create_key::CreateKeyError::UnsupportedOperationException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::UnsupportedOperationException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::UnsupportedOperationException::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
                 }),
                 "XksKeyAlreadyInUseException" => crate::operation::create_key::CreateKeyError::XksKeyAlreadyInUseException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::XksKeyAlreadyInUseException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::XksKeyAlreadyInUseException::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
                 }),
                 "XksKeyInvalidConfigurationException" => crate::operation::create_key::CreateKeyError::XksKeyInvalidConfigurationException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::XksKeyInvalidConfigurationException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::XksKeyInvalidConfigurationException::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
                 }),
                 "XksKeyNotFoundException" => crate::operation::create_key::CreateKeyError::XksKeyNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::XksKeyNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::XksKeyNotFoundException::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::create_key::CreateKeyError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_create_key::de_create_key_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, CreateKey::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::create_key::CreateKeyOutput::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))
-+
+        }
-518
+    }
-519
+}
 #[derive(Debug)]
 struct CreateKeyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateKeyRequestSerializer {
     #[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::create_key::CreateKeyInput>().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::create_key::CreateKeyInput,
                 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::create_key::CreateKeyInput,
                 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.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "TrentService.CreateKey",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_key::ser_create_key_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, CreateKey::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-538
+    }
-539
+}
 #[derive(Debug)]
 struct CreateKeyEndpointParamsInterceptor;
-542
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateKeyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CreateKeyEndpointParamsInterceptor"
-546
+    }
-547

↧ 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::<CreateKeyInput>()
             .ok_or("failed to downcast to CreateKeyInput")?;
-562
         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/kms/src/operation/create_key/_create_key_input.rs

@@ -309,309 +469,469 @@

↥ Expand context

         self.tags.as_deref().unwrap_or_default()
-310
+    }
     /// <p>Creates a multi-Region primary key that you can replicate into other Amazon Web Services Regions. You cannot change this value after you create the KMS key.</p>
     /// <p>For a multi-Region key, set this parameter to <code>True</code>. For a single-Region KMS key, omit this parameter or set it to <code>False</code>. The default value is <code>False</code>.</p>
     /// <p>This operation supports <i>multi-Region keys</i>, an KMS feature that lets you create multiple interoperable KMS keys in different Amazon Web Services Regions. Because these KMS keys have the same key ID, key material, and other metadata, you can use them interchangeably to encrypt data in one Amazon Web Services Region and decrypt it in a different Amazon Web Services Region without re-encrypting the data or making a cross-Region call. For more information about multi-Region keys, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html">Multi-Region keys in KMS</a> in the <i>Key Management Service Developer Guide</i>.</p>
     /// <p>This value creates a <i>primary key</i>, not a replica. To create a <i>replica key</i>, use the <code>ReplicateKey</code> operation.</p>
     /// <p>You can create a symmetric or asymmetric multi-Region key, and you can create a multi-Region key with imported key material. However, you cannot create a multi-Region key in a custom key store.</p>
     pub fn multi_region(&self) -> ::std::option::Option<bool> {
         self.multi_region
-318
+    }
     /// <p>Identifies the <a href="https://docs.aws.amazon.com/kms/latest/developerguide/keystore-external.html#concept-external-key">external key</a> that serves as key material for the KMS key in an <a href="https://docs.aws.amazon.com/kms/latest/developerguide/keystore-external.html">external key store</a>. Specify the ID that the <a href="https://docs.aws.amazon.com/kms/latest/developerguide/keystore-external.html#concept-xks-proxy">external key store proxy</a> uses to refer to the external key. For help, see the documentation for your external key store proxy.</p>
     /// <p>This parameter is required for a KMS key with an <code>Origin</code> value of <code>EXTERNAL_KEY_STORE</code>. It is not valid for KMS keys with any other <code>Origin</code> value.</p>
     /// <p>The external key must be an existing 256-bit AES symmetric encryption key hosted outside of Amazon Web Services in an external key manager associated with the external key store specified by the <code>CustomKeyStoreId</code> parameter. This key must be enabled and configured to perform encryption and decryption. Each KMS key in an external key store must use a different external key. For details, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/create-xks-keys.html#xks-key-requirements">Requirements for a KMS key in an external key store</a> in the <i>Key Management Service Developer Guide</i>.</p>
     /// <p>Each KMS key in an external key store is associated two backing keys. One is key material that KMS generates. The other is the external key specified by this parameter. When you use the KMS key in an external key store to encrypt data, the encryption operation is performed first by KMS using the KMS key material, and then by the external key manager using the specified external key, a process known as <i>double encryption</i>. For details, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/keystore-external.html#concept-double-encryption">Double encryption</a> in the <i>Key Management Service Developer Guide</i>.</p>
     pub fn xks_key_id(&self) -> ::std::option::Option<&str> {
         self.xks_key_id.as_deref()
-325
+    }
-326
+}
 static CREATEKEYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.kms.synthetic#CreateKeyInput",

     "com.amazonaws.kms.synthetic",
     "CreateKeyInput",
 );
 static CREATEKEYINPUT_MEMBER_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$Policy",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "policy",
     "Policy",
 ,
 );
 static CREATEKEYINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$Description",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "description",
     "Description",
 ,
 );
 static CREATEKEYINPUT_MEMBER_KEY_USAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$KeyUsage",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key_usage",
     "KeyUsage",
 ,
 );
 static CREATEKEYINPUT_MEMBER_CUSTOMER_MASTER_KEY_SPEC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$CustomerMasterKeySpec",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "customer_master_key_spec",
     "CustomerMasterKeySpec",
 ,
 );
 static CREATEKEYINPUT_MEMBER_KEY_SPEC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$KeySpec",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key_spec",
     "KeySpec",
 ,
 );
 static CREATEKEYINPUT_MEMBER_ORIGIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$Origin",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "origin",
     "Origin",
 ,
 );
 static CREATEKEYINPUT_MEMBER_CUSTOM_KEY_STORE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$CustomKeyStoreId",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "custom_key_store_id",
     "CustomKeyStoreId",
 ,
 );
 static CREATEKEYINPUT_MEMBER_BYPASS_POLICY_LOCKOUT_SAFETY_CHECK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$BypassPolicyLockoutSafetyCheck",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "bypass_policy_lockout_safety_check",
     "BypassPolicyLockoutSafetyCheck",
 ,
 );
 static CREATEKEYINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$Tags",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
 );
 static CREATEKEYINPUT_MEMBER_MULTI_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$MultiRegion",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "multi_region",
     "MultiRegion",
 ,
 );
 static CREATEKEYINPUT_MEMBER_XKS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.kms.synthetic#CreateKeyInput$XksKeyId",
         "com.amazonaws.kms.synthetic",
         "CreateKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "xks_key_id",
     "XksKeyId",
 ,
 );
 static CREATEKEYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEKEYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEKEYINPUT_MEMBER_POLICY,
         &CREATEKEYINPUT_MEMBER_DESCRIPTION,
         &CREATEKEYINPUT_MEMBER_KEY_USAGE,
         &CREATEKEYINPUT_MEMBER_CUSTOMER_MASTER_KEY_SPEC,

↧ Expand context

         &CREATEKEYINPUT_MEMBER_KEY_SPEC,
         &CREATEKEYINPUT_MEMBER_ORIGIN,
         &CREATEKEYINPUT_MEMBER_CUSTOM_KEY_STORE_ID,
         &CREATEKEYINPUT_MEMBER_BYPASS_POLICY_LOCKOUT_SAFETY_CHECK,
         &CREATEKEYINPUT_MEMBER_TAGS,
         &CREATEKEYINPUT_MEMBER_MULTI_REGION,
         &CREATEKEYINPUT_MEMBER_XKS_KEY_ID,
     ],
 );
 impl CreateKeyInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEKEYINPUT_SCHEMA;
-462
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateKeyInput {
     #[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.policy {

@@ -485,485 +610,618 @@

↥ Expand context

             ser.write_string(&CREATEKEYINPUT_MEMBER_ORIGIN, val.as_str())?;
-486
+        }
         if let Some(ref val) = self.custom_key_store_id {
             ser.write_string(&CREATEKEYINPUT_MEMBER_CUSTOM_KEY_STORE_ID, val)?;
-489
+        }
         if let Some(ref val) = self.bypass_policy_lockout_safety_check {
             ser.write_boolean(&CREATEKEYINPUT_MEMBER_BYPASS_POLICY_LOCKOUT_SAFETY_CHECK, *val)?;
-492
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &CREATEKEYINPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-499
+                    }
                     Ok(())
                 },
             )?;
-503
+        }
         if let Some(ref val) = self.multi_region {

             ser.write_boolean(&CREATEKEYINPUT_MEMBER_MULTI_REGION, *val)?;
-506
+        }
         if let Some(ref val) = self.xks_key_id {
             ser.write_string(&CREATEKEYINPUT_MEMBER_XKS_KEY_ID, val)?;
-509
+        }
         Ok(())
-511
+    }
-512
+}
 impl CreateKeyInput {
     /// 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(&CREATEKEYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEKEYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.policy = Some(deser.read_string(member)?);
-531
+                }
                 Some(1) => {
                     builder.description = Some(deser.read_string(member)?);
-534
+                }
                 Some(2) => {
                     builder.key_usage = Some(crate::types::KeyUsageType::from(deser.read_string(member)?.as_str()));
-537
+                }
                 Some(3) => {
                     builder.customer_master_key_spec = Some(crate::types::CustomerMasterKeySpec::from(deser.read_string(member)?.as_str()));
-540
+                }
                 Some(4) => {
                     builder.key_spec = Some(crate::types::KeySpec::from(deser.read_string(member)?.as_str()));
-543
+                }
                 Some(5) => {
                     builder.origin = Some(crate::types::OriginType::from(deser.read_string(member)?.as_str()));
-546
+                }
                 Some(6) => {
                     builder.custom_key_store_id = Some(deser.read_string(member)?);
-549
+                }
                 Some(7) => {
                     builder.bypass_policy_lockout_safety_check = Some(deser.read_boolean(member)?);
-552
+                }
                 Some(8) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-562
+                }
                 Some(9) => {
                     builder.multi_region = Some(deser.read_boolean(member)?);
-565
+                }
                 Some(10) => {
                     builder.xks_key_id = Some(deser.read_string(member)?);
-568
+                }
                 _ => {}
-570
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-576
+    }
-577
+}
 impl CreateKeyInput {
     /// 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 CreateKeyInput {
     /// Creates a new builder-style object to manufacture [`CreateKeyInput`](crate::operation::create_key::CreateKeyInput).
     pub fn builder() -> crate::operation::create_key::builders::CreateKeyInputBuilder {
         crate::operation::create_key::builders::CreateKeyInputBuilder::default()
-593
+    }
-594
+}
-595
 /// A builder for [`CreateKeyInput`](crate::operation::create_key::CreateKeyInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateKeyInputBuilder {
     pub(crate) policy: ::std::option::Option<::std::string::String>,
     pub(crate) description: ::std::option::Option<::std::string::String>,
     pub(crate) key_usage: ::std::option::Option<crate::types::KeyUsageType>,
     pub(crate) customer_master_key_spec: ::std::option::Option<crate::types::CustomerMasterKeySpec>,
     pub(crate) key_spec: ::std::option::Option<crate::types::KeySpec>,
     pub(crate) origin: ::std::option::Option<crate::types::OriginType>,
     pub(crate) custom_key_store_id: ::std::option::Option<::std::string::String>,
     pub(crate) bypass_policy_lockout_safety_check: ::std::option::Option<bool>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) multi_region: ::std::option::Option<bool>,
     pub(crate) xks_key_id: ::std::option::Option<::std::string::String>,
-611
+}
 impl CreateKeyInputBuilder {
     /// <p>The key policy to attach to the KMS key.</p>
     /// <p>If you provide a key policy, it must meet the following criteria:</p>
     /// <ul>
     /// <li>
     /// <p>The key policy must allow the calling principal to make a subsequent <code>PutKeyPolicy</code> request on the KMS key. This reduces the risk that the KMS key becomes unmanageable. For more information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-default.html#prevent-unmanageable-key">Default key policy</a> in the <i>Key Management Service Developer Guide</i>. (To omit this condition, set <code>BypassPolicyLockoutSafetyCheck</code> to true.)</p></li>
     /// <li>

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/create_key/_create_key_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 CreateKeyOutput {
     /// <p>Metadata associated with the KMS key.</p>
     pub key_metadata: ::std::option::Option<crate::types::KeyMetadata>,
     _request_id: Option<String>,
-9
+}
 impl CreateKeyOutput {
     /// <p>Metadata associated with the KMS key.</p>
     pub fn key_metadata(&self) -> ::std::option::Option<&crate::types::KeyMetadata> {
         self.key_metadata.as_ref()
-14
+    }
-15
+}
 static CREATEKEYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.kms.synthetic#CreateKeyOutput",

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

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/decrypt.rs

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

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

@@ -112,116 +237,512 @@

↥ Expand context

         });
-117
         ::std::option::Option::Some(cfg.freeze())
-119
+    }
-120
     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("Decrypt")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DecryptEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::decrypt::DecryptError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::decrypt::DecryptError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::decrypt::DecryptError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct DecryptResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DecryptResponseDeserializer {
     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_decrypt::de_decrypt_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::decrypt::DecryptError::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 {
                 "DependencyTimeoutException" => crate::operation::decrypt::DecryptError::DependencyTimeoutException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::DependencyTimeoutException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::DependencyTimeoutException::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
                 }),
                 "DisabledException" => crate::operation::decrypt::DecryptError::DisabledException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::DisabledException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::DisabledException::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
                 }),
                 "DryRunOperationException" => crate::operation::decrypt::DecryptError::DryRunOperationException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::DryRunOperationException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::DryRunOperationException::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
                 }),
                 "IncorrectKeyException" => crate::operation::decrypt::DecryptError::IncorrectKeyException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::IncorrectKeyException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::IncorrectKeyException::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
                 }),
                 "InvalidCiphertextException" => crate::operation::decrypt::DecryptError::InvalidCiphertextException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidCiphertextException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidCiphertextException::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
                 }),
                 "InvalidGrantTokenException" => crate::operation::decrypt::DecryptError::InvalidGrantTokenException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidGrantTokenException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidGrantTokenException::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
                 }),
                 "InvalidKeyUsageException" => crate::operation::decrypt::DecryptError::InvalidKeyUsageException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidKeyUsageException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidKeyUsageException::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
                 }),
                 "KeyUnavailableException" => crate::operation::decrypt::DecryptError::KeyUnavailableException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::KeyUnavailableException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::KeyUnavailableException::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
                 }),
                 "KMSInternalException" => crate::operation::decrypt::DecryptError::KmsInternalException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::KmsInternalException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::KmsInternalException::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
                 }),
                 "KMSInvalidStateException" => crate::operation::decrypt::DecryptError::KmsInvalidStateException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::KmsInvalidStateException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::KmsInvalidStateException::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
                 }),
                 "NotFoundException" => crate::operation::decrypt::DecryptError::NotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::NotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::NotFoundException::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::decrypt::DecryptError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_decrypt::de_decrypt_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, Decrypt::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::decrypt::DecryptOutput::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))
-+
+        }
-463
+    }
-464
+}
 #[derive(Debug)]
 struct DecryptRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DecryptRequestSerializer {
     #[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::decrypt::DecryptInput>().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::decrypt::DecryptInput,
                 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::decrypt::DecryptInput,
                 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.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "TrentService.Decrypt",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_decrypt::ser_decrypt_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, Decrypt::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-483
+    }
-484
+}
 #[derive(Debug)]
 struct DecryptEndpointParamsInterceptor;
-487
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DecryptEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DecryptEndpointParamsInterceptor"
-491
+    }
-492

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

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/create_grant.rs

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/create_grant/_create_grant_input.rs

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/create_grant/_create_grant_output.rs

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/create_key.rs

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/create_key/_create_key_input.rs

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/create_key/_create_key_output.rs

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/decrypt.rs