AWS SDK

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

@@ -186,186 +253,253 @@

             .downcast::<crate::operation::delete_access_point_policy_for_object_lambda::DeleteAccessPointPolicyForObjectLambdaInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_access_point_policy_for_object_lambda::DeleteAccessPointPolicyForObjectLambdaInput,
                 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::delete_access_point_policy_for_object_lambda::DeleteAccessPointPolicyForObjectLambdaInput,
                 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_delete_access_point_policy_for_object_lambda::ser_delete_access_point_policy_for_object_lambda_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-222
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-227
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-229
+    }
-230
+}
 #[derive(Debug)]
 struct DeleteAccessPointPolicyForObjectLambdaEndpointParamsInterceptor;
-233

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::delete_access_point_scope::DeleteAccessPointScopeInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_access_point_scope::DeleteAccessPointScopeInput,
                 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::delete_access_point_scope::DeleteAccessPointScopeInput,
                 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_delete_access_point_scope::ser_delete_access_point_scope_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").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 DeleteAccessPointScopeEndpointParamsInterceptor;
-223

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::delete_bucket::DeleteBucketInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_bucket::DeleteBucketInput,
                 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}", Bucket = bucket).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_bucket::DeleteBucketInput,
                 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_delete_bucket::ser_delete_bucket_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").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 DeleteBucketEndpointParamsInterceptor;
-223

↧ Expand context

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

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

@@ -186,186 +255,255 @@

↥ Expand context

             .downcast::<crate::operation::delete_bucket_lifecycle_configuration::DeleteBucketLifecycleConfigurationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_bucket_lifecycle_configuration::DeleteBucketLifecycleConfigurationInput,
                 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",
                     ));
-209
+                }
                 ::std::write!(output, "/v20180820/bucket/{Bucket}/lifecycleconfiguration", Bucket = bucket).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-212
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_bucket_lifecycle_configuration::DeleteBucketLifecycleConfigurationInput,
                 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_delete_bucket_lifecycle_configuration::ser_delete_bucket_lifecycle_configuration_headers(
                     input, builder,
                 )?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-224
+            }
             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("");
-229
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-231
+    }
-232
+}
 #[derive(Debug)]
 struct DeleteBucketLifecycleConfigurationEndpointParamsInterceptor;
-235

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::delete_bucket_policy::DeleteBucketPolicyInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_bucket_policy::DeleteBucketPolicyInput,
                 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::delete_bucket_policy::DeleteBucketPolicyInput,
                 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_delete_bucket_policy::ser_delete_bucket_policy_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").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 DeleteBucketPolicyEndpointParamsInterceptor;
-223

↧ Expand context

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

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

@@ -182,182 +249,249 @@

↥ Expand context

             .downcast::<crate::operation::delete_bucket_replication::DeleteBucketReplicationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_bucket_replication::DeleteBucketReplicationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 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",
                     ));
-205
+                }
                 ::std::write!(output, "/v20180820/bucket/{Bucket}/replication", Bucket = bucket).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-208
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_bucket_replication::DeleteBucketReplicationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_delete_bucket_replication::ser_delete_bucket_replication_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-218
+            }
             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("");
-223
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-225
+    }
-226
+}
 #[derive(Debug)]
 struct DeleteBucketReplicationEndpointParamsInterceptor;
-229

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::delete_bucket_tagging::DeleteBucketTaggingInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_bucket_tagging::DeleteBucketTaggingInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 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::delete_bucket_tagging::DeleteBucketTaggingInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_delete_bucket_tagging::ser_delete_bucket_tagging_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-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 DeleteBucketTaggingEndpointParamsInterceptor;
-223

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::delete_job_tagging::DeleteJobTaggingInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_job_tagging::DeleteJobTaggingInput,
                 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::delete_job_tagging::DeleteJobTaggingInput,
                 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_delete_job_tagging::ser_delete_job_tagging_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").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 DeleteJobTaggingEndpointParamsInterceptor;
-223

↧ Expand context

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

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

@@ -181,181 +258,258 @@

↥ Expand context

-181
+}
 #[derive(Debug)]
 struct DeleteMultiRegionAccessPointRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DeleteMultiRegionAccessPointRequestSerializer {
     #[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::delete_multi_region_access_point::DeleteMultiRegionAccessPointInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::delete_multi_region_access_point::DeleteMultiRegionAccessPointInput,
                 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/delete").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-207
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_multi_region_access_point::DeleteMultiRegionAccessPointInput,
                 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_delete_multi_region_access_point::ser_delete_multi_region_access_point_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-218
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_delete_multi_region_access_point::ser_delete_multi_region_access_point_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);
-229
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-231
+    }
-232
+}
 #[derive(Debug)]
 struct DeleteMultiRegionAccessPointEndpointParamsInterceptor;
-235
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteMultiRegionAccessPointEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteMultiRegionAccessPointEndpointParamsInterceptor"

↧ Expand context

-239
+    }
-240
     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::<DeleteMultiRegionAccessPointInput>()
             .ok_or("failed to downcast to DeleteMultiRegionAccessPointInput")?;
-255
         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/delete_public_access_block.rs

@@ -171,171 +238,238 @@

↥ Expand context

-171
+}
 #[derive(Debug)]
 struct DeletePublicAccessBlockRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DeletePublicAccessBlockRequestSerializer {
     #[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::delete_public_access_block::DeletePublicAccessBlockInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::delete_public_access_block::DeletePublicAccessBlockInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/configuration/publicAccessBlock").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-197
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_public_access_block::DeletePublicAccessBlockInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_delete_public_access_block::ser_delete_public_access_block_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-207
+            }
             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("");
-212
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-214
+    }
-215
+}
 #[derive(Debug)]
 struct DeletePublicAccessBlockEndpointParamsInterceptor;
-218

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::delete_storage_lens_configuration::DeleteStorageLensConfigurationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_storage_lens_configuration::DeleteStorageLensConfigurationInput,
                 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::delete_storage_lens_configuration::DeleteStorageLensConfigurationInput,
                 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_delete_storage_lens_configuration::ser_delete_storage_lens_configuration_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").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 DeleteStorageLensConfigurationEndpointParamsInterceptor;
-230

↧ Expand context

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

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

@@ -186,186 +256,256 @@

↥ Expand context

             .downcast::<crate::operation::delete_storage_lens_configuration_tagging::DeleteStorageLensConfigurationTaggingInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_storage_lens_configuration_tagging::DeleteStorageLensConfigurationTaggingInput,
                 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::delete_storage_lens_configuration_tagging::DeleteStorageLensConfigurationTaggingInput,
                 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_delete_storage_lens_configuration_tagging::ser_delete_storage_lens_configuration_tagging_headers(
                         input, builder,
                     )?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-225
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-230
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-232
+    }
-233
+}
 #[derive(Debug)]
 struct DeleteStorageLensConfigurationTaggingEndpointParamsInterceptor;
-236

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::delete_storage_lens_group::DeleteStorageLensGroupInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_storage_lens_group::DeleteStorageLensGroupInput,
                 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::delete_storage_lens_group::DeleteStorageLensGroupInput,
                 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_delete_storage_lens_group::ser_delete_storage_lens_group_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").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 DeleteStorageLensGroupEndpointParamsInterceptor;
-223

↧ Expand context

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

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

@@ -173,173 +240,240 @@

↥ Expand context

             .downcast::<crate::operation::describe_job::DescribeJobInput>()
             .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::describe_job::DescribeJobInput,
                 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",
                     ));
-196
+                }
                 ::std::write!(output, "/v20180820/jobs/{JobId}", JobId = job_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-199
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::describe_job::DescribeJobInput,
                 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_describe_job::ser_describe_job_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-209
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-214
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-216
+    }
-217
+}
 #[derive(Debug)]
 struct DescribeJobEndpointParamsInterceptor;
-220

↧ Expand context

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

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

@@ -191,191 +258,258 @@

↥ Expand context

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

                     output,
                     "/v20180820/async-requests/mrap/{RequestTokenARN}",
                     RequestTokenARN = request_token_arn
-214
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-217
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::describe_multi_region_access_point_operation::DescribeMultiRegionAccessPointOperationInput,
                 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_describe_multi_region_access_point_operation::ser_describe_multi_region_access_point_operation_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").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 DescribeMultiRegionAccessPointOperationEndpointParamsInterceptor;
-238

↧ Expand context

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

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

@@ -175,175 +245,245 @@

↥ Expand context

-175
+}
 #[derive(Debug)]
 struct DissociateAccessGrantsIdentityCenterRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DissociateAccessGrantsIdentityCenterRequestSerializer {
     #[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::dissociate_access_grants_identity_center::DissociateAccessGrantsIdentityCenterInput>()
             .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::dissociate_access_grants_identity_center::DissociateAccessGrantsIdentityCenterInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/accessgrantsinstance/identitycenter").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-201
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::dissociate_access_grants_identity_center::DissociateAccessGrantsIdentityCenterInput,
                 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_dissociate_access_grants_identity_center::ser_dissociate_access_grants_identity_center_headers(
                         input, builder,
                     )?;
                 ::std::result::Result::Ok(builder.method("DELETE").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 DissociateAccessGrantsIdentityCenterEndpointParamsInterceptor;
-225

↧ Expand context

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

AWS SDK

Files changed: