AWS SDK

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

@@ -185,185 +253,253 @@

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::delete_bucket_replication::DeleteBucketReplicationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_bucket_replication::DeleteBucketReplicationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-203
+            }
             fn uri_query(

                 _input: &crate::operation::delete_bucket_replication::DeleteBucketReplicationInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("replication");
                 ::std::result::Result::Ok(())
-211
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_bucket_replication::DeleteBucketReplicationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_delete_bucket_replication::ser_delete_bucket_replication_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-222
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-227
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-229
+    }
-230
+}
 #[derive(Debug)]
 struct DeleteBucketReplicationEndpointParamsInterceptor;
-233

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteBucketReplicationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteBucketReplicationEndpointParamsInterceptor"
-237
+    }
-238
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<DeleteBucketReplicationInput>()
             .ok_or("failed to downcast to DeleteBucketReplicationInput")?;
-253

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

@@ -172,172 +240,240 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::delete_bucket_tagging::DeleteBucketTaggingInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_bucket_tagging::DeleteBucketTaggingInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-190
+            }
             fn uri_query(

                 _input: &crate::operation::delete_bucket_tagging::DeleteBucketTaggingInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("tagging");
                 ::std::result::Result::Ok(())
-198
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_bucket_tagging::DeleteBucketTaggingInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_delete_bucket_tagging::ser_delete_bucket_tagging_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-209
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-214
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-216
+    }
-217
+}
 #[derive(Debug)]
 struct DeleteBucketTaggingEndpointParamsInterceptor;
-220

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteBucketTaggingEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteBucketTaggingEndpointParamsInterceptor"
-224
+    }
-225
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<DeleteBucketTaggingInput>()
             .ok_or("failed to downcast to DeleteBucketTaggingInput")?;
-240

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

@@ -172,172 +240,240 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::delete_bucket_website::DeleteBucketWebsiteInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_bucket_website::DeleteBucketWebsiteInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-190
+            }
             fn uri_query(

                 _input: &crate::operation::delete_bucket_website::DeleteBucketWebsiteInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("website");
                 ::std::result::Result::Ok(())
-198
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_bucket_website::DeleteBucketWebsiteInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_delete_bucket_website::ser_delete_bucket_website_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-209
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-214
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-216
+    }
-217
+}
 #[derive(Debug)]
 struct DeleteBucketWebsiteEndpointParamsInterceptor;
-220

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteBucketWebsiteEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteBucketWebsiteEndpointParamsInterceptor"
-224
+    }
-225
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<DeleteBucketWebsiteInput>()
             .ok_or("failed to downcast to DeleteBucketWebsiteInput")?;
-240

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

@@ -196,196 +264,264 @@

↥ Expand context

                 let input_1 = &_input.key;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("key", "cannot be empty or unset"))?;
                 let key = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Greedy);
                 if key.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "key",
                         "cannot be empty or unset",
                     ));
-206
+                }
                 ::std::write!(output, "/{Key}", Key = key).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-209
+            }
             fn uri_query(
                 _input: &crate::operation::delete_object::DeleteObjectInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_kv("x-id", "DeleteObject");

                 if let ::std::option::Option::Some(inner_2) = &_input.version_id {
-217
+                    {
                         query.push_kv("versionId", &::aws_smithy_http::query::fmt_string(inner_2));
-219
+                    }
-220
+                }
                 ::std::result::Result::Ok(())
-222
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_object::DeleteObjectInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_delete_object::ser_delete_object_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-233
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-238
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-240
+    }
-241
+}
 #[derive(Debug)]
 struct DeleteObjectEndpointParamsInterceptor;
-244

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteObjectEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteObjectEndpointParamsInterceptor"
-248
+    }
-249
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<DeleteObjectInput>()
             .ok_or("failed to downcast to DeleteObjectInput")?;
-264

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

@@ -188,188 +256,256 @@

↥ Expand context

                 let input_1 = &_input.key;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("key", "cannot be empty or unset"))?;
                 let key = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Greedy);
                 if key.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "key",
                         "cannot be empty or unset",
                     ));
-198
+                }
                 ::std::write!(output, "/{Key}", Key = key).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-201
+            }
             fn uri_query(
                 _input: &crate::operation::delete_object_tagging::DeleteObjectTaggingInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("tagging");

                 if let ::std::option::Option::Some(inner_2) = &_input.version_id {
-209
+                    {
                         query.push_kv("versionId", &::aws_smithy_http::query::fmt_string(inner_2));
-211
+                    }
-212
+                }
                 ::std::result::Result::Ok(())
-214
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_object_tagging::DeleteObjectTaggingInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_delete_object_tagging::ser_delete_object_tagging_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-225
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-230
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-232
+    }
-233
+}
 #[derive(Debug)]
 struct DeleteObjectTaggingEndpointParamsInterceptor;
-236

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteObjectTaggingEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteObjectTaggingEndpointParamsInterceptor"
-240
+    }
-241
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<DeleteObjectTaggingInput>()
             .ok_or("failed to downcast to DeleteObjectTaggingInput")?;
-256

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

@@ -239,239 +315,315 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::delete_objects::DeleteObjectsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_objects::DeleteObjectsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-257
+            }
             fn uri_query(

                 _input: &crate::operation::delete_objects::DeleteObjectsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("delete");
                 ::std::result::Result::Ok(())
-265
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_objects::DeleteObjectsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_delete_objects::ser_delete_objects_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-276
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
             builder
         };
         let body =
             ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_delete_objects_input::ser_delete_http_payload(&input.delete)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-286
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-288
+    }
-289
+}
 #[derive(Debug)]
 struct DeleteObjectsEndpointParamsInterceptor;
-292
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteObjectsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteObjectsEndpointParamsInterceptor"

↧ Expand context

-296
+    }
-297
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<DeleteObjectsInput>()
             .ok_or("failed to downcast to DeleteObjectsInput")?;
-312
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))

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

@@ -185,185 +253,253 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::delete_public_access_block::DeletePublicAccessBlockInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_public_access_block::DeletePublicAccessBlockInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-203
+            }
             fn uri_query(

                 _input: &crate::operation::delete_public_access_block::DeletePublicAccessBlockInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("publicAccessBlock");
                 ::std::result::Result::Ok(())
-211
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_public_access_block::DeletePublicAccessBlockInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_delete_public_access_block::ser_delete_public_access_block_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-222
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-227
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-229
+    }
-230
+}
 #[derive(Debug)]
 struct DeletePublicAccessBlockEndpointParamsInterceptor;
-233

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeletePublicAccessBlockEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeletePublicAccessBlockEndpointParamsInterceptor"
-237
+    }
-238
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<DeletePublicAccessBlockInput>()
             .ok_or("failed to downcast to DeletePublicAccessBlockInput")?;
-253

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

@@ -193,193 +263,263 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-211
+            }
             fn uri_query(

                 _input: &crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("accelerate");
                 ::std::result::Result::Ok(())
-219
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_get_bucket_accelerate_configuration::ser_get_bucket_accelerate_configuration_headers(
                     input, builder,
                 )?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-232
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-237
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-239
+    }
-240
+}
 #[derive(Debug)]
 struct GetBucketAccelerateConfigurationEndpointParamsInterceptor;
-243

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetBucketAccelerateConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetBucketAccelerateConfigurationEndpointParamsInterceptor"
-247
+    }
-248
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetBucketAccelerateConfigurationInput>()
             .ok_or("failed to downcast to GetBucketAccelerateConfigurationInput")?;
-263

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

@@ -180,180 +248,248 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::get_bucket_acl::GetBucketAclInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_bucket_acl::GetBucketAclInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-198
+            }
             fn uri_query(

                 _input: &crate::operation::get_bucket_acl::GetBucketAclInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("acl");
                 ::std::result::Result::Ok(())
-206
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_bucket_acl::GetBucketAclInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_get_bucket_acl::ser_get_bucket_acl_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-217
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-222
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-224
+    }
-225
+}
 #[derive(Debug)]
 struct GetBucketAclEndpointParamsInterceptor;
-228

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetBucketAclEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetBucketAclEndpointParamsInterceptor"
-232
+    }
-233
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetBucketAclInput>()
             .ok_or("failed to downcast to GetBucketAclInput")?;
-248

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

@@ -205,205 +274,274 @@

↥ Expand context

                 _input: &crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-211
+            }
             fn uri_query(
                 _input: &crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("analytics");
                 query.push_kv("x-id", "GetBucketAnalyticsConfiguration");
                 let inner_1 = &_input.id;
                 let inner_1 = inner_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("id", "cannot be empty or unset"))?;
                 if inner_1.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "id",
                         "cannot be empty or unset",
                     ));
-228
+                }
                 query.push_kv("id", &::aws_smithy_http::query::fmt_string(inner_1));
                 ::std::result::Result::Ok(())
-231
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder =
                     crate::protocol_serde::shape_get_bucket_analytics_configuration::ser_get_bucket_analytics_configuration_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-243
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-248
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-250
+    }
-251
+}
 #[derive(Debug)]
 struct GetBucketAnalyticsConfigurationEndpointParamsInterceptor;
-254

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetBucketAnalyticsConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetBucketAnalyticsConfigurationEndpointParamsInterceptor"
-258
+    }
-259
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetBucketAnalyticsConfigurationInput>()
             .ok_or("failed to downcast to GetBucketAnalyticsConfigurationInput")?;
-274

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

@@ -180,180 +248,248 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::get_bucket_cors::GetBucketCorsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_bucket_cors::GetBucketCorsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-198
+            }
             fn uri_query(

                 _input: &crate::operation::get_bucket_cors::GetBucketCorsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("cors");
                 ::std::result::Result::Ok(())
-206
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_bucket_cors::GetBucketCorsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_get_bucket_cors::ser_get_bucket_cors_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-217
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-222
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-224
+    }
-225
+}
 #[derive(Debug)]
 struct GetBucketCorsEndpointParamsInterceptor;
-228

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetBucketCorsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetBucketCorsEndpointParamsInterceptor"
-232
+    }
-233
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetBucketCorsInput>()
             .ok_or("failed to downcast to GetBucketCorsInput")?;
-248

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

@@ -173,173 +241,241 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::get_bucket_encryption::GetBucketEncryptionInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_bucket_encryption::GetBucketEncryptionInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             fn uri_query(

                 _input: &crate::operation::get_bucket_encryption::GetBucketEncryptionInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("encryption");
                 ::std::result::Result::Ok(())
-199
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_bucket_encryption::GetBucketEncryptionInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_get_bucket_encryption::ser_get_bucket_encryption_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-210
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-215
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-217
+    }
-218
+}
 #[derive(Debug)]
 struct GetBucketEncryptionEndpointParamsInterceptor;
-221

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetBucketEncryptionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetBucketEncryptionEndpointParamsInterceptor"
-225
+    }
-226
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetBucketEncryptionInput>()
             .ok_or("failed to downcast to GetBucketEncryptionInput")?;
-241

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

@@ -207,207 +275,275 @@

↥ Expand context

                 _input: &crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-213
+            }
             fn uri_query(
                 _input: &crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("intelligent-tiering");
                 query.push_kv("x-id", "GetBucketIntelligentTieringConfiguration");
                 let inner_1 = &_input.id;
                 let inner_1 = inner_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("id", "cannot be empty or unset"))?;
                 if inner_1.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "id",
                         "cannot be empty or unset",
                     ));
-230
+                }
                 query.push_kv("id", &::aws_smithy_http::query::fmt_string(inner_1));
                 ::std::result::Result::Ok(())
-233
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_get_bucket_intelligent_tiering_configuration::ser_get_bucket_intelligent_tiering_configuration_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-244
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-249
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-251
+    }
-252
+}
 #[derive(Debug)]
 struct GetBucketIntelligentTieringConfigurationEndpointParamsInterceptor;
-255

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetBucketIntelligentTieringConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetBucketIntelligentTieringConfigurationEndpointParamsInterceptor"
-259
+    }
-260
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetBucketIntelligentTieringConfigurationInput>()
             .ok_or("failed to downcast to GetBucketIntelligentTieringConfigurationInput")?;
-275

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

@@ -206,206 +275,275 @@

↥ Expand context

                 _input: &crate::operation::get_bucket_inventory_configuration::GetBucketInventoryConfigurationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-212
+            }
             fn uri_query(
                 _input: &crate::operation::get_bucket_inventory_configuration::GetBucketInventoryConfigurationInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("inventory");
                 query.push_kv("x-id", "GetBucketInventoryConfiguration");
                 let inner_1 = &_input.id;
                 let inner_1 = inner_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("id", "cannot be empty or unset"))?;
                 if inner_1.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "id",
                         "cannot be empty or unset",
                     ));
-229
+                }
                 query.push_kv("id", &::aws_smithy_http::query::fmt_string(inner_1));
                 ::std::result::Result::Ok(())
-232
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_bucket_inventory_configuration::GetBucketInventoryConfigurationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder =
                     crate::protocol_serde::shape_get_bucket_inventory_configuration::ser_get_bucket_inventory_configuration_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-244
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-249
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-251
+    }
-252
+}
 #[derive(Debug)]
 struct GetBucketInventoryConfigurationEndpointParamsInterceptor;
-255

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetBucketInventoryConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetBucketInventoryConfigurationEndpointParamsInterceptor"
-259
+    }
-260
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetBucketInventoryConfigurationInput>()
             .ok_or("failed to downcast to GetBucketInventoryConfigurationInput")?;
-275

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

@@ -193,193 +262,262 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-211
+            }
             fn uri_query(

                 _input: &crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("lifecycle");
                 ::std::result::Result::Ok(())
-219
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder =
                     crate::protocol_serde::shape_get_bucket_lifecycle_configuration::ser_get_bucket_lifecycle_configuration_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-231
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-236
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-238
+    }
-239
+}
 #[derive(Debug)]
 struct GetBucketLifecycleConfigurationEndpointParamsInterceptor;
-242

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetBucketLifecycleConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetBucketLifecycleConfigurationEndpointParamsInterceptor"
-246
+    }
-247
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetBucketLifecycleConfigurationInput>()
             .ok_or("failed to downcast to GetBucketLifecycleConfigurationInput")?;
-262

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

@@ -172,172 +240,240 @@

↥ Expand context

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::get_bucket_location::GetBucketLocationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_bucket_location::GetBucketLocationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-190
+            }
             fn uri_query(

                 _input: &crate::operation::get_bucket_location::GetBucketLocationInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("location");
                 ::std::result::Result::Ok(())
-198
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_bucket_location::GetBucketLocationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_get_bucket_location::ser_get_bucket_location_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-209
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-214
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-216
+    }
-217
+}
 #[derive(Debug)]
 struct GetBucketLocationEndpointParamsInterceptor;
-220

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetBucketLocationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetBucketLocationEndpointParamsInterceptor"
-224
+    }
-225
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetBucketLocationInput>()
             .ok_or("failed to downcast to GetBucketLocationInput")?;
-240

AWS SDK

Files changed: