AWS SDK

AWS SDK

rev. 03e6e47f15dfd569240d570d98975ebba692c405 (ignoring whitespace)

Files changed:

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

@@ -204,204 +272,272 @@
  224    224   
                if let ::std::option::Option::Some(inner_5) = &_input.prefix {
  225    225   
                    {
  226    226   
                        query.push_kv("prefix", &::aws_smithy_http::query::fmt_string(inner_5));
  227    227   
                    }
  228    228   
                }
  229    229   
                ::std::result::Result::Ok(())
  230    230   
            }
  231    231   
            #[allow(clippy::unnecessary_wraps)]
  232    232   
            fn update_http_builder(
  233    233   
                input: &crate::operation::list_objects::ListObjectsInput,
  234         -
                builder: ::http::request::Builder,
  235         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         234  +
                builder: ::http_1x::request::Builder,
         235  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  236    236   
                let mut uri = ::std::string::String::new();
  237    237   
                uri_base(input, &mut uri)?;
  238    238   
                uri_query(input, &mut uri)?;
  239    239   
                let builder = crate::protocol_serde::shape_list_objects::ser_list_objects_headers(input, builder)?;
  240    240   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  241    241   
            }
  242         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         242  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  243    243   
            builder
  244    244   
        };
  245    245   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  246    246   
  247    247   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  248    248   
    }
  249    249   
}
  250    250   
#[derive(Debug)]
  251    251   
struct ListObjectsEndpointParamsInterceptor;
  252    252

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

@@ -215,215 +283,283 @@
  235    235   
                if let ::std::option::Option::Some(inner_7) = &_input.start_after {
  236    236   
                    {
  237    237   
                        query.push_kv("start-after", &::aws_smithy_http::query::fmt_string(inner_7));
  238    238   
                    }
  239    239   
                }
  240    240   
                ::std::result::Result::Ok(())
  241    241   
            }
  242    242   
            #[allow(clippy::unnecessary_wraps)]
  243    243   
            fn update_http_builder(
  244    244   
                input: &crate::operation::list_objects_v2::ListObjectsV2Input,
  245         -
                builder: ::http::request::Builder,
  246         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         245  +
                builder: ::http_1x::request::Builder,
         246  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  247    247   
                let mut uri = ::std::string::String::new();
  248    248   
                uri_base(input, &mut uri)?;
  249    249   
                uri_query(input, &mut uri)?;
  250    250   
                let builder = crate::protocol_serde::shape_list_objects_v2::ser_list_objects_v2_headers(input, builder)?;
  251    251   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  252    252   
            }
  253         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         253  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  254    254   
            builder
  255    255   
        };
  256    256   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  257    257   
  258    258   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  259    259   
    }
  260    260   
}
  261    261   
#[derive(Debug)]
  262    262   
struct ListObjectsV2EndpointParamsInterceptor;
  263    263

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

@@ -210,210 +278,278 @@
  230    230   
                        "upload_id",
  231    231   
                        "cannot be empty or unset",
  232    232   
                    ));
  233    233   
                }
  234    234   
                query.push_kv("uploadId", &::aws_smithy_http::query::fmt_string(inner_4));
  235    235   
                ::std::result::Result::Ok(())
  236    236   
            }
  237    237   
            #[allow(clippy::unnecessary_wraps)]
  238    238   
            fn update_http_builder(
  239    239   
                input: &crate::operation::list_parts::ListPartsInput,
  240         -
                builder: ::http::request::Builder,
  241         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         240  +
                builder: ::http_1x::request::Builder,
         241  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  242    242   
                let mut uri = ::std::string::String::new();
  243    243   
                uri_base(input, &mut uri)?;
  244    244   
                uri_query(input, &mut uri)?;
  245    245   
                let builder = crate::protocol_serde::shape_list_parts::ser_list_parts_headers(input, builder)?;
  246    246   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  247    247   
            }
  248         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         248  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  249    249   
            builder
  250    250   
        };
  251    251   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  252    252   
  253    253   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  254    254   
    }
  255    255   
}
  256    256   
#[derive(Debug)]
  257    257   
struct ListPartsEndpointParamsInterceptor;
  258    258

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

@@ -252,252 +333,333 @@
  272    272   
                _input: &crate::operation::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationInput,
  273    273   
                mut output: &mut ::std::string::String,
  274    274   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  275    275   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  276    276   
                query.push_v("accelerate");
  277    277   
                ::std::result::Result::Ok(())
  278    278   
            }
  279    279   
            #[allow(clippy::unnecessary_wraps)]
  280    280   
            fn update_http_builder(
  281    281   
                input: &crate::operation::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationInput,
  282         -
                builder: ::http::request::Builder,
  283         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         282  +
                builder: ::http_1x::request::Builder,
         283  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  284    284   
                let mut uri = ::std::string::String::new();
  285    285   
                uri_base(input, &mut uri)?;
  286    286   
                uri_query(input, &mut uri)?;
  287    287   
                let builder = crate::protocol_serde::shape_put_bucket_accelerate_configuration::ser_put_bucket_accelerate_configuration_headers(
  288    288   
                    input, builder,
  289    289   
                )?;
  290    290   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  291    291   
            }
  292         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  293         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         292  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         293  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  294    294   
            builder
  295    295   
        };
  296    296   
        let body = ::aws_smithy_types::body::SdkBody::from(
  297    297   
            crate::protocol_serde::shape_put_bucket_accelerate_configuration_input::ser_accelerate_configuration_http_payload(
  298    298   
                &input.accelerate_configuration,
  299    299   
            )?,
  300    300   
        );
  301    301   
        if let Some(content_length) = body.content_length() {
  302    302   
            let content_length = content_length.to_string();
  303         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         303  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  304    304   
        }
  305    305   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  306    306   
    }
  307    307   
}
  308    308   
#[derive(Debug)]
  309    309   
struct PutBucketAccelerateConfigurationEndpointParamsInterceptor;
  310    310   
  311    311   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketAccelerateConfigurationEndpointParamsInterceptor {
  312    312   
    fn name(&self) -> &'static str {
  313    313   
        "PutBucketAccelerateConfigurationEndpointParamsInterceptor"

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

@@ -239,239 +316,316 @@
  259    259   
                _input: &crate::operation::put_bucket_acl::PutBucketAclInput,
  260    260   
                mut output: &mut ::std::string::String,
  261    261   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  262    262   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  263    263   
                query.push_v("acl");
  264    264   
                ::std::result::Result::Ok(())
  265    265   
            }
  266    266   
            #[allow(clippy::unnecessary_wraps)]
  267    267   
            fn update_http_builder(
  268    268   
                input: &crate::operation::put_bucket_acl::PutBucketAclInput,
  269         -
                builder: ::http::request::Builder,
  270         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         269  +
                builder: ::http_1x::request::Builder,
         270  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  271    271   
                let mut uri = ::std::string::String::new();
  272    272   
                uri_base(input, &mut uri)?;
  273    273   
                uri_query(input, &mut uri)?;
  274    274   
                let builder = crate::protocol_serde::shape_put_bucket_acl::ser_put_bucket_acl_headers(input, builder)?;
  275    275   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  276    276   
            }
  277         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  278         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         277  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         278  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  279    279   
            builder
  280    280   
        };
  281    281   
        let body = ::aws_smithy_types::body::SdkBody::from(
  282    282   
            crate::protocol_serde::shape_put_bucket_acl_input::ser_access_control_policy_http_payload(&input.access_control_policy)?,
  283    283   
        );
  284    284   
        if let Some(content_length) = body.content_length() {
  285    285   
            let content_length = content_length.to_string();
  286         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         286  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  287    287   
        }
  288    288   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  289    289   
    }
  290    290   
}
  291    291   
#[derive(Debug)]
  292    292   
struct PutBucketAclEndpointParamsInterceptor;
  293    293   
  294    294   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketAclEndpointParamsInterceptor {
  295    295   
    fn name(&self) -> &'static str {
  296    296   
        "PutBucketAclEndpointParamsInterceptor"

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

@@ -204,204 +284,284 @@
  224    224   
                        "id",
  225    225   
                        "cannot be empty or unset",
  226    226   
                    ));
  227    227   
                }
  228    228   
                query.push_kv("id", &::aws_smithy_http::query::fmt_string(inner_1));
  229    229   
                ::std::result::Result::Ok(())
  230    230   
            }
  231    231   
            #[allow(clippy::unnecessary_wraps)]
  232    232   
            fn update_http_builder(
  233    233   
                input: &crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationInput,
  234         -
                builder: ::http::request::Builder,
  235         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         234  +
                builder: ::http_1x::request::Builder,
         235  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  236    236   
                let mut uri = ::std::string::String::new();
  237    237   
                uri_base(input, &mut uri)?;
  238    238   
                uri_query(input, &mut uri)?;
  239    239   
                let builder =
  240    240   
                    crate::protocol_serde::shape_put_bucket_analytics_configuration::ser_put_bucket_analytics_configuration_headers(input, builder)?;
  241    241   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  242    242   
            }
  243         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  244         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         243  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         244  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  245    245   
            builder
  246    246   
        };
  247    247   
        let body = ::aws_smithy_types::body::SdkBody::from(
  248    248   
            crate::protocol_serde::shape_put_bucket_analytics_configuration_input::ser_analytics_configuration_http_payload(
  249    249   
                &input.analytics_configuration,
  250    250   
            )?,
  251    251   
        );
  252    252   
        if let Some(content_length) = body.content_length() {
  253    253   
            let content_length = content_length.to_string();
  254         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         254  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  255    255   
        }
  256    256   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  257    257   
    }
  258    258   
}
  259    259   
#[derive(Debug)]
  260    260   
struct PutBucketAnalyticsConfigurationEndpointParamsInterceptor;
  261    261   
  262    262   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketAnalyticsConfigurationEndpointParamsInterceptor {
  263    263   
    fn name(&self) -> &'static str {
  264    264   
        "PutBucketAnalyticsConfigurationEndpointParamsInterceptor"

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

@@ -239,239 +316,316 @@
  259    259   
                _input: &crate::operation::put_bucket_cors::PutBucketCorsInput,
  260    260   
                mut output: &mut ::std::string::String,
  261    261   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  262    262   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  263    263   
                query.push_v("cors");
  264    264   
                ::std::result::Result::Ok(())
  265    265   
            }
  266    266   
            #[allow(clippy::unnecessary_wraps)]
  267    267   
            fn update_http_builder(
  268    268   
                input: &crate::operation::put_bucket_cors::PutBucketCorsInput,
  269         -
                builder: ::http::request::Builder,
  270         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         269  +
                builder: ::http_1x::request::Builder,
         270  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  271    271   
                let mut uri = ::std::string::String::new();
  272    272   
                uri_base(input, &mut uri)?;
  273    273   
                uri_query(input, &mut uri)?;
  274    274   
                let builder = crate::protocol_serde::shape_put_bucket_cors::ser_put_bucket_cors_headers(input, builder)?;
  275    275   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  276    276   
            }
  277         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  278         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         277  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         278  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  279    279   
            builder
  280    280   
        };
  281    281   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_bucket_cors_input::ser_cors_configuration_http_payload(
  282    282   
            &input.cors_configuration,
  283    283   
        )?);
  284    284   
        if let Some(content_length) = body.content_length() {
  285    285   
            let content_length = content_length.to_string();
  286         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         286  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  287    287   
        }
  288    288   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  289    289   
    }
  290    290   
}
  291    291   
#[derive(Debug)]
  292    292   
struct PutBucketCorsEndpointParamsInterceptor;
  293    293   
  294    294   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketCorsEndpointParamsInterceptor {
  295    295   
    fn name(&self) -> &'static str {
  296    296   
        "PutBucketCorsEndpointParamsInterceptor"

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

@@ -235,235 +314,314 @@
  255    255   
                _input: &crate::operation::put_bucket_encryption::PutBucketEncryptionInput,
  256    256   
                mut output: &mut ::std::string::String,
  257    257   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  258    258   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  259    259   
                query.push_v("encryption");
  260    260   
                ::std::result::Result::Ok(())
  261    261   
            }
  262    262   
            #[allow(clippy::unnecessary_wraps)]
  263    263   
            fn update_http_builder(
  264    264   
                input: &crate::operation::put_bucket_encryption::PutBucketEncryptionInput,
  265         -
                builder: ::http::request::Builder,
  266         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         265  +
                builder: ::http_1x::request::Builder,
         266  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  267    267   
                let mut uri = ::std::string::String::new();
  268    268   
                uri_base(input, &mut uri)?;
  269    269   
                uri_query(input, &mut uri)?;
  270    270   
                let builder = crate::protocol_serde::shape_put_bucket_encryption::ser_put_bucket_encryption_headers(input, builder)?;
  271    271   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  272    272   
            }
  273         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  274         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         273  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         274  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  275    275   
            builder
  276    276   
        };
  277    277   
        let body = ::aws_smithy_types::body::SdkBody::from(
  278    278   
            crate::protocol_serde::shape_put_bucket_encryption_input::ser_server_side_encryption_configuration_http_payload(
  279    279   
                &input.server_side_encryption_configuration,
  280    280   
            )?,
  281    281   
        );
  282    282   
        if let Some(content_length) = body.content_length() {
  283    283   
            let content_length = content_length.to_string();
  284         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         284  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  285    285   
        }
  286    286   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  287    287   
    }
  288    288   
}
  289    289   
#[derive(Debug)]
  290    290   
struct PutBucketEncryptionEndpointParamsInterceptor;
  291    291   
  292    292   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketEncryptionEndpointParamsInterceptor {
  293    293   
    fn name(&self) -> &'static str {
  294    294   
        "PutBucketEncryptionEndpointParamsInterceptor"

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

@@ -206,206 +285,285 @@
  226    226   
                        "id",
  227    227   
                        "cannot be empty or unset",
  228    228   
                    ));
  229    229   
                }
  230    230   
                query.push_kv("id", &::aws_smithy_http::query::fmt_string(inner_1));
  231    231   
                ::std::result::Result::Ok(())
  232    232   
            }
  233    233   
            #[allow(clippy::unnecessary_wraps)]
  234    234   
            fn update_http_builder(
  235    235   
                input: &crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput,
  236         -
                builder: ::http::request::Builder,
  237         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         236  +
                builder: ::http_1x::request::Builder,
         237  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  238    238   
                let mut uri = ::std::string::String::new();
  239    239   
                uri_base(input, &mut uri)?;
  240    240   
                uri_query(input, &mut uri)?;
  241    241   
                let builder = crate::protocol_serde::shape_put_bucket_intelligent_tiering_configuration::ser_put_bucket_intelligent_tiering_configuration_headers(input, builder)?;
  242    242   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  243    243   
            }
  244         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  245         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         244  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         245  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  246    246   
            builder
  247    247   
        };
  248    248   
        let body = ::aws_smithy_types::body::SdkBody::from(
  249    249   
            crate::protocol_serde::shape_put_bucket_intelligent_tiering_configuration_input::ser_intelligent_tiering_configuration_http_payload(
  250    250   
                &input.intelligent_tiering_configuration,
  251    251   
            )?,
  252    252   
        );
  253    253   
        if let Some(content_length) = body.content_length() {
  254    254   
            let content_length = content_length.to_string();
  255         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         255  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  256    256   
        }
  257    257   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  258    258   
    }
  259    259   
}
  260    260   
#[derive(Debug)]
  261    261   
struct PutBucketIntelligentTieringConfigurationEndpointParamsInterceptor;
  262    262   
  263    263   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketIntelligentTieringConfigurationEndpointParamsInterceptor {
  264    264   
    fn name(&self) -> &'static str {
  265    265   
        "PutBucketIntelligentTieringConfigurationEndpointParamsInterceptor"

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

@@ -204,204 +284,284 @@
  224    224   
                        "id",
  225    225   
                        "cannot be empty or unset",
  226    226   
                    ));
  227    227   
                }
  228    228   
                query.push_kv("id", &::aws_smithy_http::query::fmt_string(inner_1));
  229    229   
                ::std::result::Result::Ok(())
  230    230   
            }
  231    231   
            #[allow(clippy::unnecessary_wraps)]
  232    232   
            fn update_http_builder(
  233    233   
                input: &crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationInput,
  234         -
                builder: ::http::request::Builder,
  235         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         234  +
                builder: ::http_1x::request::Builder,
         235  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  236    236   
                let mut uri = ::std::string::String::new();
  237    237   
                uri_base(input, &mut uri)?;
  238    238   
                uri_query(input, &mut uri)?;
  239    239   
                let builder =
  240    240   
                    crate::protocol_serde::shape_put_bucket_inventory_configuration::ser_put_bucket_inventory_configuration_headers(input, builder)?;
  241    241   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  242    242   
            }
  243         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  244         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         243  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         244  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  245    245   
            builder
  246    246   
        };
  247    247   
        let body = ::aws_smithy_types::body::SdkBody::from(
  248    248   
            crate::protocol_serde::shape_put_bucket_inventory_configuration_input::ser_inventory_configuration_http_payload(
  249    249   
                &input.inventory_configuration,
  250    250   
            )?,
  251    251   
        );
  252    252   
        if let Some(content_length) = body.content_length() {
  253    253   
            let content_length = content_length.to_string();
  254         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         254  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  255    255   
        }
  256    256   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  257    257   
    }
  258    258   
}
  259    259   
#[derive(Debug)]
  260    260   
struct PutBucketInventoryConfigurationEndpointParamsInterceptor;
  261    261   
  262    262   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketInventoryConfigurationEndpointParamsInterceptor {
  263    263   
    fn name(&self) -> &'static str {
  264    264   
        "PutBucketInventoryConfigurationEndpointParamsInterceptor"

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

@@ -253,253 +333,333 @@
  273    273   
                _input: &crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationInput,
  274    274   
                mut output: &mut ::std::string::String,
  275    275   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  276    276   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  277    277   
                query.push_v("lifecycle");
  278    278   
                ::std::result::Result::Ok(())
  279    279   
            }
  280    280   
            #[allow(clippy::unnecessary_wraps)]
  281    281   
            fn update_http_builder(
  282    282   
                input: &crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationInput,
  283         -
                builder: ::http::request::Builder,
  284         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         283  +
                builder: ::http_1x::request::Builder,
         284  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  285    285   
                let mut uri = ::std::string::String::new();
  286    286   
                uri_base(input, &mut uri)?;
  287    287   
                uri_query(input, &mut uri)?;
  288    288   
                let builder =
  289    289   
                    crate::protocol_serde::shape_put_bucket_lifecycle_configuration::ser_put_bucket_lifecycle_configuration_headers(input, builder)?;
  290    290   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  291    291   
            }
  292         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  293         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         292  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         293  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  294    294   
            builder
  295    295   
        };
  296    296   
        let body = ::aws_smithy_types::body::SdkBody::from(
  297    297   
            crate::protocol_serde::shape_put_bucket_lifecycle_configuration_input::ser_lifecycle_configuration_http_payload(
  298    298   
                &input.lifecycle_configuration,
  299    299   
            )?,
  300    300   
        );
  301    301   
        if let Some(content_length) = body.content_length() {
  302    302   
            let content_length = content_length.to_string();
  303         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         303  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  304    304   
        }
  305    305   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  306    306   
    }
  307    307   
}
  308    308   
#[derive(Debug)]
  309    309   
struct PutBucketLifecycleConfigurationEndpointParamsInterceptor;
  310    310   
  311    311   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketLifecycleConfigurationEndpointParamsInterceptor {
  312    312   
    fn name(&self) -> &'static str {
  313    313   
        "PutBucketLifecycleConfigurationEndpointParamsInterceptor"

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

@@ -239,239 +316,316 @@
  259    259   
                _input: &crate::operation::put_bucket_logging::PutBucketLoggingInput,
  260    260   
                mut output: &mut ::std::string::String,
  261    261   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  262    262   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  263    263   
                query.push_v("logging");
  264    264   
                ::std::result::Result::Ok(())
  265    265   
            }
  266    266   
            #[allow(clippy::unnecessary_wraps)]
  267    267   
            fn update_http_builder(
  268    268   
                input: &crate::operation::put_bucket_logging::PutBucketLoggingInput,
  269         -
                builder: ::http::request::Builder,
  270         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         269  +
                builder: ::http_1x::request::Builder,
         270  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  271    271   
                let mut uri = ::std::string::String::new();
  272    272   
                uri_base(input, &mut uri)?;
  273    273   
                uri_query(input, &mut uri)?;
  274    274   
                let builder = crate::protocol_serde::shape_put_bucket_logging::ser_put_bucket_logging_headers(input, builder)?;
  275    275   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  276    276   
            }
  277         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  278         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         277  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         278  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  279    279   
            builder
  280    280   
        };
  281    281   
        let body = ::aws_smithy_types::body::SdkBody::from(
  282    282   
            crate::protocol_serde::shape_put_bucket_logging_input::ser_bucket_logging_status_http_payload(&input.bucket_logging_status)?,
  283    283   
        );
  284    284   
        if let Some(content_length) = body.content_length() {
  285    285   
            let content_length = content_length.to_string();
  286         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         286  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  287    287   
        }
  288    288   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  289    289   
    }
  290    290   
}
  291    291   
#[derive(Debug)]
  292    292   
struct PutBucketLoggingEndpointParamsInterceptor;
  293    293   
  294    294   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketLoggingEndpointParamsInterceptor {
  295    295   
    fn name(&self) -> &'static str {
  296    296   
        "PutBucketLoggingEndpointParamsInterceptor"

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

@@ -196,196 +276,276 @@
  216    216   
                        "id",
  217    217   
                        "cannot be empty or unset",
  218    218   
                    ));
  219    219   
                }
  220    220   
                query.push_kv("id", &::aws_smithy_http::query::fmt_string(inner_1));
  221    221   
                ::std::result::Result::Ok(())
  222    222   
            }
  223    223   
            #[allow(clippy::unnecessary_wraps)]
  224    224   
            fn update_http_builder(
  225    225   
                input: &crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfigurationInput,
  226         -
                builder: ::http::request::Builder,
  227         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         226  +
                builder: ::http_1x::request::Builder,
         227  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  228    228   
                let mut uri = ::std::string::String::new();
  229    229   
                uri_base(input, &mut uri)?;
  230    230   
                uri_query(input, &mut uri)?;
  231    231   
                let builder =
  232    232   
                    crate::protocol_serde::shape_put_bucket_metrics_configuration::ser_put_bucket_metrics_configuration_headers(input, builder)?;
  233    233   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  234    234   
            }
  235         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  236         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         235  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         236  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  237    237   
            builder
  238    238   
        };
  239    239   
        let body = ::aws_smithy_types::body::SdkBody::from(
  240    240   
            crate::protocol_serde::shape_put_bucket_metrics_configuration_input::ser_metrics_configuration_http_payload(
  241    241   
                &input.metrics_configuration,
  242    242   
            )?,
  243    243   
        );
  244    244   
        if let Some(content_length) = body.content_length() {
  245    245   
            let content_length = content_length.to_string();
  246         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         246  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  247    247   
        }
  248    248   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  249    249   
    }
  250    250   
}
  251    251   
#[derive(Debug)]
  252    252   
struct PutBucketMetricsConfigurationEndpointParamsInterceptor;
  253    253   
  254    254   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketMetricsConfigurationEndpointParamsInterceptor {
  255    255   
    fn name(&self) -> &'static str {
  256    256   
        "PutBucketMetricsConfigurationEndpointParamsInterceptor"

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

@@ -195,195 +276,276 @@
  215    215   
                _input: &crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationInput,
  216    216   
                mut output: &mut ::std::string::String,
  217    217   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  218    218   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  219    219   
                query.push_v("notification");
  220    220   
                ::std::result::Result::Ok(())
  221    221   
            }
  222    222   
            #[allow(clippy::unnecessary_wraps)]
  223    223   
            fn update_http_builder(
  224    224   
                input: &crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationInput,
  225         -
                builder: ::http::request::Builder,
  226         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         225  +
                builder: ::http_1x::request::Builder,
         226  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  227    227   
                let mut uri = ::std::string::String::new();
  228    228   
                uri_base(input, &mut uri)?;
  229    229   
                uri_query(input, &mut uri)?;
  230    230   
                let builder = crate::protocol_serde::shape_put_bucket_notification_configuration::ser_put_bucket_notification_configuration_headers(
  231    231   
                    input, builder,
  232    232   
                )?;
  233    233   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  234    234   
            }
  235         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  236         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         235  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         236  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  237    237   
            builder
  238    238   
        };
  239    239   
        let body = ::aws_smithy_types::body::SdkBody::from(
  240    240   
            crate::protocol_serde::shape_put_bucket_notification_configuration_input::ser_notification_configuration_http_payload(
  241    241   
                &input.notification_configuration,
  242    242   
            )?,
  243    243   
        );
  244    244   
        if let Some(content_length) = body.content_length() {
  245    245   
            let content_length = content_length.to_string();
  246         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         246  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  247    247   
        }
  248    248   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  249    249   
    }
  250    250   
}
  251    251   
#[derive(Debug)]
  252    252   
struct PutBucketNotificationConfigurationEndpointParamsInterceptor;
  253    253   
  254    254   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketNotificationConfigurationEndpointParamsInterceptor {
  255    255   
    fn name(&self) -> &'static str {
  256    256   
        "PutBucketNotificationConfigurationEndpointParamsInterceptor"

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

@@ -245,245 +322,322 @@
  265    265   
                _input: &crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsInput,
  266    266   
                mut output: &mut ::std::string::String,
  267    267   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  268    268   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  269    269   
                query.push_v("ownershipControls");
  270    270   
                ::std::result::Result::Ok(())
  271    271   
            }
  272    272   
            #[allow(clippy::unnecessary_wraps)]
  273    273   
            fn update_http_builder(
  274    274   
                input: &crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsInput,
  275         -
                builder: ::http::request::Builder,
  276         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         275  +
                builder: ::http_1x::request::Builder,
         276  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  277    277   
                let mut uri = ::std::string::String::new();
  278    278   
                uri_base(input, &mut uri)?;
  279    279   
                uri_query(input, &mut uri)?;
  280    280   
                let builder = crate::protocol_serde::shape_put_bucket_ownership_controls::ser_put_bucket_ownership_controls_headers(input, builder)?;
  281    281   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  282    282   
            }
  283         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  284         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         283  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         284  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  285    285   
            builder
  286    286   
        };
  287    287   
        let body = ::aws_smithy_types::body::SdkBody::from(
  288    288   
            crate::protocol_serde::shape_put_bucket_ownership_controls_input::ser_ownership_controls_http_payload(&input.ownership_controls)?,
  289    289   
        );
  290    290   
        if let Some(content_length) = body.content_length() {
  291    291   
            let content_length = content_length.to_string();
  292         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         292  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  293    293   
        }
  294    294   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  295    295   
    }
  296    296   
}
  297    297   
#[derive(Debug)]
  298    298   
struct PutBucketOwnershipControlsEndpointParamsInterceptor;
  299    299   
  300    300   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketOwnershipControlsEndpointParamsInterceptor {
  301    301   
    fn name(&self) -> &'static str {
  302    302   
        "PutBucketOwnershipControlsEndpointParamsInterceptor"

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

@@ -239,239 +316,316 @@
  259    259   
                _input: &crate::operation::put_bucket_policy::PutBucketPolicyInput,
  260    260   
                mut output: &mut ::std::string::String,
  261    261   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  262    262   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  263    263   
                query.push_v("policy");
  264    264   
                ::std::result::Result::Ok(())
  265    265   
            }
  266    266   
            #[allow(clippy::unnecessary_wraps)]
  267    267   
            fn update_http_builder(
  268    268   
                input: &crate::operation::put_bucket_policy::PutBucketPolicyInput,
  269         -
                builder: ::http::request::Builder,
  270         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         269  +
                builder: ::http_1x::request::Builder,
         270  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  271    271   
                let mut uri = ::std::string::String::new();
  272    272   
                uri_base(input, &mut uri)?;
  273    273   
                uri_query(input, &mut uri)?;
  274    274   
                let builder = crate::protocol_serde::shape_put_bucket_policy::ser_put_bucket_policy_headers(input, builder)?;
  275    275   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  276    276   
            }
  277         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  278         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "text/plain");
         277  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         278  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "text/plain");
  279    279   
            builder
  280    280   
        };
  281    281   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_bucket_policy_input::ser_policy_http_payload(
  282    282   
            input.policy,
  283    283   
        )?);
  284    284   
        if let Some(content_length) = body.content_length() {
  285    285   
            let content_length = content_length.to_string();
  286         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         286  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  287    287   
        }
  288    288   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  289    289   
    }
  290    290   
}
  291    291   
#[derive(Debug)]
  292    292   
struct PutBucketPolicyEndpointParamsInterceptor;
  293    293   
  294    294   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutBucketPolicyEndpointParamsInterceptor {
  295    295   
    fn name(&self) -> &'static str {
  296    296   
        "PutBucketPolicyEndpointParamsInterceptor"