AWS SDK

AWS SDK

rev. 3c756f73b1f83a0eed4275d9d1e22df0b10b66fb (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/activate_key_signing_key.rs

@@ -196,196 +262,262 @@
  216    216   
                    "/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/activate",
  217    217   
                    HostedZoneId = hosted_zone_id,
  218    218   
                    Name = 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::activate_key_signing_key::ActivateKeySigningKeyInput,
  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())?;
         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 ActivateKeySigningKeyEndpointParamsInterceptor;
  242    242

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/associate_vpc_with_hosted_zone.rs

@@ -190,190 +265,265 @@
  210    210   
                    output,
  211    211   
                    "/2013-04-01/hostedzone/{HostedZoneId}/associatevpc",
  212    212   
                    HostedZoneId = hosted_zone_id
  213    213   
                )
  214    214   
                .expect("formatting should succeed");
  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::associate_vpc_with_hosted_zone::AssociateVpcWithHostedZoneInput,
  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   
                ::std::result::Result::Ok(builder.method("POST").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_associate_vpc_with_hosted_zone::ser_associate_vpc_with_hosted_zone_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 AssociateVPCWithHostedZoneEndpointParamsInterceptor;
  242    242   
  243    243   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for AssociateVPCWithHostedZoneEndpointParamsInterceptor {
  244    244   
    fn name(&self) -> &'static str {
  245    245   
        "AssociateVPCWithHostedZoneEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/change_cidr_collection.rs

@@ -176,176 +251,251 @@
  196    196   
                        "id",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/2013-04-01/cidrcollection/{Id}", Id = id).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::change_cidr_collection::ChangeCidrCollectionInput,
  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   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  211    211   
            }
  212         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  213         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         212  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         213  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  214    214   
            builder
  215    215   
        };
  216    216   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_change_cidr_collection::ser_change_cidr_collection_op_input(
  217    217   
            &input,
  218    218   
        )?);
  219    219   
        if let Some(content_length) = body.content_length() {
  220    220   
            let content_length = content_length.to_string();
  221         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         221  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  222    222   
        }
  223    223   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  224    224   
    }
  225    225   
}
  226    226   
#[derive(Debug)]
  227    227   
struct ChangeCidrCollectionEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ChangeCidrCollectionEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "ChangeCidrCollectionEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/change_resource_record_sets.rs

@@ -180,180 +255,255 @@
  200    200   
                        "cannot be empty or unset",
  201    201   
                    ));
  202    202   
                }
  203    203   
                ::std::write!(output, "/2013-04-01/hostedzone/{HostedZoneId}/rrset", HostedZoneId = hosted_zone_id)
  204    204   
                    .expect("formatting should succeed");
  205    205   
                ::std::result::Result::Ok(())
  206    206   
            }
  207    207   
            #[allow(clippy::unnecessary_wraps)]
  208    208   
            fn update_http_builder(
  209    209   
                input: &crate::operation::change_resource_record_sets::ChangeResourceRecordSetsInput,
  210         -
                builder: ::http::request::Builder,
  211         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         210  +
                builder: ::http_1x::request::Builder,
         211  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  212    212   
                let mut uri = ::std::string::String::new();
  213    213   
                uri_base(input, &mut uri)?;
  214    214   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  215    215   
            }
  216         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  217         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         216  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         217  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  218    218   
            builder
  219    219   
        };
  220    220   
        let body = ::aws_smithy_types::body::SdkBody::from(
  221    221   
            crate::protocol_serde::shape_change_resource_record_sets::ser_change_resource_record_sets_op_input(&input)?,
  222    222   
        );
  223    223   
        if let Some(content_length) = body.content_length() {
  224    224   
            let content_length = content_length.to_string();
  225         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         225  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  226    226   
        }
  227    227   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  228    228   
    }
  229    229   
}
  230    230   
#[derive(Debug)]
  231    231   
struct ChangeResourceRecordSetsEndpointParamsInterceptor;
  232    232   
  233    233   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ChangeResourceRecordSetsEndpointParamsInterceptor {
  234    234   
    fn name(&self) -> &'static str {
  235    235   
        "ChangeResourceRecordSetsEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/change_tags_for_resource.rs

@@ -193,193 +268,268 @@
  213    213   
                    "/2013-04-01/tags/{ResourceType}/{ResourceId}",
  214    214   
                    ResourceType = resource_type,
  215    215   
                    ResourceId = resource_id
  216    216   
                )
  217    217   
                .expect("formatting should succeed");
  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::change_tags_for_resource::ChangeTagsForResourceInput,
  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   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  228    228   
            }
  229         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  230         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         229  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         230  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  231    231   
            builder
  232    232   
        };
  233    233   
        let body = ::aws_smithy_types::body::SdkBody::from(
  234    234   
            crate::protocol_serde::shape_change_tags_for_resource::ser_change_tags_for_resource_op_input(&input)?,
  235    235   
        );
  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 ChangeTagsForResourceEndpointParamsInterceptor;
  245    245   
  246    246   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ChangeTagsForResourceEndpointParamsInterceptor {
  247    247   
    fn name(&self) -> &'static str {
  248    248   
        "ChangeTagsForResourceEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_cidr_collection.rs

@@ -165,165 +240,240 @@
  185    185   
                _input: &crate::operation::create_cidr_collection::CreateCidrCollectionInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/2013-04-01/cidrcollection").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::create_cidr_collection::CreateCidrCollectionInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  203    203   
            builder
  204    204   
        };
  205    205   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_cidr_collection::ser_create_cidr_collection_op_input(
  206    206   
            &input,
  207    207   
        )?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct CreateCidrCollectionEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateCidrCollectionEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "CreateCidrCollectionEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_health_check.rs

@@ -165,165 +240,240 @@
  185    185   
                _input: &crate::operation::create_health_check::CreateHealthCheckInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/2013-04-01/healthcheck").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::create_health_check::CreateHealthCheckInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  203    203   
            builder
  204    204   
        };
  205    205   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_health_check::ser_create_health_check_op_input(
  206    206   
            &input,
  207    207   
        )?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct CreateHealthCheckEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateHealthCheckEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "CreateHealthCheckEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_hosted_zone.rs

@@ -165,165 +238,238 @@
  185    185   
                _input: &crate::operation::create_hosted_zone::CreateHostedZoneInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/2013-04-01/hostedzone").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::create_hosted_zone::CreateHostedZoneInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  203    203   
            builder
  204    204   
        };
  205    205   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_hosted_zone::ser_create_hosted_zone_op_input(&input)?);
  206    206   
        if let Some(content_length) = body.content_length() {
  207    207   
            let content_length = content_length.to_string();
  208         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         208  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  209    209   
        }
  210    210   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  211    211   
    }
  212    212   
}
  213    213   
#[derive(Debug)]
  214    214   
struct CreateHostedZoneEndpointParamsInterceptor;
  215    215   
  216    216   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateHostedZoneEndpointParamsInterceptor {
  217    217   
    fn name(&self) -> &'static str {
  218    218   
        "CreateHostedZoneEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_key_signing_key.rs

@@ -165,165 +240,240 @@
  185    185   
                _input: &crate::operation::create_key_signing_key::CreateKeySigningKeyInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/2013-04-01/keysigningkey").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::create_key_signing_key::CreateKeySigningKeyInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  203    203   
            builder
  204    204   
        };
  205    205   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_key_signing_key::ser_create_key_signing_key_op_input(
  206    206   
            &input,
  207    207   
        )?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct CreateKeySigningKeyEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateKeySigningKeyEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "CreateKeySigningKeyEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_query_logging_config.rs

@@ -165,165 +240,240 @@
  185    185   
                _input: &crate::operation::create_query_logging_config::CreateQueryLoggingConfigInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/2013-04-01/queryloggingconfig").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::create_query_logging_config::CreateQueryLoggingConfigInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  203    203   
            builder
  204    204   
        };
  205    205   
        let body = ::aws_smithy_types::body::SdkBody::from(
  206    206   
            crate::protocol_serde::shape_create_query_logging_config::ser_create_query_logging_config_op_input(&input)?,
  207    207   
        );
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct CreateQueryLoggingConfigEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateQueryLoggingConfigEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "CreateQueryLoggingConfigEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_reusable_delegation_set.rs

@@ -171,171 +246,246 @@
  191    191   
                _input: &crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetInput,
  192    192   
                output: &mut ::std::string::String,
  193    193   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                use ::std::fmt::Write as _;
  195    195   
                ::std::write!(output, "/2013-04-01/delegationset").expect("formatting should succeed");
  196    196   
                ::std::result::Result::Ok(())
  197    197   
            }
  198    198   
            #[allow(clippy::unnecessary_wraps)]
  199    199   
            fn update_http_builder(
  200    200   
                input: &crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetInput,
  201         -
                builder: ::http::request::Builder,
  202         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         201  +
                builder: ::http_1x::request::Builder,
         202  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  203    203   
                let mut uri = ::std::string::String::new();
  204    204   
                uri_base(input, &mut uri)?;
  205    205   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  206    206   
            }
  207         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  208         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         207  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         208  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  209    209   
            builder
  210    210   
        };
  211    211   
        let body = ::aws_smithy_types::body::SdkBody::from(
  212    212   
            crate::protocol_serde::shape_create_reusable_delegation_set::ser_create_reusable_delegation_set_op_input(&input)?,
  213    213   
        );
  214    214   
        if let Some(content_length) = body.content_length() {
  215    215   
            let content_length = content_length.to_string();
  216         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         216  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  217    217   
        }
  218    218   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  219    219   
    }
  220    220   
}
  221    221   
#[derive(Debug)]
  222    222   
struct CreateReusableDelegationSetEndpointParamsInterceptor;
  223    223   
  224    224   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateReusableDelegationSetEndpointParamsInterceptor {
  225    225   
    fn name(&self) -> &'static str {
  226    226   
        "CreateReusableDelegationSetEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_traffic_policy.rs

@@ -165,165 +240,240 @@
  185    185   
                _input: &crate::operation::create_traffic_policy::CreateTrafficPolicyInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/2013-04-01/trafficpolicy").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::create_traffic_policy::CreateTrafficPolicyInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  203    203   
            builder
  204    204   
        };
  205    205   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_traffic_policy::ser_create_traffic_policy_op_input(
  206    206   
            &input,
  207    207   
        )?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct CreateTrafficPolicyEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateTrafficPolicyEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "CreateTrafficPolicyEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_traffic_policy_instance.rs

@@ -171,171 +246,246 @@
  191    191   
                _input: &crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceInput,
  192    192   
                output: &mut ::std::string::String,
  193    193   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                use ::std::fmt::Write as _;
  195    195   
                ::std::write!(output, "/2013-04-01/trafficpolicyinstance").expect("formatting should succeed");
  196    196   
                ::std::result::Result::Ok(())
  197    197   
            }
  198    198   
            #[allow(clippy::unnecessary_wraps)]
  199    199   
            fn update_http_builder(
  200    200   
                input: &crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceInput,
  201         -
                builder: ::http::request::Builder,
  202         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         201  +
                builder: ::http_1x::request::Builder,
         202  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  203    203   
                let mut uri = ::std::string::String::new();
  204    204   
                uri_base(input, &mut uri)?;
  205    205   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  206    206   
            }
  207         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  208         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         207  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         208  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  209    209   
            builder
  210    210   
        };
  211    211   
        let body = ::aws_smithy_types::body::SdkBody::from(
  212    212   
            crate::protocol_serde::shape_create_traffic_policy_instance::ser_create_traffic_policy_instance_op_input(&input)?,
  213    213   
        );
  214    214   
        if let Some(content_length) = body.content_length() {
  215    215   
            let content_length = content_length.to_string();
  216         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         216  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  217    217   
        }
  218    218   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  219    219   
    }
  220    220   
}
  221    221   
#[derive(Debug)]
  222    222   
struct CreateTrafficPolicyInstanceEndpointParamsInterceptor;
  223    223   
  224    224   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateTrafficPolicyInstanceEndpointParamsInterceptor {
  225    225   
    fn name(&self) -> &'static str {
  226    226   
        "CreateTrafficPolicyInstanceEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_traffic_policy_version.rs

@@ -182,182 +257,257 @@
  202    202   
                        "id",
  203    203   
                        "cannot be empty or unset",
  204    204   
                    ));
  205    205   
                }
  206    206   
                ::std::write!(output, "/2013-04-01/trafficpolicy/{Id}", Id = 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::create_traffic_policy_version::CreateTrafficPolicyVersionInput,
  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   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  217    217   
            }
  218         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  219         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         218  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         219  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  220    220   
            builder
  221    221   
        };
  222    222   
        let body = ::aws_smithy_types::body::SdkBody::from(
  223    223   
            crate::protocol_serde::shape_create_traffic_policy_version::ser_create_traffic_policy_version_op_input(&input)?,
  224    224   
        );
  225    225   
        if let Some(content_length) = body.content_length() {
  226    226   
            let content_length = content_length.to_string();
  227         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         227  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  228    228   
        }
  229    229   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  230    230   
    }
  231    231   
}
  232    232   
#[derive(Debug)]
  233    233   
struct CreateTrafficPolicyVersionEndpointParamsInterceptor;
  234    234   
  235    235   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateTrafficPolicyVersionEndpointParamsInterceptor {
  236    236   
    fn name(&self) -> &'static str {
  237    237   
        "CreateTrafficPolicyVersionEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_vpc_association_authorization.rs

@@ -196,196 +271,271 @@
  216    216   
                    output,
  217    217   
                    "/2013-04-01/hostedzone/{HostedZoneId}/authorizevpcassociation",
  218    218   
                    HostedZoneId = hosted_zone_id
  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::create_vpc_association_authorization::CreateVpcAssociationAuthorizationInput,
  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/xml");
         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/xml");
  234    234   
            builder
  235    235   
        };
  236    236   
        let body = ::aws_smithy_types::body::SdkBody::from(
  237    237   
            crate::protocol_serde::shape_create_vpc_association_authorization::ser_create_vpc_association_authorization_op_input(&input)?,
  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 CreateVPCAssociationAuthorizationEndpointParamsInterceptor;
  248    248   
  249    249   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateVPCAssociationAuthorizationEndpointParamsInterceptor {
  250    250   
    fn name(&self) -> &'static str {
  251    251   
        "CreateVPCAssociationAuthorizationEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/deactivate_key_signing_key.rs

@@ -196,196 +262,262 @@
  216    216   
                    "/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/deactivate",
  217    217   
                    HostedZoneId = hosted_zone_id,
  218    218   
                    Name = 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::deactivate_key_signing_key::DeactivateKeySigningKeyInput,
  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())?;
         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 DeactivateKeySigningKeyEndpointParamsInterceptor;
  242    242