AWS SDK

AWS SDK

rev. 61347dcfc6aea9b1bb95fa06ec94864357dd1146

Files changed:

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

@@ -1,1 +36,36 @@
    1      1   
/*
    2      2   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    3      3   
 * SPDX-License-Identifier: Apache-2.0
    4      4   
 */
    5      5   
    6         -
use aws_sdk_s3::config::{timeout::TimeoutConfig, Region};
           6  +
use aws_sdk_s3::config::{retry::RetryConfig, timeout::TimeoutConfig, Region};
    7      7   
use aws_sdk_s3::error::DisplayErrorContext;
    8      8   
use aws_sdk_s3::primitives::ByteStream;
    9      9   
use aws_sdk_s3::types::{
   10     10   
    CompressionType, CsvInput, CsvOutput, ExpressionType, FileHeaderInfo, InputSerialization,
   11     11   
    OutputSerialization,
   12     12   
};
   13     13   
use aws_sdk_s3::{Client, Config};
   14     14   
use aws_smithy_async::assert_elapsed;
   15     15   
use aws_smithy_http_client::test_util::NeverClient;
   16     16   
use std::future::Future;
@@ -105,105 +0,281 @@
  125    125   
        )
  126    126   
    }
  127    127   
    let (server_shutdown, server_shutdown_receiver) = tokio::sync::oneshot::channel();
  128    128   
    let (server_fut, server_addr) = run_server(server_shutdown_receiver).await;
  129    129   
    let server_handle = tokio::spawn(server_fut);
  130    130   
    tokio::time::sleep(Duration::from_millis(100)).await;
  131    131   
  132    132   
    let config = Config::builder()
  133    133   
        .with_test_defaults()
  134    134   
        .region(Region::new("us-east-1"))
         135  +
        .retry_config(RetryConfig::disabled())
  135    136   
        .timeout_config(
  136    137   
            TimeoutConfig::builder()
  137    138   
                .read_timeout(Duration::from_millis(300))
  138    139   
                .build(),
  139    140   
        )
  140    141   
        .endpoint_url(format!("http://{server_addr}"))
  141    142   
        .build();
  142    143   
    let client = Client::from_conf(config);
  143    144   
  144    145   
    if let Ok(result) = timeout(
  145    146   
        Duration::from_millis(1000),
  146    147   
        client.get_object().bucket("test").key("test").send(),
  147    148   
    )
  148    149   
    .await
  149    150   
    {
  150    151   
        match result {
  151    152   
            Ok(_) => panic!("should not have succeeded"),
  152    153   
            Err(err) => {
  153    154   
                let message = format!("{}", DisplayErrorContext(&err));
  154    155   
                let expected = "timeout: HTTP read timeout occurred after 300ms";
  155    156   
                assert!(
  156    157   
                    message.contains(expected),
  157    158   
                    "expected '{message}' to contain '{expected}'"
  158    159   
                );
  159    160   
            }
  160    161   
        }
  161    162   
    } else {
  162    163   
        panic!("the client didn't timeout");
  163    164   
    }
  164    165   
  165    166   
    server_shutdown.send(()).unwrap();
  166    167   
    server_handle.await.unwrap();
  167    168   
}
  168    169   
  169    170   
#[tokio::test]
  170    171   
async fn test_connect_timeout() {
  171    172   
    let config = Config::builder()
  172    173   
        .with_test_defaults()
  173    174   
        .region(Region::new("us-east-1"))
         175  +
        .retry_config(RetryConfig::disabled())
  174    176   
        .timeout_config(
  175    177   
            TimeoutConfig::builder()
  176    178   
                .connect_timeout(Duration::from_millis(300))
  177    179   
                .build(),
  178    180   
        )
  179    181   
        .endpoint_url(
  180    182   
            // Emulate a connect timeout error by hitting an unroutable IP
  181    183   
            "http://172.255.255.0:18104",
  182    184   
        )
  183    185   
        .build();
  184    186   
    let client = Client::from_conf(config);
  185    187   
  186    188   
    if let Ok(result) = timeout(
  187    189   
        Duration::from_millis(1000),
  188    190   
        client.get_object().bucket("test").key("test").send(),
  189    191   
    )
  190    192   
    .await
  191    193   
    {
  192    194   
        match result {
  193    195   
            Ok(_) => panic!("should not have succeeded"),
  194    196   
            Err(err) => {
  195    197   
                let message = format!("{}", DisplayErrorContext(&err));
  196    198   
                let expected =
  197    199   
                    "timeout: client error (Connect): HTTP connect timeout occurred after 300ms";
  198    200   
                assert!(
  199    201   
                    message.contains(expected),
  200    202   
                    "expected '{message}' to contain '{expected}'"
  201    203   
                );
  202    204   
            }
  203    205   
        }
  204    206   
    } else {
  205    207   
        panic!("the client didn't timeout");
  206    208   
    }
  207    209   
}
         210  +
         211  +
#[tokio::test]
         212  +
#[expect(deprecated)]
         213  +
async fn test_connect_timeout_enabled_by_default_with_new_behavior_version() {
         214  +
    use aws_smithy_runtime_api::client::behavior_version::BehaviorVersion;
         215  +
         216  +
    // With BehaviorVersion >= v2025_01_17, a 3.1s connect timeout is enabled by default
         217  +
    let config = Config::builder()
         218  +
        .behavior_version(BehaviorVersion::v2025_01_17())
         219  +
        .region(Region::new("us-east-1"))
         220  +
        .retry_config(RetryConfig::disabled())
         221  +
        .endpoint_url(
         222  +
            // Emulate a connect timeout error by hitting an unroutable IP
         223  +
            "http://172.255.255.0:18104",
         224  +
        )
         225  +
        .build();
         226  +
    let client = Client::from_conf(config);
         227  +
         228  +
    if let Ok(result) = timeout(
         229  +
        Duration::from_millis(5000),
         230  +
        client.get_object().bucket("test").key("test").send(),
         231  +
    )
         232  +
    .await
         233  +
    {
         234  +
        match result {
         235  +
            Ok(_) => panic!("should not have succeeded"),
         236  +
            Err(err) => {
         237  +
                let message = format!("{}", DisplayErrorContext(&err));
         238  +
                // Should timeout with the default 3.1s connect timeout
         239  +
                let expected = "HTTP connect timeout occurred after 3.1s";
         240  +
                assert!(
         241  +
                    message.contains(expected),
         242  +
                    "expected '{message}' to contain '{expected}'"
         243  +
                );
         244  +
            }
         245  +
        }
         246  +
    } else {
         247  +
        panic!("the client didn't timeout");
         248  +
    }
         249  +
}
         250  +
         251  +
#[tokio::test]
         252  +
#[expect(deprecated)]
         253  +
async fn test_old_behavior_version_has_no_default_connect_timeout() {
         254  +
    use aws_credential_types::Credentials;
         255  +
    use aws_smithy_runtime_api::client::behavior_version::BehaviorVersion;
         256  +
         257  +
    // With v2024_03_28 (older BMV), no default connect timeout should be set
         258  +
    let config = Config::builder()
         259  +
        .behavior_version(BehaviorVersion::v2024_03_28())
         260  +
        .region(Region::new("us-east-1"))
         261  +
        .credentials_provider(Credentials::for_tests())
         262  +
        .retry_config(RetryConfig::disabled())
         263  +
        .endpoint_url("http://172.255.255.0:18104") // Unroutable IP
         264  +
        .build();
         265  +
    let client = Client::from_conf(config);
         266  +
         267  +
    // The client should hang indefinitely without a timeout
         268  +
    // We wrap it in a short test timeout to verify it doesn't complete quickly
         269  +
    let result = timeout(
         270  +
        Duration::from_millis(500),
         271  +
        client.get_object().bucket("test").key("test").send(),
         272  +
    )
         273  +
    .await;
         274  +
         275  +
    // Should timeout at the test wrapper level (not at client level)
         276  +
    // This proves the client has no default connect timeout
         277  +
    assert!(
         278  +
        result.is_err(),
         279  +
        "client should hang without default timeout, causing test timeout"
         280  +
    );
         281  +
}

tmp-codegen-diff/aws-sdk/sdk/s3control/src/config.rs

@@ -1476,1476 +1535,1536 @@
 1496   1496   
    };
 1497   1497   
 1498   1498   
    let scope = "aws-sdk-s3control";
 1499   1499   
 1500   1500   
    let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
 1501   1501   
                        // defaults
 1502   1502   
                        .with_client_plugins(::aws_smithy_runtime::client::defaults::default_plugins(
 1503   1503   
                            ::aws_smithy_runtime::client::defaults::DefaultPluginParams::new()
 1504   1504   
                                .with_retry_partition_name(default_retry_partition)
 1505   1505   
                                .with_behavior_version(config.behavior_version.expect("Invalid client configuration: A behavior major version must be set when sending a request or constructing a client. You must set it during client construction or by enabling the `behavior-version-latest` cargo feature."))
        1506  +
                                .with_is_aws_sdk(true)
 1506   1507   
                        ))
 1507   1508   
                        // user config
 1508   1509   
                        .with_client_plugin(
 1509   1510   
                            ::aws_smithy_runtime_api::client::runtime_plugin::StaticRuntimePlugin::new()
 1510   1511   
                                .with_config(config.config.clone())
 1511   1512   
                                .with_runtime_components(config.runtime_components.clone())
 1512   1513   
                        )
 1513   1514   
                        // codegen config
 1514   1515   
                        .with_client_plugin(crate::config::ServiceRuntimePlugin::new(config.clone()))
 1515   1516   
                        .with_client_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePlugin::new())

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/associate_access_grants_identity_center/builders.rs

@@ -56,56 +116,117 @@
   76     76   
    pub fn as_input(&self) -> &crate::operation::associate_access_grants_identity_center::builders::AssociateAccessGrantsIdentityCenterInputBuilder {
   77     77   
        &self.inner
   78     78   
    }
   79     79   
    /// Sends the request and returns the response.
   80     80   
    ///
   81     81   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   82     82   
    /// can be matched against.
   83     83   
    ///
   84     84   
    /// By default, any retryable failures will be retried twice. Retry behavior
   85     85   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   86         -
    /// set when configuring the client.
          86  +
    /// set when configuring the client. Note: retries are enabled by default when using
          87  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   87     88   
    pub async fn send(
   88     89   
        self,
   89     90   
    ) -> ::std::result::Result<
   90     91   
        crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterOutput,
   91     92   
        ::aws_smithy_runtime_api::client::result::SdkError<
   92     93   
            crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterError,
   93     94   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   94     95   
        >,
   95     96   
    > {
   96     97   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_grant/builders.rs

@@ -58,58 +118,119 @@
   78     78   
    pub fn as_input(&self) -> &crate::operation::create_access_grant::builders::CreateAccessGrantInputBuilder {
   79     79   
        &self.inner
   80     80   
    }
   81     81   
    /// Sends the request and returns the response.
   82     82   
    ///
   83     83   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   84     84   
    /// can be matched against.
   85     85   
    ///
   86     86   
    /// By default, any retryable failures will be retried twice. Retry behavior
   87     87   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   88         -
    /// set when configuring the client.
          88  +
    /// set when configuring the client. Note: retries are enabled by default when using
          89  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   89     90   
    pub async fn send(
   90     91   
        self,
   91     92   
    ) -> ::std::result::Result<
   92     93   
        crate::operation::create_access_grant::CreateAccessGrantOutput,
   93     94   
        ::aws_smithy_runtime_api::client::result::SdkError<
   94     95   
            crate::operation::create_access_grant::CreateAccessGrantError,
   95     96   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   96     97   
        >,
   97     98   
    > {
   98     99   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_grants_instance/builders.rs

@@ -56,56 +116,117 @@
   76     76   
    pub fn as_input(&self) -> &crate::operation::create_access_grants_instance::builders::CreateAccessGrantsInstanceInputBuilder {
   77     77   
        &self.inner
   78     78   
    }
   79     79   
    /// Sends the request and returns the response.
   80     80   
    ///
   81     81   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   82     82   
    /// can be matched against.
   83     83   
    ///
   84     84   
    /// By default, any retryable failures will be retried twice. Retry behavior
   85     85   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   86         -
    /// set when configuring the client.
          86  +
    /// set when configuring the client. Note: retries are enabled by default when using
          87  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   87     88   
    pub async fn send(
   88     89   
        self,
   89     90   
    ) -> ::std::result::Result<
   90     91   
        crate::operation::create_access_grants_instance::CreateAccessGrantsInstanceOutput,
   91     92   
        ::aws_smithy_runtime_api::client::result::SdkError<
   92     93   
            crate::operation::create_access_grants_instance::CreateAccessGrantsInstanceError,
   93     94   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   94     95   
        >,
   95     96   
    > {
   96     97   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_grants_location/builders.rs

@@ -68,68 +128,129 @@
   88     88   
    pub fn as_input(&self) -> &crate::operation::create_access_grants_location::builders::CreateAccessGrantsLocationInputBuilder {
   89     89   
        &self.inner
   90     90   
    }
   91     91   
    /// Sends the request and returns the response.
   92     92   
    ///
   93     93   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   94     94   
    /// can be matched against.
   95     95   
    ///
   96     96   
    /// By default, any retryable failures will be retried twice. Retry behavior
   97     97   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   98         -
    /// set when configuring the client.
          98  +
    /// set when configuring the client. Note: retries are enabled by default when using
          99  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   99    100   
    pub async fn send(
  100    101   
        self,
  101    102   
    ) -> ::std::result::Result<
  102    103   
        crate::operation::create_access_grants_location::CreateAccessGrantsLocationOutput,
  103    104   
        ::aws_smithy_runtime_api::client::result::SdkError<
  104    105   
            crate::operation::create_access_grants_location::CreateAccessGrantsLocationError,
  105    106   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
  106    107   
        >,
  107    108   
    > {
  108    109   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_point/builders.rs

@@ -60,60 +120,121 @@
   80     80   
    pub fn as_input(&self) -> &crate::operation::create_access_point::builders::CreateAccessPointInputBuilder {
   81     81   
        &self.inner
   82     82   
    }
   83     83   
    /// Sends the request and returns the response.
   84     84   
    ///
   85     85   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   86     86   
    /// can be matched against.
   87     87   
    ///
   88     88   
    /// By default, any retryable failures will be retried twice. Retry behavior
   89     89   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   90         -
    /// set when configuring the client.
          90  +
    /// set when configuring the client. Note: retries are enabled by default when using
          91  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   91     92   
    pub async fn send(
   92     93   
        self,
   93     94   
    ) -> ::std::result::Result<
   94     95   
        crate::operation::create_access_point::CreateAccessPointOutput,
   95     96   
        ::aws_smithy_runtime_api::client::result::SdkError<
   96     97   
            crate::operation::create_access_point::CreateAccessPointError,
   97     98   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   98     99   
        >,
   99    100   
    > {
  100    101   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_point_for_object_lambda/builders.rs

@@ -54,54 +114,115 @@
   74     74   
    pub fn as_input(&self) -> &crate::operation::create_access_point_for_object_lambda::builders::CreateAccessPointForObjectLambdaInputBuilder {
   75     75   
        &self.inner
   76     76   
    }
   77     77   
    /// Sends the request and returns the response.
   78     78   
    ///
   79     79   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   80     80   
    /// can be matched against.
   81     81   
    ///
   82     82   
    /// By default, any retryable failures will be retried twice. Retry behavior
   83     83   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   84         -
    /// set when configuring the client.
          84  +
    /// set when configuring the client. Note: retries are enabled by default when using
          85  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   85     86   
    pub async fn send(
   86     87   
        self,
   87     88   
    ) -> ::std::result::Result<
   88     89   
        crate::operation::create_access_point_for_object_lambda::CreateAccessPointForObjectLambdaOutput,
   89     90   
        ::aws_smithy_runtime_api::client::result::SdkError<
   90     91   
            crate::operation::create_access_point_for_object_lambda::CreateAccessPointForObjectLambdaError,
   91     92   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   92     93   
        >,
   93     94   
    > {
   94     95   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_bucket/builders.rs

@@ -66,66 +126,127 @@
   86     86   
    pub fn as_input(&self) -> &crate::operation::create_bucket::builders::CreateBucketInputBuilder {
   87     87   
        &self.inner
   88     88   
    }
   89     89   
    /// Sends the request and returns the response.
   90     90   
    ///
   91     91   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   92     92   
    /// can be matched against.
   93     93   
    ///
   94     94   
    /// By default, any retryable failures will be retried twice. Retry behavior
   95     95   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   96         -
    /// set when configuring the client.
          96  +
    /// set when configuring the client. Note: retries are enabled by default when using
          97  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   97     98   
    pub async fn send(
   98     99   
        self,
   99    100   
    ) -> ::std::result::Result<
  100    101   
        crate::operation::create_bucket::CreateBucketOutput,
  101    102   
        ::aws_smithy_runtime_api::client::result::SdkError<
  102    103   
            crate::operation::create_bucket::CreateBucketError,
  103    104   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
  104    105   
        >,
  105    106   
    > {
  106    107   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_job/builders.rs

@@ -59,59 +119,120 @@
   79     79   
    pub fn as_input(&self) -> &crate::operation::create_job::builders::CreateJobInputBuilder {
   80     80   
        &self.inner
   81     81   
    }
   82     82   
    /// Sends the request and returns the response.
   83     83   
    ///
   84     84   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   85     85   
    /// can be matched against.
   86     86   
    ///
   87     87   
    /// By default, any retryable failures will be retried twice. Retry behavior
   88     88   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   89         -
    /// set when configuring the client.
          89  +
    /// set when configuring the client. Note: retries are enabled by default when using
          90  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   90     91   
    pub async fn send(
   91     92   
        self,
   92     93   
    ) -> ::std::result::Result<
   93     94   
        crate::operation::create_job::CreateJobOutput,
   94     95   
        ::aws_smithy_runtime_api::client::result::SdkError<
   95     96   
            crate::operation::create_job::CreateJobError,
   96     97   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   97     98   
        >,
   98     99   
    > {
   99    100   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_multi_region_access_point/builders.rs

@@ -58,58 +118,119 @@
   78     78   
    pub fn as_input(&self) -> &crate::operation::create_multi_region_access_point::builders::CreateMultiRegionAccessPointInputBuilder {
   79     79   
        &self.inner
   80     80   
    }
   81     81   
    /// Sends the request and returns the response.
   82     82   
    ///
   83     83   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   84     84   
    /// can be matched against.
   85     85   
    ///
   86     86   
    /// By default, any retryable failures will be retried twice. Retry behavior
   87     87   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   88         -
    /// set when configuring the client.
          88  +
    /// set when configuring the client. Note: retries are enabled by default when using
          89  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   89     90   
    pub async fn send(
   90     91   
        self,
   91     92   
    ) -> ::std::result::Result<
   92     93   
        crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointOutput,
   93     94   
        ::aws_smithy_runtime_api::client::result::SdkError<
   94     95   
            crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointError,
   95     96   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   96     97   
        >,
   97     98   
    > {
   98     99   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_storage_lens_group/builders.rs

@@ -44,44 +104,105 @@
   64     64   
    pub fn as_input(&self) -> &crate::operation::create_storage_lens_group::builders::CreateStorageLensGroupInputBuilder {
   65     65   
        &self.inner
   66     66   
    }
   67     67   
    /// Sends the request and returns the response.
   68     68   
    ///
   69     69   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   70     70   
    /// can be matched against.
   71     71   
    ///
   72     72   
    /// By default, any retryable failures will be retried twice. Retry behavior
   73     73   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   74         -
    /// set when configuring the client.
          74  +
    /// set when configuring the client. Note: retries are enabled by default when using
          75  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   75     76   
    pub async fn send(
   76     77   
        self,
   77     78   
    ) -> ::std::result::Result<
   78     79   
        crate::operation::create_storage_lens_group::CreateStorageLensGroupOutput,
   79     80   
        ::aws_smithy_runtime_api::client::result::SdkError<
   80     81   
            crate::operation::create_storage_lens_group::CreateStorageLensGroupError,
   81     82   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   82     83   
        >,
   83     84   
    > {
   84     85   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/delete_access_grant/builders.rs

@@ -50,50 +110,111 @@
   70     70   
    pub fn as_input(&self) -> &crate::operation::delete_access_grant::builders::DeleteAccessGrantInputBuilder {
   71     71   
        &self.inner
   72     72   
    }
   73     73   
    /// Sends the request and returns the response.
   74     74   
    ///
   75     75   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   76     76   
    /// can be matched against.
   77     77   
    ///
   78     78   
    /// By default, any retryable failures will be retried twice. Retry behavior
   79     79   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   80         -
    /// set when configuring the client.
          80  +
    /// set when configuring the client. Note: retries are enabled by default when using
          81  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   81     82   
    pub async fn send(
   82     83   
        self,
   83     84   
    ) -> ::std::result::Result<
   84     85   
        crate::operation::delete_access_grant::DeleteAccessGrantOutput,
   85     86   
        ::aws_smithy_runtime_api::client::result::SdkError<
   86     87   
            crate::operation::delete_access_grant::DeleteAccessGrantError,
   87     88   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   88     89   
        >,
   89     90   
    > {
   90     91   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/delete_access_grants_instance/builders.rs

@@ -50,50 +110,111 @@
   70     70   
    pub fn as_input(&self) -> &crate::operation::delete_access_grants_instance::builders::DeleteAccessGrantsInstanceInputBuilder {
   71     71   
        &self.inner
   72     72   
    }
   73     73   
    /// Sends the request and returns the response.
   74     74   
    ///
   75     75   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   76     76   
    /// can be matched against.
   77     77   
    ///
   78     78   
    /// By default, any retryable failures will be retried twice. Retry behavior
   79     79   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   80         -
    /// set when configuring the client.
          80  +
    /// set when configuring the client. Note: retries are enabled by default when using
          81  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   81     82   
    pub async fn send(
   82     83   
        self,
   83     84   
    ) -> ::std::result::Result<
   84     85   
        crate::operation::delete_access_grants_instance::DeleteAccessGrantsInstanceOutput,
   85     86   
        ::aws_smithy_runtime_api::client::result::SdkError<
   86     87   
            crate::operation::delete_access_grants_instance::DeleteAccessGrantsInstanceError,
   87     88   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   88     89   
        >,
   89     90   
    > {
   90     91   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/delete_access_grants_instance_resource_policy/builders.rs

@@ -52,52 +112,113 @@
   72     72   
    ) -> &crate::operation::delete_access_grants_instance_resource_policy::builders::DeleteAccessGrantsInstanceResourcePolicyInputBuilder {
   73     73   
        &self.inner
   74     74   
    }
   75     75   
    /// Sends the request and returns the response.
   76     76   
    ///
   77     77   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   78     78   
    /// can be matched against.
   79     79   
    ///
   80     80   
    /// By default, any retryable failures will be retried twice. Retry behavior
   81     81   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   82         -
    /// set when configuring the client.
          82  +
    /// set when configuring the client. Note: retries are enabled by default when using
          83  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   83     84   
    pub async fn send(
   84     85   
        self,
   85     86   
    ) -> ::std::result::Result<
   86     87   
        crate::operation::delete_access_grants_instance_resource_policy::DeleteAccessGrantsInstanceResourcePolicyOutput,
   87     88   
        ::aws_smithy_runtime_api::client::result::SdkError<
   88     89   
            crate::operation::delete_access_grants_instance_resource_policy::DeleteAccessGrantsInstanceResourcePolicyError,
   89     90   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   90     91   
        >,
   91     92   
    > {
   92     93   
        let input = self

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/delete_access_grants_location/builders.rs

@@ -50,50 +110,111 @@
   70     70   
    pub fn as_input(&self) -> &crate::operation::delete_access_grants_location::builders::DeleteAccessGrantsLocationInputBuilder {
   71     71   
        &self.inner
   72     72   
    }
   73     73   
    /// Sends the request and returns the response.
   74     74   
    ///
   75     75   
    /// If an error occurs, an `SdkError` will be returned with additional details that
   76     76   
    /// can be matched against.
   77     77   
    ///
   78     78   
    /// By default, any retryable failures will be retried twice. Retry behavior
   79     79   
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   80         -
    /// set when configuring the client.
          80  +
    /// set when configuring the client. Note: retries are enabled by default when using
          81  +
    /// `aws_config::load_from_env()` or when using `BehaviorVersion::v2025_01_17()` or later.
   81     82   
    pub async fn send(
   82     83   
        self,
   83     84   
    ) -> ::std::result::Result<
   84     85   
        crate::operation::delete_access_grants_location::DeleteAccessGrantsLocationOutput,
   85     86   
        ::aws_smithy_runtime_api::client::result::SdkError<
   86     87   
            crate::operation::delete_access_grants_location::DeleteAccessGrantsLocationError,
   87     88   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   88     89   
        >,
   89     90   
    > {
   90     91   
        let input = self