AWS SDK

AWS SDK

rev. ee474c7509d7728618c23068f3741e8e5b339ef9

Files changed:

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/initiate_vault_lock.rs

@@ -196,196 +271,271 @@
  216    216   
                    "/{accountId}/vaults/{vaultName}/lock-policy",
  217    217   
                    accountId = account_id,
  218    218   
                    vaultName = vault_name
  219    219   
                )
  220    220   
                .expect("formatting should succeed");
  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::initiate_vault_lock::InitiateVaultLockInput,
  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   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  231    231   
            }
  232         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  233         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         232  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         233  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  234    234   
            builder
  235    235   
        };
  236    236   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_initiate_vault_lock_input::ser_policy_http_payload(
  237    237   
            &input.policy,
  238    238   
        )?);
  239    239   
        if let Some(content_length) = body.content_length() {
  240    240   
            let content_length = content_length.to_string();
  241         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         241  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  242    242   
        }
  243    243   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  244    244   
    }
  245    245   
}
  246    246   
#[derive(Debug)]
  247    247   
struct InitiateVaultLockEndpointParamsInterceptor;
  248    248   
  249    249   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InitiateVaultLockEndpointParamsInterceptor {
  250    250   
    fn name(&self) -> &'static str {
  251    251   
        "InitiateVaultLockEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/list_jobs.rs

@@ -214,214 +281,281 @@
  234    234   
                if let ::std::option::Option::Some(inner_6) = &_input.completed {
  235    235   
                    {
  236    236   
                        query.push_kv("completed", &::aws_smithy_http::query::fmt_string(inner_6));
  237    237   
                    }
  238    238   
                }
  239    239   
                ::std::result::Result::Ok(())
  240    240   
            }
  241    241   
            #[allow(clippy::unnecessary_wraps)]
  242    242   
            fn update_http_builder(
  243    243   
                input: &crate::operation::list_jobs::ListJobsInput,
  244         -
                builder: ::http::request::Builder,
  245         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         244  +
                builder: ::http_1x::request::Builder,
         245  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  246    246   
                let mut uri = ::std::string::String::new();
  247    247   
                uri_base(input, &mut uri)?;
  248    248   
                uri_query(input, &mut uri)?;
  249    249   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  250    250   
            }
  251         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         251  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  252    252   
            builder
  253    253   
        };
  254    254   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  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 ListJobsEndpointParamsInterceptor;
  261    261

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/list_multipart_uploads.rs

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

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

@@ -220,220 +287,287 @@
  240    240   
                if let ::std::option::Option::Some(inner_5) = &_input.limit {
  241    241   
                    {
  242    242   
                        query.push_kv("limit", ::aws_smithy_types::primitive::Encoder::from(*inner_5).encode());
  243    243   
                    }
  244    244   
                }
  245    245   
                ::std::result::Result::Ok(())
  246    246   
            }
  247    247   
            #[allow(clippy::unnecessary_wraps)]
  248    248   
            fn update_http_builder(
  249    249   
                input: &crate::operation::list_parts::ListPartsInput,
  250         -
                builder: ::http::request::Builder,
  251         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         250  +
                builder: ::http_1x::request::Builder,
         251  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  252    252   
                let mut uri = ::std::string::String::new();
  253    253   
                uri_base(input, &mut uri)?;
  254    254   
                uri_query(input, &mut uri)?;
  255    255   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  256    256   
            }
  257         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         257  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  258    258   
            builder
  259    259   
        };
  260    260   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  261    261   
  262    262   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  263    263   
    }
  264    264   
}
  265    265   
#[derive(Debug)]
  266    266   
struct ListPartsEndpointParamsInterceptor;
  267    267

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/list_provisioned_capacity.rs

@@ -179,179 +245,245 @@
  199    199   
                        "account_id",
  200    200   
                        "cannot be empty or unset",
  201    201   
                    ));
  202    202   
                }
  203    203   
                ::std::write!(output, "/{accountId}/provisioned-capacity", accountId = account_id).expect("formatting should succeed");
  204    204   
                ::std::result::Result::Ok(())
  205    205   
            }
  206    206   
            #[allow(clippy::unnecessary_wraps)]
  207    207   
            fn update_http_builder(
  208    208   
                input: &crate::operation::list_provisioned_capacity::ListProvisionedCapacityInput,
  209         -
                builder: ::http::request::Builder,
  210         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         209  +
                builder: ::http_1x::request::Builder,
         210  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  211    211   
                let mut uri = ::std::string::String::new();
  212    212   
                uri_base(input, &mut uri)?;
  213    213   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  214    214   
            }
  215         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         215  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  216    216   
            builder
  217    217   
        };
  218    218   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  219    219   
  220    220   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  221    221   
    }
  222    222   
}
  223    223   
#[derive(Debug)]
  224    224   
struct ListProvisionedCapacityEndpointParamsInterceptor;
  225    225

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/list_tags_for_vault.rs

@@ -196,196 +262,262 @@
  216    216   
                    "/{accountId}/vaults/{vaultName}/tags",
  217    217   
                    accountId = account_id,
  218    218   
                    vaultName = vault_name
  219    219   
                )
  220    220   
                .expect("formatting should succeed");
  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::list_tags_for_vault::ListTagsForVaultInput,
  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   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  231    231   
            }
  232         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         232  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  233    233   
            builder
  234    234   
        };
  235    235   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  236    236   
  237    237   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  238    238   
    }
  239    239   
}
  240    240   
#[derive(Debug)]
  241    241   
struct ListTagsForVaultEndpointParamsInterceptor;
  242    242

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/list_vaults.rs

@@ -191,191 +258,258 @@
  211    211   
                if let ::std::option::Option::Some(inner_3) = &_input.limit {
  212    212   
                    {
  213    213   
                        query.push_kv("limit", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
  214    214   
                    }
  215    215   
                }
  216    216   
                ::std::result::Result::Ok(())
  217    217   
            }
  218    218   
            #[allow(clippy::unnecessary_wraps)]
  219    219   
            fn update_http_builder(
  220    220   
                input: &crate::operation::list_vaults::ListVaultsInput,
  221         -
                builder: ::http::request::Builder,
  222         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         221  +
                builder: ::http_1x::request::Builder,
         222  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  223    223   
                let mut uri = ::std::string::String::new();
  224    224   
                uri_base(input, &mut uri)?;
  225    225   
                uri_query(input, &mut uri)?;
  226    226   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  227    227   
            }
  228         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         228  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  229    229   
            builder
  230    230   
        };
  231    231   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  232    232   
  233    233   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  234    234   
    }
  235    235   
}
  236    236   
#[derive(Debug)]
  237    237   
struct ListVaultsEndpointParamsInterceptor;
  238    238

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/purchase_provisioned_capacity.rs

@@ -185,185 +251,251 @@
  205    205   
                        "account_id",
  206    206   
                        "cannot be empty or unset",
  207    207   
                    ));
  208    208   
                }
  209    209   
                ::std::write!(output, "/{accountId}/provisioned-capacity", accountId = account_id).expect("formatting should succeed");
  210    210   
                ::std::result::Result::Ok(())
  211    211   
            }
  212    212   
            #[allow(clippy::unnecessary_wraps)]
  213    213   
            fn update_http_builder(
  214    214   
                input: &crate::operation::purchase_provisioned_capacity::PurchaseProvisionedCapacityInput,
  215         -
                builder: ::http::request::Builder,
  216         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         215  +
                builder: ::http_1x::request::Builder,
         216  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  217    217   
                let mut uri = ::std::string::String::new();
  218    218   
                uri_base(input, &mut uri)?;
  219    219   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  220    220   
            }
  221         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         221  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  222    222   
            builder
  223    223   
        };
  224    224   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  225    225   
  226    226   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  227    227   
    }
  228    228   
}
  229    229   
#[derive(Debug)]
  230    230   
struct PurchaseProvisionedCapacityEndpointParamsInterceptor;
  231    231

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/remove_tags_from_vault.rs

@@ -204,204 +280,280 @@
  224    224   
                _input: &crate::operation::remove_tags_from_vault::RemoveTagsFromVaultInput,
  225    225   
                mut output: &mut ::std::string::String,
  226    226   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  227    227   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  228    228   
                query.push_kv("operation", "remove");
  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::remove_tags_from_vault::RemoveTagsFromVaultInput,
  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   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  240    240   
            }
  241         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  242         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         241  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         242  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  243    243   
            builder
  244    244   
        };
  245    245   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_remove_tags_from_vault::ser_remove_tags_from_vault_input(
  246    246   
            &input,
  247    247   
        )?);
  248    248   
        if let Some(content_length) = body.content_length() {
  249    249   
            let content_length = content_length.to_string();
  250         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         250  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  251    251   
        }
  252    252   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  253    253   
    }
  254    254   
}
  255    255   
#[derive(Debug)]
  256    256   
struct RemoveTagsFromVaultEndpointParamsInterceptor;
  257    257   
  258    258   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RemoveTagsFromVaultEndpointParamsInterceptor {
  259    259   
    fn name(&self) -> &'static str {
  260    260   
        "RemoveTagsFromVaultEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/set_data_retrieval_policy.rs

@@ -179,179 +254,254 @@
  199    199   
                        "account_id",
  200    200   
                        "cannot be empty or unset",
  201    201   
                    ));
  202    202   
                }
  203    203   
                ::std::write!(output, "/{accountId}/policies/data-retrieval", accountId = account_id).expect("formatting should succeed");
  204    204   
                ::std::result::Result::Ok(())
  205    205   
            }
  206    206   
            #[allow(clippy::unnecessary_wraps)]
  207    207   
            fn update_http_builder(
  208    208   
                input: &crate::operation::set_data_retrieval_policy::SetDataRetrievalPolicyInput,
  209         -
                builder: ::http::request::Builder,
  210         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         209  +
                builder: ::http_1x::request::Builder,
         210  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  211    211   
                let mut uri = ::std::string::String::new();
  212    212   
                uri_base(input, &mut uri)?;
  213    213   
                ::std::result::Result::Ok(builder.method("PUT").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/json");
         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/json");
  217    217   
            builder
  218    218   
        };
  219    219   
        let body = ::aws_smithy_types::body::SdkBody::from(
  220    220   
            crate::protocol_serde::shape_set_data_retrieval_policy::ser_set_data_retrieval_policy_input(&input)?,
  221    221   
        );
  222    222   
        if let Some(content_length) = body.content_length() {
  223    223   
            let content_length = content_length.to_string();
  224         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         224  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  225    225   
        }
  226    226   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  227    227   
    }
  228    228   
}
  229    229   
#[derive(Debug)]
  230    230   
struct SetDataRetrievalPolicyEndpointParamsInterceptor;
  231    231   
  232    232   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SetDataRetrievalPolicyEndpointParamsInterceptor {
  233    233   
    fn name(&self) -> &'static str {
  234    234   
        "SetDataRetrievalPolicyEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/set_vault_access_policy.rs

@@ -196,196 +271,271 @@
  216    216   
                    "/{accountId}/vaults/{vaultName}/access-policy",
  217    217   
                    accountId = account_id,
  218    218   
                    vaultName = vault_name
  219    219   
                )
  220    220   
                .expect("formatting should succeed");
  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::set_vault_access_policy::SetVaultAccessPolicyInput,
  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   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  231    231   
            }
  232         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  233         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         232  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         233  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  234    234   
            builder
  235    235   
        };
  236    236   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_set_vault_access_policy_input::ser_policy_http_payload(
  237    237   
            &input.policy,
  238    238   
        )?);
  239    239   
        if let Some(content_length) = body.content_length() {
  240    240   
            let content_length = content_length.to_string();
  241         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         241  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  242    242   
        }
  243    243   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  244    244   
    }
  245    245   
}
  246    246   
#[derive(Debug)]
  247    247   
struct SetVaultAccessPolicyEndpointParamsInterceptor;
  248    248   
  249    249   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SetVaultAccessPolicyEndpointParamsInterceptor {
  250    250   
    fn name(&self) -> &'static str {
  251    251   
        "SetVaultAccessPolicyEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/set_vault_notifications.rs

@@ -196,196 +271,271 @@
  216    216   
                    "/{accountId}/vaults/{vaultName}/notification-configuration",
  217    217   
                    accountId = account_id,
  218    218   
                    vaultName = vault_name
  219    219   
                )
  220    220   
                .expect("formatting should succeed");
  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::set_vault_notifications::SetVaultNotificationsInput,
  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   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  231    231   
            }
  232         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  233         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         232  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         233  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  234    234   
            builder
  235    235   
        };
  236    236   
        let body = ::aws_smithy_types::body::SdkBody::from(
  237    237   
            crate::protocol_serde::shape_set_vault_notifications_input::ser_vault_notification_config_http_payload(&input.vault_notification_config)?,
  238    238   
        );
  239    239   
        if let Some(content_length) = body.content_length() {
  240    240   
            let content_length = content_length.to_string();
  241         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         241  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  242    242   
        }
  243    243   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  244    244   
    }
  245    245   
}
  246    246   
#[derive(Debug)]
  247    247   
struct SetVaultNotificationsEndpointParamsInterceptor;
  248    248   
  249    249   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SetVaultNotificationsEndpointParamsInterceptor {
  250    250   
    fn name(&self) -> &'static str {
  251    251   
        "SetVaultNotificationsEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/upload_archive.rs

@@ -194,194 +268,268 @@
  214    214   
                    "/{accountId}/vaults/{vaultName}/archives",
  215    215   
                    accountId = account_id,
  216    216   
                    vaultName = vault_name
  217    217   
                )
  218    218   
                .expect("formatting should succeed");
  219    219   
                ::std::result::Result::Ok(())
  220    220   
            }
  221    221   
            #[allow(clippy::unnecessary_wraps)]
  222    222   
            fn update_http_builder(
  223    223   
                input: &crate::operation::upload_archive::UploadArchiveInput,
  224         -
                builder: ::http::request::Builder,
  225         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         224  +
                builder: ::http_1x::request::Builder,
         225  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  226    226   
                let mut uri = ::std::string::String::new();
  227    227   
                uri_base(input, &mut uri)?;
  228    228   
                let builder = crate::protocol_serde::shape_upload_archive::ser_upload_archive_headers(input, builder)?;
  229    229   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  230    230   
            }
  231         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  232         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
         231  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         232  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
  233    233   
            builder
  234    234   
        };
  235    235   
        let body = crate::protocol_serde::shape_upload_archive_input::ser_body_http_payload(input.body)?.into_inner();
  236    236   
        if let Some(content_length) = body.content_length() {
  237    237   
            let content_length = content_length.to_string();
  238         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         238  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  239    239   
        }
  240    240   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  241    241   
    }
  242    242   
}
  243    243   
#[derive(Debug)]
  244    244   
struct UploadArchiveEndpointParamsInterceptor;
  245    245   
  246    246   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UploadArchiveEndpointParamsInterceptor {
  247    247   
    fn name(&self) -> &'static str {
  248    248   
        "UploadArchiveEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/upload_multipart_part.rs

@@ -209,209 +283,283 @@
  229    229   
                    accountId = account_id,
  230    230   
                    vaultName = vault_name,
  231    231   
                    uploadId = upload_id
  232    232   
                )
  233    233   
                .expect("formatting should succeed");
  234    234   
                ::std::result::Result::Ok(())
  235    235   
            }
  236    236   
            #[allow(clippy::unnecessary_wraps)]
  237    237   
            fn update_http_builder(
  238    238   
                input: &crate::operation::upload_multipart_part::UploadMultipartPartInput,
  239         -
                builder: ::http::request::Builder,
  240         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         239  +
                builder: ::http_1x::request::Builder,
         240  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  241    241   
                let mut uri = ::std::string::String::new();
  242    242   
                uri_base(input, &mut uri)?;
  243    243   
                let builder = crate::protocol_serde::shape_upload_multipart_part::ser_upload_multipart_part_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())?;
  247         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
         246  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         247  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
  248    248   
            builder
  249    249   
        };
  250    250   
        let body = crate::protocol_serde::shape_upload_multipart_part_input::ser_body_http_payload(input.body)?.into_inner();
  251    251   
        if let Some(content_length) = body.content_length() {
  252    252   
            let content_length = content_length.to_string();
  253         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         253  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  254    254   
        }
  255    255   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  256    256   
    }
  257    257   
}
  258    258   
#[derive(Debug)]
  259    259   
struct UploadMultipartPartEndpointParamsInterceptor;
  260    260   
  261    261   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UploadMultipartPartEndpointParamsInterceptor {
  262    262   
    fn name(&self) -> &'static str {
  263    263   
        "UploadMultipartPartEndpointParamsInterceptor"

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

@@ -110,110 +165,165 @@
  130    130   
                crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled("Failed to parse location from header `Location")
  131    131   
            })?,
  132    132   
        );
  133    133   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  134    134   
        output.build()
  135    135   
    })
  136    136   
}
  137    137   
  138    138   
pub fn ser_complete_multipart_upload_headers(
  139    139   
    input: &crate::operation::complete_multipart_upload::CompleteMultipartUploadInput,
  140         -
    mut builder: ::http::request::Builder,
  141         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         140  +
    mut builder: ::http_1x::request::Builder,
         141  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  142    142   
    if let ::std::option::Option::Some(inner_1) = &input.archive_size {
  143    143   
        let formatted_2 = inner_1.as_str();
  144    144   
        let header_value = formatted_2;
  145         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         145  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  146    146   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  147    147   
                "archive_size",
  148    148   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  149    149   
            )
  150    150   
        })?;
  151    151   
        builder = builder.header("x-amz-archive-size", header_value);
  152    152   
    }
  153    153   
    if let ::std::option::Option::Some(inner_3) = &input.checksum {
  154    154   
        let formatted_4 = inner_3.as_str();
  155    155   
        let header_value = formatted_4;
  156         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         156  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  157    157   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  158    158   
                "checksum",
  159    159   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  160    160   
            )
  161    161   
        })?;
  162    162   
        builder = builder.header("x-amz-sha256-tree-hash", header_value);
  163    163   
    }
  164    164   
    Ok(builder)
  165    165   
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_get_job_output.rs

@@ -110,110 +154,154 @@
  130    130   
                tmp.message = _error_message;
  131    131   
            }
  132    132   
            tmp
  133    133   
        }),
  134    134   
        _ => crate::operation::get_job_output::GetJobOutputError::generic(generic),
  135    135   
    })
  136    136   
}
  137    137   
  138    138   
pub fn ser_get_job_output_headers(
  139    139   
    input: &crate::operation::get_job_output::GetJobOutputInput,
  140         -
    mut builder: ::http::request::Builder,
  141         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         140  +
    mut builder: ::http_1x::request::Builder,
         141  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  142    142   
    if let ::std::option::Option::Some(inner_1) = &input.range {
  143    143   
        let formatted_2 = inner_1.as_str();
  144    144   
        let header_value = formatted_2;
  145         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         145  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  146    146   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  147    147   
                "range",
  148    148   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  149    149   
            )
  150    150   
        })?;
  151    151   
        builder = builder.header("Range", header_value);
  152    152   
    }
  153    153   
    Ok(builder)
  154    154   
}