AWS SDK

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/list_access_points.rs

@@ -197,197 +265,265 @@

                 if let ::std::option::Option::Some(inner_1) = &_input.bucket {
-198
+                    {
                         query.push_kv("bucket", &::aws_smithy_http::query::fmt_string(inner_1));
-200
+                    }
-201
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.next_token {
-203
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_2));
-205
+                    }
-206
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.max_results {
-208
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-210
+                    }
-211
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.data_source_id {
-213
+                    {
                         query.push_kv("dataSourceId", &::aws_smithy_http::query::fmt_string(inner_4));
-215
+                    }
-216
+                }

                 if let ::std::option::Option::Some(inner_5) = &_input.data_source_type {
-218
+                    {
                         query.push_kv("dataSourceType", &::aws_smithy_http::query::fmt_string(inner_5));
-220
+                    }
-221
+                }
                 ::std::result::Result::Ok(())
-223
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_access_points::ListAccessPointsInput,
                 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_access_points::ser_list_access_points_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-234
+            }
             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("");
-239
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-241
+    }
-242
+}
 #[derive(Debug)]
 struct ListAccessPointsEndpointParamsInterceptor;
-245

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListAccessPointsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListAccessPointsEndpointParamsInterceptor"
-249
+    }
-250
     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::<ListAccessPointsInput>()
             .ok_or("failed to downcast to ListAccessPointsInput")?;
-265

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/list_access_points_for_directory_buckets.rs

@@ -197,197 +268,268 @@

↥ Expand context

             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/accesspointfordirectory").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-201
+            }
             fn uri_query(
                 _input: &crate::operation::list_access_points_for_directory_buckets::ListAccessPointsForDirectoryBucketsInput,
                 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);
                 if let ::std::option::Option::Some(inner_1) = &_input.directory_bucket {
-208
+                    {
                         query.push_kv("directoryBucket", &::aws_smithy_http::query::fmt_string(inner_1));
-210
+                    }
-211
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.next_token {
-213
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_2));
-215
+                    }
-216
+                }

                 if let ::std::option::Option::Some(inner_3) = &_input.max_results {
-218
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-220
+                    }
-221
+                }
                 ::std::result::Result::Ok(())
-223
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_access_points_for_directory_buckets::ListAccessPointsForDirectoryBucketsInput,
                 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_access_points_for_directory_buckets::ser_list_access_points_for_directory_buckets_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 ListAccessPointsForDirectoryBucketsEndpointParamsInterceptor;
-248

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/list_access_points_for_object_lambda.rs

@@ -192,192 +262,262 @@

↥ Expand context

         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_access_points_for_object_lambda::ListAccessPointsForObjectLambdaInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/accesspointforobjectlambda").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-201
+            }
             fn uri_query(
                 _input: &crate::operation::list_access_points_for_object_lambda::ListAccessPointsForObjectLambdaInput,
                 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);
                 if let ::std::option::Option::Some(inner_1) = &_input.next_token {
-208
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_1));
-210
+                    }
-211
+                }

                 if let ::std::option::Option::Some(inner_2) = &_input.max_results {
-213
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-215
+                    }
-216
+                }
                 ::std::result::Result::Ok(())
-218
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_access_points_for_object_lambda::ListAccessPointsForObjectLambdaInput,
                 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_access_points_for_object_lambda::ser_list_access_points_for_object_lambda_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 ListAccessPointsForObjectLambdaEndpointParamsInterceptor;
-242

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/list_caller_access_grants.rs

@@ -192,192 +260,260 @@

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_caller_access_grants::ListCallerAccessGrantsInput,
                 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);
                 if let ::std::option::Option::Some(inner_1) = &_input.grant_scope {
-198
+                    {
                         query.push_kv("grantscope", &::aws_smithy_http::query::fmt_string(inner_1));
-200
+                    }
-201
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.next_token {
-203
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_2));
-205
+                    }
-206
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.max_results {
-208
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-210
+                    }
-211
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.allowed_by_application {
-213
+                    {
                         query.push_kv("allowedByApplication", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-215
+                    }
-216
+                }
                 ::std::result::Result::Ok(())
-218
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_caller_access_grants::ListCallerAccessGrantsInput,
                 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_caller_access_grants::ser_list_caller_access_grants_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-229
+            }
             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("");
-234
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-236
+    }
-237
+}
 #[derive(Debug)]
 struct ListCallerAccessGrantsEndpointParamsInterceptor;
-240

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListCallerAccessGrantsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListCallerAccessGrantsEndpointParamsInterceptor"
-244
+    }
-245
     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::<ListCallerAccessGrantsInput>()
             .ok_or("failed to downcast to ListCallerAccessGrantsInput")?;
-260

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/list_jobs.rs

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

↥ Expand context

                 ::std::write!(output, "/v20180820/jobs").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-182
+            }
             fn uri_query(
                 _input: &crate::operation::list_jobs::ListJobsInput,
                 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);
                 if let ::std::option::Option::Some(inner_1) = &_input.job_statuses {
-189
+                    {
                         for inner_2 in inner_1 {
                             query.push_kv("jobStatuses", &::aws_smithy_http::query::fmt_string(inner_2));
-192
+                        }
-193
+                    }
-194
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.next_token {
-196
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_3));
-198
+                    }
-199
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.max_results {
-201
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-203
+                    }
-204
+                }
                 ::std::result::Result::Ok(())
-206
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_jobs::ListJobsInput,
                 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_jobs::ser_list_jobs_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 ListJobsEndpointParamsInterceptor;
-228

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListJobsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListJobsEndpointParamsInterceptor"
-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::<ListJobsInput>()
             .ok_or("failed to downcast to ListJobsInput")?;
-248

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/list_multi_region_access_points.rs

@@ -188,188 +257,257 @@

↥ Expand context

         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_multi_region_access_points::ListMultiRegionAccessPointsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/mrap/instances").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-197
+            }
             fn uri_query(
                 _input: &crate::operation::list_multi_region_access_points::ListMultiRegionAccessPointsInput,
                 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);
                 if let ::std::option::Option::Some(inner_1) = &_input.next_token {
-204
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_1));
-206
+                    }
-207
+                }

                 if let ::std::option::Option::Some(inner_2) = &_input.max_results {
-209
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-211
+                    }
-212
+                }
                 ::std::result::Result::Ok(())
-214
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_multi_region_access_points::ListMultiRegionAccessPointsInput,
                 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_multi_region_access_points::ser_list_multi_region_access_points_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-226
+            }
             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("");
-231
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-233
+    }
-234
+}
 #[derive(Debug)]
 struct ListMultiRegionAccessPointsEndpointParamsInterceptor;
-237

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/list_regional_buckets.rs

@@ -182,182 +250,250 @@

↥ Expand context

         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_regional_buckets::ListRegionalBucketsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/bucket").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             fn uri_query(
                 _input: &crate::operation::list_regional_buckets::ListRegionalBucketsInput,
                 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);
                 if let ::std::option::Option::Some(inner_1) = &_input.next_token {
-198
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_1));
-200
+                    }
-201
+                }

                 if let ::std::option::Option::Some(inner_2) = &_input.max_results {
-203
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-205
+                    }
-206
+                }
                 ::std::result::Result::Ok(())
-208
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_regional_buckets::ListRegionalBucketsInput,
                 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_regional_buckets::ser_list_regional_buckets_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-219
+            }
             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("");
-224
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-226
+    }
-227
+}
 #[derive(Debug)]
 struct ListRegionalBucketsEndpointParamsInterceptor;
-230

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListRegionalBucketsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListRegionalBucketsEndpointParamsInterceptor"
-234
+    }
-235
     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::<ListRegionalBucketsInput>()
             .ok_or("failed to downcast to ListRegionalBucketsInput")?;
-250

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/list_storage_lens_configurations.rs

@@ -183,183 +252,252 @@

↥ Expand context

             .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::list_storage_lens_configurations::ListStorageLensConfigurationsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/storagelens").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-197
+            }
             fn uri_query(
                 _input: &crate::operation::list_storage_lens_configurations::ListStorageLensConfigurationsInput,
                 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);

                 if let ::std::option::Option::Some(inner_1) = &_input.next_token {
-204
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_1));
-206
+                    }
-207
+                }
                 ::std::result::Result::Ok(())
-209
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_storage_lens_configurations::ListStorageLensConfigurationsInput,
                 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_storage_lens_configurations::ser_list_storage_lens_configurations_headers(input, builder)?;
                 ::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 ListStorageLensConfigurationsEndpointParamsInterceptor;
-232

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/list_storage_lens_groups.rs

@@ -177,177 +245,245 @@

↥ Expand context

             .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::list_storage_lens_groups::ListStorageLensGroupsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/storagelensgroup").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             fn uri_query(
                 _input: &crate::operation::list_storage_lens_groups::ListStorageLensGroupsInput,
                 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);

                 if let ::std::option::Option::Some(inner_1) = &_input.next_token {
-198
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_1));
-200
+                    }
-201
+                }
                 ::std::result::Result::Ok(())
-203
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_storage_lens_groups::ListStorageLensGroupsInput,
                 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_storage_lens_groups::ser_list_storage_lens_groups_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-214
+            }
             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("");
-219
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-221
+    }
-222
+}
 #[derive(Debug)]
 struct ListStorageLensGroupsEndpointParamsInterceptor;
-225

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListStorageLensGroupsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListStorageLensGroupsEndpointParamsInterceptor"
-229
+    }
-230
     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::<ListStorageLensGroupsInput>()
             .ok_or("failed to downcast to ListStorageLensGroupsInput")?;
-245

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/list_tags_for_resource.rs

@@ -176,176 +243,243 @@

↥ Expand context

             .downcast::<crate::operation::list_tags_for_resource::ListTagsForResourceInput>()
             .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::list_tags_for_resource::ListTagsForResourceInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.resource_arn;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("resource_arn", "cannot be empty or unset"))?;
                 let resource_arn = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Greedy);
                 if resource_arn.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "resource_arn",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/v20180820/tags/{ResourceArn}", ResourceArn = resource_arn).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_tags_for_resource::ListTagsForResourceInput,
                 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)?;
                 let builder = crate::protocol_serde::shape_list_tags_for_resource::ser_list_tags_for_resource_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-212
+            }
             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("");
-217
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-219
+    }
-220
+}
 #[derive(Debug)]
 struct ListTagsForResourceEndpointParamsInterceptor;
-223

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTagsForResourceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListTagsForResourceEndpointParamsInterceptor"
-227
+    }
-228
     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::<ListTagsForResourceInput>()
             .ok_or("failed to downcast to ListTagsForResourceInput")?;
-243

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/put_access_grants_instance_resource_policy.rs

@@ -175,175 +254,254 @@

↥ Expand context

-175
+}
 #[derive(Debug)]
 struct PutAccessGrantsInstanceResourcePolicyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutAccessGrantsInstanceResourcePolicyRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _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_access_grants_instance_resource_policy::PutAccessGrantsInstanceResourcePolicyInput>()
             .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_access_grants_instance_resource_policy::PutAccessGrantsInstanceResourcePolicyInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/accessgrantsinstance/resourcepolicy").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-201
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_access_grants_instance_resource_policy::PutAccessGrantsInstanceResourcePolicyInput,
                 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)?;
                 let builder =
                     crate::protocol_serde::shape_put_access_grants_instance_resource_policy::ser_put_access_grants_instance_resource_policy_headers(
                         input, builder,
                     )?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-214
+            }
             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_access_grants_instance_resource_policy::ser_put_access_grants_instance_resource_policy_op_input(&input)?,
         );
         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);
-225
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-227
+    }
-228
+}
 #[derive(Debug)]
 struct PutAccessGrantsInstanceResourcePolicyEndpointParamsInterceptor;
-231
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutAccessGrantsInstanceResourcePolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutAccessGrantsInstanceResourcePolicyEndpointParamsInterceptor"

↧ Expand context

-235
+    }
-236
     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::<PutAccessGrantsInstanceResourcePolicyInput>()
             .ok_or("failed to downcast to PutAccessGrantsInstanceResourcePolicyInput")?;
-251
         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/s3control/src/operation/put_access_point_configuration_for_object_lambda.rs

@@ -183,183 +257,257 @@

↥ Expand context

             .downcast::<crate::operation::put_access_point_configuration_for_object_lambda::PutAccessPointConfigurationForObjectLambdaInput>()
             .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_access_point_configuration_for_object_lambda::PutAccessPointConfigurationForObjectLambdaInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "name",
                         "cannot be empty or unset",
                     ));
-206
+                }
                 ::std::write!(output, "/v20180820/accesspointforobjectlambda/{Name}/configuration", Name = name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-209
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_access_point_configuration_for_object_lambda::PutAccessPointConfigurationForObjectLambdaInput,
                 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)?;
                 let builder = crate::protocol_serde::shape_put_access_point_configuration_for_object_lambda::ser_put_access_point_configuration_for_object_lambda_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-219
+            }
             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_access_point_configuration_for_object_lambda::ser_put_access_point_configuration_for_object_lambda_op_input(&input)?);
         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);
-228
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-230
+    }
-231
+}
 #[derive(Debug)]
 struct PutAccessPointConfigurationForObjectLambdaEndpointParamsInterceptor;
-234
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutAccessPointConfigurationForObjectLambdaEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutAccessPointConfigurationForObjectLambdaEndpointParamsInterceptor"

↧ Expand context

-238
+    }
-239
     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::<PutAccessPointConfigurationForObjectLambdaInput>()
             .ok_or("failed to downcast to PutAccessPointConfigurationForObjectLambdaInput")?;
-254
         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/s3control/src/operation/put_access_point_policy.rs

@@ -176,176 +252,252 @@

↥ Expand context

             .downcast::<crate::operation::put_access_point_policy::PutAccessPointPolicyInput>()
             .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_access_point_policy::PutAccessPointPolicyInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "name",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/v20180820/accesspoint/{Name}/policy", Name = name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_access_point_policy::PutAccessPointPolicyInput,
                 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)?;
                 let builder = crate::protocol_serde::shape_put_access_point_policy::ser_put_access_point_policy_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-212
+            }
             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_access_point_policy::ser_put_access_point_policy_op_input(&input)?,
         );
         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);
-223
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-225
+    }
-226
+}
 #[derive(Debug)]
 struct PutAccessPointPolicyEndpointParamsInterceptor;
-229
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutAccessPointPolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutAccessPointPolicyEndpointParamsInterceptor"

↧ Expand context

-233
+    }
-234
     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::<PutAccessPointPolicyInput>()
             .ok_or("failed to downcast to PutAccessPointPolicyInput")?;
-249
         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/s3control/src/operation/put_access_point_policy_for_object_lambda.rs

@@ -186,186 +265,265 @@

↥ Expand context

             .downcast::<crate::operation::put_access_point_policy_for_object_lambda::PutAccessPointPolicyForObjectLambdaInput>()
             .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_access_point_policy_for_object_lambda::PutAccessPointPolicyForObjectLambdaInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "name",
                         "cannot be empty or unset",
                     ));
-209
+                }
                 ::std::write!(output, "/v20180820/accesspointforobjectlambda/{Name}/policy", Name = name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-212
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_access_point_policy_for_object_lambda::PutAccessPointPolicyForObjectLambdaInput,
                 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)?;
                 let builder =
                     crate::protocol_serde::shape_put_access_point_policy_for_object_lambda::ser_put_access_point_policy_for_object_lambda_headers(
                         input, builder,
                     )?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-225
+            }
             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_access_point_policy_for_object_lambda::ser_put_access_point_policy_for_object_lambda_op_input(&input)?,
         );
         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);
-236
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-238
+    }
-239
+}
 #[derive(Debug)]
 struct PutAccessPointPolicyForObjectLambdaEndpointParamsInterceptor;
-242
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutAccessPointPolicyForObjectLambdaEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutAccessPointPolicyForObjectLambdaEndpointParamsInterceptor"

↧ Expand context

-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::<PutAccessPointPolicyForObjectLambdaInput>()
             .ok_or("failed to downcast to PutAccessPointPolicyForObjectLambdaInput")?;
-262
         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/s3control/src/operation/put_access_point_scope.rs

@@ -176,176 +252,252 @@

↥ Expand context

             .downcast::<crate::operation::put_access_point_scope::PutAccessPointScopeInput>()
             .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_access_point_scope::PutAccessPointScopeInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "name",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/v20180820/accesspoint/{Name}/scope", Name = name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_access_point_scope::PutAccessPointScopeInput,
                 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)?;
                 let builder = crate::protocol_serde::shape_put_access_point_scope::ser_put_access_point_scope_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-212
+            }
             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_access_point_scope::ser_put_access_point_scope_op_input(
             &input,
         )?);
         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);
-223
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-225
+    }
-226
+}
 #[derive(Debug)]
 struct PutAccessPointScopeEndpointParamsInterceptor;
-229
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutAccessPointScopeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutAccessPointScopeEndpointParamsInterceptor"

↧ Expand context

-233
+    }
-234
     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::<PutAccessPointScopeInput>()
             .ok_or("failed to downcast to PutAccessPointScopeInput")?;
-249
         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/s3control/src/operation/put_bucket_lifecycle_configuration.rs

@@ -184,184 +263,263 @@

↥ Expand context

             .downcast::<crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationInput>()
             .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_lifecycle_configuration::PutBucketLifecycleConfigurationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.bucket;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "cannot be empty or unset"))?;
                 let bucket = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if bucket.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "bucket",
                         "cannot be empty or unset",
                     ));
-207
+                }
                 ::std::write!(output, "/v20180820/bucket/{Bucket}/lifecycleconfiguration", Bucket = bucket).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-210
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationInput,
                 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)?;
                 let builder =
                     crate::protocol_serde::shape_put_bucket_lifecycle_configuration::ser_put_bucket_lifecycle_configuration_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-221
+            }
             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_lifecycle_configuration_input::ser_lifecycle_configuration_http_payload(
                 &input.lifecycle_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);
-234
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-236
+    }
-237
+}
 #[derive(Debug)]
 struct PutBucketLifecycleConfigurationEndpointParamsInterceptor;
-240
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketLifecycleConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutBucketLifecycleConfigurationEndpointParamsInterceptor"

↧ Expand context

-244
+    }
-245
     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::<PutBucketLifecycleConfigurationInput>()
             .ok_or("failed to downcast to PutBucketLifecycleConfigurationInput")?;
-260
         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: