AWS SDK

AWS SDK

rev. f6356c10a335c46b7f149fcf1eaedbf60e39c8d5 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/qldbsession/Cargo.toml

@@ -1,1 +111,111 @@
   13     13   
codegen-version = "ci"
   14     14   
[package.metadata.docs.rs]
   15     15   
all-features = true
   16     16   
targets = ["x86_64-unknown-linux-gnu"]
   17     17   
[dependencies.aws-credential-types]
   18     18   
path = "../aws-credential-types"
   19     19   
version = "1.2.0"
   20     20   
   21     21   
[dependencies.aws-runtime]
   22     22   
path = "../aws-runtime"
   23         -
version = "1.2.3"
          23  +
version = "1.3.0"
   24     24   
   25     25   
[dependencies.aws-smithy-async]
   26     26   
path = "../aws-smithy-async"
   27     27   
version = "1.2.1"
   28     28   
   29     29   
[dependencies.aws-smithy-http]
   30     30   
path = "../aws-smithy-http"
   31     31   
version = "0.60.8"
   32     32   
   33     33   
[dependencies.aws-smithy-json]
   34     34   
path = "../aws-smithy-json"
   35     35   
version = "0.60.7"
   36     36   
   37     37   
[dependencies.aws-smithy-runtime]
   38     38   
path = "../aws-smithy-runtime"
   39     39   
features = ["client"]
   40     40   
version = "1.6.0"
   41     41   
   42     42   
[dependencies.aws-smithy-runtime-api]
   43     43   
path = "../aws-smithy-runtime-api"
   44     44   
features = ["client", "http-02x"]
   45     45   
version = "1.7.0"
   46     46   
   47     47   
[dependencies.aws-smithy-types]
   48     48   
path = "../aws-smithy-types"
   49     49   
version = "1.2.0"
   50     50   
   51     51   
[dependencies.aws-types]
   52     52   
path = "../aws-types"
   53     53   
version = "1.3.1"
   54     54   
   55     55   
[dependencies.bytes]
   56     56   
version = "1.4.0"
   57     57   
   58     58   
[dependencies.http]
   59     59   
version = "0.2.9"
   60     60   
   61     61   
[dependencies.once_cell]
   62     62   
version = "1.16"
   63     63   
   64     64   
[dependencies.regex-lite]
   65     65   
version = "0.1.5"
   66     66   
   67     67   
[dependencies.tracing]
   68     68   
version = "0.1"
   69     69   
[dev-dependencies.aws-config]
   70     70   
path = "../aws-config"
   71     71   
version = "1.5.2"
   72     72   
   73     73   
[dev-dependencies.aws-credential-types]
   74     74   
path = "../aws-credential-types"
   75     75   
features = ["test-util"]
   76     76   
version = "1.2.0"
   77     77   
   78     78   
[dev-dependencies.aws-runtime]
   79     79   
path = "../aws-runtime"
   80     80   
features = ["test-util"]
   81         -
version = "1.2.3"
          81  +
version = "1.3.0"
   82     82   
   83     83   
[dev-dependencies.aws-smithy-async]
   84     84   
path = "../aws-smithy-async"
   85     85   
features = ["test-util"]
   86     86   
version = "1.2.1"
   87     87   
   88     88   
[dev-dependencies.aws-smithy-protocol-test]
   89     89   
path = "../aws-smithy-protocol-test"
   90     90   
version = "0.60.7"
   91     91   

tmp-codegen-diff/aws-sdk/sdk/route53/Cargo.toml

@@ -1,1 +53,53 @@
   13     13   
codegen-version = "ci"
   14     14   
[package.metadata.docs.rs]
   15     15   
all-features = true
   16     16   
targets = ["x86_64-unknown-linux-gnu"]
   17     17   
[dependencies.aws-credential-types]
   18     18   
path = "../aws-credential-types"
   19     19   
version = "1.2.0"
   20     20   
   21     21   
[dependencies.aws-runtime]
   22     22   
path = "../aws-runtime"
   23         -
version = "1.2.3"
          23  +
version = "1.3.0"
   24     24   
   25     25   
[dependencies.aws-smithy-async]
   26     26   
path = "../aws-smithy-async"
   27     27   
version = "1.2.1"
   28     28   
   29     29   
[dependencies.aws-smithy-http]
   30     30   
path = "../aws-smithy-http"
   31     31   
version = "0.60.8"
   32     32   
   33     33   
[dependencies.aws-smithy-json]

tmp-codegen-diff/aws-sdk/sdk/s3/Cargo.toml

@@ -1,1 +58,58 @@
   18     18   
version = "0.8.11"
   19     19   
default-features = false
   20     20   
   21     21   
[dependencies.aws-credential-types]
   22     22   
path = "../aws-credential-types"
   23     23   
version = "1.2.0"
   24     24   
   25     25   
[dependencies.aws-runtime]
   26     26   
path = "../aws-runtime"
   27     27   
features = ["event-stream", "http-02x"]
   28         -
version = "1.2.3"
          28  +
version = "1.3.0"
   29     29   
   30     30   
[dependencies.aws-sigv4]
   31     31   
path = "../aws-sigv4"
   32     32   
version = "1.2.2"
   33     33   
   34     34   
[dependencies.aws-smithy-async]
   35     35   
path = "../aws-smithy-async"
   36     36   
version = "1.2.1"
   37     37   
   38     38   
[dependencies.aws-smithy-checksums]
@@ -111,111 +171,171 @@
  131    131   
version = "1.5.2"
  132    132   
  133    133   
[dev-dependencies.aws-credential-types]
  134    134   
path = "../aws-credential-types"
  135    135   
features = ["test-util"]
  136    136   
version = "1.2.0"
  137    137   
  138    138   
[dev-dependencies.aws-runtime]
  139    139   
path = "../aws-runtime"
  140    140   
features = ["test-util"]
  141         -
version = "1.2.3"
         141  +
version = "1.3.0"
  142    142   
  143    143   
[dev-dependencies.aws-smithy-async]
  144    144   
path = "../aws-smithy-async"
  145    145   
features = ["test-util"]
  146    146   
version = "1.2.1"
  147    147   
  148    148   
[dev-dependencies.aws-smithy-experimental]
  149    149   
path = "../aws-smithy-experimental"
  150    150   
features = ["crypto-ring"]
  151    151   
version = "0.1.2"

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

@@ -94,94 +163,161 @@
  114    114   
        ::std::option::Option::Some(cfg.freeze())
  115    115   
    }
  116    116   
  117    117   
    fn runtime_components(
  118    118   
        &self,
  119    119   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  120    120   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  121    121   
        #[allow(unused_mut)]
  122    122   
                    let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("AbortMultipartUpload")
  123    123   
                            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  124         -
            .with_interceptor(AbortMultipartUploadEndpointParamsInterceptor)
  125         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  126         -
                crate::operation::abort_multipart_upload::AbortMultipartUploadError,
  127         -
            >::new())
  128         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  129         -
                crate::operation::abort_multipart_upload::AbortMultipartUploadError,
  130         -
            >::new())
  131         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  132         -
                crate::operation::abort_multipart_upload::AbortMultipartUploadError,
  133         -
            >::new());
         124  +
.with_interceptor(AbortMultipartUploadEndpointParamsInterceptor)
         125  +
                            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::abort_multipart_upload::AbortMultipartUploadError>::new())
         126  +
.with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::abort_multipart_upload::AbortMultipartUploadError>::new())
         127  +
.with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::abort_multipart_upload::AbortMultipartUploadError>::builder().transient_errors({
         128  +
                                            let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         129  +
                                            transient_errors.push("InternalError");
         130  +
                                            ::std::borrow::Cow::Owned(transient_errors)
         131  +
                                            }).build());
  134    132   
  135    133   
        ::std::borrow::Cow::Owned(rcb)
  136    134   
    }
  137    135   
}
  138    136   
  139    137   
#[derive(Debug)]
  140    138   
struct AbortMultipartUploadResponseDeserializer;
  141    139   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for AbortMultipartUploadResponseDeserializer {
  142    140   
    fn deserialize_nonstreaming(
  143    141   
        &self,

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

@@ -102,102 +164,172 @@
  122    122   
        #[allow(unused_mut)]
  123    123   
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CompleteMultipartUpload")
  124    124   
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  125    125   
            .with_interceptor(CompleteMultipartUploadEndpointParamsInterceptor)
  126    126   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  127    127   
                crate::operation::complete_multipart_upload::CompleteMultipartUploadError,
  128    128   
            >::new())
  129    129   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  130    130   
                crate::operation::complete_multipart_upload::CompleteMultipartUploadError,
  131    131   
            >::new())
  132         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         132  +
            .with_retry_classifier(
         133  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  133    134   
                    crate::operation::complete_multipart_upload::CompleteMultipartUploadError,
  134         -
            >::new());
         135  +
                >::builder()
         136  +
                .transient_errors({
         137  +
                    let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         138  +
                    transient_errors.push("InternalError");
         139  +
                    ::std::borrow::Cow::Owned(transient_errors)
         140  +
                })
         141  +
                .build(),
         142  +
            );
  135    143   
  136    144   
        ::std::borrow::Cow::Owned(rcb)
  137    145   
    }
  138    146   
}
  139    147   
  140    148   
#[derive(Debug)]
  141    149   
struct CompleteMultipartUploadResponseDeserializer;
  142    150   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CompleteMultipartUploadResponseDeserializer {
  143    151   
    fn deserialize_nonstreaming(
  144    152   
        &self,

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

@@ -98,98 +160,166 @@
  118    118   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  119    119   
        #[allow(unused_mut)]
  120    120   
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CopyObject")
  121    121   
            .with_interceptor(CopyObjectEndpointParamsInterceptor)
  122    122   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  123    123   
                crate::operation::copy_object::CopyObjectError,
  124    124   
            >::new())
  125    125   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  126    126   
                crate::operation::copy_object::CopyObjectError,
  127    127   
            >::new())
  128         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  129         -
                crate::operation::copy_object::CopyObjectError,
  130         -
            >::new());
         128  +
            .with_retry_classifier(
         129  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::copy_object::CopyObjectError>::builder()
         130  +
                    .transient_errors({
         131  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         132  +
                        transient_errors.push("InternalError");
         133  +
                        ::std::borrow::Cow::Owned(transient_errors)
         134  +
                    })
         135  +
                    .build(),
         136  +
            );
  131    137   
  132    138   
        ::std::borrow::Cow::Owned(rcb)
  133    139   
    }
  134    140   
}
  135    141   
  136    142   
#[derive(Debug)]
  137    143   
struct CopyObjectResponseDeserializer;
  138    144   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CopyObjectResponseDeserializer {
  139    145   
    fn deserialize_nonstreaming(
  140    146   
        &self,

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

@@ -98,98 +160,166 @@
  118    118   
        #[allow(unused_mut)]
  119    119   
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateBucket")
  120    120   
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  121    121   
            .with_interceptor(CreateBucketEndpointParamsInterceptor)
  122    122   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  123    123   
                crate::operation::create_bucket::CreateBucketError,
  124    124   
            >::new())
  125    125   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  126    126   
                crate::operation::create_bucket::CreateBucketError,
  127    127   
            >::new())
  128         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  129         -
                crate::operation::create_bucket::CreateBucketError,
  130         -
            >::new());
         128  +
            .with_retry_classifier(
         129  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::create_bucket::CreateBucketError>::builder()
         130  +
                    .transient_errors({
         131  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         132  +
                        transient_errors.push("InternalError");
         133  +
                        ::std::borrow::Cow::Owned(transient_errors)
         134  +
                    })
         135  +
                    .build(),
         136  +
            );
  131    137   
  132    138   
        ::std::borrow::Cow::Owned(rcb)
  133    139   
    }
  134    140   
}
  135    141   
  136    142   
#[derive(Debug)]
  137    143   
struct CreateBucketResponseDeserializer;
  138    144   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateBucketResponseDeserializer {
  139    145   
    fn deserialize_nonstreaming(
  140    146   
        &self,

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

@@ -93,93 +164,173 @@
  113    113   
        });
  114    114   
  115    115   
        ::std::option::Option::Some(cfg.freeze())
  116    116   
    }
  117    117   
  118    118   
    fn runtime_components(
  119    119   
        &self,
  120    120   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  121    121   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  122    122   
        #[allow(unused_mut)]
  123         -
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateMultipartUpload")
         123  +
        let mut rcb =
         124  +
            ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateMultipartUpload")
  124    125   
                .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  125    126   
                .with_interceptor(CreateMultipartUploadEndpointParamsInterceptor)
  126    127   
                .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  127    128   
                    crate::operation::create_multipart_upload::CreateMultipartUploadError,
  128    129   
                >::new())
  129    130   
                .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  130    131   
                    crate::operation::create_multipart_upload::CreateMultipartUploadError,
  131    132   
                >::new())
  132         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         133  +
                .with_retry_classifier(
         134  +
                    ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  133    135   
                        crate::operation::create_multipart_upload::CreateMultipartUploadError,
  134         -
            >::new());
         136  +
                    >::builder()
         137  +
                    .transient_errors({
         138  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         139  +
                        transient_errors.push("InternalError");
         140  +
                        ::std::borrow::Cow::Owned(transient_errors)
         141  +
                    })
         142  +
                    .build(),
         143  +
                );
  135    144   
  136    145   
        ::std::borrow::Cow::Owned(rcb)
  137    146   
    }
  138    147   
}
  139    148   
  140    149   
#[derive(Debug)]
  141    150   
struct CreateMultipartUploadResponseDeserializer;
  142    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateMultipartUploadResponseDeserializer {
  143    152   
    fn deserialize_nonstreaming(
  144    153   
        &self,

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

@@ -99,99 +161,167 @@
  119    119   
        #[allow(unused_mut)]
  120    120   
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateSession")
  121    121   
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  122    122   
            .with_interceptor(CreateSessionEndpointParamsInterceptor)
  123    123   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  124    124   
                crate::operation::create_session::CreateSessionError,
  125    125   
            >::new())
  126    126   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  127    127   
                crate::operation::create_session::CreateSessionError,
  128    128   
            >::new())
  129         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  130         -
                crate::operation::create_session::CreateSessionError,
  131         -
            >::new());
         129  +
            .with_retry_classifier(
         130  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::create_session::CreateSessionError>::builder()
         131  +
                    .transient_errors({
         132  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         133  +
                        transient_errors.push("InternalError");
         134  +
                        ::std::borrow::Cow::Owned(transient_errors)
         135  +
                    })
         136  +
                    .build(),
         137  +
            );
  132    138   
  133    139   
        ::std::borrow::Cow::Owned(rcb)
  134    140   
    }
  135    141   
}
  136    142   
  137    143   
#[derive(Debug)]
  138    144   
struct CreateSessionResponseDeserializer;
  139    145   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateSessionResponseDeserializer {
  140    146   
    fn deserialize_nonstreaming(
  141    147   
        &self,

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

@@ -98,98 +160,166 @@
  118    118   
        #[allow(unused_mut)]
  119    119   
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucket")
  120    120   
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  121    121   
            .with_interceptor(DeleteBucketEndpointParamsInterceptor)
  122    122   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  123    123   
                crate::operation::delete_bucket::DeleteBucketError,
  124    124   
            >::new())
  125    125   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  126    126   
                crate::operation::delete_bucket::DeleteBucketError,
  127    127   
            >::new())
  128         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  129         -
                crate::operation::delete_bucket::DeleteBucketError,
  130         -
            >::new());
         128  +
            .with_retry_classifier(
         129  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::delete_bucket::DeleteBucketError>::builder()
         130  +
                    .transient_errors({
         131  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         132  +
                        transient_errors.push("InternalError");
         133  +
                        ::std::borrow::Cow::Owned(transient_errors)
         134  +
                    })
         135  +
                    .build(),
         136  +
            );
  131    137   
  132    138   
        ::std::borrow::Cow::Owned(rcb)
  133    139   
    }
  134    140   
}
  135    141   
  136    142   
#[derive(Debug)]
  137    143   
struct DeleteBucketResponseDeserializer;
  138    144   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketResponseDeserializer {
  139    145   
    fn deserialize_nonstreaming(
  140    146   
        &self,

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

@@ -108,108 +170,178 @@
  128    128   
        #[allow(unused_mut)]
  129    129   
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketAnalyticsConfiguration")
  130    130   
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  131    131   
            .with_interceptor(DeleteBucketAnalyticsConfigurationEndpointParamsInterceptor)
  132    132   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  133    133   
                crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationError,
  134    134   
            >::new())
  135    135   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  136    136   
                crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationError,
  137    137   
            >::new())
  138         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         138  +
            .with_retry_classifier(
         139  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  139    140   
                    crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationError,
  140         -
            >::new());
         141  +
                >::builder()
         142  +
                .transient_errors({
         143  +
                    let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         144  +
                    transient_errors.push("InternalError");
         145  +
                    ::std::borrow::Cow::Owned(transient_errors)
         146  +
                })
         147  +
                .build(),
         148  +
            );
  141    149   
  142    150   
        ::std::borrow::Cow::Owned(rcb)
  143    151   
    }
  144    152   
}
  145    153   
  146    154   
#[derive(Debug)]
  147    155   
struct DeleteBucketAnalyticsConfigurationResponseDeserializer;
  148    156   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketAnalyticsConfigurationResponseDeserializer {
  149    157   
    fn deserialize_nonstreaming(
  150    158   
        &self,

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

@@ -98,98 +160,166 @@
  118    118   
        #[allow(unused_mut)]
  119    119   
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketCors")
  120    120   
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  121    121   
            .with_interceptor(DeleteBucketCorsEndpointParamsInterceptor)
  122    122   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  123    123   
                crate::operation::delete_bucket_cors::DeleteBucketCorsError,
  124    124   
            >::new())
  125    125   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  126    126   
                crate::operation::delete_bucket_cors::DeleteBucketCorsError,
  127    127   
            >::new())
  128         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  129         -
                crate::operation::delete_bucket_cors::DeleteBucketCorsError,
  130         -
            >::new());
         128  +
            .with_retry_classifier(
         129  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::delete_bucket_cors::DeleteBucketCorsError>::builder()
         130  +
                    .transient_errors({
         131  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         132  +
                        transient_errors.push("InternalError");
         133  +
                        ::std::borrow::Cow::Owned(transient_errors)
         134  +
                    })
         135  +
                    .build(),
         136  +
            );
  131    137   
  132    138   
        ::std::borrow::Cow::Owned(rcb)
  133    139   
    }
  134    140   
}
  135    141   
  136    142   
#[derive(Debug)]
  137    143   
struct DeleteBucketCorsResponseDeserializer;
  138    144   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketCorsResponseDeserializer {
  139    145   
    fn deserialize_nonstreaming(
  140    146   
        &self,

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

@@ -92,92 +163,172 @@
  112    112   
        });
  113    113   
  114    114   
        ::std::option::Option::Some(cfg.freeze())
  115    115   
    }
  116    116   
  117    117   
    fn runtime_components(
  118    118   
        &self,
  119    119   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  120    120   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  121    121   
        #[allow(unused_mut)]
  122         -
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketEncryption")
         122  +
        let mut rcb =
         123  +
            ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketEncryption")
  123    124   
                .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  124    125   
                .with_interceptor(DeleteBucketEncryptionEndpointParamsInterceptor)
  125    126   
                .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  126    127   
                    crate::operation::delete_bucket_encryption::DeleteBucketEncryptionError,
  127    128   
                >::new())
  128    129   
                .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  129    130   
                    crate::operation::delete_bucket_encryption::DeleteBucketEncryptionError,
  130    131   
                >::new())
  131         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         132  +
                .with_retry_classifier(
         133  +
                    ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  132    134   
                        crate::operation::delete_bucket_encryption::DeleteBucketEncryptionError,
  133         -
            >::new());
         135  +
                    >::builder()
         136  +
                    .transient_errors({
         137  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         138  +
                        transient_errors.push("InternalError");
         139  +
                        ::std::borrow::Cow::Owned(transient_errors)
         140  +
                    })
         141  +
                    .build(),
         142  +
                );
  134    143   
  135    144   
        ::std::borrow::Cow::Owned(rcb)
  136    145   
    }
  137    146   
}
  138    147   
  139    148   
#[derive(Debug)]
  140    149   
struct DeleteBucketEncryptionResponseDeserializer;
  141    150   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketEncryptionResponseDeserializer {
  142    151   
    fn deserialize_nonstreaming(
  143    152   
        &self,

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

@@ -109,109 +171,179 @@
  129    129   
        let mut rcb =
  130    130   
            ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketIntelligentTieringConfiguration")
  131    131   
                .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  132    132   
                .with_interceptor(DeleteBucketIntelligentTieringConfigurationEndpointParamsInterceptor)
  133    133   
                .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  134    134   
                    crate::operation::delete_bucket_intelligent_tiering_configuration::DeleteBucketIntelligentTieringConfigurationError,
  135    135   
                >::new())
  136    136   
                .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  137    137   
                    crate::operation::delete_bucket_intelligent_tiering_configuration::DeleteBucketIntelligentTieringConfigurationError,
  138    138   
                >::new())
  139         -
                .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         139  +
                .with_retry_classifier(
         140  +
                    ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  140    141   
                        crate::operation::delete_bucket_intelligent_tiering_configuration::DeleteBucketIntelligentTieringConfigurationError,
  141         -
                >::new());
         142  +
                    >::builder()
         143  +
                    .transient_errors({
         144  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         145  +
                        transient_errors.push("InternalError");
         146  +
                        ::std::borrow::Cow::Owned(transient_errors)
         147  +
                    })
         148  +
                    .build(),
         149  +
                );
  142    150   
  143    151   
        ::std::borrow::Cow::Owned(rcb)
  144    152   
    }
  145    153   
}
  146    154   
  147    155   
#[derive(Debug)]
  148    156   
struct DeleteBucketIntelligentTieringConfigurationResponseDeserializer;
  149    157   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketIntelligentTieringConfigurationResponseDeserializer {
  150    158   
    fn deserialize_nonstreaming(
  151    159   
        &self,

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

@@ -108,108 +170,178 @@
  128    128   
        #[allow(unused_mut)]
  129    129   
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketInventoryConfiguration")
  130    130   
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  131    131   
            .with_interceptor(DeleteBucketInventoryConfigurationEndpointParamsInterceptor)
  132    132   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  133    133   
                crate::operation::delete_bucket_inventory_configuration::DeleteBucketInventoryConfigurationError,
  134    134   
            >::new())
  135    135   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  136    136   
                crate::operation::delete_bucket_inventory_configuration::DeleteBucketInventoryConfigurationError,
  137    137   
            >::new())
  138         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         138  +
            .with_retry_classifier(
         139  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  139    140   
                    crate::operation::delete_bucket_inventory_configuration::DeleteBucketInventoryConfigurationError,
  140         -
            >::new());
         141  +
                >::builder()
         142  +
                .transient_errors({
         143  +
                    let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         144  +
                    transient_errors.push("InternalError");
         145  +
                    ::std::borrow::Cow::Owned(transient_errors)
         146  +
                })
         147  +
                .build(),
         148  +
            );
  141    149   
  142    150   
        ::std::borrow::Cow::Owned(rcb)
  143    151   
    }
  144    152   
}
  145    153   
  146    154   
#[derive(Debug)]
  147    155   
struct DeleteBucketInventoryConfigurationResponseDeserializer;
  148    156   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketInventoryConfigurationResponseDeserializer {
  149    157   
    fn deserialize_nonstreaming(
  150    158   
        &self,

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

@@ -92,92 +163,172 @@
  112    112   
        });
  113    113   
  114    114   
        ::std::option::Option::Some(cfg.freeze())
  115    115   
    }
  116    116   
  117    117   
    fn runtime_components(
  118    118   
        &self,
  119    119   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  120    120   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  121    121   
        #[allow(unused_mut)]
  122         -
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketLifecycle")
         122  +
        let mut rcb =
         123  +
            ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketLifecycle")
  123    124   
                .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  124    125   
                .with_interceptor(DeleteBucketLifecycleEndpointParamsInterceptor)
  125    126   
                .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  126    127   
                    crate::operation::delete_bucket_lifecycle::DeleteBucketLifecycleError,
  127    128   
                >::new())
  128    129   
                .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  129    130   
                    crate::operation::delete_bucket_lifecycle::DeleteBucketLifecycleError,
  130    131   
                >::new())
  131         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         132  +
                .with_retry_classifier(
         133  +
                    ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  132    134   
                        crate::operation::delete_bucket_lifecycle::DeleteBucketLifecycleError,
  133         -
            >::new());
         135  +
                    >::builder()
         136  +
                    .transient_errors({
         137  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         138  +
                        transient_errors.push("InternalError");
         139  +
                        ::std::borrow::Cow::Owned(transient_errors)
         140  +
                    })
         141  +
                    .build(),
         142  +
                );
  134    143   
  135    144   
        ::std::borrow::Cow::Owned(rcb)
  136    145   
    }
  137    146   
}
  138    147   
  139    148   
#[derive(Debug)]
  140    149   
struct DeleteBucketLifecycleResponseDeserializer;
  141    150   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketLifecycleResponseDeserializer {
  142    151   
    fn deserialize_nonstreaming(
  143    152   
        &self,