AWS SDK

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

@@ -110,110 +170,171 @@

-110
+{
     fn send(
         self,
         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<crate::operation::put_object::PutObjectOutput, crate::operation::put_object::PutObjectError>,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-118
+    }
-119
+}
 impl PutObjectFluentBuilder {
     /// Creates a new `PutObjectFluentBuilder`.
     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,
-127
+        }
-128
+    }
     /// Access the PutObject as a reference.

     pub fn as_input(&self) -> &crate::operation::put_object::builders::PutObjectInputBuilder {
         &self.inner
-132
+    }
     /// 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_object::PutObjectOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_object::PutObjectError,
             ::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_object::PutObject::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_object::PutObject::orchestrate(&runtime_plugins, input).await
-161
+    }
-162
     /// 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_object::PutObjectOutput,
         crate::operation::put_object::PutObjectError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -162,162 +222,223 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_object_acl::PutObjectAclOutput,
             crate::operation::put_object_acl::PutObjectAclError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-170
+    }
-171
+}
 impl PutObjectAclFluentBuilder {
     /// Creates a new `PutObjectAclFluentBuilder`.
     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,
-179
+        }
-180
+    }
     /// Access the PutObjectAcl as a reference.

     pub fn as_input(&self) -> &crate::operation::put_object_acl::builders::PutObjectAclInputBuilder {
         &self.inner
-184
+    }
     /// 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_object_acl::PutObjectAclOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_object_acl::PutObjectAclError,
             ::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_object_acl::PutObjectAcl::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_object_acl::PutObjectAcl::orchestrate(&runtime_plugins, input).await
-213
+    }
-214
     /// 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_object_acl::PutObjectAclOutput,
         crate::operation::put_object_acl::PutObjectAclError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_object_legal_hold/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::put_object_legal_hold::PutObjectLegalHoldOutput,
             crate::operation::put_object_legal_hold::PutObjectLegalHoldError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-52
+    }
-53
+}
 impl PutObjectLegalHoldFluentBuilder {
     /// Creates a new `PutObjectLegalHoldFluentBuilder`.
     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 PutObjectLegalHold as a reference.

     pub fn as_input(&self) -> &crate::operation::put_object_legal_hold::builders::PutObjectLegalHoldInputBuilder {
         &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::put_object_legal_hold::PutObjectLegalHoldOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_object_legal_hold::PutObjectLegalHoldError,
             ::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_object_legal_hold::PutObjectLegalHold::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_object_legal_hold::PutObjectLegalHold::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::put_object_legal_hold::PutObjectLegalHoldOutput,
         crate::operation::put_object_legal_hold::PutObjectLegalHoldError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -52,52 +112,113 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::put_object_lock_configuration::PutObjectLockConfigurationOutput,
             crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-60
+    }
-61
+}
 impl PutObjectLockConfigurationFluentBuilder {
     /// Creates a new `PutObjectLockConfigurationFluentBuilder`.
     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,
-69
+        }
-70
+    }
     /// Access the PutObjectLockConfiguration as a reference.

     pub fn as_input(&self) -> &crate::operation::put_object_lock_configuration::builders::PutObjectLockConfigurationInputBuilder {
         &self.inner
-74
+    }
     /// 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_object_lock_configuration::PutObjectLockConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
             ::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_object_lock_configuration::PutObjectLockConfiguration::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_object_lock_configuration::PutObjectLockConfiguration::orchestrate(&runtime_plugins, input).await
-103
+    }
-104
     /// 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_object_lock_configuration::PutObjectLockConfigurationOutput,
         crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_object_retention/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::put_object_retention::PutObjectRetentionOutput,
             crate::operation::put_object_retention::PutObjectRetentionError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-52
+    }
-53
+}
 impl PutObjectRetentionFluentBuilder {
     /// Creates a new `PutObjectRetentionFluentBuilder`.
     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 PutObjectRetention as a reference.

     pub fn as_input(&self) -> &crate::operation::put_object_retention::builders::PutObjectRetentionInputBuilder {
         &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::put_object_retention::PutObjectRetentionOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_object_retention::PutObjectRetentionError,
             ::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_object_retention::PutObjectRetention::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_object_retention::PutObjectRetention::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::put_object_retention::PutObjectRetentionOutput,
         crate::operation::put_object_retention::PutObjectRetentionError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_object_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_object_tagging::PutObjectTaggingOutput,
             crate::operation::put_object_tagging::PutObjectTaggingError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-73
+    }
-74
+}
 impl PutObjectTaggingFluentBuilder {
     /// Creates a new `PutObjectTaggingFluentBuilder`.
     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 PutObjectTagging as a reference.

     pub fn as_input(&self) -> &crate::operation::put_object_tagging::builders::PutObjectTaggingInputBuilder {
         &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_object_tagging::PutObjectTaggingOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_object_tagging::PutObjectTaggingError,
             ::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_object_tagging::PutObjectTagging::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_object_tagging::PutObjectTagging::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_object_tagging::PutObjectTaggingOutput,
         crate::operation::put_object_tagging::PutObjectTaggingError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_public_access_block/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::put_public_access_block::PutPublicAccessBlockOutput,
             crate::operation::put_public_access_block::PutPublicAccessBlockError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-65
+    }
-66
+}
 impl PutPublicAccessBlockFluentBuilder {
     /// Creates a new `PutPublicAccessBlockFluentBuilder`.
     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 PutPublicAccessBlock as a reference.

     pub fn as_input(&self) -> &crate::operation::put_public_access_block::builders::PutPublicAccessBlockInputBuilder {
         &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::put_public_access_block::PutPublicAccessBlockOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_public_access_block::PutPublicAccessBlockError,
             ::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_public_access_block::PutPublicAccessBlock::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::put_public_access_block::PutPublicAccessBlock::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::put_public_access_block::PutPublicAccessBlockOutput,
         crate::operation::put_public_access_block::PutPublicAccessBlockError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/rename_object/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::rename_object::RenameObjectOutput,
             crate::operation::rename_object::RenameObjectError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-69
+    }
-70
+}
 impl RenameObjectFluentBuilder {
     /// Creates a new `RenameObjectFluentBuilder`.
     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 RenameObject as a reference.

     pub fn as_input(&self) -> &crate::operation::rename_object::builders::RenameObjectInputBuilder {
         &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::rename_object::RenameObjectOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::rename_object::RenameObjectError,
             ::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::rename_object::RenameObject::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::rename_object::RenameObject::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::rename_object::RenameObjectOutput,
         crate::operation::rename_object::RenameObjectError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

@@ -131,131 +191,192 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::restore_object::RestoreObjectOutput,
             crate::operation::restore_object::RestoreObjectError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-139
+    }
-140
+}
 impl RestoreObjectFluentBuilder {
     /// Creates a new `RestoreObjectFluentBuilder`.
     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,
-148
+        }
-149
+    }
     /// Access the RestoreObject as a reference.

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

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

@@ -105,105 +165,166 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::select_object_content::SelectObjectContentOutput,
             crate::operation::select_object_content::SelectObjectContentError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-113
+    }
-114
+}
 impl SelectObjectContentFluentBuilder {
     /// Creates a new `SelectObjectContentFluentBuilder`.
     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,
-122
+        }
-123
+    }
     /// Access the SelectObjectContent as a reference.

     pub fn as_input(&self) -> &crate::operation::select_object_content::builders::SelectObjectContentInputBuilder {
         &self.inner
-127
+    }
     /// 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::select_object_content::SelectObjectContentOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::select_object_content::SelectObjectContentError,
             ::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::select_object_content::SelectObjectContent::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output = crate::operation::select_object_content::SelectObjectContent::orchestrate(&runtime_plugins, input).await?;
-156
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,

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

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

↥ Expand context

             crate::operation::update_bucket_metadata_inventory_table_configuration::UpdateBucketMetadataInventoryTableConfigurationOutput,
             crate::operation::update_bucket_metadata_inventory_table_configuration::UpdateBucketMetadataInventoryTableConfigurationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-87
+    }
-88
+}
 impl UpdateBucketMetadataInventoryTableConfigurationFluentBuilder {
     /// Creates a new `UpdateBucketMetadataInventoryTableConfigurationFluentBuilder`.
     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 UpdateBucketMetadataInventoryTableConfiguration as a reference.
     pub fn as_input(
         &self,
     ) -> &crate::operation::update_bucket_metadata_inventory_table_configuration::builders::UpdateBucketMetadataInventoryTableConfigurationInputBuilder

-102
+    {
         &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::update_bucket_metadata_inventory_table_configuration::UpdateBucketMetadataInventoryTableConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::update_bucket_metadata_inventory_table_configuration::UpdateBucketMetadataInventoryTableConfigurationError,
             ::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::update_bucket_metadata_inventory_table_configuration::UpdateBucketMetadataInventoryTableConfiguration::operation_runtime_plugins(
                             self.handle.runtime_plugins.clone(),
                             &self.handle.conf,
                             self.config_override,
                         );
         crate::operation::update_bucket_metadata_inventory_table_configuration::UpdateBucketMetadataInventoryTableConfiguration::orchestrate(
             &runtime_plugins,
             input,
-135
+        )
         .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::update_bucket_metadata_inventory_table_configuration::UpdateBucketMetadataInventoryTableConfigurationOutput,

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

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

↥ Expand context

             crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationOutput,
             crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-67
+    }
-68
+}
 impl UpdateBucketMetadataJournalTableConfigurationFluentBuilder {
     /// Creates a new `UpdateBucketMetadataJournalTableConfigurationFluentBuilder`.
     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,
-76
+        }
-77
+    }
     /// Access the UpdateBucketMetadataJournalTableConfiguration as a reference.
     pub fn as_input(
         &self,
     ) -> &crate::operation::update_bucket_metadata_journal_table_configuration::builders::UpdateBucketMetadataJournalTableConfigurationInputBuilder

