AWS SDK

AWS SDK

rev. f6356c10a335c46b7f149fcf1eaedbf60e39c8d5

Files changed:

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

@@ -114,114 +176,182 @@
  134    134   
                    };
  135    135   
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  136    136   
                },
  137    137   
            ))
  138    138   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  139    139   
                crate::operation::put_bucket_policy::PutBucketPolicyError,
  140    140   
            >::new())
  141    141   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  142    142   
                crate::operation::put_bucket_policy::PutBucketPolicyError,
  143    143   
            >::new())
  144         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  145         -
                crate::operation::put_bucket_policy::PutBucketPolicyError,
  146         -
            >::new());
         144  +
            .with_retry_classifier(
         145  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_policy::PutBucketPolicyError>::builder()
         146  +
                    .transient_errors({
         147  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         148  +
                        transient_errors.push("InternalError");
         149  +
                        ::std::borrow::Cow::Owned(transient_errors)
         150  +
                    })
         151  +
                    .build(),
         152  +
            );
  147    153   
  148    154   
        ::std::borrow::Cow::Owned(rcb)
  149    155   
    }
  150    156   
}
  151    157   
  152    158   
#[derive(Debug)]
  153    159   
struct PutBucketPolicyResponseDeserializer;
  154    160   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketPolicyResponseDeserializer {
  155    161   
    fn deserialize_nonstreaming(
  156    162   
        &self,

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

@@ -93,93 +179,175 @@
  113    113   
        cfg.store_put(crate::s3_express::checksum::provide_default_checksum_algorithm());
  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("PutBucketReplication")
  124         -
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  125         -
            .with_interceptor(PutBucketReplicationEndpointParamsInterceptor)
  126         -
            .with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(
  127         -
                |input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
  128         -
                    let input: &crate::operation::put_bucket_replication::PutBucketReplicationInput = input.downcast_ref().expect("correct type");
  129         -
                    let checksum_algorithm = input.checksum_algorithm();
  130         -
                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
  131         -
                    let checksum_algorithm = match checksum_algorithm {
  132         -
                        Some(algo) => Some(
  133         -
                            algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
  134         -
                                .map_err(::aws_smithy_types::error::operation::BuildError::other)?,
  135         -
                        ),
  136         -
                        None => None,
  137         -
                    };
  138         -
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  139         -
                },
  140         -
            ))
  141         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  142         -
                crate::operation::put_bucket_replication::PutBucketReplicationError,
  143         -
            >::new())
  144         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  145         -
                crate::operation::put_bucket_replication::PutBucketReplicationError,
  146         -
            >::new())
  147         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  148         -
                crate::operation::put_bucket_replication::PutBucketReplicationError,
  149         -
            >::new());
         123  +
                    let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutBucketReplication")
         124  +
                            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
         125  +
.with_interceptor(PutBucketReplicationEndpointParamsInterceptor)
         126  +
.with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(|input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
         127  +
                                    let input: &crate::operation::put_bucket_replication::PutBucketReplicationInput = input.downcast_ref().expect("correct type");
         128  +
                                    let checksum_algorithm = input.checksum_algorithm();
         129  +
                                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
         130  +
let checksum_algorithm = match checksum_algorithm {
         131  +
                Some(algo) => Some(
         132  +
                    algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
         133  +
                    .map_err(::aws_smithy_types::error::operation::BuildError::other)?
         134  +
                ),
         135  +
                None => None,
         136  +
            };
         137  +
                                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
         138  +
                                }))
         139  +
                            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_bucket_replication::PutBucketReplicationError>::new())
         140  +
.with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_bucket_replication::PutBucketReplicationError>::new())
         141  +
.with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_replication::PutBucketReplicationError>::builder().transient_errors({
         142  +
                                            let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         143  +
                                            transient_errors.push("InternalError");
         144  +
                                            ::std::borrow::Cow::Owned(transient_errors)
         145  +
                                            }).build());
  150    146   
  151    147   
        ::std::borrow::Cow::Owned(rcb)
  152    148   
    }
  153    149   
}
  154    150   
  155    151   
#[derive(Debug)]
  156    152   
struct PutBucketReplicationResponseDeserializer;
  157    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketReplicationResponseDeserializer {
  158    154   
    fn deserialize_nonstreaming(
  159    155   
        &self,

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

@@ -118,118 +180,188 @@
  138    138   
                    };
  139    139   
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  140    140   
                },
  141    141   
            ))
  142    142   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  143    143   
                crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,
  144    144   
            >::new())
  145    145   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  146    146   
                crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,
  147    147   
            >::new())
  148         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  149         -
                crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,
  150         -
            >::new());
         148  +
            .with_retry_classifier(
         149  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         150  +
                    crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,
         151  +
                >::builder()
         152  +
                .transient_errors({
         153  +
                    let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         154  +
                    transient_errors.push("InternalError");
         155  +
                    ::std::borrow::Cow::Owned(transient_errors)
         156  +
                })
         157  +
                .build(),
         158  +
            );
  151    159   
  152    160   
        ::std::borrow::Cow::Owned(rcb)
  153    161   
    }
  154    162   
}
  155    163   
  156    164   
#[derive(Debug)]
  157    165   
struct PutBucketRequestPaymentResponseDeserializer;
  158    166   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketRequestPaymentResponseDeserializer {
  159    167   
    fn deserialize_nonstreaming(
  160    168   
        &self,

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

@@ -114,114 +176,182 @@
  134    134   
                    };
  135    135   
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  136    136   
                },
  137    137   
            ))
  138    138   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  139    139   
                crate::operation::put_bucket_tagging::PutBucketTaggingError,
  140    140   
            >::new())
  141    141   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  142    142   
                crate::operation::put_bucket_tagging::PutBucketTaggingError,
  143    143   
            >::new())
  144         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  145         -
                crate::operation::put_bucket_tagging::PutBucketTaggingError,
  146         -
            >::new());
         144  +
            .with_retry_classifier(
         145  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_tagging::PutBucketTaggingError>::builder()
         146  +
                    .transient_errors({
         147  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         148  +
                        transient_errors.push("InternalError");
         149  +
                        ::std::borrow::Cow::Owned(transient_errors)
         150  +
                    })
         151  +
                    .build(),
         152  +
            );
  147    153   
  148    154   
        ::std::borrow::Cow::Owned(rcb)
  149    155   
    }
  150    156   
}
  151    157   
  152    158   
#[derive(Debug)]
  153    159   
struct PutBucketTaggingResponseDeserializer;
  154    160   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketTaggingResponseDeserializer {
  155    161   
    fn deserialize_nonstreaming(
  156    162   
        &self,

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

@@ -90,90 +176,172 @@
  110    110   
        cfg.store_put(crate::s3_express::checksum::provide_default_checksum_algorithm());
  111    111   
  112    112   
        ::std::option::Option::Some(cfg.freeze())
  113    113   
    }
  114    114   
  115    115   
    fn runtime_components(
  116    116   
        &self,
  117    117   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  118    118   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  119    119   
        #[allow(unused_mut)]
  120         -
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutBucketVersioning")
  121         -
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  122         -
            .with_interceptor(PutBucketVersioningEndpointParamsInterceptor)
  123         -
            .with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(
  124         -
                |input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
  125         -
                    let input: &crate::operation::put_bucket_versioning::PutBucketVersioningInput = input.downcast_ref().expect("correct type");
  126         -
                    let checksum_algorithm = input.checksum_algorithm();
  127         -
                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
  128         -
                    let checksum_algorithm = match checksum_algorithm {
  129         -
                        Some(algo) => Some(
  130         -
                            algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
  131         -
                                .map_err(::aws_smithy_types::error::operation::BuildError::other)?,
  132         -
                        ),
  133         -
                        None => None,
  134         -
                    };
  135         -
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  136         -
                },
  137         -
            ))
  138         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  139         -
                crate::operation::put_bucket_versioning::PutBucketVersioningError,
  140         -
            >::new())
  141         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  142         -
                crate::operation::put_bucket_versioning::PutBucketVersioningError,
  143         -
            >::new())
  144         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  145         -
                crate::operation::put_bucket_versioning::PutBucketVersioningError,
  146         -
            >::new());
         120  +
                    let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutBucketVersioning")
         121  +
                            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
         122  +
.with_interceptor(PutBucketVersioningEndpointParamsInterceptor)
         123  +
.with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(|input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
         124  +
                                    let input: &crate::operation::put_bucket_versioning::PutBucketVersioningInput = input.downcast_ref().expect("correct type");
         125  +
                                    let checksum_algorithm = input.checksum_algorithm();
         126  +
                                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
         127  +
let checksum_algorithm = match checksum_algorithm {
         128  +
                Some(algo) => Some(
         129  +
                    algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
         130  +
                    .map_err(::aws_smithy_types::error::operation::BuildError::other)?
         131  +
                ),
         132  +
                None => None,
         133  +
            };
         134  +
                                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
         135  +
                                }))
         136  +
                            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_bucket_versioning::PutBucketVersioningError>::new())
         137  +
.with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_bucket_versioning::PutBucketVersioningError>::new())
         138  +
.with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_versioning::PutBucketVersioningError>::builder().transient_errors({
         139  +
                                            let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         140  +
                                            transient_errors.push("InternalError");
         141  +
                                            ::std::borrow::Cow::Owned(transient_errors)
         142  +
                                            }).build());
  147    143   
  148    144   
        ::std::borrow::Cow::Owned(rcb)
  149    145   
    }
  150    146   
}
  151    147   
  152    148   
#[derive(Debug)]
  153    149   
struct PutBucketVersioningResponseDeserializer;
  154    150   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketVersioningResponseDeserializer {
  155    151   
    fn deserialize_nonstreaming(
  156    152   
        &self,

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

@@ -114,114 +176,182 @@
  134    134   
                    };
  135    135   
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  136    136   
                },
  137    137   
            ))
  138    138   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  139    139   
                crate::operation::put_bucket_website::PutBucketWebsiteError,
  140    140   
            >::new())
  141    141   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  142    142   
                crate::operation::put_bucket_website::PutBucketWebsiteError,
  143    143   
            >::new())
  144         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  145         -
                crate::operation::put_bucket_website::PutBucketWebsiteError,
  146         -
            >::new());
         144  +
            .with_retry_classifier(
         145  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_website::PutBucketWebsiteError>::builder()
         146  +
                    .transient_errors({
         147  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         148  +
                        transient_errors.push("InternalError");
         149  +
                        ::std::borrow::Cow::Owned(transient_errors)
         150  +
                    })
         151  +
                    .build(),
         152  +
            );
  147    153   
  148    154   
        ::std::borrow::Cow::Owned(rcb)
  149    155   
    }
  150    156   
}
  151    157   
  152    158   
#[derive(Debug)]
  153    159   
struct PutBucketWebsiteResponseDeserializer;
  154    160   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketWebsiteResponseDeserializer {
  155    161   
    fn deserialize_nonstreaming(
  156    162   
        &self,

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

@@ -114,114 +176,182 @@
  134    134   
                    };
  135    135   
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  136    136   
                },
  137    137   
            ))
  138    138   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  139    139   
                crate::operation::put_object::PutObjectError,
  140    140   
            >::new())
  141    141   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  142    142   
                crate::operation::put_object::PutObjectError,
  143    143   
            >::new())
  144         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  145         -
                crate::operation::put_object::PutObjectError,
  146         -
            >::new());
         144  +
            .with_retry_classifier(
         145  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object::PutObjectError>::builder()
         146  +
                    .transient_errors({
         147  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         148  +
                        transient_errors.push("InternalError");
         149  +
                        ::std::borrow::Cow::Owned(transient_errors)
         150  +
                    })
         151  +
                    .build(),
         152  +
            );
  147    153   
  148    154   
        ::std::borrow::Cow::Owned(rcb)
  149    155   
    }
  150    156   
}
  151    157   
  152    158   
#[derive(Debug)]
  153    159   
struct PutObjectResponseDeserializer;
  154    160   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectResponseDeserializer {
  155    161   
    fn deserialize_nonstreaming(
  156    162   
        &self,

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

@@ -114,114 +176,182 @@
  134    134   
                    };
  135    135   
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  136    136   
                },
  137    137   
            ))
  138    138   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  139    139   
                crate::operation::put_object_acl::PutObjectAclError,
  140    140   
            >::new())
  141    141   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  142    142   
                crate::operation::put_object_acl::PutObjectAclError,
  143    143   
            >::new())
  144         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  145         -
                crate::operation::put_object_acl::PutObjectAclError,
  146         -
            >::new());
         144  +
            .with_retry_classifier(
         145  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_acl::PutObjectAclError>::builder()
         146  +
                    .transient_errors({
         147  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         148  +
                        transient_errors.push("InternalError");
         149  +
                        ::std::borrow::Cow::Owned(transient_errors)
         150  +
                    })
         151  +
                    .build(),
         152  +
            );
  147    153   
  148    154   
        ::std::borrow::Cow::Owned(rcb)
  149    155   
    }
  150    156   
}
  151    157   
  152    158   
#[derive(Debug)]
  153    159   
struct PutObjectAclResponseDeserializer;
  154    160   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectAclResponseDeserializer {
  155    161   
    fn deserialize_nonstreaming(
  156    162   
        &self,

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

@@ -90,90 +176,172 @@
  110    110   
        cfg.store_put(crate::s3_express::checksum::provide_default_checksum_algorithm());
  111    111   
  112    112   
        ::std::option::Option::Some(cfg.freeze())
  113    113   
    }
  114    114   
  115    115   
    fn runtime_components(
  116    116   
        &self,
  117    117   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  118    118   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  119    119   
        #[allow(unused_mut)]
  120         -
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutObjectLegalHold")
  121         -
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  122         -
            .with_interceptor(PutObjectLegalHoldEndpointParamsInterceptor)
  123         -
            .with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(
  124         -
                |input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
  125         -
                    let input: &crate::operation::put_object_legal_hold::PutObjectLegalHoldInput = input.downcast_ref().expect("correct type");
  126         -
                    let checksum_algorithm = input.checksum_algorithm();
  127         -
                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
  128         -
                    let checksum_algorithm = match checksum_algorithm {
  129         -
                        Some(algo) => Some(
  130         -
                            algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
  131         -
                                .map_err(::aws_smithy_types::error::operation::BuildError::other)?,
  132         -
                        ),
  133         -
                        None => None,
  134         -
                    };
  135         -
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  136         -
                },
  137         -
            ))
  138         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  139         -
                crate::operation::put_object_legal_hold::PutObjectLegalHoldError,
  140         -
            >::new())
  141         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  142         -
                crate::operation::put_object_legal_hold::PutObjectLegalHoldError,
  143         -
            >::new())
  144         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  145         -
                crate::operation::put_object_legal_hold::PutObjectLegalHoldError,
  146         -
            >::new());
         120  +
                    let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutObjectLegalHold")
         121  +
                            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
         122  +
.with_interceptor(PutObjectLegalHoldEndpointParamsInterceptor)
         123  +
.with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(|input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
         124  +
                                    let input: &crate::operation::put_object_legal_hold::PutObjectLegalHoldInput = input.downcast_ref().expect("correct type");
         125  +
                                    let checksum_algorithm = input.checksum_algorithm();
         126  +
                                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
         127  +
let checksum_algorithm = match checksum_algorithm {
         128  +
                Some(algo) => Some(
         129  +
                    algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
         130  +
                    .map_err(::aws_smithy_types::error::operation::BuildError::other)?
         131  +
                ),
         132  +
                None => None,
         133  +
            };
         134  +
                                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
         135  +
                                }))
         136  +
                            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_object_legal_hold::PutObjectLegalHoldError>::new())
         137  +
.with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_object_legal_hold::PutObjectLegalHoldError>::new())
         138  +
.with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_legal_hold::PutObjectLegalHoldError>::builder().transient_errors({
         139  +
                                            let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         140  +
                                            transient_errors.push("InternalError");
         141  +
                                            ::std::borrow::Cow::Owned(transient_errors)
         142  +
                                            }).build());
  147    143   
  148    144   
        ::std::borrow::Cow::Owned(rcb)
  149    145   
    }
  150    146   
}
  151    147   
  152    148   
#[derive(Debug)]
  153    149   
struct PutObjectLegalHoldResponseDeserializer;
  154    150   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectLegalHoldResponseDeserializer {
  155    151   
    fn deserialize_nonstreaming(
  156    152   
        &self,

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

@@ -119,119 +181,189 @@
  139    139   
                    };
  140    140   
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  141    141   
                },
  142    142   
            ))
  143    143   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  144    144   
                crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
  145    145   
            >::new())
  146    146   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  147    147   
                crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
  148    148   
            >::new())
  149         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  150         -
                crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
  151         -
            >::new());
         149  +
            .with_retry_classifier(
         150  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         151  +
                    crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
         152  +
                >::builder()
         153  +
                .transient_errors({
         154  +
                    let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         155  +
                    transient_errors.push("InternalError");
         156  +
                    ::std::borrow::Cow::Owned(transient_errors)
         157  +
                })
         158  +
                .build(),
         159  +
            );
  152    160   
  153    161   
        ::std::borrow::Cow::Owned(rcb)
  154    162   
    }
  155    163   
}
  156    164   
  157    165   
#[derive(Debug)]
  158    166   
struct PutObjectLockConfigurationResponseDeserializer;
  159    167   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectLockConfigurationResponseDeserializer {
  160    168   
    fn deserialize_nonstreaming(
  161    169   
        &self,

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

@@ -90,90 +176,172 @@
  110    110   
        cfg.store_put(crate::s3_express::checksum::provide_default_checksum_algorithm());
  111    111   
  112    112   
        ::std::option::Option::Some(cfg.freeze())
  113    113   
    }
  114    114   
  115    115   
    fn runtime_components(
  116    116   
        &self,
  117    117   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  118    118   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  119    119   
        #[allow(unused_mut)]
  120         -
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutObjectRetention")
  121         -
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  122         -
            .with_interceptor(PutObjectRetentionEndpointParamsInterceptor)
  123         -
            .with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(
  124         -
                |input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
  125         -
                    let input: &crate::operation::put_object_retention::PutObjectRetentionInput = input.downcast_ref().expect("correct type");
  126         -
                    let checksum_algorithm = input.checksum_algorithm();
  127         -
                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
  128         -
                    let checksum_algorithm = match checksum_algorithm {
  129         -
                        Some(algo) => Some(
  130         -
                            algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
  131         -
                                .map_err(::aws_smithy_types::error::operation::BuildError::other)?,
  132         -
                        ),
  133         -
                        None => None,
  134         -
                    };
  135         -
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  136         -
                },
  137         -
            ))
  138         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  139         -
                crate::operation::put_object_retention::PutObjectRetentionError,
  140         -
            >::new())
  141         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  142         -
                crate::operation::put_object_retention::PutObjectRetentionError,
  143         -
            >::new())
  144         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  145         -
                crate::operation::put_object_retention::PutObjectRetentionError,
  146         -
            >::new());
         120  +
                    let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutObjectRetention")
         121  +
                            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
         122  +
.with_interceptor(PutObjectRetentionEndpointParamsInterceptor)
         123  +
.with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(|input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
         124  +
                                    let input: &crate::operation::put_object_retention::PutObjectRetentionInput = input.downcast_ref().expect("correct type");
         125  +
                                    let checksum_algorithm = input.checksum_algorithm();
         126  +
                                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
         127  +
let checksum_algorithm = match checksum_algorithm {
         128  +
                Some(algo) => Some(
         129  +
                    algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
         130  +
                    .map_err(::aws_smithy_types::error::operation::BuildError::other)?
         131  +
                ),
         132  +
                None => None,
         133  +
            };
         134  +
                                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
         135  +
                                }))
         136  +
                            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_object_retention::PutObjectRetentionError>::new())
         137  +
.with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_object_retention::PutObjectRetentionError>::new())
         138  +
.with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_retention::PutObjectRetentionError>::builder().transient_errors({
         139  +
                                            let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         140  +
                                            transient_errors.push("InternalError");
         141  +
                                            ::std::borrow::Cow::Owned(transient_errors)
         142  +
                                            }).build());
  147    143   
  148    144   
        ::std::borrow::Cow::Owned(rcb)
  149    145   
    }
  150    146   
}
  151    147   
  152    148   
#[derive(Debug)]
  153    149   
struct PutObjectRetentionResponseDeserializer;
  154    150   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectRetentionResponseDeserializer {
  155    151   
    fn deserialize_nonstreaming(
  156    152   
        &self,

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

@@ -114,114 +176,182 @@
  134    134   
                    };
  135    135   
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  136    136   
                },
  137    137   
            ))
  138    138   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  139    139   
                crate::operation::put_object_tagging::PutObjectTaggingError,
  140    140   
            >::new())
  141    141   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  142    142   
                crate::operation::put_object_tagging::PutObjectTaggingError,
  143    143   
            >::new())
  144         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  145         -
                crate::operation::put_object_tagging::PutObjectTaggingError,
  146         -
            >::new());
         144  +
            .with_retry_classifier(
         145  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_tagging::PutObjectTaggingError>::builder()
         146  +
                    .transient_errors({
         147  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         148  +
                        transient_errors.push("InternalError");
         149  +
                        ::std::borrow::Cow::Owned(transient_errors)
         150  +
                    })
         151  +
                    .build(),
         152  +
            );
  147    153   
  148    154   
        ::std::borrow::Cow::Owned(rcb)
  149    155   
    }
  150    156   
}
  151    157   
  152    158   
#[derive(Debug)]
  153    159   
struct PutObjectTaggingResponseDeserializer;
  154    160   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectTaggingResponseDeserializer {
  155    161   
    fn deserialize_nonstreaming(
  156    162   
        &self,

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

@@ -93,93 +179,175 @@
  113    113   
        cfg.store_put(crate::s3_express::checksum::provide_default_checksum_algorithm());
  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("PutPublicAccessBlock")
  124         -
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  125         -
            .with_interceptor(PutPublicAccessBlockEndpointParamsInterceptor)
  126         -
            .with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(
  127         -
                |input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
  128         -
                    let input: &crate::operation::put_public_access_block::PutPublicAccessBlockInput = input.downcast_ref().expect("correct type");
  129         -
                    let checksum_algorithm = input.checksum_algorithm();
  130         -
                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
  131         -
                    let checksum_algorithm = match checksum_algorithm {
  132         -
                        Some(algo) => Some(
  133         -
                            algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
  134         -
                                .map_err(::aws_smithy_types::error::operation::BuildError::other)?,
  135         -
                        ),
  136         -
                        None => None,
  137         -
                    };
  138         -
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  139         -
                },
  140         -
            ))
  141         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  142         -
                crate::operation::put_public_access_block::PutPublicAccessBlockError,
  143         -
            >::new())
  144         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  145         -
                crate::operation::put_public_access_block::PutPublicAccessBlockError,
  146         -
            >::new())
  147         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  148         -
                crate::operation::put_public_access_block::PutPublicAccessBlockError,
  149         -
            >::new());
         123  +
                    let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutPublicAccessBlock")
         124  +
                            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
         125  +
.with_interceptor(PutPublicAccessBlockEndpointParamsInterceptor)
         126  +
.with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(|input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
         127  +
                                    let input: &crate::operation::put_public_access_block::PutPublicAccessBlockInput = input.downcast_ref().expect("correct type");
         128  +
                                    let checksum_algorithm = input.checksum_algorithm();
         129  +
                                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
         130  +
let checksum_algorithm = match checksum_algorithm {
         131  +
                Some(algo) => Some(
         132  +
                    algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
         133  +
                    .map_err(::aws_smithy_types::error::operation::BuildError::other)?
         134  +
                ),
         135  +
                None => None,
         136  +
            };
         137  +
                                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
         138  +
                                }))
         139  +
                            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_public_access_block::PutPublicAccessBlockError>::new())
         140  +
.with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_public_access_block::PutPublicAccessBlockError>::new())
         141  +
.with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_public_access_block::PutPublicAccessBlockError>::builder().transient_errors({
         142  +
                                            let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         143  +
                                            transient_errors.push("InternalError");
         144  +
                                            ::std::borrow::Cow::Owned(transient_errors)
         145  +
                                            }).build());
  150    146   
  151    147   
        ::std::borrow::Cow::Owned(rcb)
  152    148   
    }
  153    149   
}
  154    150   
  155    151   
#[derive(Debug)]
  156    152   
struct PutPublicAccessBlockResponseDeserializer;
  157    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutPublicAccessBlockResponseDeserializer {
  158    154   
    fn deserialize_nonstreaming(
  159    155   
        &self,

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

@@ -113,113 +175,181 @@
  133    133   
                    };
  134    134   
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  135    135   
                },
  136    136   
            ))
  137    137   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  138    138   
                crate::operation::restore_object::RestoreObjectError,
  139    139   
            >::new())
  140    140   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  141    141   
                crate::operation::restore_object::RestoreObjectError,
  142    142   
            >::new())
  143         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  144         -
                crate::operation::restore_object::RestoreObjectError,
  145         -
            >::new());
         143  +
            .with_retry_classifier(
         144  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::restore_object::RestoreObjectError>::builder()
         145  +
                    .transient_errors({
         146  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         147  +
                        transient_errors.push("InternalError");
         148  +
                        ::std::borrow::Cow::Owned(transient_errors)
         149  +
                    })
         150  +
                    .build(),
         151  +
            );
  146    152   
  147    153   
        ::std::borrow::Cow::Owned(rcb)
  148    154   
    }
  149    155   
}
  150    156   
  151    157   
#[derive(Debug)]
  152    158   
struct RestoreObjectResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RestoreObjectResponseDeserializer {
  154    160   
    fn deserialize_nonstreaming(
  155    161   
        &self,

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

@@ -89,89 +160,158 @@
  109    109   
        });
  110    110   
  111    111   
        ::std::option::Option::Some(cfg.freeze())
  112    112   
    }
  113    113   
  114    114   
    fn runtime_components(
  115    115   
        &self,
  116    116   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  117    117   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  118    118   
        #[allow(unused_mut)]
  119         -
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("SelectObjectContent")
  120         -
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  121         -
            .with_interceptor(SelectObjectContentEndpointParamsInterceptor)
  122         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  123         -
                crate::operation::select_object_content::SelectObjectContentError,
  124         -
            >::new())
  125         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  126         -
                crate::operation::select_object_content::SelectObjectContentError,
  127         -
            >::new())
  128         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  129         -
                crate::operation::select_object_content::SelectObjectContentError,
  130         -
            >::new());
         119  +
                    let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("SelectObjectContent")
         120  +
                            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
         121  +
.with_interceptor(SelectObjectContentEndpointParamsInterceptor)
         122  +
                            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::select_object_content::SelectObjectContentError>::new())
         123  +
.with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::select_object_content::SelectObjectContentError>::new())
         124  +
.with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::select_object_content::SelectObjectContentError>::builder().transient_errors({
         125  +
                                            let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         126  +
                                            transient_errors.push("InternalError");
         127  +
                                            ::std::borrow::Cow::Owned(transient_errors)
         128  +
                                            }).build());
  131    129   
  132    130   
        ::std::borrow::Cow::Owned(rcb)
  133    131   
    }
  134    132   
}
  135    133   
  136    134   
#[derive(Debug)]
  137    135   
struct SelectObjectContentResponseDeserializer;
  138    136   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for SelectObjectContentResponseDeserializer {
  139    137   
    fn deserialize_streaming(
  140    138   
        &self,

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

@@ -114,114 +176,182 @@
  134    134   
                    };
  135    135   
                    ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
  136    136   
                },
  137    137   
            ))
  138    138   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  139    139   
                crate::operation::upload_part::UploadPartError,
  140    140   
            >::new())
  141    141   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  142    142   
                crate::operation::upload_part::UploadPartError,
  143    143   
            >::new())
  144         -
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
  145         -
                crate::operation::upload_part::UploadPartError,
  146         -
            >::new());
         144  +
            .with_retry_classifier(
         145  +
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::upload_part::UploadPartError>::builder()
         146  +
                    .transient_errors({
         147  +
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
         148  +
                        transient_errors.push("InternalError");
         149  +
                        ::std::borrow::Cow::Owned(transient_errors)
         150  +
                    })
         151  +
                    .build(),
         152  +
            );
  147    153   
  148    154   
        ::std::borrow::Cow::Owned(rcb)
  149    155   
    }
  150    156   
}
  151    157   
  152    158   
#[derive(Debug)]
  153    159   
struct UploadPartResponseDeserializer;
  154    160   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UploadPartResponseDeserializer {
  155    161   
    fn deserialize_nonstreaming(
  156    162   
        &self,