AWS SDK

AWS SDK

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5

Files changed:

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/list_layer_versions.rs

@@ -203,203 +270,270 @@
  223    223   
                if let ::std::option::Option::Some(inner_5) = &_input.compatible_architecture {
  224    224   
                    {
  225    225   
                        query.push_kv("CompatibleArchitecture", &::aws_smithy_http::query::fmt_string(inner_5));
  226    226   
                    }
  227    227   
                }
  228    228   
                ::std::result::Result::Ok(())
  229    229   
            }
  230    230   
            #[allow(clippy::unnecessary_wraps)]
  231    231   
            fn update_http_builder(
  232    232   
                input: &crate::operation::list_layer_versions::ListLayerVersionsInput,
  233         -
                builder: ::http::request::Builder,
  234         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         233  +
                builder: ::http_1x::request::Builder,
         234  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  235    235   
                let mut uri = ::std::string::String::new();
  236    236   
                uri_base(input, &mut uri)?;
  237    237   
                uri_query(input, &mut uri)?;
  238    238   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  239    239   
            }
  240         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         240  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  241    241   
            builder
  242    242   
        };
  243    243   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  244    244   
  245    245   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  246    246   
    }
  247    247   
}
  248    248   
#[derive(Debug)]
  249    249   
struct ListLayerVersionsEndpointParamsInterceptor;
  250    250

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/list_layers.rs

@@ -187,187 +254,254 @@
  207    207   
                if let ::std::option::Option::Some(inner_4) = &_input.compatible_architecture {
  208    208   
                    {
  209    209   
                        query.push_kv("CompatibleArchitecture", &::aws_smithy_http::query::fmt_string(inner_4));
  210    210   
                    }
  211    211   
                }
  212    212   
                ::std::result::Result::Ok(())
  213    213   
            }
  214    214   
            #[allow(clippy::unnecessary_wraps)]
  215    215   
            fn update_http_builder(
  216    216   
                input: &crate::operation::list_layers::ListLayersInput,
  217         -
                builder: ::http::request::Builder,
  218         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         217  +
                builder: ::http_1x::request::Builder,
         218  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  219    219   
                let mut uri = ::std::string::String::new();
  220    220   
                uri_base(input, &mut uri)?;
  221    221   
                uri_query(input, &mut uri)?;
  222    222   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  223    223   
            }
  224         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         224  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  225    225   
            builder
  226    226   
        };
  227    227   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  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 ListLayersEndpointParamsInterceptor;
  234    234

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/list_provisioned_concurrency_configs.rs

@@ -209,209 +276,276 @@
  229    229   
                if let ::std::option::Option::Some(inner_3) = &_input.max_items {
  230    230   
                    {
  231    231   
                        query.push_kv("MaxItems", ::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_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsInput,
  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 ListProvisionedConcurrencyConfigsEndpointParamsInterceptor;
  256    256

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/list_tags.rs

@@ -167,167 +233,233 @@
  187    187   
                        "resource",
  188    188   
                        "cannot be empty or unset",
  189    189   
                    ));
  190    190   
                }
  191    191   
                ::std::write!(output, "/2017-03-31/tags/{Resource}", Resource = resource).expect("formatting should succeed");
  192    192   
                ::std::result::Result::Ok(())
  193    193   
            }
  194    194   
            #[allow(clippy::unnecessary_wraps)]
  195    195   
            fn update_http_builder(
  196    196   
                input: &crate::operation::list_tags::ListTagsInput,
  197         -
                builder: ::http::request::Builder,
  198         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         197  +
                builder: ::http_1x::request::Builder,
         198  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  199    199   
                let mut uri = ::std::string::String::new();
  200    200   
                uri_base(input, &mut uri)?;
  201    201   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  202    202   
            }
  203         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         203  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  204    204   
            builder
  205    205   
        };
  206    206   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  207    207   
  208    208   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  209    209   
    }
  210    210   
}
  211    211   
#[derive(Debug)]
  212    212   
struct ListTagsEndpointParamsInterceptor;
  213    213

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/list_versions_by_function.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/publish_layer_version.rs

@@ -176,176 +251,251 @@
  196    196   
                        "layer_name",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/2018-10-31/layers/{LayerName}/versions", LayerName = layer_name).expect("formatting should succeed");
  201    201   
                ::std::result::Result::Ok(())
  202    202   
            }
  203    203   
            #[allow(clippy::unnecessary_wraps)]
  204    204   
            fn update_http_builder(
  205    205   
                input: &crate::operation::publish_layer_version::PublishLayerVersionInput,
  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/json");
         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/json");
  214    214   
            builder
  215    215   
        };
  216    216   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_publish_layer_version::ser_publish_layer_version_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 PublishLayerVersionEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PublishLayerVersionEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "PublishLayerVersionEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/publish_version.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/put_function_code_signing_config.rs

@@ -187,187 +262,262 @@
  207    207   
                    output,
  208    208   
                    "/2020-06-30/functions/{FunctionName}/code-signing-config",
  209    209   
                    FunctionName = function_name
  210    210   
                )
  211    211   
                .expect("formatting should succeed");
  212    212   
                ::std::result::Result::Ok(())
  213    213   
            }
  214    214   
            #[allow(clippy::unnecessary_wraps)]
  215    215   
            fn update_http_builder(
  216    216   
                input: &crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigInput,
  217         -
                builder: ::http::request::Builder,
  218         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         217  +
                builder: ::http_1x::request::Builder,
         218  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  219    219   
                let mut uri = ::std::string::String::new();
  220    220   
                uri_base(input, &mut uri)?;
  221    221   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  222    222   
            }
  223         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  224         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         223  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         224  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  225    225   
            builder
  226    226   
        };
  227    227   
        let body = ::aws_smithy_types::body::SdkBody::from(
  228    228   
            crate::protocol_serde::shape_put_function_code_signing_config::ser_put_function_code_signing_config_input(&input)?,
  229    229   
        );
  230    230   
        if let Some(content_length) = body.content_length() {
  231    231   
            let content_length = content_length.to_string();
  232         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         232  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  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 PutFunctionCodeSigningConfigEndpointParamsInterceptor;
  239    239   
  240    240   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutFunctionCodeSigningConfigEndpointParamsInterceptor {
  241    241   
    fn name(&self) -> &'static str {
  242    242   
        "PutFunctionCodeSigningConfigEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/put_function_concurrency.rs

@@ -177,177 +252,252 @@
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/2017-10-31/functions/{FunctionName}/concurrency", FunctionName = function_name)
  201    201   
                    .expect("formatting should succeed");
  202    202   
                ::std::result::Result::Ok(())
  203    203   
            }
  204    204   
            #[allow(clippy::unnecessary_wraps)]
  205    205   
            fn update_http_builder(
  206    206   
                input: &crate::operation::put_function_concurrency::PutFunctionConcurrencyInput,
  207         -
                builder: ::http::request::Builder,
  208         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         207  +
                builder: ::http_1x::request::Builder,
         208  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  209    209   
                let mut uri = ::std::string::String::new();
  210    210   
                uri_base(input, &mut uri)?;
  211    211   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  212    212   
            }
  213         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  214         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         213  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         214  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  215    215   
            builder
  216    216   
        };
  217    217   
        let body = ::aws_smithy_types::body::SdkBody::from(
  218    218   
            crate::protocol_serde::shape_put_function_concurrency::ser_put_function_concurrency_input(&input)?,
  219    219   
        );
  220    220   
        if let Some(content_length) = body.content_length() {
  221    221   
            let content_length = content_length.to_string();
  222         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         222  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  223    223   
        }
  224    224   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  225    225   
    }
  226    226   
}
  227    227   
#[derive(Debug)]
  228    228   
struct PutFunctionConcurrencyEndpointParamsInterceptor;
  229    229   
  230    230   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutFunctionConcurrencyEndpointParamsInterceptor {
  231    231   
    fn name(&self) -> &'static str {
  232    232   
        "PutFunctionConcurrencyEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/put_function_event_invoke_config.rs

@@ -199,199 +275,275 @@
  219    219   
                if let ::std::option::Option::Some(inner_2) = &_input.qualifier {
  220    220   
                    {
  221    221   
                        query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
  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::put_function_event_invoke_config::PutFunctionEventInvokeConfigInput,
  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("PUT").uri(uri))
  235    235   
            }
  236         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  237         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         236  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         237  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  238    238   
            builder
  239    239   
        };
  240    240   
        let body = ::aws_smithy_types::body::SdkBody::from(
  241    241   
            crate::protocol_serde::shape_put_function_event_invoke_config::ser_put_function_event_invoke_config_input(&input)?,
  242    242   
        );
  243    243   
        if let Some(content_length) = body.content_length() {
  244    244   
            let content_length = content_length.to_string();
  245         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         245  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  246    246   
        }
  247    247   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  248    248   
    }
  249    249   
}
  250    250   
#[derive(Debug)]
  251    251   
struct PutFunctionEventInvokeConfigEndpointParamsInterceptor;
  252    252   
  253    253   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutFunctionEventInvokeConfigEndpointParamsInterceptor {
  254    254   
    fn name(&self) -> &'static str {
  255    255   
        "PutFunctionEventInvokeConfigEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/put_function_recursion_config.rs

@@ -181,181 +256,256 @@
  201    201   
                    output,
  202    202   
                    "/2024-08-31/functions/{FunctionName}/recursion-config",
  203    203   
                    FunctionName = function_name
  204    204   
                )
  205    205   
                .expect("formatting should succeed");
  206    206   
                ::std::result::Result::Ok(())
  207    207   
            }
  208    208   
            #[allow(clippy::unnecessary_wraps)]
  209    209   
            fn update_http_builder(
  210    210   
                input: &crate::operation::put_function_recursion_config::PutFunctionRecursionConfigInput,
  211         -
                builder: ::http::request::Builder,
  212         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         211  +
                builder: ::http_1x::request::Builder,
         212  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  213    213   
                let mut uri = ::std::string::String::new();
  214    214   
                uri_base(input, &mut uri)?;
  215    215   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  216    216   
            }
  217         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  218         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         217  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         218  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  219    219   
            builder
  220    220   
        };
  221    221   
        let body = ::aws_smithy_types::body::SdkBody::from(
  222    222   
            crate::protocol_serde::shape_put_function_recursion_config::ser_put_function_recursion_config_input(&input)?,
  223    223   
        );
  224    224   
        if let Some(content_length) = body.content_length() {
  225    225   
            let content_length = content_length.to_string();
  226         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         226  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  227    227   
        }
  228    228   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  229    229   
    }
  230    230   
}
  231    231   
#[derive(Debug)]
  232    232   
struct PutFunctionRecursionConfigEndpointParamsInterceptor;
  233    233   
  234    234   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutFunctionRecursionConfigEndpointParamsInterceptor {
  235    235   
    fn name(&self) -> &'static str {
  236    236   
        "PutFunctionRecursionConfigEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/put_provisioned_concurrency_config.rs

@@ -207,207 +283,283 @@
  227    227   
                        "qualifier",
  228    228   
                        "cannot be empty or unset",
  229    229   
                    ));
  230    230   
                }
  231    231   
                query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
  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::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigInput,
  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("PUT").uri(uri))
  243    243   
            }
  244         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  245         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         244  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         245  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  246    246   
            builder
  247    247   
        };
  248    248   
        let body = ::aws_smithy_types::body::SdkBody::from(
  249    249   
            crate::protocol_serde::shape_put_provisioned_concurrency_config::ser_put_provisioned_concurrency_config_input(&input)?,
  250    250   
        );
  251    251   
        if let Some(content_length) = body.content_length() {
  252    252   
            let content_length = content_length.to_string();
  253         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         253  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  254    254   
        }
  255    255   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  256    256   
    }
  257    257   
}
  258    258   
#[derive(Debug)]
  259    259   
struct PutProvisionedConcurrencyConfigEndpointParamsInterceptor;
  260    260   
  261    261   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutProvisionedConcurrencyConfigEndpointParamsInterceptor {
  262    262   
    fn name(&self) -> &'static str {
  263    263   
        "PutProvisionedConcurrencyConfigEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/put_runtime_management_config.rs

@@ -193,193 +269,269 @@
  213    213   
                if let ::std::option::Option::Some(inner_2) = &_input.qualifier {
  214    214   
                    {
  215    215   
                        query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
  216    216   
                    }
  217    217   
                }
  218    218   
                ::std::result::Result::Ok(())
  219    219   
            }
  220    220   
            #[allow(clippy::unnecessary_wraps)]
  221    221   
            fn update_http_builder(
  222    222   
                input: &crate::operation::put_runtime_management_config::PutRuntimeManagementConfigInput,
  223         -
                builder: ::http::request::Builder,
  224         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         223  +
                builder: ::http_1x::request::Builder,
         224  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  225    225   
                let mut uri = ::std::string::String::new();
  226    226   
                uri_base(input, &mut uri)?;
  227    227   
                uri_query(input, &mut uri)?;
  228    228   
                ::std::result::Result::Ok(builder.method("PUT").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/json");
         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/json");
  232    232   
            builder
  233    233   
        };
  234    234   
        let body = ::aws_smithy_types::body::SdkBody::from(
  235    235   
            crate::protocol_serde::shape_put_runtime_management_config::ser_put_runtime_management_config_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 PutRuntimeManagementConfigEndpointParamsInterceptor;
  246    246   
  247    247   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutRuntimeManagementConfigEndpointParamsInterceptor {
  248    248   
    fn name(&self) -> &'static str {
  249    249   
        "PutRuntimeManagementConfigEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/remove_layer_version_permission.rs

@@ -224,224 +291,291 @@
  244    244   
                if let ::std::option::Option::Some(inner_4) = &_input.revision_id {
  245    245   
                    {
  246    246   
                        query.push_kv("RevisionId", &::aws_smithy_http::query::fmt_string(inner_4));
  247    247   
                    }
  248    248   
                }
  249    249   
                ::std::result::Result::Ok(())
  250    250   
            }
  251    251   
            #[allow(clippy::unnecessary_wraps)]
  252    252   
            fn update_http_builder(
  253    253   
                input: &crate::operation::remove_layer_version_permission::RemoveLayerVersionPermissionInput,
  254         -
                builder: ::http::request::Builder,
  255         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         254  +
                builder: ::http_1x::request::Builder,
         255  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  256    256   
                let mut uri = ::std::string::String::new();
  257    257   
                uri_base(input, &mut uri)?;
  258    258   
                uri_query(input, &mut uri)?;
  259    259   
                ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
  260    260   
            }
  261         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         261  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  262    262   
            builder
  263    263   
        };
  264    264   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  265    265   
  266    266   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  267    267   
    }
  268    268   
}
  269    269   
#[derive(Debug)]
  270    270   
struct RemoveLayerVersionPermissionEndpointParamsInterceptor;
  271    271

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/remove_permission.rs

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

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

@@ -173,173 +246,246 @@
  193    193   
                        "resource",
  194    194   
                        "cannot be empty or unset",
  195    195   
                    ));
  196    196   
                }
  197    197   
                ::std::write!(output, "/2017-03-31/tags/{Resource}", Resource = resource).expect("formatting should succeed");
  198    198   
                ::std::result::Result::Ok(())
  199    199   
            }
  200    200   
            #[allow(clippy::unnecessary_wraps)]
  201    201   
            fn update_http_builder(
  202    202   
                input: &crate::operation::tag_resource::TagResourceInput,
  203         -
                builder: ::http::request::Builder,
  204         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         203  +
                builder: ::http_1x::request::Builder,
         204  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  205    205   
                let mut uri = ::std::string::String::new();
  206    206   
                uri_base(input, &mut uri)?;
  207    207   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  208    208   
            }
  209         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  210         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         209  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         210  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  211    211   
            builder
  212    212   
        };
  213    213   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_tag_resource::ser_tag_resource_input(&input)?);
  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 TagResourceEndpointParamsInterceptor;
  223    223   
  224    224   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TagResourceEndpointParamsInterceptor {
  225    225   
    fn name(&self) -> &'static str {
  226    226   
        "TagResourceEndpointParamsInterceptor"