AWS SDK

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

@@ -233,233 +301,301 @@

-233
+                    }
-234
+                }
                 if let ::std::option::Option::Some(inner_6) = &_input.response_content_type {
-236
+                    {
                         query.push_kv("response-content-type", &::aws_smithy_http::query::fmt_string(inner_6));
-238
+                    }
-239
+                }
                 if let ::std::option::Option::Some(inner_7) = &_input.response_expires {
-241
+                    {
                         query.push_kv(
                             "response-expires",
                             &::aws_smithy_http::query::fmt_timestamp(inner_7, ::aws_smithy_types::date_time::Format::HttpDate)?,
                         );
-246
+                    }
-247
+                }
                 if let ::std::option::Option::Some(inner_8) = &_input.version_id {
-249
+                    {
                         query.push_kv("versionId", &::aws_smithy_http::query::fmt_string(inner_8));
-251
+                    }
-252
+                }

                 if let ::std::option::Option::Some(inner_9) = &_input.part_number {
-254
+                    {
                         query.push_kv("partNumber", ::aws_smithy_types::primitive::Encoder::from(*inner_9).encode());
-256
+                    }
-257
+                }
                 ::std::result::Result::Ok(())
-259
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::head_object::HeadObjectInput,
                 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_head_object::ser_head_object_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("HEAD").uri(uri))
-270
+            }
             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("");
-275
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-277
+    }
-278
+}
 #[derive(Debug)]
 struct HeadObjectEndpointParamsInterceptor;
-281

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HeadObjectEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HeadObjectEndpointParamsInterceptor"
-285
+    }
-286
     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::<HeadObjectInput>()
             .ok_or("failed to downcast to HeadObjectInput")?;
-301

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

@@ -201,201 +271,271 @@

↥ Expand context

             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_bucket_analytics_configurations::ListBucketAnalyticsConfigurationsInput,
                 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::list_bucket_analytics_configurations::ListBucketAnalyticsConfigurationsInput,
                 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", "ListBucketAnalyticsConfigurations");

                 if let ::std::option::Option::Some(inner_1) = &_input.continuation_token {
-222
+                    {
                         query.push_kv("continuation-token", &::aws_smithy_http::query::fmt_string(inner_1));
-224
+                    }
-225
+                }
                 ::std::result::Result::Ok(())
-227
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_bucket_analytics_configurations::ListBucketAnalyticsConfigurationsInput,
                 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_list_bucket_analytics_configurations::ser_list_bucket_analytics_configurations_headers(
                     input, builder,
                 )?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-240
+            }
             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("");
-245
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-247
+    }
-248
+}
 #[derive(Debug)]
 struct ListBucketAnalyticsConfigurationsEndpointParamsInterceptor;
-251

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListBucketAnalyticsConfigurationsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListBucketAnalyticsConfigurationsEndpointParamsInterceptor"
-255
+    }
-256
     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::<ListBucketAnalyticsConfigurationsInput>()
             .ok_or("failed to downcast to ListBucketAnalyticsConfigurationsInput")?;
-271

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

@@ -200,200 +268,268 @@

↥ Expand context

             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsInput,
                 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::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsInput,
                 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", "ListBucketIntelligentTieringConfigurations");

                 if let ::std::option::Option::Some(inner_1) = &_input.continuation_token {
-221
+                    {
                         query.push_kv("continuation-token", &::aws_smithy_http::query::fmt_string(inner_1));
-223
+                    }
-224
+                }
                 ::std::result::Result::Ok(())
-226
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsInput,
                 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_list_bucket_intelligent_tiering_configurations::ser_list_bucket_intelligent_tiering_configurations_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-237
+            }
             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("");
-242
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-244
+    }
-245
+}
 #[derive(Debug)]
 struct ListBucketIntelligentTieringConfigurationsEndpointParamsInterceptor;
-248

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListBucketIntelligentTieringConfigurationsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListBucketIntelligentTieringConfigurationsEndpointParamsInterceptor"
-252
+    }
-253
     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::<ListBucketIntelligentTieringConfigurationsInput>()
             .ok_or("failed to downcast to ListBucketIntelligentTieringConfigurationsInput")?;
-268

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

@@ -202,202 +272,272 @@

↥ Expand context

             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_bucket_inventory_configurations::ListBucketInventoryConfigurationsInput,
                 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(())
-214
+            }
             fn uri_query(
                 _input: &crate::operation::list_bucket_inventory_configurations::ListBucketInventoryConfigurationsInput,
                 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", "ListBucketInventoryConfigurations");

                 if let ::std::option::Option::Some(inner_1) = &_input.continuation_token {
-223
+                    {
                         query.push_kv("continuation-token", &::aws_smithy_http::query::fmt_string(inner_1));
-225
+                    }
-226
+                }
                 ::std::result::Result::Ok(())
-228
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_bucket_inventory_configurations::ListBucketInventoryConfigurationsInput,
                 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_list_bucket_inventory_configurations::ser_list_bucket_inventory_configurations_headers(
                     input, builder,
                 )?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-241
+            }
             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("");
-246
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-248
+    }
-249
+}
 #[derive(Debug)]
 struct ListBucketInventoryConfigurationsEndpointParamsInterceptor;
-252

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListBucketInventoryConfigurationsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListBucketInventoryConfigurationsEndpointParamsInterceptor"
-256
+    }
-257
     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::<ListBucketInventoryConfigurationsInput>()
             .ok_or("failed to downcast to ListBucketInventoryConfigurationsInput")?;
-272

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

@@ -199,199 +268,268 @@

↥ Expand context

             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsInput,
                 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::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsInput,
                 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("metrics");
                 query.push_kv("x-id", "ListBucketMetricsConfigurations");

                 if let ::std::option::Option::Some(inner_1) = &_input.continuation_token {
-220
+                    {
                         query.push_kv("continuation-token", &::aws_smithy_http::query::fmt_string(inner_1));
-222
+                    }
-223
+                }
                 ::std::result::Result::Ok(())
-225
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsInput,
                 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_list_bucket_metrics_configurations::ser_list_bucket_metrics_configurations_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-237
+            }
             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("");
-242
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-244
+    }
-245
+}
 #[derive(Debug)]
 struct ListBucketMetricsConfigurationsEndpointParamsInterceptor;
-248

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListBucketMetricsConfigurationsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListBucketMetricsConfigurationsEndpointParamsInterceptor"
-252
+    }
-253
     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::<ListBucketMetricsConfigurationsInput>()
             .ok_or("failed to downcast to ListBucketMetricsConfigurationsInput")?;
-268

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

@@ -200,200 +267,267 @@

↥ Expand context

                 _input: &crate::operation::list_buckets::ListBucketsInput,
                 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", "ListBuckets");
                 if let ::std::option::Option::Some(inner_1) = &_input.max_buckets {
-206
+                    {
                         query.push_kv("max-buckets", ::aws_smithy_types::primitive::Encoder::from(*inner_1).encode());
-208
+                    }
-209
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.continuation_token {
-211
+                    {
                         query.push_kv("continuation-token", &::aws_smithy_http::query::fmt_string(inner_2));
-213
+                    }
-214
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.prefix {
-216
+                    {
                         query.push_kv("prefix", &::aws_smithy_http::query::fmt_string(inner_3));
-218
+                    }
-219
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.bucket_region {
-221
+                    {
                         query.push_kv("bucket-region", &::aws_smithy_http::query::fmt_string(inner_4));
-223
+                    }
-224
+                }
                 ::std::result::Result::Ok(())
-226
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_buckets::ListBucketsInput,
                 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)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-236
+            }
             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("");
-241
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-243
+    }
-244
+}
 #[derive(Debug)]
 struct ListBucketsEndpointParamsInterceptor;
-247

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListBucketsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListBucketsEndpointParamsInterceptor"
-251
+    }
-252
     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::<ListBucketsInput>()
             .ok_or("failed to downcast to ListBucketsInput")?;
-267

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

@@ -185,185 +252,252 @@

↥ Expand context

             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_directory_buckets::ListDirectoryBucketsInput,
                 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(())
-193
+            }
             fn uri_query(
                 _input: &crate::operation::list_directory_buckets::ListDirectoryBucketsInput,
                 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", "ListDirectoryBuckets");
                 if let ::std::option::Option::Some(inner_1) = &_input.continuation_token {
-201
+                    {
                         query.push_kv("continuation-token", &::aws_smithy_http::query::fmt_string(inner_1));
-203
+                    }
-204
+                }

                 if let ::std::option::Option::Some(inner_2) = &_input.max_directory_buckets {
-206
+                    {
                         query.push_kv("max-directory-buckets", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-208
+                    }
-209
+                }
                 ::std::result::Result::Ok(())
-211
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_directory_buckets::ListDirectoryBucketsInput,
                 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)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-221
+            }
             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("");
-226
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-228
+    }
-229
+}
 #[derive(Debug)]
 struct ListDirectoryBucketsEndpointParamsInterceptor;
-232

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListDirectoryBucketsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListDirectoryBucketsEndpointParamsInterceptor"
-236
+    }
-237
     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::<ListDirectoryBucketsInput>()
             .ok_or("failed to downcast to ListDirectoryBucketsInput")?;
-252

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

@@ -205,205 +273,273 @@

↥ Expand context

                 if let ::std::option::Option::Some(inner_2) = &_input.encoding_type {
-206
+                    {
                         query.push_kv("encoding-type", &::aws_smithy_http::query::fmt_string(inner_2));
-208
+                    }
-209
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.key_marker {
-211
+                    {
                         query.push_kv("key-marker", &::aws_smithy_http::query::fmt_string(inner_3));
-213
+                    }
-214
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.max_uploads {
-216
+                    {
                         query.push_kv("max-uploads", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-218
+                    }
-219
+                }
                 if let ::std::option::Option::Some(inner_5) = &_input.prefix {
-221
+                    {
                         query.push_kv("prefix", &::aws_smithy_http::query::fmt_string(inner_5));
-223
+                    }
-224
+                }

                 if let ::std::option::Option::Some(inner_6) = &_input.upload_id_marker {
-226
+                    {
                         query.push_kv("upload-id-marker", &::aws_smithy_http::query::fmt_string(inner_6));
-228
+                    }
-229
+                }
                 ::std::result::Result::Ok(())
-231
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_multipart_uploads::ListMultipartUploadsInput,
                 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_list_multipart_uploads::ser_list_multipart_uploads_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-242
+            }
             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("");
-247
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-249
+    }
-250
+}
 #[derive(Debug)]
 struct ListMultipartUploadsEndpointParamsInterceptor;
-253

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListMultipartUploadsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListMultipartUploadsEndpointParamsInterceptor"
-257
+    }
-258
     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::<ListMultipartUploadsInput>()
             .ok_or("failed to downcast to ListMultipartUploadsInput")?;
-273

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

@@ -202,202 +270,270 @@

↥ Expand context

                 if let ::std::option::Option::Some(inner_2) = &_input.encoding_type {
-203
+                    {
                         query.push_kv("encoding-type", &::aws_smithy_http::query::fmt_string(inner_2));
-205
+                    }
-206
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.key_marker {
-208
+                    {
                         query.push_kv("key-marker", &::aws_smithy_http::query::fmt_string(inner_3));
-210
+                    }
-211
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.max_keys {
-213
+                    {
                         query.push_kv("max-keys", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-215
+                    }
-216
+                }
                 if let ::std::option::Option::Some(inner_5) = &_input.prefix {
-218
+                    {
                         query.push_kv("prefix", &::aws_smithy_http::query::fmt_string(inner_5));
-220
+                    }
-221
+                }

                 if let ::std::option::Option::Some(inner_6) = &_input.version_id_marker {
-223
+                    {
                         query.push_kv("version-id-marker", &::aws_smithy_http::query::fmt_string(inner_6));
-225
+                    }
-226
+                }
                 ::std::result::Result::Ok(())
-228
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_object_versions::ListObjectVersionsInput,
                 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_list_object_versions::ser_list_object_versions_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-239
+            }
             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("");
-244
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-246
+    }
-247
+}
 #[derive(Debug)]
 struct ListObjectVersionsEndpointParamsInterceptor;
-250

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListObjectVersionsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListObjectVersionsEndpointParamsInterceptor"
-254
+    }
-255
     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::<ListObjectVersionsInput>()
             .ok_or("failed to downcast to ListObjectVersionsInput")?;
-270

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

@@ -204,204 +272,272 @@

↥ Expand context

                 if let ::std::option::Option::Some(inner_1) = &_input.delimiter {
-205
+                    {
                         query.push_kv("delimiter", &::aws_smithy_http::query::fmt_string(inner_1));
-207
+                    }
-208
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.encoding_type {
-210
+                    {
                         query.push_kv("encoding-type", &::aws_smithy_http::query::fmt_string(inner_2));
-212
+                    }
-213
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.marker {
-215
+                    {
                         query.push_kv("marker", &::aws_smithy_http::query::fmt_string(inner_3));
-217
+                    }
-218
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.max_keys {
-220
+                    {
                         query.push_kv("max-keys", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-222
+                    }
-223
+                }

                 if let ::std::option::Option::Some(inner_5) = &_input.prefix {
-225
+                    {
                         query.push_kv("prefix", &::aws_smithy_http::query::fmt_string(inner_5));
-227
+                    }
-228
+                }
                 ::std::result::Result::Ok(())
-230
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_objects::ListObjectsInput,
                 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_list_objects::ser_list_objects_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-241
+            }
             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("");
-246
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-248
+    }
-249
+}
 #[derive(Debug)]
 struct ListObjectsEndpointParamsInterceptor;
-252

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListObjectsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListObjectsEndpointParamsInterceptor"
-256
+    }
-257
     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::<ListObjectsInput>()
             .ok_or("failed to downcast to ListObjectsInput")?;
-272

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

@@ -215,215 +283,283 @@

↥ Expand context

                 if let ::std::option::Option::Some(inner_3) = &_input.max_keys {
-216
+                    {
                         query.push_kv("max-keys", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-218
+                    }
-219
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.prefix {
-221
+                    {
                         query.push_kv("prefix", &::aws_smithy_http::query::fmt_string(inner_4));
-223
+                    }
-224
+                }
                 if let ::std::option::Option::Some(inner_5) = &_input.continuation_token {
-226
+                    {
                         query.push_kv("continuation-token", &::aws_smithy_http::query::fmt_string(inner_5));
-228
+                    }
-229
+                }
                 if let ::std::option::Option::Some(inner_6) = &_input.fetch_owner {
-231
+                    {
                         query.push_kv("fetch-owner", ::aws_smithy_types::primitive::Encoder::from(*inner_6).encode());
-233
+                    }
-234
+                }

                 if let ::std::option::Option::Some(inner_7) = &_input.start_after {
-236
+                    {
                         query.push_kv("start-after", &::aws_smithy_http::query::fmt_string(inner_7));
-238
+                    }
-239
+                }
                 ::std::result::Result::Ok(())
-241
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_objects_v2::ListObjectsV2Input,
                 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_list_objects_v2::ser_list_objects_v2_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-252
+            }
             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("");
-257
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-259
+    }
-260
+}
 #[derive(Debug)]
 struct ListObjectsV2EndpointParamsInterceptor;
-263

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListObjectsV2EndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListObjectsV2EndpointParamsInterceptor"
-267
+    }
-268
     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::<ListObjectsV2Input>()
             .ok_or("failed to downcast to ListObjectsV2Input")?;
-283

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

@@ -210,210 +278,278 @@

↥ Expand context

                 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", "ListParts");
                 if let ::std::option::Option::Some(inner_2) = &_input.max_parts {
-215
+                    {
                         query.push_kv("max-parts", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-217
+                    }
-218
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.part_number_marker {
-220
+                    {
                         query.push_kv("part-number-marker", &::aws_smithy_http::query::fmt_string(inner_3));
-222
+                    }
-223
+                }
                 let inner_4 = &_input.upload_id;
                 let inner_4 = inner_4
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("upload_id", "cannot be empty or unset"))?;
                 if inner_4.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "upload_id",
                         "cannot be empty or unset",
                     ));
-233
+                }
                 query.push_kv("uploadId", &::aws_smithy_http::query::fmt_string(inner_4));
                 ::std::result::Result::Ok(())
-236
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_parts::ListPartsInput,
                 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_list_parts::ser_list_parts_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-247
+            }
             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("");
-252
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-254
+    }
-255
+}
 #[derive(Debug)]
 struct ListPartsEndpointParamsInterceptor;
-258

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListPartsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListPartsEndpointParamsInterceptor"
-262
+    }
-263
     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::<ListPartsInput>()
             .ok_or("failed to downcast to ListPartsInput")?;
-278

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

@@ -252,252 +333,333 @@

↥ 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::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationInput>()
             .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::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationInput,
                 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(())
-270
+            }
             fn uri_query(

                 _input: &crate::operation::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationInput,
                 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(())
-278
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationInput,
                 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_put_bucket_accelerate_configuration::ser_put_bucket_accelerate_configuration_headers(
                     input, builder,
                 )?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-291
+            }
             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_put_bucket_accelerate_configuration_input::ser_accelerate_configuration_http_payload(
                 &input.accelerate_configuration,
             )?,
         );
         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);
-304
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-306
+    }
-307
+}
 #[derive(Debug)]
 struct PutBucketAccelerateConfigurationEndpointParamsInterceptor;
-310
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketAccelerateConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutBucketAccelerateConfigurationEndpointParamsInterceptor"

↧ Expand context

-314
+    }
-315
     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::<PutBucketAccelerateConfigurationInput>()
             .ok_or("failed to downcast to PutBucketAccelerateConfigurationInput")?;
-330
         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/put_bucket_acl.rs

@@ -239,239 +316,316 @@

↥ 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::put_bucket_acl::PutBucketAclInput>()
             .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::put_bucket_acl::PutBucketAclInput,
                 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::put_bucket_acl::PutBucketAclInput,
                 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(())
-265
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_bucket_acl::PutBucketAclInput,
                 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_put_bucket_acl::ser_put_bucket_acl_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").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_put_bucket_acl_input::ser_access_control_policy_http_payload(&input.access_control_policy)?,
         );
         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);
-287
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-289
+    }
-290
+}
 #[derive(Debug)]
 struct PutBucketAclEndpointParamsInterceptor;
-293
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketAclEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutBucketAclEndpointParamsInterceptor"

↧ Expand context

-297
+    }
-298
     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::<PutBucketAclInput>()
             .ok_or("failed to downcast to PutBucketAclInput")?;
-313
         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/put_bucket_analytics_configuration.rs

@@ -204,204 +284,284 @@

↥ Expand context

             fn uri_base(
                 _input: &crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationInput,
                 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::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationInput,
                 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");
                 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",
                     ));
-227
+                }
                 query.push_kv("id", &::aws_smithy_http::query::fmt_string(inner_1));
                 ::std::result::Result::Ok(())
-230
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationInput,
                 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_put_bucket_analytics_configuration::ser_put_bucket_analytics_configuration_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-242
+            }
             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_put_bucket_analytics_configuration_input::ser_analytics_configuration_http_payload(
                 &input.analytics_configuration,
             )?,
         );
         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);
-255
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-257
+    }
-258
+}
 #[derive(Debug)]
 struct PutBucketAnalyticsConfigurationEndpointParamsInterceptor;
-261
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketAnalyticsConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutBucketAnalyticsConfigurationEndpointParamsInterceptor"

↧ Expand context

-265
+    }
-266
     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::<PutBucketAnalyticsConfigurationInput>()
             .ok_or("failed to downcast to PutBucketAnalyticsConfigurationInput")?;
-281
         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/put_bucket_cors.rs

@@ -239,239 +316,316 @@

↥ 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::put_bucket_cors::PutBucketCorsInput>()
             .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::put_bucket_cors::PutBucketCorsInput,
                 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::put_bucket_cors::PutBucketCorsInput,
                 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(())
-265
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_bucket_cors::PutBucketCorsInput,
                 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_put_bucket_cors::ser_put_bucket_cors_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").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_put_bucket_cors_input::ser_cors_configuration_http_payload(
             &input.cors_configuration,
         )?);
         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);
-287
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-289
+    }
-290
+}
 #[derive(Debug)]
 struct PutBucketCorsEndpointParamsInterceptor;
-293
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketCorsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutBucketCorsEndpointParamsInterceptor"

↧ Expand context

-297
+    }
-298
     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::<PutBucketCorsInput>()
             .ok_or("failed to downcast to PutBucketCorsInput")?;
-313
         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))

AWS SDK

Files changed: