AWS SDK

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

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

         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             GetObjectAttributesResponseDeserializer,
         ));
-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("GetObjectAttributes", "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("GetObjectAttributes")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetObjectAttributesEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_object_attributes::GetObjectAttributesError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_object_attributes::GetObjectAttributesError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::get_object_attributes::GetObjectAttributesError,
             >::new());
 .with_interceptor(GetObjectAttributesEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::get_object_attributes::GetObjectAttributesError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::get_object_attributes::GetObjectAttributesError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::get_object_attributes::GetObjectAttributesError>::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 GetObjectAttributesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetObjectAttributesResponseDeserializer {
     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 != 200 || force_error {
             crate::protocol_serde::shape_get_object_attributes::de_get_object_attributes_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_object_attributes::de_get_object_attributes_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-157
+    }
-158
+}

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

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

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             GetObjectLegalHoldResponseDeserializer,
         ));
-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("GetObjectLegalHold", "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("GetObjectLegalHold")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetObjectLegalHoldEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_object_legal_hold::GetObjectLegalHoldError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_object_legal_hold::GetObjectLegalHoldError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::get_object_legal_hold::GetObjectLegalHoldError,
             >::new());
 .with_interceptor(GetObjectLegalHoldEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::get_object_legal_hold::GetObjectLegalHoldError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::get_object_legal_hold::GetObjectLegalHoldError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::get_object_legal_hold::GetObjectLegalHoldError>::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 GetObjectLegalHoldResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetObjectLegalHoldResponseDeserializer {
     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 != 200 || force_error {
             crate::protocol_serde::shape_get_object_legal_hold::de_get_object_legal_hold_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_object_legal_hold::de_get_object_legal_hold_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-157
+    }
-158
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_object_lock_configuration.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("GetObjectLockConfiguration")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetObjectLockConfigurationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_object_lock_configuration::GetObjectLockConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_object_lock_configuration::GetObjectLockConfigurationError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::get_object_lock_configuration::GetObjectLockConfigurationError,
             >::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 GetObjectLockConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetObjectLockConfigurationResponseDeserializer {
     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 != 200 || force_error {
             crate::protocol_serde::shape_get_object_lock_configuration::de_get_object_lock_configuration_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_object_lock_configuration::de_get_object_lock_configuration_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-171
+    }
-172
+}

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

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

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             GetObjectRetentionResponseDeserializer,
         ));
-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("GetObjectRetention", "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("GetObjectRetention")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetObjectRetentionEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_object_retention::GetObjectRetentionError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_object_retention::GetObjectRetentionError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::get_object_retention::GetObjectRetentionError,
             >::new());
 .with_interceptor(GetObjectRetentionEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::get_object_retention::GetObjectRetentionError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::get_object_retention::GetObjectRetentionError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::get_object_retention::GetObjectRetentionError>::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 GetObjectRetentionResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetObjectRetentionResponseDeserializer {
     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 != 200 || force_error {
             crate::protocol_serde::shape_get_object_retention::de_get_object_retention_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_object_retention::de_get_object_retention_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-157
+    }
-158
+}

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

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

↥ Expand context

-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("GetObjectTagging", "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("GetObjectTagging")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetObjectTaggingEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_object_tagging::GetObjectTaggingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_object_tagging::GetObjectTaggingError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::get_object_tagging::GetObjectTaggingError,
             >::new());
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::get_object_tagging::GetObjectTaggingError>::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 GetObjectTaggingResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetObjectTaggingResponseDeserializer {
     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_object_tagging::de_get_object_tagging_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_object_tagging::de_get_object_tagging_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_object_torrent.rs

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

↥ Expand context

-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("GetObjectTorrent", "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("GetObjectTorrent")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetObjectTorrentEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_object_torrent::GetObjectTorrentError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_object_torrent::GetObjectTorrentError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::get_object_torrent::GetObjectTorrentError,
             >::new());
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::get_object_torrent::GetObjectTorrentError>::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 GetObjectTorrentResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetObjectTorrentResponseDeserializer {
     fn deserialize_streaming(
         &self,

↧ Expand context

         response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
-153
         // If this is an error, defer to the non-streaming parser
         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-157
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_get_object_torrent::de_get_object_torrent_http_response(response),
         ))
-161
+    }
-162
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {

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

@@ -94,94 +163,161 @@

↥ Expand context

-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(
             "GetPublicAccessBlock",
             "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("GetPublicAccessBlock")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetPublicAccessBlockEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_public_access_block::GetPublicAccessBlockError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_public_access_block::GetPublicAccessBlockError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::get_public_access_block::GetPublicAccessBlockError,
             >::new());
 .with_interceptor(GetPublicAccessBlockEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::get_public_access_block::GetPublicAccessBlockError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::get_public_access_block::GetPublicAccessBlockError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::get_public_access_block::GetPublicAccessBlockError>::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());
-132
         ::std::borrow::Cow::Owned(rcb)
-134
+    }
-135
+}
-136
 #[derive(Debug)]
 struct GetPublicAccessBlockResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetPublicAccessBlockResponseDeserializer {
     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;
-152
+        }
         ::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_public_access_block::de_get_public_access_block_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_public_access_block::de_get_public_access_block_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-160
+    }
-161
+}

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

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

↥ Expand context

-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("HeadBucket", "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("HeadBucket")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(HeadBucketEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::head_bucket::HeadBucketError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::head_bucket::HeadBucketError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::head_bucket::HeadBucketError,
             >::new());
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::head_bucket::HeadBucketError>::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 HeadBucketResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HeadBucketResponseDeserializer {
     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_head_bucket::de_head_bucket_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_head_bucket::de_head_bucket_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-165
+    }
-166
+}

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

@@ -99,99 +161,167 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::SensitiveOutput);
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("HeadObject", "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("HeadObject")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(HeadObjectEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::head_object::HeadObjectError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::head_object::HeadObjectError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::head_object::HeadObjectError,
             >::new());
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::head_object::HeadObjectError>::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(),
             );
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct HeadObjectResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HeadObjectResponseDeserializer {
     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;
-158
+        }
         ::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_head_object::de_head_object_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_head_object::de_head_object_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-166
+    }
-167
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_bucket_analytics_configurations.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("ListBucketAnalyticsConfigurations")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListBucketAnalyticsConfigurationsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_bucket_analytics_configurations::ListBucketAnalyticsConfigurationsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_bucket_analytics_configurations::ListBucketAnalyticsConfigurationsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::list_bucket_analytics_configurations::ListBucketAnalyticsConfigurationsError,
             >::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 ListBucketAnalyticsConfigurationsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListBucketAnalyticsConfigurationsResponseDeserializer {
     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_list_bucket_analytics_configurations::de_list_bucket_analytics_configurations_http_error(
                 status, headers, body,
-174
+            )
         } else {
             crate::protocol_serde::shape_list_bucket_analytics_configurations::de_list_bucket_analytics_configurations_http_response(
                 status, headers, body,
-178
+            )

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

@@ -109,109 +171,179 @@

↥ Expand context

         ));
         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("ListBucketIntelligentTieringConfigurations")
                 .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
                 .with_interceptor(ListBucketIntelligentTieringConfigurationsEndpointParamsInterceptor)
                 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                     crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsError,
                 >::new())
                 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                     crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsError,
                 >::new())
                 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 .with_retry_classifier(
                     ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                         crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsError,
                 >::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(),
                 );
-150
         ::std::borrow::Cow::Owned(rcb)
-152
+    }
-153
+}
-154
 #[derive(Debug)]
 struct ListBucketIntelligentTieringConfigurationsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListBucketIntelligentTieringConfigurationsResponseDeserializer {
     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;
-170
+        }
         ::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_list_bucket_intelligent_tiering_configurations::de_list_bucket_intelligent_tiering_configurations_http_error(
                 status, headers, body,
-175
+            )
         } else {
             crate::protocol_serde::shape_list_bucket_intelligent_tiering_configurations::de_list_bucket_intelligent_tiering_configurations_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)

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

@@ -109,109 +171,179 @@

↥ 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;
-116
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-121
         ::std::option::Option::Some(cfg.freeze())
-123
+    }
-124
     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("ListBucketInventoryConfigurations")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListBucketInventoryConfigurationsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_bucket_inventory_configurations::ListBucketInventoryConfigurationsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_bucket_inventory_configurations::ListBucketInventoryConfigurationsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::list_bucket_inventory_configurations::ListBucketInventoryConfigurationsError,
             >::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(),
             );
-150
         ::std::borrow::Cow::Owned(rcb)
-152
+    }
-153
+}
-154
 #[derive(Debug)]
 struct ListBucketInventoryConfigurationsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListBucketInventoryConfigurationsResponseDeserializer {
     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;
-170
+        }
         ::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_list_bucket_inventory_configurations::de_list_bucket_inventory_configurations_http_error(
                 status, headers, body,
-175
+            )
         } else {
             crate::protocol_serde::shape_list_bucket_inventory_configurations::de_list_bucket_inventory_configurations_http_response(
                 status, headers, body,
-179
+            )

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_bucket_metrics_configurations.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("ListBucketMetricsConfigurations")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListBucketMetricsConfigurationsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsError,
             >::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 ListBucketMetricsConfigurationsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListBucketMetricsConfigurationsResponseDeserializer {
     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_list_bucket_metrics_configurations::de_list_bucket_metrics_configurations_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_list_bucket_metrics_configurations::de_list_bucket_metrics_configurations_http_response(
                 status, headers, body,
-176
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)

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

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

↥ Expand context

-98
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("ListBuckets", "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("ListBuckets")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListBucketsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_buckets::ListBucketsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_buckets::ListBucketsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::list_buckets::ListBucketsError,
             >::new());
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::list_buckets::ListBucketsError>::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 ListBucketsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListBucketsResponseDeserializer {
     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_list_buckets::de_list_buckets_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_list_buckets::de_list_buckets_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-165
+    }
-166
+}

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

@@ -94,94 +163,161 @@

↥ Expand context

-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(
             "ListDirectoryBuckets",
             "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("ListDirectoryBuckets")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListDirectoryBucketsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_directory_buckets::ListDirectoryBucketsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_directory_buckets::ListDirectoryBucketsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::list_directory_buckets::ListDirectoryBucketsError,
             >::new());
 .with_interceptor(ListDirectoryBucketsEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::list_directory_buckets::ListDirectoryBucketsError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::list_directory_buckets::ListDirectoryBucketsError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::list_directory_buckets::ListDirectoryBucketsError>::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());
-132
         ::std::borrow::Cow::Owned(rcb)
-134
+    }
-135
+}
-136
 #[derive(Debug)]
 struct ListDirectoryBucketsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListDirectoryBucketsResponseDeserializer {
     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;
-152
+        }
         ::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_list_directory_buckets::de_list_directory_buckets_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_list_directory_buckets::de_list_directory_buckets_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-160
+    }
-161
+}

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

@@ -94,94 +163,161 @@

↥ Expand context

-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(
             "ListMultipartUploads",
             "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("ListMultipartUploads")
                             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListMultipartUploadsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_multipart_uploads::ListMultipartUploadsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_multipart_uploads::ListMultipartUploadsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::list_multipart_uploads::ListMultipartUploadsError,
             >::new());
 .with_interceptor(ListMultipartUploadsEndpointParamsInterceptor)
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::list_multipart_uploads::ListMultipartUploadsError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::list_multipart_uploads::ListMultipartUploadsError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::list_multipart_uploads::ListMultipartUploadsError>::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());
-132
         ::std::borrow::Cow::Owned(rcb)
-134
+    }
-135
+}
-136
 #[derive(Debug)]
 struct ListMultipartUploadsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListMultipartUploadsResponseDeserializer {
     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;
-152
+        }
         ::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_list_multipart_uploads::de_list_multipart_uploads_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_list_multipart_uploads::de_list_multipart_uploads_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-160
+    }
-161
+}

AWS SDK

Files changed: