AWS SDK

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

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

-181
+}
 #[derive(Debug)]
 struct CreateMultiRegionAccessPointRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateMultiRegionAccessPointRequestSerializer {
     #[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::create_multi_region_access_point::CreateMultiRegionAccessPointInput>()
             .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::create_multi_region_access_point::CreateMultiRegionAccessPointInput,
                 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/create").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-207
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointInput,
                 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_create_multi_region_access_point::ser_create_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_create_multi_region_access_point::ser_create_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 CreateMultiRegionAccessPointEndpointParamsInterceptor;
-235
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateMultiRegionAccessPointEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CreateMultiRegionAccessPointEndpointParamsInterceptor"

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

@@ -165,165 +241,241 @@

↥ Expand context

-165
+}
 #[derive(Debug)]
 struct CreateStorageLensGroupRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateStorageLensGroupRequestSerializer {
     #[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::create_storage_lens_group::CreateStorageLensGroupInput>()
             .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::create_storage_lens_group::CreateStorageLensGroupInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/storagelensgroup").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::create_storage_lens_group::CreateStorageLensGroupInput,
                 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_create_storage_lens_group::ser_create_storage_lens_group_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").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_create_storage_lens_group::ser_create_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);
-212
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-214
+    }
-215
+}
 #[derive(Debug)]
 struct CreateStorageLensGroupEndpointParamsInterceptor;
-218
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateStorageLensGroupEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CreateStorageLensGroupEndpointParamsInterceptor"

↧ Expand context

-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::<CreateStorageLensGroupInput>()
             .ok_or("failed to downcast to CreateStorageLensGroupInput")?;
-238
         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_access_grant.rs

@@ -181,181 +248,248 @@

↥ Expand context

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

                     output,
                     "/v20180820/accessgrantsinstance/grant/{AccessGrantId}",
                     AccessGrantId = access_grant_id
-204
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-207
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_access_grant::DeleteAccessGrantInput,
                 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_grant::ser_delete_access_grant_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-217
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-222
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-224
+    }
-225
+}
 #[derive(Debug)]
 struct DeleteAccessGrantEndpointParamsInterceptor;
-228

↧ Expand context

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

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

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

↥ Expand context

-171
+}
 #[derive(Debug)]
 struct DeleteAccessGrantsInstanceRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DeleteAccessGrantsInstanceRequestSerializer {
     #[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_access_grants_instance::DeleteAccessGrantsInstanceInput>()
             .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_grants_instance::DeleteAccessGrantsInstanceInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/accessgrantsinstance").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-197
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_access_grants_instance::DeleteAccessGrantsInstanceInput,
                 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_grants_instance::ser_delete_access_grants_instance_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 DeleteAccessGrantsInstanceEndpointParamsInterceptor;
-218

↧ Expand context

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

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

@@ -175,175 +242,242 @@

↥ Expand context

-175
+}
 #[derive(Debug)]
 struct DeleteAccessGrantsInstanceResourcePolicyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DeleteAccessGrantsInstanceResourcePolicyRequestSerializer {
     #[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_access_grants_instance_resource_policy::DeleteAccessGrantsInstanceResourcePolicyInput>()
             .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_grants_instance_resource_policy::DeleteAccessGrantsInstanceResourcePolicyInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v20180820/accessgrantsinstance/resourcepolicy").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-201
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_access_grants_instance_resource_policy::DeleteAccessGrantsInstanceResourcePolicyInput,
                 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_grants_instance_resource_policy::ser_delete_access_grants_instance_resource_policy_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-211
+            }
             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("");
-216
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-218
+    }
-219
+}
 #[derive(Debug)]
 struct DeleteAccessGrantsInstanceResourcePolicyEndpointParamsInterceptor;
-222

↧ Expand context

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

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

@@ -187,187 +254,254 @@

↥ Expand context

             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::delete_access_grants_location::DeleteAccessGrantsLocationInput,
                 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::delete_access_grants_location::DeleteAccessGrantsLocationInput,
                 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_grants_location::ser_delete_access_grants_location_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
-223
+            }
             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("");
-228
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-230
+    }
-231
+}
 #[derive(Debug)]
 struct DeleteAccessGrantsLocationEndpointParamsInterceptor;
-234

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::delete_access_point::DeleteAccessPointInput>()
             .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::DeleteAccessPointInput,
                 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}", 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::DeleteAccessPointInput,
                 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::ser_delete_access_point_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 DeleteAccessPointEndpointParamsInterceptor;
-223

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::delete_access_point_for_object_lambda::DeleteAccessPointForObjectLambdaInput>()
             .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_for_object_lambda::DeleteAccessPointForObjectLambdaInput,
                 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}", 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_for_object_lambda::DeleteAccessPointForObjectLambdaInput,
                 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_for_object_lambda::ser_delete_access_point_for_object_lambda_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 DeleteAccessPointForObjectLambdaEndpointParamsInterceptor;
-235

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::delete_access_point_policy::DeleteAccessPointPolicyInput>()
             .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::DeleteAccessPointPolicyInput,
                 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",
                     ));
-205
+                }
                 ::std::write!(output, "/v20180820/accesspoint/{Name}/policy", Name = name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-208
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_access_point_policy::DeleteAccessPointPolicyInput,
                 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::ser_delete_access_point_policy_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 DeleteAccessPointPolicyEndpointParamsInterceptor;
-229

↧ Expand context

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

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

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

↥ Expand context

             .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

AWS SDK

Files changed: