AWS SDK

AWS SDK

rev. ee474c7509d7728618c23068f3741e8e5b339ef9

Files changed:

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

@@ -182,182 +259,259 @@
  202    202   
                        "config_id",
  203    203   
                        "cannot be empty or unset",
  204    204   
                    ));
  205    205   
                }
  206    206   
                ::std::write!(output, "/v20180820/storagelens/{ConfigId}", ConfigId = config_id).expect("formatting should succeed");
  207    207   
                ::std::result::Result::Ok(())
  208    208   
            }
  209    209   
            #[allow(clippy::unnecessary_wraps)]
  210    210   
            fn update_http_builder(
  211    211   
                input: &crate::operation::put_storage_lens_configuration::PutStorageLensConfigurationInput,
  212         -
                builder: ::http::request::Builder,
  213         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         212  +
                builder: ::http_1x::request::Builder,
         213  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  214    214   
                let mut uri = ::std::string::String::new();
  215    215   
                uri_base(input, &mut uri)?;
  216    216   
                let builder =
  217    217   
                    crate::protocol_serde::shape_put_storage_lens_configuration::ser_put_storage_lens_configuration_headers(input, builder)?;
  218    218   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  219    219   
            }
  220         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  221         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         220  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         221  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  222    222   
            builder
  223    223   
        };
  224    224   
        let body = ::aws_smithy_types::body::SdkBody::from(
  225    225   
            crate::protocol_serde::shape_put_storage_lens_configuration::ser_put_storage_lens_configuration_op_input(&input)?,
  226    226   
        );
  227    227   
        if let Some(content_length) = body.content_length() {
  228    228   
            let content_length = content_length.to_string();
  229         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         229  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  230    230   
        }
  231    231   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  232    232   
    }
  233    233   
}
  234    234   
#[derive(Debug)]
  235    235   
struct PutStorageLensConfigurationEndpointParamsInterceptor;
  236    236   
  237    237   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutStorageLensConfigurationEndpointParamsInterceptor {
  238    238   
    fn name(&self) -> &'static str {
  239    239   
        "PutStorageLensConfigurationEndpointParamsInterceptor"

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

@@ -186,186 +265,265 @@
  206    206   
                        "config_id",
  207    207   
                        "cannot be empty or unset",
  208    208   
                    ));
  209    209   
                }
  210    210   
                ::std::write!(output, "/v20180820/storagelens/{ConfigId}/tagging", ConfigId = config_id).expect("formatting should succeed");
  211    211   
                ::std::result::Result::Ok(())
  212    212   
            }
  213    213   
            #[allow(clippy::unnecessary_wraps)]
  214    214   
            fn update_http_builder(
  215    215   
                input: &crate::operation::put_storage_lens_configuration_tagging::PutStorageLensConfigurationTaggingInput,
  216         -
                builder: ::http::request::Builder,
  217         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         216  +
                builder: ::http_1x::request::Builder,
         217  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  218    218   
                let mut uri = ::std::string::String::new();
  219    219   
                uri_base(input, &mut uri)?;
  220    220   
                let builder =
  221    221   
                    crate::protocol_serde::shape_put_storage_lens_configuration_tagging::ser_put_storage_lens_configuration_tagging_headers(
  222    222   
                        input, builder,
  223    223   
                    )?;
  224    224   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  225    225   
            }
  226         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  227         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         226  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         227  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  228    228   
            builder
  229    229   
        };
  230    230   
        let body = ::aws_smithy_types::body::SdkBody::from(
  231    231   
            crate::protocol_serde::shape_put_storage_lens_configuration_tagging::ser_put_storage_lens_configuration_tagging_op_input(&input)?,
  232    232   
        );
  233    233   
        if let Some(content_length) = body.content_length() {
  234    234   
            let content_length = content_length.to_string();
  235         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         235  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  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 PutStorageLensConfigurationTaggingEndpointParamsInterceptor;
  242    242   
  243    243   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutStorageLensConfigurationTaggingEndpointParamsInterceptor {
  244    244   
    fn name(&self) -> &'static str {
  245    245   
        "PutStorageLensConfigurationTaggingEndpointParamsInterceptor"

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

@@ -186,186 +265,265 @@
  206    206   
                        "mrap",
  207    207   
                        "cannot be empty or unset",
  208    208   
                    ));
  209    209   
                }
  210    210   
                ::std::write!(output, "/v20180820/mrap/instances/{Mrap}/routes", Mrap = mrap).expect("formatting should succeed");
  211    211   
                ::std::result::Result::Ok(())
  212    212   
            }
  213    213   
            #[allow(clippy::unnecessary_wraps)]
  214    214   
            fn update_http_builder(
  215    215   
                input: &crate::operation::submit_multi_region_access_point_routes::SubmitMultiRegionAccessPointRoutesInput,
  216         -
                builder: ::http::request::Builder,
  217         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         216  +
                builder: ::http_1x::request::Builder,
         217  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  218    218   
                let mut uri = ::std::string::String::new();
  219    219   
                uri_base(input, &mut uri)?;
  220    220   
                let builder =
  221    221   
                    crate::protocol_serde::shape_submit_multi_region_access_point_routes::ser_submit_multi_region_access_point_routes_headers(
  222    222   
                        input, builder,
  223    223   
                    )?;
  224    224   
                ::std::result::Result::Ok(builder.method("PATCH").uri(uri))
  225    225   
            }
  226         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  227         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         226  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         227  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  228    228   
            builder
  229    229   
        };
  230    230   
        let body = ::aws_smithy_types::body::SdkBody::from(
  231    231   
            crate::protocol_serde::shape_submit_multi_region_access_point_routes::ser_submit_multi_region_access_point_routes_op_input(&input)?,
  232    232   
        );
  233    233   
        if let Some(content_length) = body.content_length() {
  234    234   
            let content_length = content_length.to_string();
  235         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         235  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  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 SubmitMultiRegionAccessPointRoutesEndpointParamsInterceptor;
  242    242   
  243    243   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SubmitMultiRegionAccessPointRoutesEndpointParamsInterceptor {
  244    244   
    fn name(&self) -> &'static str {
  245    245   
        "SubmitMultiRegionAccessPointRoutesEndpointParamsInterceptor"

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

@@ -173,173 +247,247 @@
  193    193   
                        "resource_arn",
  194    194   
                        "cannot be empty or unset",
  195    195   
                    ));
  196    196   
                }
  197    197   
                ::std::write!(output, "/v20180820/tags/{ResourceArn}", ResourceArn = resource_arn).expect("formatting should succeed");
  198    198   
                ::std::result::Result::Ok(())
  199    199   
            }
  200    200   
            #[allow(clippy::unnecessary_wraps)]
  201    201   
            fn update_http_builder(
  202    202   
                input: &crate::operation::tag_resource::TagResourceInput,
  203         -
                builder: ::http::request::Builder,
  204         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         203  +
                builder: ::http_1x::request::Builder,
         204  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  205    205   
                let mut uri = ::std::string::String::new();
  206    206   
                uri_base(input, &mut uri)?;
  207    207   
                let builder = crate::protocol_serde::shape_tag_resource::ser_tag_resource_headers(input, builder)?;
  208    208   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  209    209   
            }
  210         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  211         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         210  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         211  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  212    212   
            builder
  213    213   
        };
  214    214   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_tag_resource::ser_tag_resource_op_input(&input)?);
  215    215   
        if let Some(content_length) = body.content_length() {
  216    216   
            let content_length = content_length.to_string();
  217         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         217  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  218    218   
        }
  219    219   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  220    220   
    }
  221    221   
}
  222    222   
#[derive(Debug)]
  223    223   
struct TagResourceEndpointParamsInterceptor;
  224    224   
  225    225   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TagResourceEndpointParamsInterceptor {
  226    226   
    fn name(&self) -> &'static str {
  227    227   
        "TagResourceEndpointParamsInterceptor"

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

@@ -190,190 +258,258 @@
  210    210   
                    .as_ref()
  211    211   
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("tag_keys", "cannot be empty or unset"))?;
  212    212   
                for inner_3 in inner_2 {
  213    213   
                    query.push_kv("tagKeys", &::aws_smithy_http::query::fmt_string(inner_3));
  214    214   
                }
  215    215   
                ::std::result::Result::Ok(())
  216    216   
            }
  217    217   
            #[allow(clippy::unnecessary_wraps)]
  218    218   
            fn update_http_builder(
  219    219   
                input: &crate::operation::untag_resource::UntagResourceInput,
  220         -
                builder: ::http::request::Builder,
  221         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         220  +
                builder: ::http_1x::request::Builder,
         221  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  222    222   
                let mut uri = ::std::string::String::new();
  223    223   
                uri_base(input, &mut uri)?;
  224    224   
                uri_query(input, &mut uri)?;
  225    225   
                let builder = crate::protocol_serde::shape_untag_resource::ser_untag_resource_headers(input, builder)?;
  226    226   
                ::std::result::Result::Ok(builder.method("DELETE").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 UntagResourceEndpointParamsInterceptor;
  238    238   

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

@@ -187,187 +263,263 @@
  207    207   
                    output,
  208    208   
                    "/v20180820/accessgrantsinstance/location/{AccessGrantsLocationId}",
  209    209   
                    AccessGrantsLocationId = access_grants_location_id
  210    210   
                )
  211    211   
                .expect("formatting should succeed");
  212    212   
                ::std::result::Result::Ok(())
  213    213   
            }
  214    214   
            #[allow(clippy::unnecessary_wraps)]
  215    215   
            fn update_http_builder(
  216    216   
                input: &crate::operation::update_access_grants_location::UpdateAccessGrantsLocationInput,
  217         -
                builder: ::http::request::Builder,
  218         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         217  +
                builder: ::http_1x::request::Builder,
         218  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  219    219   
                let mut uri = ::std::string::String::new();
  220    220   
                uri_base(input, &mut uri)?;
  221    221   
                let builder = crate::protocol_serde::shape_update_access_grants_location::ser_update_access_grants_location_headers(input, builder)?;
  222    222   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  223    223   
            }
  224         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  225         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         224  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         225  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  226    226   
            builder
  227    227   
        };
  228    228   
        let body = ::aws_smithy_types::body::SdkBody::from(
  229    229   
            crate::protocol_serde::shape_update_access_grants_location::ser_update_access_grants_location_op_input(&input)?,
  230    230   
        );
  231    231   
        if let Some(content_length) = body.content_length() {
  232    232   
            let content_length = content_length.to_string();
  233         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         233  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  234    234   
        }
  235    235   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  236    236   
    }
  237    237   
}
  238    238   
#[derive(Debug)]
  239    239   
struct UpdateAccessGrantsLocationEndpointParamsInterceptor;
  240    240   
  241    241   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateAccessGrantsLocationEndpointParamsInterceptor {
  242    242   
    fn name(&self) -> &'static str {
  243    243   
        "UpdateAccessGrantsLocationEndpointParamsInterceptor"

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

@@ -188,188 +256,256 @@
  208    208   
                let inner_2 = &_input.priority;
  209    209   
                let inner_2 = inner_2
  210    210   
                    .as_ref()
  211    211   
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("priority", "cannot be empty or unset"))?;
  212    212   
                query.push_kv("priority", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
  213    213   
                ::std::result::Result::Ok(())
  214    214   
            }
  215    215   
            #[allow(clippy::unnecessary_wraps)]
  216    216   
            fn update_http_builder(
  217    217   
                input: &crate::operation::update_job_priority::UpdateJobPriorityInput,
  218         -
                builder: ::http::request::Builder,
  219         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         218  +
                builder: ::http_1x::request::Builder,
         219  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  220    220   
                let mut uri = ::std::string::String::new();
  221    221   
                uri_base(input, &mut uri)?;
  222    222   
                uri_query(input, &mut uri)?;
  223    223   
                let builder = crate::protocol_serde::shape_update_job_priority::ser_update_job_priority_headers(input, builder)?;
  224    224   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  225    225   
            }
  226         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         226  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  227    227   
            builder
  228    228   
        };
  229    229   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  230    230   
  231    231   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  232    232   
    }
  233    233   
}
  234    234   
#[derive(Debug)]
  235    235   
struct UpdateJobPriorityEndpointParamsInterceptor;
  236    236   

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

@@ -193,193 +261,261 @@
  213    213   
                if let ::std::option::Option::Some(inner_3) = &_input.status_update_reason {
  214    214   
                    {
  215    215   
                        query.push_kv("statusUpdateReason", &::aws_smithy_http::query::fmt_string(inner_3));
  216    216   
                    }
  217    217   
                }
  218    218   
                ::std::result::Result::Ok(())
  219    219   
            }
  220    220   
            #[allow(clippy::unnecessary_wraps)]
  221    221   
            fn update_http_builder(
  222    222   
                input: &crate::operation::update_job_status::UpdateJobStatusInput,
  223         -
                builder: ::http::request::Builder,
  224         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         223  +
                builder: ::http_1x::request::Builder,
         224  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  225    225   
                let mut uri = ::std::string::String::new();
  226    226   
                uri_base(input, &mut uri)?;
  227    227   
                uri_query(input, &mut uri)?;
  228    228   
                let builder = crate::protocol_serde::shape_update_job_status::ser_update_job_status_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())?;
         231  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  232    232   
            builder
  233    233   
        };
  234    234   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  235    235   
  236    236   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  237    237   
    }
  238    238   
}
  239    239   
#[derive(Debug)]
  240    240   
struct UpdateJobStatusEndpointParamsInterceptor;
  241    241   

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

@@ -176,176 +252,252 @@
  196    196   
                        "name",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/v20180820/storagelensgroup/{Name}", Name = name).expect("formatting should succeed");
  201    201   
                ::std::result::Result::Ok(())
  202    202   
            }
  203    203   
            #[allow(clippy::unnecessary_wraps)]
  204    204   
            fn update_http_builder(
  205    205   
                input: &crate::operation::update_storage_lens_group::UpdateStorageLensGroupInput,
  206         -
                builder: ::http::request::Builder,
  207         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         206  +
                builder: ::http_1x::request::Builder,
         207  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  208    208   
                let mut uri = ::std::string::String::new();
  209    209   
                uri_base(input, &mut uri)?;
  210    210   
                let builder = crate::protocol_serde::shape_update_storage_lens_group::ser_update_storage_lens_group_headers(input, builder)?;
  211    211   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  212    212   
            }
  213         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  214         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         213  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         214  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  215    215   
            builder
  216    216   
        };
  217    217   
        let body = ::aws_smithy_types::body::SdkBody::from(
  218    218   
            crate::protocol_serde::shape_update_storage_lens_group::ser_update_storage_lens_group_op_input(&input)?,
  219    219   
        );
  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 UpdateStorageLensGroupEndpointParamsInterceptor;
  229    229   
  230    230   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateStorageLensGroupEndpointParamsInterceptor {
  231    231   
    fn name(&self) -> &'static str {
  232    232   
        "UpdateStorageLensGroupEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_associate_access_grants_identity_center.rs

@@ -9,9 +70,70 @@
   29     29   
        #[allow(unused_mut)]
   30     30   
        let mut output =
   31     31   
            crate::operation::associate_access_grants_identity_center::builders::AssociateAccessGrantsIdentityCenterOutputBuilder::default();
   32     32   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   33     33   
        output.build()
   34     34   
    })
   35     35   
}
   36     36   
   37     37   
pub fn ser_associate_access_grants_identity_center_headers(
   38     38   
    input: &crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterInput,
   39         -
    mut builder: ::http::request::Builder,
   40         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          39  +
    mut builder: ::http_1x::request::Builder,
          40  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   41     41   
    if let ::std::option::Option::Some(inner_1) = &input.account_id {
   42     42   
        let formatted_2 = inner_1.as_str();
   43     43   
        let header_value = formatted_2;
   44         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          44  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   45     45   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   46     46   
                "account_id",
   47     47   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   48     48   
            )
   49     49   
        })?;
   50     50   
        builder = builder.header("x-amz-account-id", header_value);
   51     51   
    }
   52     52   
    Ok(builder)
   53     53   
}
   54     54   

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_create_access_grant.rs

@@ -6,6 +71,71 @@
   26     26   
        let mut output = crate::operation::create_access_grant::builders::CreateAccessGrantOutputBuilder::default();
   27     27   
        output = crate::protocol_serde::shape_create_access_grant::de_create_access_grant(_response_body, output)
   28     28   
            .map_err(crate::operation::create_access_grant::CreateAccessGrantError::unhandled)?;
   29     29   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   30     30   
        output.build()
   31     31   
    })
   32     32   
}
   33     33   
   34     34   
pub fn ser_create_access_grant_headers(
   35     35   
    input: &crate::operation::create_access_grant::CreateAccessGrantInput,
   36         -
    mut builder: ::http::request::Builder,
   37         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          36  +
    mut builder: ::http_1x::request::Builder,
          37  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   38     38   
    if let ::std::option::Option::Some(inner_1) = &input.account_id {
   39     39   
        let formatted_2 = inner_1.as_str();
   40     40   
        let header_value = formatted_2;
   41         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          41  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   42     42   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   43     43   
                "account_id",
   44     44   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   45     45   
            )
   46     46   
        })?;
   47     47   
        builder = builder.header("x-amz-account-id", header_value);
   48     48   
    }
   49     49   
    Ok(builder)
   50     50   
}
   51     51   

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_create_access_grants_instance.rs

@@ -12,12 +77,77 @@
   32     32   
        let mut output = crate::operation::create_access_grants_instance::builders::CreateAccessGrantsInstanceOutputBuilder::default();
   33     33   
        output = crate::protocol_serde::shape_create_access_grants_instance::de_create_access_grants_instance(_response_body, output)
   34     34   
            .map_err(crate::operation::create_access_grants_instance::CreateAccessGrantsInstanceError::unhandled)?;
   35     35   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   36     36   
        output.build()
   37     37   
    })
   38     38   
}
   39     39   
   40     40   
pub fn ser_create_access_grants_instance_headers(
   41     41   
    input: &crate::operation::create_access_grants_instance::CreateAccessGrantsInstanceInput,
   42         -
    mut builder: ::http::request::Builder,
   43         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          42  +
    mut builder: ::http_1x::request::Builder,
          43  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   44     44   
    if let ::std::option::Option::Some(inner_1) = &input.account_id {
   45     45   
        let formatted_2 = inner_1.as_str();
   46     46   
        let header_value = formatted_2;
   47         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          47  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   48     48   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   49     49   
                "account_id",
   50     50   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   51     51   
            )
   52     52   
        })?;
   53     53   
        builder = builder.header("x-amz-account-id", header_value);
   54     54   
    }
   55     55   
    Ok(builder)
   56     56   
}
   57     57   

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_create_access_grants_location.rs

@@ -12,12 +77,77 @@
   32     32   
        let mut output = crate::operation::create_access_grants_location::builders::CreateAccessGrantsLocationOutputBuilder::default();
   33     33   
        output = crate::protocol_serde::shape_create_access_grants_location::de_create_access_grants_location(_response_body, output)
   34     34   
            .map_err(crate::operation::create_access_grants_location::CreateAccessGrantsLocationError::unhandled)?;
   35     35   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   36     36   
        output.build()
   37     37   
    })
   38     38   
}
   39     39   
   40     40   
pub fn ser_create_access_grants_location_headers(
   41     41   
    input: &crate::operation::create_access_grants_location::CreateAccessGrantsLocationInput,
   42         -
    mut builder: ::http::request::Builder,
   43         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          42  +
    mut builder: ::http_1x::request::Builder,
          43  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   44     44   
    if let ::std::option::Option::Some(inner_1) = &input.account_id {
   45     45   
        let formatted_2 = inner_1.as_str();
   46     46   
        let header_value = formatted_2;
   47         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          47  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   48     48   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   49     49   
                "account_id",
   50     50   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   51     51   
            )
   52     52   
        })?;
   53     53   
        builder = builder.header("x-amz-account-id", header_value);
   54     54   
    }
   55     55   
    Ok(builder)
   56     56   
}
   57     57   

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_create_access_point.rs

@@ -6,6 +71,71 @@
   26     26   
        let mut output = crate::operation::create_access_point::builders::CreateAccessPointOutputBuilder::default();
   27     27   
        output = crate::protocol_serde::shape_create_access_point::de_create_access_point(_response_body, output)
   28     28   
            .map_err(crate::operation::create_access_point::CreateAccessPointError::unhandled)?;
   29     29   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   30     30   
        output.build()
   31     31   
    })
   32     32   
}
   33     33   
   34     34   
pub fn ser_create_access_point_headers(
   35     35   
    input: &crate::operation::create_access_point::CreateAccessPointInput,
   36         -
    mut builder: ::http::request::Builder,
   37         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          36  +
    mut builder: ::http_1x::request::Builder,
          37  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   38     38   
    if let ::std::option::Option::Some(inner_1) = &input.account_id {
   39     39   
        let formatted_2 = inner_1.as_str();
   40     40   
        let header_value = formatted_2;
   41         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          41  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   42     42   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   43     43   
                "account_id",
   44     44   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   45     45   
            )
   46     46   
        })?;
   47     47   
        builder = builder.header("x-amz-account-id", header_value);
   48     48   
    }
   49     49   
    Ok(builder)
   50     50   
}
   51     51   

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_create_access_point_for_object_lambda.rs

@@ -10,10 +75,75 @@
   30     30   
        let mut output = crate::operation::create_access_point_for_object_lambda::builders::CreateAccessPointForObjectLambdaOutputBuilder::default();
   31     31   
        output = crate::protocol_serde::shape_create_access_point_for_object_lambda::de_create_access_point_for_object_lambda(_response_body, output)
   32     32   
            .map_err(crate::operation::create_access_point_for_object_lambda::CreateAccessPointForObjectLambdaError::unhandled)?;
   33     33   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   34     34   
        output.build()
   35     35   
    })
   36     36   
}
   37     37   
   38     38   
pub fn ser_create_access_point_for_object_lambda_headers(
   39     39   
    input: &crate::operation::create_access_point_for_object_lambda::CreateAccessPointForObjectLambdaInput,
   40         -
    mut builder: ::http::request::Builder,
   41         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          40  +
    mut builder: ::http_1x::request::Builder,
          41  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   42     42   
    if let ::std::option::Option::Some(inner_1) = &input.account_id {
   43     43   
        let formatted_2 = inner_1.as_str();
   44     44   
        let header_value = formatted_2;
   45         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          45  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   46     46   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   47     47   
                "account_id",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("x-amz-account-id", header_value);
   52     52   
    }
   53     53   
    Ok(builder)
   54     54   
}
   55     55   

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_create_bucket.rs

@@ -46,46 +189,189 @@
   66     66   
            crate::protocol_serde::shape_create_bucket_output::de_location_header(_response_headers)
   67     67   
                .map_err(|_| crate::operation::create_bucket::CreateBucketError::unhandled("Failed to parse Location from header `Location"))?,
   68     68   
        );
   69     69   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   70     70   
        output.build()
   71     71   
    })
   72     72   
}
   73     73   
   74     74   
pub fn ser_create_bucket_headers(
   75     75   
    input: &crate::operation::create_bucket::CreateBucketInput,
   76         -
    mut builder: ::http::request::Builder,
   77         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          76  +
    mut builder: ::http_1x::request::Builder,
          77  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   78     78   
    if let ::std::option::Option::Some(inner_1) = &input.acl {
   79     79   
        let formatted_2 = inner_1.as_str();
   80     80   
        let header_value = formatted_2;
   81         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          81  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   82     82   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   83     83   
                "acl",
   84     84   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   85     85   
            )
   86     86   
        })?;
   87     87   
        builder = builder.header("x-amz-acl", header_value);
   88     88   
    }
   89     89   
    if let ::std::option::Option::Some(inner_3) = &input.grant_full_control {
   90     90   
        let formatted_4 = inner_3.as_str();
   91     91   
        let header_value = formatted_4;
   92         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          92  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   93     93   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   94     94   
                "grant_full_control",
   95     95   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   96     96   
            )
   97     97   
        })?;
   98     98   
        builder = builder.header("x-amz-grant-full-control", header_value);
   99     99   
    }
  100    100   
    if let ::std::option::Option::Some(inner_5) = &input.grant_read {
  101    101   
        let formatted_6 = inner_5.as_str();
  102    102   
        let header_value = formatted_6;
  103         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         103  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  104    104   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  105    105   
                "grant_read",
  106    106   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  107    107   
            )
  108    108   
        })?;
  109    109   
        builder = builder.header("x-amz-grant-read", header_value);
  110    110   
    }
  111    111   
    if let ::std::option::Option::Some(inner_7) = &input.grant_read_acp {
  112    112   
        let formatted_8 = inner_7.as_str();
  113    113   
        let header_value = formatted_8;
  114         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         114  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  115    115   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  116    116   
                "grant_read_acp",
  117    117   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  118    118   
            )
  119    119   
        })?;
  120    120   
        builder = builder.header("x-amz-grant-read-acp", header_value);
  121    121   
    }
  122    122   
    if let ::std::option::Option::Some(inner_9) = &input.grant_write {
  123    123   
        let formatted_10 = inner_9.as_str();
  124    124   
        let header_value = formatted_10;
  125         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         125  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  126    126   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  127    127   
                "grant_write",
  128    128   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  129    129   
            )
  130    130   
        })?;
  131    131   
        builder = builder.header("x-amz-grant-write", header_value);
  132    132   
    }
  133    133   
    if let ::std::option::Option::Some(inner_11) = &input.grant_write_acp {
  134    134   
        let formatted_12 = inner_11.as_str();
  135    135   
        let header_value = formatted_12;
  136         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         136  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  137    137   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  138    138   
                "grant_write_acp",
  139    139   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  140    140   
            )
  141    141   
        })?;
  142    142   
        builder = builder.header("x-amz-grant-write-acp", header_value);
  143    143   
    }
  144    144   
    if let ::std::option::Option::Some(inner_13) = &input.object_lock_enabled_for_bucket {
  145    145   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);
  146    146   
        let formatted_14 = encoder.encode();
  147    147   
        let header_value = formatted_14;
  148         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         148  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  149    149   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  150    150   
                "object_lock_enabled_for_bucket",
  151    151   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  152    152   
            )
  153    153   
        })?;
  154    154   
        builder = builder.header("x-amz-bucket-object-lock-enabled", header_value);
  155    155   
    }
  156    156   
    if let ::std::option::Option::Some(inner_15) = &input.outpost_id {
  157    157   
        let formatted_16 = inner_15.as_str();
  158    158   
        let header_value = formatted_16;
  159         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         159  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  160    160   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  161    161   
                "outpost_id",
  162    162   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  163    163   
            )
  164    164   
        })?;
  165    165   
        builder = builder.header("x-amz-outpost-id", header_value);
  166    166   
    }
  167    167   
    Ok(builder)
  168    168   
}
  169    169