AWS SDK

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

@@ -65,65 +125,126 @@

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::enable_key_rotation::EnableKeyRotationOutput,
             crate::operation::enable_key_rotation::EnableKeyRotationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-73
+    }
-74
+}
 impl EnableKeyRotationFluentBuilder {
     /// Creates a new `EnableKeyRotationFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-82
+        }
-83
+    }
     /// Access the EnableKeyRotation as a reference.

     pub fn as_input(&self) -> &crate::operation::enable_key_rotation::builders::EnableKeyRotationInputBuilder {
         &self.inner
-87
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::enable_key_rotation::EnableKeyRotationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::enable_key_rotation::EnableKeyRotationError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::enable_key_rotation::EnableKeyRotation::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::enable_key_rotation::EnableKeyRotation::orchestrate(&runtime_plugins, input).await
-116
+    }
-117
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::enable_key_rotation::EnableKeyRotationOutput,
         crate::operation::enable_key_rotation::EnableKeyRotationError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -88,88 +148,149 @@

↥ Expand context

-88
+{
     fn send(
         self,
         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<crate::operation::encrypt::EncryptOutput, crate::operation::encrypt::EncryptError>,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-96
+    }
-97
+}
 impl EncryptFluentBuilder {
     /// Creates a new `EncryptFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-105
+        }
-106
+    }
     /// Access the Encrypt as a reference.

     pub fn as_input(&self) -> &crate::operation::encrypt::builders::EncryptInputBuilder {
         &self.inner
-110
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::encrypt::EncryptOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::encrypt::EncryptError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::encrypt::Encrypt::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::encrypt::Encrypt::orchestrate(&runtime_plugins, input).await
-139
+    }
-140
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<crate::operation::encrypt::EncryptOutput, crate::operation::encrypt::EncryptError, Self>
-145
+    {
         crate::client::customize::CustomizableOperation::new(self)
-147
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));

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

@@ -81,81 +141,142 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::generate_data_key::GenerateDataKeyOutput,
             crate::operation::generate_data_key::GenerateDataKeyError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-89
+    }
-90
+}
 impl GenerateDataKeyFluentBuilder {
     /// Creates a new `GenerateDataKeyFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-98
+        }
-99
+    }
     /// Access the GenerateDataKey as a reference.

     pub fn as_input(&self) -> &crate::operation::generate_data_key::builders::GenerateDataKeyInputBuilder {
         &self.inner
-103
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::generate_data_key::GenerateDataKeyOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::generate_data_key::GenerateDataKeyError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::generate_data_key::GenerateDataKey::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::generate_data_key::GenerateDataKey::orchestrate(&runtime_plugins, input).await
-132
+    }
-133
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::generate_data_key::GenerateDataKeyOutput,
         crate::operation::generate_data_key::GenerateDataKeyError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -64,64 +124,125 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::generate_data_key_pair::GenerateDataKeyPairOutput,
             crate::operation::generate_data_key_pair::GenerateDataKeyPairError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-72
+    }
-73
+}
 impl GenerateDataKeyPairFluentBuilder {
     /// Creates a new `GenerateDataKeyPairFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-81
+        }
-82
+    }
     /// Access the GenerateDataKeyPair as a reference.

     pub fn as_input(&self) -> &crate::operation::generate_data_key_pair::builders::GenerateDataKeyPairInputBuilder {
         &self.inner
-86
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::generate_data_key_pair::GenerateDataKeyPairOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::generate_data_key_pair::GenerateDataKeyPairError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::generate_data_key_pair::GenerateDataKeyPair::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::generate_data_key_pair::GenerateDataKeyPair::orchestrate(&runtime_plugins, input).await
-115
+    }
-116
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::generate_data_key_pair::GenerateDataKeyPairOutput,
         crate::operation::generate_data_key_pair::GenerateDataKeyPairError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -62,62 +122,123 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextOutput,
             crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-70
+    }
-71
+}
 impl GenerateDataKeyPairWithoutPlaintextFluentBuilder {
     /// Creates a new `GenerateDataKeyPairWithoutPlaintextFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-79
+        }
-80
+    }
     /// Access the GenerateDataKeyPairWithoutPlaintext as a reference.

     pub fn as_input(&self) -> &crate::operation::generate_data_key_pair_without_plaintext::builders::GenerateDataKeyPairWithoutPlaintextInputBuilder {
         &self.inner
-84
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins =
             crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintext::operation_runtime_plugins(
                 self.handle.runtime_plugins.clone(),
                 &self.handle.conf,
                 self.config_override,
             );
         crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintext::orchestrate(&runtime_plugins, input).await
-114
+    }
-115
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextOutput,
         crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError,
         Self,
     > {

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

@@ -66,66 +126,127 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextOutput,
             crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-74
+    }
-75
+}
 impl GenerateDataKeyWithoutPlaintextFluentBuilder {
     /// Creates a new `GenerateDataKeyWithoutPlaintextFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-83
+        }
-84
+    }
     /// Access the GenerateDataKeyWithoutPlaintext as a reference.

     pub fn as_input(&self) -> &crate::operation::generate_data_key_without_plaintext::builders::GenerateDataKeyWithoutPlaintextInputBuilder {
         &self.inner
-88
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintext::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintext::orchestrate(&runtime_plugins, input).await
-117
+    }
-118
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextOutput,
         crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -48,48 +108,109 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::generate_mac::GenerateMacOutput,
             crate::operation::generate_mac::GenerateMacError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-56
+    }
-57
+}
 impl GenerateMacFluentBuilder {
     /// Creates a new `GenerateMacFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-65
+        }
-66
+    }
     /// Access the GenerateMac as a reference.

     pub fn as_input(&self) -> &crate::operation::generate_mac::builders::GenerateMacInputBuilder {
         &self.inner
-70
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::generate_mac::GenerateMacOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::generate_mac::GenerateMacError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::generate_mac::GenerateMac::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::generate_mac::GenerateMac::orchestrate(&runtime_plugins, input).await
-99
+    }
-100
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::generate_mac::GenerateMacOutput,
         crate::operation::generate_mac::GenerateMacError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -47,47 +107,108 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::generate_random::GenerateRandomOutput,
             crate::operation::generate_random::GenerateRandomError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-55
+    }
-56
+}
 impl GenerateRandomFluentBuilder {
     /// Creates a new `GenerateRandomFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-64
+        }
-65
+    }
     /// Access the GenerateRandom as a reference.

     pub fn as_input(&self) -> &crate::operation::generate_random::builders::GenerateRandomInputBuilder {
         &self.inner
-69
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::generate_random::GenerateRandomOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::generate_random::GenerateRandomError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::generate_random::GenerateRandom::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::generate_random::GenerateRandom::orchestrate(&runtime_plugins, input).await
-98
+    }
-99
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::generate_random::GenerateRandomOutput,
         crate::operation::generate_random::GenerateRandomError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -44,44 +104,105 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::get_key_policy::GetKeyPolicyOutput,
             crate::operation::get_key_policy::GetKeyPolicyError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-52
+    }
-53
+}
 impl GetKeyPolicyFluentBuilder {
     /// Creates a new `GetKeyPolicyFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-61
+        }
-62
+    }
     /// Access the GetKeyPolicy as a reference.

     pub fn as_input(&self) -> &crate::operation::get_key_policy::builders::GetKeyPolicyInputBuilder {
         &self.inner
-66
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::get_key_policy::GetKeyPolicyOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_key_policy::GetKeyPolicyError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::get_key_policy::GetKeyPolicy::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::get_key_policy::GetKeyPolicy::orchestrate(&runtime_plugins, input).await
-95
+    }
-96
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::get_key_policy::GetKeyPolicyOutput,
         crate::operation::get_key_policy::GetKeyPolicyError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -66,66 +126,127 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::get_key_rotation_status::GetKeyRotationStatusOutput,
             crate::operation::get_key_rotation_status::GetKeyRotationStatusError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-74
+    }
-75
+}
 impl GetKeyRotationStatusFluentBuilder {
     /// Creates a new `GetKeyRotationStatusFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-83
+        }
-84
+    }
     /// Access the GetKeyRotationStatus as a reference.

     pub fn as_input(&self) -> &crate::operation::get_key_rotation_status::builders::GetKeyRotationStatusInputBuilder {
         &self.inner
-88
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::get_key_rotation_status::GetKeyRotationStatusOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_key_rotation_status::GetKeyRotationStatusError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::get_key_rotation_status::GetKeyRotationStatus::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::get_key_rotation_status::GetKeyRotationStatus::orchestrate(&runtime_plugins, input).await
-117
+    }
-118
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::get_key_rotation_status::GetKeyRotationStatusOutput,
         crate::operation::get_key_rotation_status::GetKeyRotationStatusError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -72,72 +132,133 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::get_parameters_for_import::GetParametersForImportOutput,
             crate::operation::get_parameters_for_import::GetParametersForImportError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-80
+    }
-81
+}
 impl GetParametersForImportFluentBuilder {
     /// Creates a new `GetParametersForImportFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-89
+        }
-90
+    }
     /// Access the GetParametersForImport as a reference.

     pub fn as_input(&self) -> &crate::operation::get_parameters_for_import::builders::GetParametersForImportInputBuilder {
         &self.inner
-94
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::get_parameters_for_import::GetParametersForImportOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_parameters_for_import::GetParametersForImportError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::get_parameters_for_import::GetParametersForImport::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::get_parameters_for_import::GetParametersForImport::orchestrate(&runtime_plugins, input).await
-123
+    }
-124
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::get_parameters_for_import::GetParametersForImportOutput,
         crate::operation::get_parameters_for_import::GetParametersForImportError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -57,57 +117,118 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::get_public_key::GetPublicKeyOutput,
             crate::operation::get_public_key::GetPublicKeyError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-65
+    }
-66
+}
 impl GetPublicKeyFluentBuilder {
     /// Creates a new `GetPublicKeyFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-74
+        }
-75
+    }
     /// Access the GetPublicKey as a reference.

     pub fn as_input(&self) -> &crate::operation::get_public_key::builders::GetPublicKeyInputBuilder {
         &self.inner
-79
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::get_public_key::GetPublicKeyOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_public_key::GetPublicKeyError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::get_public_key::GetPublicKey::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::get_public_key::GetPublicKey::orchestrate(&runtime_plugins, input).await
-108
+    }
-109
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::get_public_key::GetPublicKeyOutput,
         crate::operation::get_public_key::GetPublicKeyError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -83,83 +143,144 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::import_key_material::ImportKeyMaterialOutput,
             crate::operation::import_key_material::ImportKeyMaterialError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-91
+    }
-92
+}
 impl ImportKeyMaterialFluentBuilder {
     /// Creates a new `ImportKeyMaterialFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-100
+        }
-101
+    }
     /// Access the ImportKeyMaterial as a reference.

     pub fn as_input(&self) -> &crate::operation::import_key_material::builders::ImportKeyMaterialInputBuilder {
         &self.inner
-105
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::import_key_material::ImportKeyMaterialOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::import_key_material::ImportKeyMaterialError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::import_key_material::ImportKeyMaterial::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::import_key_material::ImportKeyMaterial::orchestrate(&runtime_plugins, input).await
-134
+    }
-135
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::import_key_material::ImportKeyMaterialOutput,
         crate::operation::import_key_material::ImportKeyMaterialError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -56,56 +116,117 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::list_aliases::ListAliasesOutput,
             crate::operation::list_aliases::ListAliasesError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-64
+    }
-65
+}
 impl ListAliasesFluentBuilder {
     /// Creates a new `ListAliasesFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-73
+        }
-74
+    }
     /// Access the ListAliases as a reference.

     pub fn as_input(&self) -> &crate::operation::list_aliases::builders::ListAliasesInputBuilder {
         &self.inner
-78
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::list_aliases::ListAliasesOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::list_aliases::ListAliasesError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::list_aliases::ListAliases::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::list_aliases::ListAliases::orchestrate(&runtime_plugins, input).await
-107
+    }
-108
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::list_aliases::ListAliasesOutput,
         crate::operation::list_aliases::ListAliasesError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -58,58 +118,119 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::list_grants::ListGrantsOutput,
             crate::operation::list_grants::ListGrantsError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-66
+    }
-67
+}
 impl ListGrantsFluentBuilder {
     /// Creates a new `ListGrantsFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-75
+        }
-76
+    }
     /// Access the ListGrants as a reference.

     pub fn as_input(&self) -> &crate::operation::list_grants::builders::ListGrantsInputBuilder {
         &self.inner
-80
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::list_grants::ListGrantsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::list_grants::ListGrantsError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::list_grants::ListGrants::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::list_grants::ListGrants::orchestrate(&runtime_plugins, input).await
-109
+    }
-110
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::list_grants::ListGrantsOutput,
         crate::operation::list_grants::ListGrantsError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -50,50 +110,111 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::list_key_policies::ListKeyPoliciesOutput,
             crate::operation::list_key_policies::ListKeyPoliciesError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-58
+    }
-59
+}
 impl ListKeyPoliciesFluentBuilder {
     /// Creates a new `ListKeyPoliciesFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-67
+        }
-68
+    }
     /// Access the ListKeyPolicies as a reference.

     pub fn as_input(&self) -> &crate::operation::list_key_policies::builders::ListKeyPoliciesInputBuilder {
         &self.inner
-72
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     /// set when configuring the client. Note: retries are enabled by default when using
     /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::list_key_policies::ListKeyPoliciesOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::list_key_policies::ListKeyPoliciesError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = self

↧ Expand context

             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::list_key_policies::ListKeyPolicies::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::list_key_policies::ListKeyPolicies::orchestrate(&runtime_plugins, input).await
-101
+    }
-102
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::list_key_policies::ListKeyPoliciesOutput,
         crate::operation::list_key_policies::ListKeyPoliciesError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

AWS SDK

Files changed: