AWS SDK

AWS SDK

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5

Files changed:

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

@@ -251,251 +328,328 @@
  271    271   
                if let ::std::option::Option::Some(inner_2) = &_input.version_id {
  272    272   
                    {
  273    273   
                        query.push_kv("versionId", &::aws_smithy_http::query::fmt_string(inner_2));
  274    274   
                    }
  275    275   
                }
  276    276   
                ::std::result::Result::Ok(())
  277    277   
            }
  278    278   
            #[allow(clippy::unnecessary_wraps)]
  279    279   
            fn update_http_builder(
  280    280   
                input: &crate::operation::put_object_legal_hold::PutObjectLegalHoldInput,
  281         -
                builder: ::http::request::Builder,
  282         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         281  +
                builder: ::http_1x::request::Builder,
         282  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  283    283   
                let mut uri = ::std::string::String::new();
  284    284   
                uri_base(input, &mut uri)?;
  285    285   
                uri_query(input, &mut uri)?;
  286    286   
                let builder = crate::protocol_serde::shape_put_object_legal_hold::ser_put_object_legal_hold_headers(input, builder)?;
  287    287   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  288    288   
            }
  289         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  290         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         289  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         290  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  291    291   
            builder
  292    292   
        };
  293    293   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_object_legal_hold_input::ser_legal_hold_http_payload(
  294    294   
            &input.legal_hold,
  295    295   
        )?);
  296    296   
        if let Some(content_length) = body.content_length() {
  297    297   
            let content_length = content_length.to_string();
  298         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         298  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  299    299   
        }
  300    300   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  301    301   
    }
  302    302   
}
  303    303   
#[derive(Debug)]
  304    304   
struct PutObjectLegalHoldEndpointParamsInterceptor;
  305    305   
  306    306   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutObjectLegalHoldEndpointParamsInterceptor {
  307    307   
    fn name(&self) -> &'static str {
  308    308   
        "PutObjectLegalHoldEndpointParamsInterceptor"

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

@@ -245,245 +324,324 @@
  265    265   
                _input: &crate::operation::put_object_lock_configuration::PutObjectLockConfigurationInput,
  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("object-lock");
  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_object_lock_configuration::PutObjectLockConfigurationInput,
  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_object_lock_configuration::ser_put_object_lock_configuration_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_object_lock_configuration_input::ser_object_lock_configuration_http_payload(
  289    289   
                &input.object_lock_configuration,
  290    290   
            )?,
  291    291   
        );
  292    292   
        if let Some(content_length) = body.content_length() {
  293    293   
            let content_length = content_length.to_string();
  294         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         294  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  295    295   
        }
  296    296   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  297    297   
    }
  298    298   
}
  299    299   
#[derive(Debug)]
  300    300   
struct PutObjectLockConfigurationEndpointParamsInterceptor;
  301    301   
  302    302   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutObjectLockConfigurationEndpointParamsInterceptor {
  303    303   
    fn name(&self) -> &'static str {
  304    304   
        "PutObjectLockConfigurationEndpointParamsInterceptor"

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

@@ -251,251 +328,328 @@
  271    271   
                if let ::std::option::Option::Some(inner_2) = &_input.version_id {
  272    272   
                    {
  273    273   
                        query.push_kv("versionId", &::aws_smithy_http::query::fmt_string(inner_2));
  274    274   
                    }
  275    275   
                }
  276    276   
                ::std::result::Result::Ok(())
  277    277   
            }
  278    278   
            #[allow(clippy::unnecessary_wraps)]
  279    279   
            fn update_http_builder(
  280    280   
                input: &crate::operation::put_object_retention::PutObjectRetentionInput,
  281         -
                builder: ::http::request::Builder,
  282         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         281  +
                builder: ::http_1x::request::Builder,
         282  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  283    283   
                let mut uri = ::std::string::String::new();
  284    284   
                uri_base(input, &mut uri)?;
  285    285   
                uri_query(input, &mut uri)?;
  286    286   
                let builder = crate::protocol_serde::shape_put_object_retention::ser_put_object_retention_headers(input, builder)?;
  287    287   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  288    288   
            }
  289         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  290         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         289  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         290  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  291    291   
            builder
  292    292   
        };
  293    293   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_object_retention_input::ser_retention_http_payload(
  294    294   
            &input.retention,
  295    295   
        )?);
  296    296   
        if let Some(content_length) = body.content_length() {
  297    297   
            let content_length = content_length.to_string();
  298         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         298  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  299    299   
        }
  300    300   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  301    301   
    }
  302    302   
}
  303    303   
#[derive(Debug)]
  304    304   
struct PutObjectRetentionEndpointParamsInterceptor;
  305    305   
  306    306   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutObjectRetentionEndpointParamsInterceptor {
  307    307   
    fn name(&self) -> &'static str {
  308    308   
        "PutObjectRetentionEndpointParamsInterceptor"

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

@@ -255,255 +332,332 @@
  275    275   
                if let ::std::option::Option::Some(inner_2) = &_input.version_id {
  276    276   
                    {
  277    277   
                        query.push_kv("versionId", &::aws_smithy_http::query::fmt_string(inner_2));
  278    278   
                    }
  279    279   
                }
  280    280   
                ::std::result::Result::Ok(())
  281    281   
            }
  282    282   
            #[allow(clippy::unnecessary_wraps)]
  283    283   
            fn update_http_builder(
  284    284   
                input: &crate::operation::put_object_tagging::PutObjectTaggingInput,
  285         -
                builder: ::http::request::Builder,
  286         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         285  +
                builder: ::http_1x::request::Builder,
         286  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  287    287   
                let mut uri = ::std::string::String::new();
  288    288   
                uri_base(input, &mut uri)?;
  289    289   
                uri_query(input, &mut uri)?;
  290    290   
                let builder = crate::protocol_serde::shape_put_object_tagging::ser_put_object_tagging_headers(input, builder)?;
  291    291   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  292    292   
            }
  293         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  294         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         293  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         294  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  295    295   
            builder
  296    296   
        };
  297    297   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_object_tagging_input::ser_tagging_http_payload(
  298    298   
            &input.tagging,
  299    299   
        )?);
  300    300   
        if let Some(content_length) = body.content_length() {
  301    301   
            let content_length = content_length.to_string();
  302         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         302  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  303    303   
        }
  304    304   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  305    305   
    }
  306    306   
}
  307    307   
#[derive(Debug)]
  308    308   
struct PutObjectTaggingEndpointParamsInterceptor;
  309    309   
  310    310   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutObjectTaggingEndpointParamsInterceptor {
  311    311   
    fn name(&self) -> &'static str {
  312    312   
        "PutObjectTaggingEndpointParamsInterceptor"

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

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

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

@@ -198,198 +266,266 @@
  218    218   
                _input: &crate::operation::rename_object::RenameObjectInput,
  219    219   
                mut output: &mut ::std::string::String,
  220    220   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  221    221   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  222    222   
                query.push_v("renameObject");
  223    223   
                ::std::result::Result::Ok(())
  224    224   
            }
  225    225   
            #[allow(clippy::unnecessary_wraps)]
  226    226   
            fn update_http_builder(
  227    227   
                input: &crate::operation::rename_object::RenameObjectInput,
  228         -
                builder: ::http::request::Builder,
  229         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         228  +
                builder: ::http_1x::request::Builder,
         229  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  230    230   
                let mut uri = ::std::string::String::new();
  231    231   
                uri_base(input, &mut uri)?;
  232    232   
                uri_query(input, &mut uri)?;
  233    233   
                let builder = crate::protocol_serde::shape_rename_object::ser_rename_object_headers(input, builder)?;
  234    234   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  235    235   
            }
  236         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         236  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  237    237   
            builder
  238    238   
        };
  239    239   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  240    240   
  241    241   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  242    242   
    }
  243    243   
}
  244    244   
#[derive(Debug)]
  245    245   
struct RenameObjectEndpointParamsInterceptor;
  246    246

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

@@ -254,254 +331,331 @@
  274    274   
                if let ::std::option::Option::Some(inner_2) = &_input.version_id {
  275    275   
                    {
  276    276   
                        query.push_kv("versionId", &::aws_smithy_http::query::fmt_string(inner_2));
  277    277   
                    }
  278    278   
                }
  279    279   
                ::std::result::Result::Ok(())
  280    280   
            }
  281    281   
            #[allow(clippy::unnecessary_wraps)]
  282    282   
            fn update_http_builder(
  283    283   
                input: &crate::operation::restore_object::RestoreObjectInput,
  284         -
                builder: ::http::request::Builder,
  285         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         284  +
                builder: ::http_1x::request::Builder,
         285  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  286    286   
                let mut uri = ::std::string::String::new();
  287    287   
                uri_base(input, &mut uri)?;
  288    288   
                uri_query(input, &mut uri)?;
  289    289   
                let builder = crate::protocol_serde::shape_restore_object::ser_restore_object_headers(input, builder)?;
  290    290   
                ::std::result::Result::Ok(builder.method("POST").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(crate::protocol_serde::shape_restore_object_input::ser_restore_request_http_payload(
  297    297   
            &input.restore_request,
  298    298   
        )?);
  299    299   
        if let Some(content_length) = body.content_length() {
  300    300   
            let content_length = content_length.to_string();
  301         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         301  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  302    302   
        }
  303    303   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  304    304   
    }
  305    305   
}
  306    306   
#[derive(Debug)]
  307    307   
struct RestoreObjectEndpointParamsInterceptor;
  308    308   
  309    309   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RestoreObjectEndpointParamsInterceptor {
  310    310   
    fn name(&self) -> &'static str {
  311    311   
        "RestoreObjectEndpointParamsInterceptor"

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

@@ -192,192 +269,269 @@
  212    212   
                mut output: &mut ::std::string::String,
  213    213   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  214    214   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  215    215   
                query.push_v("select");
  216    216   
                query.push_kv("select-type", "2");
  217    217   
                ::std::result::Result::Ok(())
  218    218   
            }
  219    219   
            #[allow(clippy::unnecessary_wraps)]
  220    220   
            fn update_http_builder(
  221    221   
                input: &crate::operation::select_object_content::SelectObjectContentInput,
  222         -
                builder: ::http::request::Builder,
  223         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         222  +
                builder: ::http_1x::request::Builder,
         223  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  224    224   
                let mut uri = ::std::string::String::new();
  225    225   
                uri_base(input, &mut uri)?;
  226    226   
                uri_query(input, &mut uri)?;
  227    227   
                let builder = crate::protocol_serde::shape_select_object_content::ser_select_object_content_headers(input, builder)?;
  228    228   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  229    229   
            }
  230         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  231         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         230  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         231  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  232    232   
            builder
  233    233   
        };
  234    234   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_select_object_content::ser_select_object_content_op_input(
  235    235   
            &input,
  236    236   
        )?);
  237    237   
        if let Some(content_length) = body.content_length() {
  238    238   
            let content_length = content_length.to_string();
  239         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         239  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  240    240   
        }
  241    241   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  242    242   
    }
  243    243   
}
  244    244   
#[derive(Debug)]
  245    245   
struct SelectObjectContentEndpointParamsInterceptor;
  246    246   
  247    247   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SelectObjectContentEndpointParamsInterceptor {
  248    248   
    fn name(&self) -> &'static str {
  249    249   
        "SelectObjectContentEndpointParamsInterceptor"

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

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

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

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

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

@@ -265,265 +340,340 @@
  285    285   
                        "upload_id",
  286    286   
                        "cannot be empty or unset",
  287    287   
                    ));
  288    288   
                }
  289    289   
                query.push_kv("uploadId", &::aws_smithy_http::query::fmt_string(inner_3));
  290    290   
                ::std::result::Result::Ok(())
  291    291   
            }
  292    292   
            #[allow(clippy::unnecessary_wraps)]
  293    293   
            fn update_http_builder(
  294    294   
                input: &crate::operation::upload_part::UploadPartInput,
  295         -
                builder: ::http::request::Builder,
  296         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         295  +
                builder: ::http_1x::request::Builder,
         296  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  297    297   
                let mut uri = ::std::string::String::new();
  298    298   
                uri_base(input, &mut uri)?;
  299    299   
                uri_query(input, &mut uri)?;
  300    300   
                let builder = crate::protocol_serde::shape_upload_part::ser_upload_part_headers(input, builder)?;
  301    301   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  302    302   
            }
  303         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  304         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
         303  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         304  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
  305    305   
            builder
  306    306   
        };
  307    307   
        let body = crate::protocol_serde::shape_upload_part_input::ser_body_http_payload(input.body)?.into_inner();
  308    308   
        if let Some(content_length) = body.content_length() {
  309    309   
            let content_length = content_length.to_string();
  310         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         310  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  311    311   
        }
  312    312   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  313    313   
    }
  314    314   
}
  315    315   
#[derive(Debug)]
  316    316   
struct UploadPartEndpointParamsInterceptor;
  317    317   
  318    318   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UploadPartEndpointParamsInterceptor {
  319    319   
    fn name(&self) -> &'static str {
  320    320   
        "UploadPartEndpointParamsInterceptor"

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

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

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

@@ -178,178 +252,252 @@
  198    198   
                _input: &crate::operation::write_get_object_response::WriteGetObjectResponseInput,
  199    199   
                output: &mut ::std::string::String,
  200    200   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  201    201   
                use ::std::fmt::Write as _;
  202    202   
                ::std::write!(output, "/WriteGetObjectResponse").expect("formatting should succeed");
  203    203   
                ::std::result::Result::Ok(())
  204    204   
            }
  205    205   
            #[allow(clippy::unnecessary_wraps)]
  206    206   
            fn update_http_builder(
  207    207   
                input: &crate::operation::write_get_object_response::WriteGetObjectResponseInput,
  208         -
                builder: ::http::request::Builder,
  209         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         208  +
                builder: ::http_1x::request::Builder,
         209  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  210    210   
                let mut uri = ::std::string::String::new();
  211    211   
                uri_base(input, &mut uri)?;
  212    212   
                let builder = crate::protocol_serde::shape_write_get_object_response::ser_write_get_object_response_headers(input, builder)?;
  213    213   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  214    214   
            }
  215         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  216         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
         215  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         216  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
  217    217   
            builder
  218    218   
        };
  219    219   
        let body = crate::protocol_serde::shape_write_get_object_response_input::ser_body_http_payload(input.body)?.into_inner();
  220    220   
        if let Some(content_length) = body.content_length() {
  221    221   
            let content_length = content_length.to_string();
  222         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         222  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  223    223   
        }
  224    224   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  225    225   
    }
  226    226   
}
  227    227   
#[derive(Debug)]
  228    228   
struct WriteGetObjectResponseEndpointParamsInterceptor;
  229    229   
  230    230   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for WriteGetObjectResponseEndpointParamsInterceptor {
  231    231   
    fn name(&self) -> &'static str {
  232    232   
        "WriteGetObjectResponseEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/s3/src/presigning.rs

@@ -173,173 +273,271 @@
  193    193   
    }
  194    194   
}
  195    195   
  196    196   
impl PresignedRequest {
  197    197   
    #[allow(dead_code)]
  198    198   
    pub(crate) fn new(inner: HttpRequest) -> Result<Self, BoxError> {
  199    199   
        // throw out the body so we're sure it's cloneable
  200    200   
        let http_request = inner.map(|_body| SdkBody::empty());
  201    201   
        // this should never fail, a presigned request should always be convertible, but better to
  202    202   
        // protect against this potential panic
  203         -
        let _ = http_request.try_clone().expect("must be cloneable, body is empty").try_into_http02x()?;
         203  +
        let _ = http_request.try_clone().expect("must be cloneable, body is empty").try_into_http1x()?;
  204    204   
        Ok(Self { http_request })
  205    205   
    }
  206    206   
  207    207   
    /// Returns the HTTP request method.
  208    208   
    pub fn method(&self) -> &str {
  209    209   
        self.http_request.method()
  210    210   
    }
  211    211   
  212    212   
    /// Returns the HTTP request URI.
  213    213   
    pub fn uri(&self) -> &str {
  214    214   
        self.http_request.uri()
  215    215   
    }
  216    216   
  217    217   
    /// Returns any HTTP headers that need to go along with the request, except for `Host`,
  218    218   
    /// which should be sent based on the endpoint in the URI by the HTTP client rather than
  219    219   
    /// added directly.
  220    220   
    pub fn headers(&self) -> impl Iterator<Item = (&str, &str)> {
  221    221   
        self.http_request.headers().iter()
  222    222   
    }
  223    223   
  224    224   
    /// Given a body, produce an `http::Request` from this `PresignedRequest`
  225    225   
    #[deprecated = "Prefer the `make_http_1x_request()` instead by enabling the `http-1x` feature."]
  226    226   
    #[allow(deprecated)]
  227    227   
    pub fn make_http_02x_request<B>(&self, body: B) -> http::Request<B> {
  228    228   
        self.clone().into_http_02x_request(body)
  229    229   
    }
  230    230   
  231    231   
    /// Converts this `PresignedRequest` directly into an `http` request.
  232    232   
    #[deprecated = "Prefer the `into_http_1x_request` instead by enabling the `http-1x` feature."]
  233    233   
    pub fn into_http_02x_request<B>(self, body: B) -> http::Request<B> {
  234    234   
        self.http_request
  235    235   
            .try_into_http02x()
  236    236   
            .expect("constructor validated convertibility")
  237    237   
            .map(|_req| body)
  238    238   
    }
  239    239   
  240         -
    #[cfg(feature = "http-1x")]
  241    240   
    /// Given a body, produce an `http_1x::Request` from this `PresignedRequest`
  242    241   
    pub fn make_http_1x_request<B>(&self, body: B) -> http_1x::Request<B> {
  243    242   
        self.clone().into_http_1x_request(body)
  244    243   
    }
  245    244   
  246         -
    #[cfg(feature = "http-1x")]
  247    245   
    /// Converts this `PresignedRequest` directly into an `http_1x` request.
  248    246   
    pub fn into_http_1x_request<B>(self, body: B) -> http_1x::Request<B> {
  249    247   
        self.http_request
  250    248   
            .try_into_http1x()
  251    249   
            .expect("constructor validated convertibility")
  252    250   
            .map(|_req| body)
  253    251   
    }
  254    252   
}
  255    253   
  256    254   
impl fmt::Debug for PresignedRequest {

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_abort_multipart_upload.rs

@@ -40,40 +106,106 @@
   60     60   
            })?,
   61     61   
        );
   62     62   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   63     63   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   64     64   
        output.build()
   65     65   
    })
   66     66   
}
   67     67   
   68     68   
pub fn ser_abort_multipart_upload_headers(
   69     69   
    input: &crate::operation::abort_multipart_upload::AbortMultipartUploadInput,
   70         -
    mut builder: ::http::request::Builder,
   71         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          70  +
    mut builder: ::http_1x::request::Builder,
          71  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   72     72   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   73     73   
        let formatted_2 = inner_1.as_str();
   74     74   
        let header_value = formatted_2;
   75         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          75  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   76     76   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   77     77   
                "request_payer",
   78     78   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   79     79   
            )
   80     80   
        })?;
   81     81   
        builder = builder.header("x-amz-request-payer", header_value);
   82     82   
    }
   83     83   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   84     84   
        let formatted_4 = inner_3.as_str();
   85     85   
        let header_value = formatted_4;
   86         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          86  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   87     87   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   88     88   
                "expected_bucket_owner",
   89     89   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   90     90   
            )
   91     91   
        })?;
   92     92   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   93     93   
    }
   94     94   
    if let ::std::option::Option::Some(inner_5) = &input.if_match_initiated_time {
   95     95   
        let formatted_6 = inner_5.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
   96     96   
        let header_value = formatted_6;
   97         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          97  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   98     98   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   99     99   
                "if_match_initiated_time",
  100    100   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  101    101   
            )
  102    102   
        })?;
  103    103   
        builder = builder.header("x-amz-if-match-initiated-time", header_value);
  104    104   
    }
  105    105   
    Ok(builder)
  106    106   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_complete_multipart_upload.rs

@@ -56,56 +265,265 @@
   76     76   
            })?,
   77     77   
        );
   78     78   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   79     79   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   80     80   
        output.build()
   81     81   
    })
   82     82   
}
   83     83   
   84     84   
pub fn ser_complete_multipart_upload_headers(
   85     85   
    input: &crate::operation::complete_multipart_upload::CompleteMultipartUploadInput,
   86         -
    mut builder: ::http::request::Builder,
   87         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          86  +
    mut builder: ::http_1x::request::Builder,
          87  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   88     88   
    if let ::std::option::Option::Some(inner_1) = &input.checksum_crc32 {
   89     89   
        let formatted_2 = inner_1.as_str();
   90     90   
        let header_value = formatted_2;
   91         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          91  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   92     92   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   93     93   
                "checksum_crc32",
   94     94   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   95     95   
            )
   96     96   
        })?;
   97     97   
        builder = builder.header("x-amz-checksum-crc32", header_value);
   98     98   
    }
   99     99   
    if let ::std::option::Option::Some(inner_3) = &input.checksum_crc32_c {
  100    100   
        let formatted_4 = inner_3.as_str();
  101    101   
        let header_value = formatted_4;
  102         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         102  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  103    103   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  104    104   
                "checksum_crc32_c",
  105    105   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  106    106   
            )
  107    107   
        })?;
  108    108   
        builder = builder.header("x-amz-checksum-crc32c", header_value);
  109    109   
    }
  110    110   
    if let ::std::option::Option::Some(inner_5) = &input.checksum_crc64_nvme {
  111    111   
        let formatted_6 = inner_5.as_str();
  112    112   
        let header_value = formatted_6;
  113         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         113  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  114    114   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  115    115   
                "checksum_crc64_nvme",
  116    116   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  117    117   
            )
  118    118   
        })?;
  119    119   
        builder = builder.header("x-amz-checksum-crc64nvme", header_value);
  120    120   
    }
  121    121   
    if let ::std::option::Option::Some(inner_7) = &input.checksum_sha1 {
  122    122   
        let formatted_8 = inner_7.as_str();
  123    123   
        let header_value = formatted_8;
  124         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         124  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  125    125   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  126    126   
                "checksum_sha1",
  127    127   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  128    128   
            )
  129    129   
        })?;
  130    130   
        builder = builder.header("x-amz-checksum-sha1", header_value);
  131    131   
    }
  132    132   
    if let ::std::option::Option::Some(inner_9) = &input.checksum_sha256 {
  133    133   
        let formatted_10 = inner_9.as_str();
  134    134   
        let header_value = formatted_10;
  135         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         135  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  136    136   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  137    137   
                "checksum_sha256",
  138    138   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  139    139   
            )
  140    140   
        })?;
  141    141   
        builder = builder.header("x-amz-checksum-sha256", header_value);
  142    142   
    }
  143    143   
    if let ::std::option::Option::Some(inner_11) = &input.checksum_type {
  144    144   
        let formatted_12 = inner_11.as_str();
  145    145   
        let header_value = formatted_12;
  146         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         146  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  147    147   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  148    148   
                "checksum_type",
  149    149   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  150    150   
            )
  151    151   
        })?;
  152    152   
        builder = builder.header("x-amz-checksum-type", header_value);
  153    153   
    }
  154    154   
    if let ::std::option::Option::Some(inner_13) = &input.mpu_object_size {
  155    155   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);
  156    156   
        let formatted_14 = encoder.encode();
  157    157   
        let header_value = formatted_14;
  158         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         158  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  159    159   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  160    160   
                "mpu_object_size",
  161    161   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  162    162   
            )
  163    163   
        })?;
  164    164   
        builder = builder.header("x-amz-mp-object-size", header_value);
  165    165   
    }
  166    166   
    if let ::std::option::Option::Some(inner_15) = &input.request_payer {
  167    167   
        let formatted_16 = inner_15.as_str();
  168    168   
        let header_value = formatted_16;
  169         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         169  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  170    170   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  171    171   
                "request_payer",
  172    172   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  173    173   
            )
  174    174   
        })?;
  175    175   
        builder = builder.header("x-amz-request-payer", header_value);
  176    176   
    }
  177    177   
    if let ::std::option::Option::Some(inner_17) = &input.expected_bucket_owner {
  178    178   
        let formatted_18 = inner_17.as_str();
  179    179   
        let header_value = formatted_18;
  180         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         180  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  181    181   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  182    182   
                "expected_bucket_owner",
  183    183   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  184    184   
            )
  185    185   
        })?;
  186    186   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  187    187   
    }
  188    188   
    if let ::std::option::Option::Some(inner_19) = &input.if_match {
  189    189   
        let formatted_20 = inner_19.as_str();
  190    190   
        let header_value = formatted_20;
  191         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         191  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  192    192   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  193    193   
                "if_match",
  194    194   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  195    195   
            )
  196    196   
        })?;
  197    197   
        builder = builder.header("If-Match", header_value);
  198    198   
    }
  199    199   
    if let ::std::option::Option::Some(inner_21) = &input.if_none_match {
  200    200   
        let formatted_22 = inner_21.as_str();
  201    201   
        let header_value = formatted_22;
  202         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         202  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  203    203   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  204    204   
                "if_none_match",
  205    205   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  206    206   
            )
  207    207   
        })?;
  208    208   
        builder = builder.header("If-None-Match", header_value);
  209    209   
    }
  210    210   
    if let ::std::option::Option::Some(inner_23) = &input.sse_customer_algorithm {
  211    211   
        let formatted_24 = inner_23.as_str();
  212    212   
        let header_value = formatted_24;
  213         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         213  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  214    214   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  215    215   
                "sse_customer_algorithm",
  216    216   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  217    217   
            )
  218    218   
        })?;
  219    219   
        builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
  220    220   
    }
  221    221   
    if let ::std::option::Option::Some(inner_25) = &input.sse_customer_key {
  222    222   
        let formatted_26 = inner_25.as_str();
  223    223   
        let header_value = formatted_26;
  224         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         224  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  225    225   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  226    226   
                "sse_customer_key",
  227    227   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  228    228   
            )
  229    229   
        })?;
  230    230   
        builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
  231    231   
    }
  232    232   
    if let ::std::option::Option::Some(inner_27) = &input.sse_customer_key_md5 {
  233    233   
        let formatted_28 = inner_27.as_str();
  234    234   
        let header_value = formatted_28;
  235         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         235  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  236    236   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  237    237   
                "sse_customer_key_md5",
  238    238   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  239    239   
            )
  240    240   
        })?;
  241    241   
        builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  242    242   
    }
  243    243   
    Ok(builder)
  244    244   
}
  245    245