AWS SDK

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

@@ -108,108 +170,178 @@

             "s3",
         ));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-115
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketMetricsConfiguration")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteBucketMetricsConfigurationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_bucket_metrics_configuration::DeleteBucketMetricsConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_bucket_metrics_configuration::DeleteBucketMetricsConfigurationError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::delete_bucket_metrics_configuration::DeleteBucketMetricsConfigurationError,
             >::new());
                 >::builder()
                 .transient_errors({
                     let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                     transient_errors.push("InternalError");
                     ::std::borrow::Cow::Owned(transient_errors)
                 })
                 .build(),
             );
-149
         ::std::borrow::Cow::Owned(rcb)
-151
+    }
-152
+}
-153
 #[derive(Debug)]
 struct DeleteBucketMetricsConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketMetricsConfigurationResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-169
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_delete_bucket_metrics_configuration::de_delete_bucket_metrics_configuration_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_bucket_metrics_configuration::de_delete_bucket_metrics_configuration_http_response(
                 status, headers, body,
-176
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)

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

@@ -102,102 +164,172 @@

↥ Expand context

             "s3",
         ));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-109
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-114
         ::std::option::Option::Some(cfg.freeze())
-116
+    }
-117
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketOwnershipControls")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteBucketOwnershipControlsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_bucket_ownership_controls::DeleteBucketOwnershipControlsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_bucket_ownership_controls::DeleteBucketOwnershipControlsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::delete_bucket_ownership_controls::DeleteBucketOwnershipControlsError,
             >::new());
                 >::builder()
                 .transient_errors({
                     let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                     transient_errors.push("InternalError");
                     ::std::borrow::Cow::Owned(transient_errors)
                 })
                 .build(),
             );
-143
         ::std::borrow::Cow::Owned(rcb)
-145
+    }
-146
+}
-147
 #[derive(Debug)]
 struct DeleteBucketOwnershipControlsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketOwnershipControlsResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-163
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_delete_bucket_ownership_controls::de_delete_bucket_ownership_controls_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_bucket_ownership_controls::de_delete_bucket_ownership_controls_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-171
+    }
-172
+}

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

@@ -91,91 +160,158 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             DeleteBucketPolicyResponseDeserializer,
         ));
-94
         cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
             ::aws_smithy_runtime_api::client::auth::static_resolver::StaticAuthSchemeOptionResolverParams::new(),
         ));
-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("DeleteBucketPolicy", "s3"));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-105
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-110

         ::std::option::Option::Some(cfg.freeze())
-112
+    }
-113
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
                     let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketPolicy")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteBucketPolicyEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_bucket_policy::DeleteBucketPolicyError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_bucket_policy::DeleteBucketPolicyError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::delete_bucket_policy::DeleteBucketPolicyError,
             >::new());
 .with_interceptor(DeleteBucketPolicyEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::delete_bucket_policy::DeleteBucketPolicyError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::delete_bucket_policy::DeleteBucketPolicyError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::delete_bucket_policy::DeleteBucketPolicyError>::builder().transient_errors({
                                             let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                                             transient_errors.push("InternalError");
                                             ::std::borrow::Cow::Owned(transient_errors)
                                             }).build());
-129
         ::std::borrow::Cow::Owned(rcb)
-131
+    }
-132
+}
-133
 #[derive(Debug)]
 struct DeleteBucketPolicyResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketPolicyResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-149
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_delete_bucket_policy::de_delete_bucket_policy_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_bucket_policy::de_delete_bucket_policy_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-157
+    }
-158
+}

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

@@ -101,101 +163,171 @@

↥ Expand context

             "s3",
         ));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-108
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-113
         ::std::option::Option::Some(cfg.freeze())
-115
+    }
-116
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketReplication")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteBucketReplicationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_bucket_replication::DeleteBucketReplicationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_bucket_replication::DeleteBucketReplicationError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::delete_bucket_replication::DeleteBucketReplicationError,
             >::new());
                 >::builder()
                 .transient_errors({
                     let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                     transient_errors.push("InternalError");
                     ::std::borrow::Cow::Owned(transient_errors)
                 })
                 .build(),
             );
-142
         ::std::borrow::Cow::Owned(rcb)
-144
+    }
-145
+}
-146
 #[derive(Debug)]
 struct DeleteBucketReplicationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketReplicationResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-162
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_delete_bucket_replication::de_delete_bucket_replication_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_bucket_replication::de_delete_bucket_replication_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-170
+    }
-171
+}

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

@@ -91,91 +160,158 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             DeleteBucketTaggingResponseDeserializer,
         ));
-94
         cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
             ::aws_smithy_runtime_api::client::auth::static_resolver::StaticAuthSchemeOptionResolverParams::new(),
         ));
-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("DeleteBucketTagging", "s3"));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-105
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-110

         ::std::option::Option::Some(cfg.freeze())
-112
+    }
-113
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
                     let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketTagging")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteBucketTaggingEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_bucket_tagging::DeleteBucketTaggingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_bucket_tagging::DeleteBucketTaggingError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::delete_bucket_tagging::DeleteBucketTaggingError,
             >::new());
 .with_interceptor(DeleteBucketTaggingEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::delete_bucket_tagging::DeleteBucketTaggingError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::delete_bucket_tagging::DeleteBucketTaggingError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::delete_bucket_tagging::DeleteBucketTaggingError>::builder().transient_errors({
                                             let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                                             transient_errors.push("InternalError");
                                             ::std::borrow::Cow::Owned(transient_errors)
                                             }).build());
-129
         ::std::borrow::Cow::Owned(rcb)
-131
+    }
-132
+}
-133
 #[derive(Debug)]
 struct DeleteBucketTaggingResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketTaggingResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-149
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_delete_bucket_tagging::de_delete_bucket_tagging_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_bucket_tagging::de_delete_bucket_tagging_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-157
+    }
-158
+}

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

@@ -91,91 +160,158 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             DeleteBucketWebsiteResponseDeserializer,
         ));
-94
         cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
             ::aws_smithy_runtime_api::client::auth::static_resolver::StaticAuthSchemeOptionResolverParams::new(),
         ));
-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("DeleteBucketWebsite", "s3"));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-105
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-110

         ::std::option::Option::Some(cfg.freeze())
-112
+    }
-113
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
                     let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteBucketWebsite")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteBucketWebsiteEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_bucket_website::DeleteBucketWebsiteError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_bucket_website::DeleteBucketWebsiteError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::delete_bucket_website::DeleteBucketWebsiteError,
             >::new());
 .with_interceptor(DeleteBucketWebsiteEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::delete_bucket_website::DeleteBucketWebsiteError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::delete_bucket_website::DeleteBucketWebsiteError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::delete_bucket_website::DeleteBucketWebsiteError>::builder().transient_errors({
                                             let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                                             transient_errors.push("InternalError");
                                             ::std::borrow::Cow::Owned(transient_errors)
                                             }).build());
-129
         ::std::borrow::Cow::Owned(rcb)
-131
+    }
-132
+}
-133
 #[derive(Debug)]
 struct DeleteBucketWebsiteResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteBucketWebsiteResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-149
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_delete_bucket_website::de_delete_bucket_website_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_bucket_website::de_delete_bucket_website_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-157
+    }
-158
+}

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

@@ -98,98 +160,166 @@

↥ Expand context

-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("DeleteObject", "s3"));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-105
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-110
         ::std::option::Option::Some(cfg.freeze())
-112
+    }
-113
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteObject")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteObjectEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_object::DeleteObjectError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_object::DeleteObjectError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::delete_object::DeleteObjectError,
             >::new());
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::delete_object::DeleteObjectError>::builder()
                     .transient_errors({
                         let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                         transient_errors.push("InternalError");
                         ::std::borrow::Cow::Owned(transient_errors)
                     })
                     .build(),
             );
-137
         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct DeleteObjectResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteObjectResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-157
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_delete_object::de_delete_object_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_object::de_delete_object_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-165
+    }
-166
+}

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

@@ -91,91 +160,158 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             DeleteObjectTaggingResponseDeserializer,
         ));
-94
         cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
             ::aws_smithy_runtime_api::client::auth::static_resolver::StaticAuthSchemeOptionResolverParams::new(),
         ));
-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("DeleteObjectTagging", "s3"));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-105
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-110

         ::std::option::Option::Some(cfg.freeze())
-112
+    }
-113
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
                     let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteObjectTagging")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteObjectTaggingEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_object_tagging::DeleteObjectTaggingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_object_tagging::DeleteObjectTaggingError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::delete_object_tagging::DeleteObjectTaggingError,
             >::new());
 .with_interceptor(DeleteObjectTaggingEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::delete_object_tagging::DeleteObjectTaggingError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::delete_object_tagging::DeleteObjectTaggingError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::delete_object_tagging::DeleteObjectTaggingError>::builder().transient_errors({
                                             let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                                             transient_errors.push("InternalError");
                                             ::std::borrow::Cow::Owned(transient_errors)
                                             }).build());
-129
         ::std::borrow::Cow::Owned(rcb)
-131
+    }
-132
+}
-133
 #[derive(Debug)]
 struct DeleteObjectTaggingResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteObjectTaggingResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-149
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_delete_object_tagging::de_delete_object_tagging_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_object_tagging::de_delete_object_tagging_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-157
+    }
-158
+}

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

@@ -114,114 +176,182 @@

↥ Expand context

-114
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteObjects")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeleteObjectsEndpointParamsInterceptor)
             .with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(
                 |input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {
                     let input: &crate::operation::delete_objects::DeleteObjectsInput = input.downcast_ref().expect("correct type");
                     let checksum_algorithm = input.checksum_algorithm();
                     let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str()).or(Some("md5"));
                     let checksum_algorithm = match checksum_algorithm {
                         Some(algo) => Some(
                             algo.parse::<::aws_smithy_checksums::ChecksumAlgorithm>()
                                 .map_err(::aws_smithy_types::error::operation::BuildError::other)?,
                         ),
                         None => None,

                     };
                     ::std::result::Result::<_, ::aws_smithy_runtime_api::box_error::BoxError>::Ok(checksum_algorithm)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_objects::DeleteObjectsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_objects::DeleteObjectsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::delete_objects::DeleteObjectsError,
             >::new());
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::delete_objects::DeleteObjectsError>::builder()
                     .transient_errors({
                         let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                         transient_errors.push("InternalError");
                         ::std::borrow::Cow::Owned(transient_errors)
                     })
                     .build(),
             );
-153
         ::std::borrow::Cow::Owned(rcb)
-155
+    }
-156
+}
-157
 #[derive(Debug)]
 struct DeleteObjectsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteObjectsResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-173
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_delete_objects::de_delete_objects_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_objects::de_delete_objects_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-181
+    }
-182
+}

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

@@ -101,101 +163,171 @@

↥ Expand context

             "s3",
         ));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-108
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-113
         ::std::option::Option::Some(cfg.freeze())
-115
+    }
-116
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeletePublicAccessBlock")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DeletePublicAccessBlockEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_public_access_block::DeletePublicAccessBlockError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_public_access_block::DeletePublicAccessBlockError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::delete_public_access_block::DeletePublicAccessBlockError,
             >::new());
                 >::builder()
                 .transient_errors({
                     let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                     transient_errors.push("InternalError");
                     ::std::borrow::Cow::Owned(transient_errors)
                 })
                 .build(),
             );
-142
         ::std::borrow::Cow::Owned(rcb)
-144
+    }
-145
+}
-146
 #[derive(Debug)]
 struct DeletePublicAccessBlockResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeletePublicAccessBlockResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-162
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_delete_public_access_block::de_delete_public_access_block_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_delete_public_access_block::de_delete_public_access_block_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-170
+    }
-171
+}

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

@@ -108,108 +170,178 @@

↥ Expand context

             "s3",
         ));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-115
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("GetBucketAccelerateConfiguration")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetBucketAccelerateConfigurationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationError,
             >::new());
                 >::builder()
                 .transient_errors({
                     let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                     transient_errors.push("InternalError");
                     ::std::borrow::Cow::Owned(transient_errors)
                 })
                 .build(),
             );
-149
         ::std::borrow::Cow::Owned(rcb)
-151
+    }
-152
+}
-153
 #[derive(Debug)]
 struct GetBucketAccelerateConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketAccelerateConfigurationResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-169
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_get_bucket_accelerate_configuration::de_get_bucket_accelerate_configuration_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_bucket_accelerate_configuration::de_get_bucket_accelerate_configuration_http_response(
                 status, headers, body,
-176
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)

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

@@ -98,98 +160,166 @@

↥ Expand context

-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("GetBucketAcl", "s3"));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-105
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-110
         ::std::option::Option::Some(cfg.freeze())
-112
+    }
-113
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("GetBucketAcl")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetBucketAclEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_bucket_acl::GetBucketAclError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_bucket_acl::GetBucketAclError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::get_bucket_acl::GetBucketAclError,
             >::new());
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::get_bucket_acl::GetBucketAclError>::builder()
                     .transient_errors({
                         let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                         transient_errors.push("InternalError");
                         ::std::borrow::Cow::Owned(transient_errors)
                     })
                     .build(),
             );
-137
         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct GetBucketAclResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketAclResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-157
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_get_bucket_acl::de_get_bucket_acl_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_bucket_acl::de_get_bucket_acl_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-165
+    }
-166
+}

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

@@ -108,108 +170,178 @@

↥ Expand context

             "s3",
         ));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-115
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("GetBucketAnalyticsConfiguration")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetBucketAnalyticsConfigurationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationError,
             >::new());
                 >::builder()
                 .transient_errors({
                     let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                     transient_errors.push("InternalError");
                     ::std::borrow::Cow::Owned(transient_errors)
                 })
                 .build(),
             );
-149
         ::std::borrow::Cow::Owned(rcb)
-151
+    }
-152
+}
-153
 #[derive(Debug)]
 struct GetBucketAnalyticsConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketAnalyticsConfigurationResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-169
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_get_bucket_analytics_configuration::de_get_bucket_analytics_configuration_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_bucket_analytics_configuration::de_get_bucket_analytics_configuration_http_response(
                 status, headers, body,
-176
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)

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

@@ -98,98 +160,166 @@

↥ Expand context

-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("GetBucketCors", "s3"));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-105
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-110
         ::std::option::Option::Some(cfg.freeze())
-112
+    }
-113
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("GetBucketCors")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetBucketCorsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_bucket_cors::GetBucketCorsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_bucket_cors::GetBucketCorsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::get_bucket_cors::GetBucketCorsError,
             >::new());
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::get_bucket_cors::GetBucketCorsError>::builder()
                     .transient_errors({
                         let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                         transient_errors.push("InternalError");
                         ::std::borrow::Cow::Owned(transient_errors)
                     })
                     .build(),
             );
-137
         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct GetBucketCorsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketCorsResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-157
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_get_bucket_cors::de_get_bucket_cors_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_bucket_cors::de_get_bucket_cors_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-165
+    }
-166
+}

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

@@ -92,92 +161,159 @@

↥ Expand context

             GetBucketEncryptionResponseDeserializer,
         ));
-94
         cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
             ::aws_smithy_runtime_api::client::auth::static_resolver::StaticAuthSchemeOptionResolverParams::new(),
         ));
-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::SensitiveOutput);
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("GetBucketEncryption", "s3"));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-106
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-111

         ::std::option::Option::Some(cfg.freeze())
-113
+    }
-114
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
                     let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("GetBucketEncryption")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetBucketEncryptionEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_bucket_encryption::GetBucketEncryptionError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_bucket_encryption::GetBucketEncryptionError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::get_bucket_encryption::GetBucketEncryptionError,
             >::new());
 .with_interceptor(GetBucketEncryptionEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::get_bucket_encryption::GetBucketEncryptionError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::get_bucket_encryption::GetBucketEncryptionError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::get_bucket_encryption::GetBucketEncryptionError>::builder().transient_errors({
                                             let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                                             transient_errors.push("InternalError");
                                             ::std::borrow::Cow::Owned(transient_errors)
                                             }).build());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct GetBucketEncryptionResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketEncryptionResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-150
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_get_bucket_encryption::de_get_bucket_encryption_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_bucket_encryption::de_get_bucket_encryption_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-158
+    }
-159
+}

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

@@ -108,108 +170,178 @@

↥ Expand context

             "s3",
         ));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = false;
         signing_options.content_sha256_header = true;
         signing_options.normalize_uri_path = false;
         signing_options.payload_override = None;
-115
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("GetBucketIntelligentTieringConfiguration")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetBucketIntelligentTieringConfigurationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationError,
             >::new());
                 >::builder()
                 .transient_errors({
                     let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                     transient_errors.push("InternalError");
                     ::std::borrow::Cow::Owned(transient_errors)
                 })
                 .build(),
             );
-149
         ::std::borrow::Cow::Owned(rcb)
-151
+    }
-152
+}
-153
 #[derive(Debug)]
 struct GetBucketIntelligentTieringConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketIntelligentTieringConfigurationResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,

↧ Expand context

         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
             force_error = true;
-169
+        }
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_get_bucket_intelligent_tiering_configuration::de_get_bucket_intelligent_tiering_configuration_http_error(
                 status, headers, body,
-174
+            )
         } else {
             crate::protocol_serde::shape_get_bucket_intelligent_tiering_configuration::de_get_bucket_intelligent_tiering_configuration_http_response(
                 status, headers, body,
-178
+            )

AWS SDK

Files changed: