AWS SDK

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

@@ -176,176 +250,250 @@

             .downcast::<crate::operation::put_bucket_policy::PutBucketPolicyInput>()
             .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_policy::PutBucketPolicyInput,
                 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",
                     ));
-199
+                }
                 ::std::write!(output, "/v20180820/bucket/{Bucket}/policy", Bucket = bucket).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_bucket_policy::PutBucketPolicyInput,
                 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_policy::ser_put_bucket_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_bucket_policy::ser_put_bucket_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);
-221
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-223
+    }
-224
+}
 #[derive(Debug)]
 struct PutBucketPolicyEndpointParamsInterceptor;
-227
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketPolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutBucketPolicyEndpointParamsInterceptor"

↧ Expand context

-231
+    }
-232
     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::<PutBucketPolicyInput>()
             .ok_or("failed to downcast to PutBucketPolicyInput")?;
-247
         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_replication.rs

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

↥ Expand context

             .downcast::<crate::operation::put_bucket_replication::PutBucketReplicationInput>()
             .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_replication::PutBucketReplicationInput,
                 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",
                     ));
-199
+                }
                 ::std::write!(output, "/v20180820/bucket/{Bucket}/replication", Bucket = bucket).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_bucket_replication::PutBucketReplicationInput,
                 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_replication::ser_put_bucket_replication_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_bucket_replication_input::ser_replication_configuration_http_payload(&input.replication_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);
-223
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-225
+    }
-226
+}
 #[derive(Debug)]
 struct PutBucketReplicationEndpointParamsInterceptor;
-229
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketReplicationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutBucketReplicationEndpointParamsInterceptor"

↧ 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::<PutBucketReplicationInput>()
             .ok_or("failed to downcast to PutBucketReplicationInput")?;
-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_tagging.rs

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

↥ Expand context

             .downcast::<crate::operation::put_bucket_tagging::PutBucketTaggingInput>()
             .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_tagging::PutBucketTaggingInput,
                 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",
                     ));
-199
+                }
                 ::std::write!(output, "/v20180820/bucket/{Bucket}/tagging", Bucket = bucket).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_bucket_tagging::PutBucketTaggingInput,
                 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_tagging::ser_put_bucket_tagging_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_bucket_tagging_input::ser_tagging_http_payload(
             &input.tagging,
         )?);
         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 PutBucketTaggingEndpointParamsInterceptor;
-229
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketTaggingEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutBucketTaggingEndpointParamsInterceptor"

↧ 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::<PutBucketTaggingInput>()
             .ok_or("failed to downcast to PutBucketTaggingInput")?;
-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_versioning.rs

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

↥ Expand context

             .downcast::<crate::operation::put_bucket_versioning::PutBucketVersioningInput>()
             .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_versioning::PutBucketVersioningInput,
                 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",
                     ));
-199
+                }
                 ::std::write!(output, "/v20180820/bucket/{Bucket}/versioning", Bucket = bucket).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_bucket_versioning::PutBucketVersioningInput,
                 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_versioning::ser_put_bucket_versioning_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_bucket_versioning_input::ser_versioning_configuration_http_payload(&input.versioning_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);
-223
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-225
+    }
-226
+}
 #[derive(Debug)]
 struct PutBucketVersioningEndpointParamsInterceptor;
-229
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketVersioningEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutBucketVersioningEndpointParamsInterceptor"

↧ 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::<PutBucketVersioningInput>()
             .ok_or("failed to downcast to PutBucketVersioningInput")?;
-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_job_tagging.rs

@@ -176,176 +250,250 @@

↥ Expand context

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

                         "job_id",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/v20180820/jobs/{JobId}/tagging", JobId = job_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_job_tagging::PutJobTaggingInput,
                 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_job_tagging::ser_put_job_tagging_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_job_tagging::ser_put_job_tagging_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);
-221
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-223
+    }
-224
+}
 #[derive(Debug)]
 struct PutJobTaggingEndpointParamsInterceptor;
-227
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutJobTaggingEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutJobTaggingEndpointParamsInterceptor"

↧ Expand context

-231
+    }
-232
     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::<PutJobTaggingInput>()
             .ok_or("failed to downcast to PutJobTaggingInput")?;
-247
         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_multi_region_access_point_policy.rs

@@ -185,185 +263,263 @@

↥ Expand context

-185
+}
 #[derive(Debug)]
 struct PutMultiRegionAccessPointPolicyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutMultiRegionAccessPointPolicyRequestSerializer {
     #[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_multi_region_access_point_policy::PutMultiRegionAccessPointPolicyInput>()
             .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_multi_region_access_point_policy::PutMultiRegionAccessPointPolicyInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/async-requests/mrap/put-policy").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-211
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_multi_region_access_point_policy::PutMultiRegionAccessPointPolicyInput,
                 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_multi_region_access_point_policy::ser_put_multi_region_access_point_policy_headers(
                     input, builder,
                 )?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-223
+            }
             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_multi_region_access_point_policy::ser_put_multi_region_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);
-234
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-236
+    }
-237
+}
 #[derive(Debug)]
 struct PutMultiRegionAccessPointPolicyEndpointParamsInterceptor;
-240
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutMultiRegionAccessPointPolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutMultiRegionAccessPointPolicyEndpointParamsInterceptor"

↧ 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::<PutMultiRegionAccessPointPolicyInput>()
             .ok_or("failed to downcast to PutMultiRegionAccessPointPolicyInput")?;
-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))

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

@@ -165,165 +243,243 @@

↥ Expand context

-165
+}
 #[derive(Debug)]
 struct PutPublicAccessBlockRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutPublicAccessBlockRequestSerializer {
     #[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_public_access_block::PutPublicAccessBlockInput>()
             .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_public_access_block::PutPublicAccessBlockInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/configuration/publicAccessBlock").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_public_access_block::PutPublicAccessBlockInput,
                 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_public_access_block::ser_put_public_access_block_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-201
+            }
             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_public_access_block_input::ser_public_access_block_configuration_http_payload(
                 &input.public_access_block_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);
-214
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-216
+    }
-217
+}
 #[derive(Debug)]
 struct PutPublicAccessBlockEndpointParamsInterceptor;
-220
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutPublicAccessBlockEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutPublicAccessBlockEndpointParamsInterceptor"

↧ Expand context

-224
+    }
-225
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<PutPublicAccessBlockInput>()
             .ok_or("failed to downcast to PutPublicAccessBlockInput")?;
-240
         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_storage_lens_configuration.rs

@@ -182,182 +259,259 @@

↥ Expand context

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

                         "config_id",
                         "cannot be empty or unset",
                     ));
-205
+                }
                 ::std::write!(output, "/v20180820/storagelens/{ConfigId}", ConfigId = config_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-208
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_storage_lens_configuration::PutStorageLensConfigurationInput,
                 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_storage_lens_configuration::ser_put_storage_lens_configuration_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_storage_lens_configuration::ser_put_storage_lens_configuration_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);
-230
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-232
+    }
-233
+}
 #[derive(Debug)]
 struct PutStorageLensConfigurationEndpointParamsInterceptor;
-236
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutStorageLensConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutStorageLensConfigurationEndpointParamsInterceptor"

↧ Expand context

-240
+    }
-241
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<PutStorageLensConfigurationInput>()
             .ok_or("failed to downcast to PutStorageLensConfigurationInput")?;
-256
         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_storage_lens_configuration_tagging.rs

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

↥ Expand context

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

                         "config_id",
                         "cannot be empty or unset",
                     ));
-209
+                }
                 ::std::write!(output, "/v20180820/storagelens/{ConfigId}/tagging", ConfigId = config_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-212
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_storage_lens_configuration_tagging::PutStorageLensConfigurationTaggingInput,
                 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_storage_lens_configuration_tagging::ser_put_storage_lens_configuration_tagging_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_storage_lens_configuration_tagging::ser_put_storage_lens_configuration_tagging_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 PutStorageLensConfigurationTaggingEndpointParamsInterceptor;
-242
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutStorageLensConfigurationTaggingEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutStorageLensConfigurationTaggingEndpointParamsInterceptor"

↧ 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::<PutStorageLensConfigurationTaggingInput>()
             .ok_or("failed to downcast to PutStorageLensConfigurationTaggingInput")?;
-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/submit_multi_region_access_point_routes.rs

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

↥ Expand context

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

                         "mrap",
                         "cannot be empty or unset",
                     ));
-209
+                }
                 ::std::write!(output, "/v20180820/mrap/instances/{Mrap}/routes", Mrap = mrap).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-212
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::submit_multi_region_access_point_routes::SubmitMultiRegionAccessPointRoutesInput,
                 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_submit_multi_region_access_point_routes::ser_submit_multi_region_access_point_routes_headers(
                         input, builder,
                     )?;
                 ::std::result::Result::Ok(builder.method("PATCH").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_submit_multi_region_access_point_routes::ser_submit_multi_region_access_point_routes_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 SubmitMultiRegionAccessPointRoutesEndpointParamsInterceptor;
-242
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SubmitMultiRegionAccessPointRoutesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SubmitMultiRegionAccessPointRoutesEndpointParamsInterceptor"

↧ 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::<SubmitMultiRegionAccessPointRoutesInput>()
             .ok_or("failed to downcast to SubmitMultiRegionAccessPointRoutesInput")?;
-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/tag_resource.rs

@@ -173,173 +247,247 @@

↥ Expand context

             .downcast::<crate::operation::tag_resource::TagResourceInput>()
             .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::tag_resource::TagResourceInput,
                 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",
                     ));
-196
+                }
                 ::std::write!(output, "/v20180820/tags/{ResourceArn}", ResourceArn = resource_arn).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-199
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::tag_resource::TagResourceInput,
                 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_tag_resource::ser_tag_resource_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-209
+            }
             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_tag_resource::ser_tag_resource_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);
-218
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-220
+    }
-221
+}
 #[derive(Debug)]
 struct TagResourceEndpointParamsInterceptor;
-224
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TagResourceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TagResourceEndpointParamsInterceptor"

↧ Expand context

-228
+    }
-229
     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::<TagResourceInput>()
             .ok_or("failed to downcast to TagResourceInput")?;
-244
         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/untag_resource.rs

@@ -190,190 +258,258 @@

↥ Expand context

                 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
+            }
             fn uri_query(
                 _input: &crate::operation::untag_resource::UntagResourceInput,
                 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);
                 let inner_2 = &_input.tag_keys;
                 let inner_2 = inner_2

                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("tag_keys", "cannot be empty or unset"))?;
                 for inner_3 in inner_2 {
                     query.push_kv("tagKeys", &::aws_smithy_http::query::fmt_string(inner_3));
-214
+                }
                 ::std::result::Result::Ok(())
-216
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::untag_resource::UntagResourceInput,
                 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_untag_resource::ser_untag_resource_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-227
+            }
             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("");
-232
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-234
+    }
-235
+}
 #[derive(Debug)]
 struct UntagResourceEndpointParamsInterceptor;
-238

↧ Expand context

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

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

@@ -187,187 +263,263 @@

↥ Expand context

             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::update_access_grants_location::UpdateAccessGrantsLocationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.access_grants_location_id;
                 let input_1 = input_1.as_ref().ok_or_else(|| {
                     ::aws_smithy_types::error::operation::BuildError::missing_field("access_grants_location_id", "cannot be empty or unset")
                 })?;
                 let access_grants_location_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if access_grants_location_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "access_grants_location_id",
                         "cannot be empty or unset",
                     ));
-205
+                }
                 ::std::write!(

                     output,
                     "/v20180820/accessgrantsinstance/location/{AccessGrantsLocationId}",
                     AccessGrantsLocationId = access_grants_location_id
-210
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-213
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_access_grants_location::UpdateAccessGrantsLocationInput,
                 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_update_access_grants_location::ser_update_access_grants_location_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-223
+            }
             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_update_access_grants_location::ser_update_access_grants_location_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);
-234
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-236
+    }
-237
+}
 #[derive(Debug)]
 struct UpdateAccessGrantsLocationEndpointParamsInterceptor;
-240
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateAccessGrantsLocationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateAccessGrantsLocationEndpointParamsInterceptor"

↧ 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::<UpdateAccessGrantsLocationInput>()
             .ok_or("failed to downcast to UpdateAccessGrantsLocationInput")?;
-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))

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

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

↥ Expand context

                 use ::std::fmt::Write as _;
                 let input_1 = &_input.job_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("job_id", "cannot be empty or unset"))?;
                 let job_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if job_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "job_id",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/v20180820/jobs/{JobId}/priority", JobId = job_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             fn uri_query(
                 _input: &crate::operation::update_job_priority::UpdateJobPriorityInput,
                 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);

                 let inner_2 = &_input.priority;
                 let inner_2 = inner_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("priority", "cannot be empty or unset"))?;
                 query.push_kv("priority", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
                 ::std::result::Result::Ok(())
-214
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_job_priority::UpdateJobPriorityInput,
                 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_update_job_priority::ser_update_job_priority_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-225
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-230
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-232
+    }
-233
+}
 #[derive(Debug)]
 struct UpdateJobPriorityEndpointParamsInterceptor;
-236

↧ Expand context

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

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

@@ -193,193 +261,261 @@

↥ Expand context

                 let job_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if job_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "job_id",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/v20180820/jobs/{JobId}/status", JobId = job_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             fn uri_query(
                 _input: &crate::operation::update_job_status::UpdateJobStatusInput,
                 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);
                 let inner_2 = &_input.requested_job_status;
                 let inner_2 = inner_2.as_ref().ok_or_else(|| {
                     ::aws_smithy_types::error::operation::BuildError::missing_field("requested_job_status", "cannot be empty or unset")
                 })?;
                 query.push_kv("requestedJobStatus", &::aws_smithy_http::query::fmt_string(inner_2));

                 if let ::std::option::Option::Some(inner_3) = &_input.status_update_reason {
-214
+                    {
                         query.push_kv("statusUpdateReason", &::aws_smithy_http::query::fmt_string(inner_3));
-216
+                    }
-217
+                }
                 ::std::result::Result::Ok(())
-219
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_job_status::UpdateJobStatusInput,
                 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_update_job_status::ser_update_job_status_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-230
+            }
             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("");
-235
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-237
+    }
-238
+}
 #[derive(Debug)]
 struct UpdateJobStatusEndpointParamsInterceptor;
-241

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::update_storage_lens_group::UpdateStorageLensGroupInput>()
             .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::update_storage_lens_group::UpdateStorageLensGroupInput,
                 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/storagelensgroup/{Name}", Name = name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_storage_lens_group::UpdateStorageLensGroupInput,
                 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_update_storage_lens_group::ser_update_storage_lens_group_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_update_storage_lens_group::ser_update_storage_lens_group_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 UpdateStorageLensGroupEndpointParamsInterceptor;
-229
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateStorageLensGroupEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateStorageLensGroupEndpointParamsInterceptor"

↧ 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::<UpdateStorageLensGroupInput>()
             .ok_or("failed to downcast to UpdateStorageLensGroupInput")?;
-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))

AWS SDK

Files changed: