AWS SDK

AWS SDK

rev. 03e6e47f15dfd569240d570d98975ebba692c405

Files changed:

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

@@ -207,207 +274,274 @@
  227    227   
                if let ::std::option::Option::Some(inner_5) = &_input.max_items {
  228    228   
                    {
  229    229   
                        query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_5).encode());
  230    230   
                    }
  231    231   
                }
  232    232   
                ::std::result::Result::Ok(())
  233    233   
            }
  234    234   
            #[allow(clippy::unnecessary_wraps)]
  235    235   
            fn update_http_builder(
  236    236   
                input: &crate::operation::list_resource_record_sets::ListResourceRecordSetsInput,
  237         -
                builder: ::http::request::Builder,
  238         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         237  +
                builder: ::http_1x::request::Builder,
         238  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  239    239   
                let mut uri = ::std::string::String::new();
  240    240   
                uri_base(input, &mut uri)?;
  241    241   
                uri_query(input, &mut uri)?;
  242    242   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  243    243   
            }
  244         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         244  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  245    245   
            builder
  246    246   
        };
  247    247   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  248    248   
  249    249   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  250    250   
    }
  251    251   
}
  252    252   
#[derive(Debug)]
  253    253   
struct ListResourceRecordSetsEndpointParamsInterceptor;
  254    254   

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

@@ -188,188 +255,255 @@
  208    208   
                if let ::std::option::Option::Some(inner_2) = &_input.max_items {
  209    209   
                    {
  210    210   
                        query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
  211    211   
                    }
  212    212   
                }
  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::list_reusable_delegation_sets::ListReusableDelegationSetsInput,
  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   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  224    224   
            }
  225         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         225  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  226    226   
            builder
  227    227   
        };
  228    228   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  229    229   
  230    230   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  231    231   
    }
  232    232   
}
  233    233   
#[derive(Debug)]
  234    234   
struct ListReusableDelegationSetsEndpointParamsInterceptor;
  235    235   

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

@@ -193,193 +259,259 @@
  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::list_tags_for_resource::ListTagsForResourceInput,
  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("GET").uri(uri))
  228    228   
            }
  229         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         229  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  230    230   
            builder
  231    231   
        };
  232    232   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  233    233   
  234    234   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  235    235   
    }
  236    236   
}
  237    237   
#[derive(Debug)]
  238    238   
struct ListTagsForResourceEndpointParamsInterceptor;
  239    239   

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

@@ -176,176 +251,251 @@
  196    196   
                        "resource_type",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/2013-04-01/tags/{ResourceType}", ResourceType = resource_type).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::list_tags_for_resources::ListTagsForResourcesInput,
  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(
  217    217   
            crate::protocol_serde::shape_list_tags_for_resources::ser_list_tags_for_resources_op_input(&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 ListTagsForResourcesEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTagsForResourcesEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "ListTagsForResourcesEndpointParamsInterceptor"

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

@@ -182,182 +249,249 @@
  202    202   
                if let ::std::option::Option::Some(inner_2) = &_input.max_items {
  203    203   
                    {
  204    204   
                        query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
  205    205   
                    }
  206    206   
                }
  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::list_traffic_policies::ListTrafficPoliciesInput,
  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   
                uri_query(input, &mut uri)?;
  217    217   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  218    218   
            }
  219         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         219  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  220    220   
            builder
  221    221   
        };
  222    222   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  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 ListTrafficPoliciesEndpointParamsInterceptor;
  229    229   

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

@@ -198,198 +265,265 @@
  218    218   
                if let ::std::option::Option::Some(inner_4) = &_input.max_items {
  219    219   
                    {
  220    220   
                        query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
  221    221   
                    }
  222    222   
                }
  223    223   
                ::std::result::Result::Ok(())
  224    224   
            }
  225    225   
            #[allow(clippy::unnecessary_wraps)]
  226    226   
            fn update_http_builder(
  227    227   
                input: &crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesInput,
  228         -
                builder: ::http::request::Builder,
  229         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         228  +
                builder: ::http_1x::request::Builder,
         229  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  230    230   
                let mut uri = ::std::string::String::new();
  231    231   
                uri_base(input, &mut uri)?;
  232    232   
                uri_query(input, &mut uri)?;
  233    233   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  234    234   
            }
  235         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         235  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  236    236   
            builder
  237    237   
        };
  238    238   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  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 ListTrafficPolicyInstancesEndpointParamsInterceptor;
  245    245   

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

@@ -208,208 +275,275 @@
  228    228   
                if let ::std::option::Option::Some(inner_4) = &_input.max_items {
  229    229   
                    {
  230    230   
                        query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
  231    231   
                    }
  232    232   
                }
  233    233   
                ::std::result::Result::Ok(())
  234    234   
            }
  235    235   
            #[allow(clippy::unnecessary_wraps)]
  236    236   
            fn update_http_builder(
  237    237   
                input: &crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneInput,
  238         -
                builder: ::http::request::Builder,
  239         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         238  +
                builder: ::http_1x::request::Builder,
         239  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  240    240   
                let mut uri = ::std::string::String::new();
  241    241   
                uri_base(input, &mut uri)?;
  242    242   
                uri_query(input, &mut uri)?;
  243    243   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  244    244   
            }
  245         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         245  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  246    246   
            builder
  247    247   
        };
  248    248   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  249    249   
  250    250   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  251    251   
    }
  252    252   
}
  253    253   
#[derive(Debug)]
  254    254   
struct ListTrafficPolicyInstancesByHostedZoneEndpointParamsInterceptor;
  255    255   

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

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

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

@@ -199,199 +266,266 @@
  219    219   
                if let ::std::option::Option::Some(inner_3) = &_input.max_items {
  220    220   
                    {
  221    221   
                        query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
  222    222   
                    }
  223    223   
                }
  224    224   
                ::std::result::Result::Ok(())
  225    225   
            }
  226    226   
            #[allow(clippy::unnecessary_wraps)]
  227    227   
            fn update_http_builder(
  228    228   
                input: &crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsInput,
  229         -
                builder: ::http::request::Builder,
  230         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         229  +
                builder: ::http_1x::request::Builder,
         230  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  231    231   
                let mut uri = ::std::string::String::new();
  232    232   
                uri_base(input, &mut uri)?;
  233    233   
                uri_query(input, &mut uri)?;
  234    234   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  235    235   
            }
  236         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         236  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  237    237   
            builder
  238    238   
        };
  239    239   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  240    240   
  241    241   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  242    242   
    }
  243    243   
}
  244    244   
#[derive(Debug)]
  245    245   
struct ListTrafficPolicyVersionsEndpointParamsInterceptor;
  246    246   

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

@@ -209,209 +276,276 @@
  229    229   
                if let ::std::option::Option::Some(inner_3) = &_input.max_results {
  230    230   
                    {
  231    231   
                        query.push_kv("maxresults", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
  232    232   
                    }
  233    233   
                }
  234    234   
                ::std::result::Result::Ok(())
  235    235   
            }
  236    236   
            #[allow(clippy::unnecessary_wraps)]
  237    237   
            fn update_http_builder(
  238    238   
                input: &crate::operation::list_vpc_association_authorizations::ListVpcAssociationAuthorizationsInput,
  239         -
                builder: ::http::request::Builder,
  240         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         239  +
                builder: ::http_1x::request::Builder,
         240  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  241    241   
                let mut uri = ::std::string::String::new();
  242    242   
                uri_base(input, &mut uri)?;
  243    243   
                uri_query(input, &mut uri)?;
  244    244   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  245    245   
            }
  246         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         246  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  247    247   
            builder
  248    248   
        };
  249    249   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  250    250   
  251    251   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  252    252   
    }
  253    253   
}
  254    254   
#[derive(Debug)]
  255    255   
struct ListVPCAssociationAuthorizationsEndpointParamsInterceptor;
  256    256   

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

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

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

@@ -176,176 +251,251 @@
  196    196   
                        "health_check_id",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/2013-04-01/healthcheck/{HealthCheckId}", HealthCheckId = health_check_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::update_health_check::UpdateHealthCheckInput,
  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_update_health_check::ser_update_health_check_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 UpdateHealthCheckEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateHealthCheckEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "UpdateHealthCheckEndpointParamsInterceptor"

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

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

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

@@ -194,194 +269,269 @@
  214    214   
                        "version",
  215    215   
                        "cannot be empty or unset",
  216    216   
                    ));
  217    217   
                }
  218    218   
                ::std::write!(output, "/2013-04-01/trafficpolicy/{Id}/{Version}", Id = id, Version = version).expect("formatting should succeed");
  219    219   
                ::std::result::Result::Ok(())
  220    220   
            }
  221    221   
            #[allow(clippy::unnecessary_wraps)]
  222    222   
            fn update_http_builder(
  223    223   
                input: &crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentInput,
  224         -
                builder: ::http::request::Builder,
  225         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         224  +
                builder: ::http_1x::request::Builder,
         225  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  226    226   
                let mut uri = ::std::string::String::new();
  227    227   
                uri_base(input, &mut uri)?;
  228    228   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  229    229   
            }
  230         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  231         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         230  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         231  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  232    232   
            builder
  233    233   
        };
  234    234   
        let body = ::aws_smithy_types::body::SdkBody::from(
  235    235   
            crate::protocol_serde::shape_update_traffic_policy_comment::ser_update_traffic_policy_comment_op_input(&input)?,
  236    236   
        );
  237    237   
        if let Some(content_length) = body.content_length() {
  238    238   
            let content_length = content_length.to_string();
  239         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         239  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  240    240   
        }
  241    241   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  242    242   
    }
  243    243   
}
  244    244   
#[derive(Debug)]
  245    245   
struct UpdateTrafficPolicyCommentEndpointParamsInterceptor;
  246    246   
  247    247   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTrafficPolicyCommentEndpointParamsInterceptor {
  248    248   
    fn name(&self) -> &'static str {
  249    249   
        "UpdateTrafficPolicyCommentEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/update_traffic_policy_instance.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/trafficpolicyinstance/{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::update_traffic_policy_instance::UpdateTrafficPolicyInstanceInput,
  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_update_traffic_policy_instance::ser_update_traffic_policy_instance_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 UpdateTrafficPolicyInstanceEndpointParamsInterceptor;
  234    234   
  235    235   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTrafficPolicyInstanceEndpointParamsInterceptor {
  236    236   
    fn name(&self) -> &'static str {
  237    237   
        "UpdateTrafficPolicyInstanceEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/serialization_settings.rs

@@ -1,1 +78,83 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/*
    3      3   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    4      4   
 * SPDX-License-Identifier: Apache-2.0
    5      5   
 */
    6      6   
    7      7   
#![allow(dead_code)]
    8      8   
    9      9   
use aws_smithy_http::header::set_request_header_if_absent;
   10     10   
use aws_smithy_types::config_bag::{Storable, StoreReplace};
   11         -
use http::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
          11  +
use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
   12     12   
   13     13   
/// Configuration for how default protocol headers are serialized
   14     14   
#[derive(Clone, Debug, Default)]
   15     15   
pub(crate) struct HeaderSerializationSettings {
   16     16   
    omit_default_content_length: bool,
   17     17   
    omit_default_content_type: bool,
   18     18   
}
   19     19   
   20     20   
impl HeaderSerializationSettings {
   21     21   
    /// Creates new [`HeaderSerializationSettings`]
   22     22   
    pub(crate) fn new() -> Self {
   23     23   
        Default::default()
   24     24   
    }
   25     25   
   26     26   
    /// Omit the default `Content-Length` header during serialization
   27     27   
    pub(crate) fn omit_default_content_length(self) -> Self {
   28     28   
        Self {
   29     29   
            omit_default_content_length: true,
   30     30   
            ..self
   31     31   
        }
   32     32   
    }
   33     33   
   34     34   
    /// Omit the default `Content-Type` header during serialization
   35     35   
    pub(crate) fn omit_default_content_type(self) -> Self {
   36     36   
        Self {
   37     37   
            omit_default_content_type: true,
   38     38   
            ..self
   39     39   
        }
   40     40   
    }
   41     41   
   42     42   
    /// Returns true if the given default header name should be serialized
   43     43   
    fn include_header(&self, header: &HeaderName) -> bool {
   44     44   
        (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
   45     45   
    }
   46     46   
   47     47   
    /// Sets a default header on the given request builder if it should be serialized
   48         -
    pub(crate) fn set_default_header(&self, mut request: http::request::Builder, header_name: HeaderName, value: &str) -> http::request::Builder {
          48  +
    pub(crate) fn set_default_header(
          49  +
        &self,
          50  +
        mut request: http_1x::request::Builder,
          51  +
        header_name: HeaderName,
          52  +
        value: &str,
          53  +
    ) -> http_1x::request::Builder {
   49     54   
        if self.include_header(&header_name) {
   50     55   
            request = set_request_header_if_absent(request, header_name, value);
   51     56   
        }
   52     57   
        request
   53     58   
    }
   54     59   
}
   55     60   
   56     61   
impl Storable for HeaderSerializationSettings {
   57     62   
    type Storer = StoreReplace<Self>;
   58     63   
}