-82
+    {
         &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::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationError,
             ::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::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfiguration::operation_runtime_plugins(
                             self.handle.runtime_plugins.clone(),
                             &self.handle.conf,
                             self.config_override,
                         );
         crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfiguration::orchestrate(
             &runtime_plugins,
             input,
-115
+        )
         .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::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationOutput,

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

@@ -131,131 +191,192 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::upload_part::UploadPartOutput,
             crate::operation::upload_part::UploadPartError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-139
+    }
-140
+}
 impl UploadPartFluentBuilder {
     /// Creates a new `UploadPartFluentBuilder`.
     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,
-148
+        }
-149
+    }
     /// Access the UploadPart as a reference.

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

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

@@ -143,143 +203,204 @@

↥ Expand context

         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::upload_part_copy::UploadPartCopyOutput,
             crate::operation::upload_part_copy::UploadPartCopyError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-151
+    }
-152
+}
 impl UploadPartCopyFluentBuilder {
     /// Creates a new `UploadPartCopyFluentBuilder`.
     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,
-160
+        }
-161
+    }
     /// Access the UploadPartCopy as a reference.

     pub fn as_input(&self) -> &crate::operation::upload_part_copy::builders::UploadPartCopyInputBuilder {
         &self.inner
-165
+    }
     /// 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::upload_part_copy::UploadPartCopyOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::upload_part_copy::UploadPartCopyError,
             ::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::upload_part_copy::UploadPartCopy::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::upload_part_copy::UploadPartCopy::orchestrate(&runtime_plugins, input).await
-194
+    }
-195
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::upload_part_copy::UploadPartCopyOutput,
         crate::operation::upload_part_copy::UploadPartCopyError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

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

     pub fn as_input(&self) -> &crate::operation::write_get_object_response::builders::WriteGetObjectResponseInputBuilder {
         &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::write_get_object_response::WriteGetObjectResponseOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::write_get_object_response::WriteGetObjectResponseError,
             ::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::write_get_object_response::WriteGetObjectResponse::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::write_get_object_response::WriteGetObjectResponse::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::write_get_object_response::WriteGetObjectResponseOutput,
         crate::operation::write_get_object_response::WriteGetObjectResponseError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)

tmp-codegen-diff/aws-sdk/sdk/s3/tests/client_construction.rs

@@ -11,11 +50,81 @@

↥ Expand context

     #[tokio::test]
     async fn using_config_loader() {
         // When using `aws_config::load_from_env`, things should just work
         let config = aws_config::load_from_env().await;
         assert!(config.timeout_config().unwrap().has_timeouts());
         assert!(config.retry_config().unwrap().has_retry());
         let _s3 = s3::Client::new(&config);
-18
+    }
-19
     #[test]
     fn manual_config_construction_all_defaults() {
         // When manually constructing `SdkConfig` with everything unset,
         // it should work since there will be no timeouts or retries enabled,
         // and thus, no sleep impl is required.
         let config = SdkConfig::builder()
             .stalled_stream_protection(StalledStreamProtectionConfig::disabled())
             .build();
         assert!(config.timeout_config().is_none());
         assert!(config.retry_config().is_none());
         let _s3 = s3::Client::new(&config);

-31
+    }
-32
     #[test]
     fn bytestream_from_path_exists() {
         let _ = aws_sdk_s3::primitives::ByteStream::from_path("a/b.txt");
-36
+    }
-37
+}
-38
 mod with_service_config {
     use aws_sdk_s3 as s3;
     use aws_smithy_runtime_api::client::behavior_version::BehaviorVersion;
-42
     #[test]
     fn manual_config_construction_all_defaults() {
         // When manually constructing `Config` with everything unset,
         // it should work since there will be no timeouts or retries enabled,
         // and thus, no sleep impl is required.
         let config = s3::Config::builder().build();
         let _s3 = s3::Client::from_conf(config);
-50
+    }
-+
     #[test]
     #[allow(deprecated)]
     fn test_client_with_new_behavior_version_builds_successfully() {
         // With v2025_01_17, retries are enabled by default
         // This test verifies the client builds without panicking about missing sleep impl
         let config = s3::Config::builder()
             .behavior_version(BehaviorVersion::v2025_01_17())
             .region(aws_types::region::Region::new("us-east-1"))
             .credentials_provider(aws_credential_types::Credentials::for_tests())
             .build();
-+
         // Should build successfully even though retries are enabled
         // (sleep impl is provided by default)
         let _client = s3::Client::from_conf(config);
-+
+    }
-+
     #[test]
     #[allow(deprecated)]
     fn test_client_with_old_behavior_version_builds_successfully() {
         // With v2024_03_28, retries are disabled by default
         let config = s3::Config::builder()
             .behavior_version(BehaviorVersion::v2024_03_28())
             .region(aws_types::region::Region::new("us-east-1"))
             .credentials_provider(aws_credential_types::Credentials::for_tests())
             .build();
-+
         // Should build successfully with retries disabled
         let _client = s3::Client::from_conf(config);
-+
+    }
-81
+}

AWS SDK

Files changed: