AWS SDK

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_acl/builders.rs

@@ -169,169 +229,230 @@

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_acl::PutBucketAclOutput,
             crate::operation::put_bucket_acl::PutBucketAclError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-177
+    }
-178
+}
 impl PutBucketAclFluentBuilder {
     /// Creates a new `PutBucketAclFluentBuilder`.
     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,
-186
+        }
-187
+    }
     /// Access the PutBucketAcl as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_acl::builders::PutBucketAclInputBuilder {
         &self.inner
-191
+    }
     /// 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::put_bucket_acl::PutBucketAclOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_acl::PutBucketAclError,
             ::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::put_bucket_acl::PutBucketAcl::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_acl::PutBucketAcl::orchestrate(&runtime_plugins, input).await
-220
+    }
-221
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_acl::PutBucketAclOutput,
         crate::operation::put_bucket_acl::PutBucketAclError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_analytics_configuration/builders.rs

@@ -86,86 +146,147 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationOutput,
             crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-94
+    }
-95
+}
 impl PutBucketAnalyticsConfigurationFluentBuilder {
     /// Creates a new `PutBucketAnalyticsConfigurationFluentBuilder`.
     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,
-103
+        }
-104
+    }
     /// Access the PutBucketAnalyticsConfiguration as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_analytics_configuration::builders::PutBucketAnalyticsConfigurationInputBuilder {
         &self.inner
-108
+    }
     /// 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::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationError,
             ::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::put_bucket_analytics_configuration::PutBucketAnalyticsConfiguration::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfiguration::orchestrate(&runtime_plugins, input).await
-137
+    }
-138
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationOutput,
         crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_cors/builders.rs

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

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_cors::PutBucketCorsOutput,
             crate::operation::put_bucket_cors::PutBucketCorsError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-73
+    }
-74
+}
 impl PutBucketCorsFluentBuilder {
     /// Creates a new `PutBucketCorsFluentBuilder`.
     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 PutBucketCors as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_cors::builders::PutBucketCorsInputBuilder {
         &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::put_bucket_cors::PutBucketCorsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_cors::PutBucketCorsError,
             ::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::put_bucket_cors::PutBucketCors::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_cors::PutBucketCors::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::put_bucket_cors::PutBucketCorsOutput,
         crate::operation::put_bucket_cors::PutBucketCorsError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_encryption/builders.rs

@@ -98,98 +158,159 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_encryption::PutBucketEncryptionOutput,
             crate::operation::put_bucket_encryption::PutBucketEncryptionError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-106
+    }
-107
+}
 impl PutBucketEncryptionFluentBuilder {
     /// Creates a new `PutBucketEncryptionFluentBuilder`.
     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,
-115
+        }
-116
+    }
     /// Access the PutBucketEncryption as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_encryption::builders::PutBucketEncryptionInputBuilder {
         &self.inner
-120
+    }
     /// 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::put_bucket_encryption::PutBucketEncryptionOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_encryption::PutBucketEncryptionError,
             ::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::put_bucket_encryption::PutBucketEncryption::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_encryption::PutBucketEncryption::orchestrate(&runtime_plugins, input).await
-149
+    }
-150
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_encryption::PutBucketEncryptionOutput,
         crate::operation::put_bucket_encryption::PutBucketEncryptionError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_intelligent_tiering_configuration/builders.rs

@@ -82,82 +142,143 @@

↥ Expand context

         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationOutput,
             crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-88
+    }
-89
+}
 impl PutBucketIntelligentTieringConfigurationFluentBuilder {
     /// Creates a new `PutBucketIntelligentTieringConfigurationFluentBuilder`.
     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,
-97
+        }
-98
+    }
     /// Access the PutBucketIntelligentTieringConfiguration as a reference.
     pub fn as_input(
         &self,

     ) -> &crate::operation::put_bucket_intelligent_tiering_configuration::builders::PutBucketIntelligentTieringConfigurationInputBuilder {
         &self.inner
-104
+    }
     /// 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::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationError,
             ::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::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfiguration::operation_runtime_plugins(
                 self.handle.runtime_plugins.clone(),
                 &self.handle.conf,
                 self.config_override,
             );
         crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfiguration::orchestrate(&runtime_plugins, input)
             .await
-135
+    }
-136
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationOutput,
         crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationError,
         Self,

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_inventory_configuration/builders.rs

@@ -89,89 +149,150 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationOutput,
             crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-97
+    }
-98
+}
 impl PutBucketInventoryConfigurationFluentBuilder {
     /// Creates a new `PutBucketInventoryConfigurationFluentBuilder`.
     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,
-106
+        }
-107
+    }
     /// Access the PutBucketInventoryConfiguration as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_inventory_configuration::builders::PutBucketInventoryConfigurationInputBuilder {
         &self.inner
-111
+    }
     /// 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::put_bucket_inventory_configuration::PutBucketInventoryConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationError,
             ::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::put_bucket_inventory_configuration::PutBucketInventoryConfiguration::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfiguration::orchestrate(&runtime_plugins, input).await
-140
+    }
-141
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationOutput,
         crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_lifecycle_configuration/builders.rs

@@ -102,102 +162,163 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationOutput,
             crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-110
+    }
-111
+}
 impl PutBucketLifecycleConfigurationFluentBuilder {
     /// Creates a new `PutBucketLifecycleConfigurationFluentBuilder`.
     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,
-119
+        }
-120
+    }
     /// Access the PutBucketLifecycleConfiguration as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_lifecycle_configuration::builders::PutBucketLifecycleConfigurationInputBuilder {
         &self.inner
-124
+    }
     /// 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::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationError,
             ::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::put_bucket_lifecycle_configuration::PutBucketLifecycleConfiguration::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfiguration::orchestrate(&runtime_plugins, input).await
-153
+    }
-154
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationOutput,
         crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_logging/builders.rs

@@ -100,100 +160,161 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_logging::PutBucketLoggingOutput,
             crate::operation::put_bucket_logging::PutBucketLoggingError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-108
+    }
-109
+}
 impl PutBucketLoggingFluentBuilder {
     /// Creates a new `PutBucketLoggingFluentBuilder`.
     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,
-117
+        }
-118
+    }
     /// Access the PutBucketLogging as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_logging::builders::PutBucketLoggingInputBuilder {
         &self.inner
-122
+    }
     /// 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::put_bucket_logging::PutBucketLoggingOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_logging::PutBucketLoggingError,
             ::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::put_bucket_logging::PutBucketLogging::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_logging::PutBucketLogging::orchestrate(&runtime_plugins, input).await
-151
+    }
-152
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_logging::PutBucketLoggingOutput,
         crate::operation::put_bucket_logging::PutBucketLoggingError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_metrics_configuration/builders.rs

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

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfigurationOutput,
             crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfigurationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-73
+    }
-74
+}
 impl PutBucketMetricsConfigurationFluentBuilder {
     /// Creates a new `PutBucketMetricsConfigurationFluentBuilder`.
     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 PutBucketMetricsConfiguration as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_metrics_configuration::builders::PutBucketMetricsConfigurationInputBuilder {
         &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::put_bucket_metrics_configuration::PutBucketMetricsConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfigurationError,
             ::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::put_bucket_metrics_configuration::PutBucketMetricsConfiguration::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfiguration::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::put_bucket_metrics_configuration::PutBucketMetricsConfigurationOutput,
         crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfigurationError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_notification_configuration/builders.rs

@@ -60,60 +120,121 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationOutput,
             crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-68
+    }
-69
+}
 impl PutBucketNotificationConfigurationFluentBuilder {
     /// Creates a new `PutBucketNotificationConfigurationFluentBuilder`.
     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,
-77
+        }
-78
+    }
     /// Access the PutBucketNotificationConfiguration as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_notification_configuration::builders::PutBucketNotificationConfigurationInputBuilder {
         &self.inner
-82
+    }
     /// 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::put_bucket_notification_configuration::PutBucketNotificationConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationError,
             ::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::put_bucket_notification_configuration::PutBucketNotificationConfiguration::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfiguration::orchestrate(&runtime_plugins, input).await
-111
+    }
-112
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationOutput,
         crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_ownership_controls/builders.rs

@@ -51,51 +111,112 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsOutput,
             crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-59
+    }
-60
+}
 impl PutBucketOwnershipControlsFluentBuilder {
     /// Creates a new `PutBucketOwnershipControlsFluentBuilder`.
     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,
-68
+        }
-69
+    }
     /// Access the PutBucketOwnershipControls as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_ownership_controls::builders::PutBucketOwnershipControlsInputBuilder {
         &self.inner
-73
+    }
     /// 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::put_bucket_ownership_controls::PutBucketOwnershipControlsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsError,
             ::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::put_bucket_ownership_controls::PutBucketOwnershipControls::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControls::orchestrate(&runtime_plugins, input).await
-102
+    }
-103
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsOutput,
         crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_policy/builders.rs

@@ -79,79 +139,140 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_policy::PutBucketPolicyOutput,
             crate::operation::put_bucket_policy::PutBucketPolicyError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-87
+    }
-88
+}
 impl PutBucketPolicyFluentBuilder {
     /// Creates a new `PutBucketPolicyFluentBuilder`.
     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,
-96
+        }
-97
+    }
     /// Access the PutBucketPolicy as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_policy::builders::PutBucketPolicyInputBuilder {
         &self.inner
-101
+    }
     /// 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::put_bucket_policy::PutBucketPolicyOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_policy::PutBucketPolicyError,
             ::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::put_bucket_policy::PutBucketPolicy::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_policy::PutBucketPolicy::orchestrate(&runtime_plugins, input).await
-130
+    }
-131
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_policy::PutBucketPolicyOutput,
         crate::operation::put_bucket_policy::PutBucketPolicyError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_replication/builders.rs

@@ -74,74 +134,135 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_replication::PutBucketReplicationOutput,
             crate::operation::put_bucket_replication::PutBucketReplicationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-82
+    }
-83
+}
 impl PutBucketReplicationFluentBuilder {
     /// Creates a new `PutBucketReplicationFluentBuilder`.
     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,
-91
+        }
-92
+    }
     /// Access the PutBucketReplication as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_replication::builders::PutBucketReplicationInputBuilder {
         &self.inner
-96
+    }
     /// 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::put_bucket_replication::PutBucketReplicationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_replication::PutBucketReplicationError,
             ::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::put_bucket_replication::PutBucketReplication::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_replication::PutBucketReplication::orchestrate(&runtime_plugins, input).await
-125
+    }
-126
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_replication::PutBucketReplicationOutput,
         crate::operation::put_bucket_replication::PutBucketReplicationError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_request_payment/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::put_bucket_request_payment::PutBucketRequestPaymentOutput,
             crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-58
+    }
-59
+}
 impl PutBucketRequestPaymentFluentBuilder {
     /// Creates a new `PutBucketRequestPaymentFluentBuilder`.
     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 PutBucketRequestPayment as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_request_payment::builders::PutBucketRequestPaymentInputBuilder {
         &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::put_bucket_request_payment::PutBucketRequestPaymentOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,
             ::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::put_bucket_request_payment::PutBucketRequestPayment::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_request_payment::PutBucketRequestPayment::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::put_bucket_request_payment::PutBucketRequestPaymentOutput,
         crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_tagging/builders.rs

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

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_tagging::PutBucketTaggingOutput,
             crate::operation::put_bucket_tagging::PutBucketTaggingError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-73
+    }
-74
+}
 impl PutBucketTaggingFluentBuilder {
     /// Creates a new `PutBucketTaggingFluentBuilder`.
     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 PutBucketTagging as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_tagging::builders::PutBucketTaggingInputBuilder {
         &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::put_bucket_tagging::PutBucketTaggingOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_tagging::PutBucketTaggingError,
             ::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::put_bucket_tagging::PutBucketTagging::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_tagging::PutBucketTagging::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::put_bucket_tagging::PutBucketTaggingOutput,
         crate::operation::put_bucket_tagging::PutBucketTaggingError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_versioning/builders.rs

@@ -61,61 +121,122 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_bucket_versioning::PutBucketVersioningOutput,
             crate::operation::put_bucket_versioning::PutBucketVersioningError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-69
+    }
-70
+}
 impl PutBucketVersioningFluentBuilder {
     /// Creates a new `PutBucketVersioningFluentBuilder`.
     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,
-78
+        }
-79
+    }
     /// Access the PutBucketVersioning as a reference.

     pub fn as_input(&self) -> &crate::operation::put_bucket_versioning::builders::PutBucketVersioningInputBuilder {
         &self.inner
-83
+    }
     /// 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::put_bucket_versioning::PutBucketVersioningOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_bucket_versioning::PutBucketVersioningError,
             ::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::put_bucket_versioning::PutBucketVersioning::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_bucket_versioning::PutBucketVersioning::orchestrate(&runtime_plugins, input).await
-112
+    }
-113
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::put_bucket_versioning::PutBucketVersioningOutput,
         crate::operation::put_bucket_versioning::PutBucketVersioningError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

AWS SDK

Files changed: