AWS SDK

AWS SDK

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5 (ignoring whitespace)

Files changed:

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"

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

@@ -187,187 +254,254 @@
  207    207   
                    .as_ref()
  208    208   
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("tag_keys", "cannot be empty or unset"))?;
  209    209   
                for inner_3 in inner_2 {
  210    210   
                    query.push_kv("tagKeys", &::aws_smithy_http::query::fmt_string(inner_3));
  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::untag_resource::UntagResourceInput,
  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("DELETE").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 UntagResourceEndpointParamsInterceptor;
  234    234

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

@@ -190,190 +263,263 @@
  210    210   
                    "/2015-03-31/functions/{FunctionName}/aliases/{Name}",
  211    211   
                    FunctionName = function_name,
  212    212   
                    Name = name
  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::update_alias::UpdateAliasInput,
  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("PUT").uri(uri))
  225    225   
            }
  226         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  227         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         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/json");
  228    228   
            builder
  229    229   
        };
  230    230   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_alias::ser_update_alias_input(&input)?);
  231    231   
        if let Some(content_length) = body.content_length() {
  232    232   
            let content_length = content_length.to_string();
  233         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         233  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  234    234   
        }
  235    235   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  236    236   
    }
  237    237   
}
  238    238   
#[derive(Debug)]
  239    239   
struct UpdateAliasEndpointParamsInterceptor;
  240    240   
  241    241   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateAliasEndpointParamsInterceptor {
  242    242   
    fn name(&self) -> &'static str {
  243    243   
        "UpdateAliasEndpointParamsInterceptor"

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

@@ -181,181 +256,256 @@
  201    201   
                    output,
  202    202   
                    "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}",
  203    203   
                    CodeSigningConfigArn = code_signing_config_arn
  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::update_code_signing_config::UpdateCodeSigningConfigInput,
  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_update_code_signing_config::ser_update_code_signing_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 UpdateCodeSigningConfigEndpointParamsInterceptor;
  233    233   
  234    234   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateCodeSigningConfigEndpointParamsInterceptor {
  235    235   
    fn name(&self) -> &'static str {
  236    236   
        "UpdateCodeSigningConfigEndpointParamsInterceptor"

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

@@ -176,176 +251,251 @@
  196    196   
                        "uuid",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/2015-03-31/event-source-mappings/{UUID}", UUID = uuid).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_event_source_mapping::UpdateEventSourceMappingInput,
  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("PUT").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(
  217    217   
            crate::protocol_serde::shape_update_event_source_mapping::ser_update_event_source_mapping_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 UpdateEventSourceMappingEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateEventSourceMappingEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "UpdateEventSourceMappingEndpointParamsInterceptor"

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

@@ -177,177 +251,251 @@
  197    197   
                        "function_name",
  198    198   
                        "cannot be empty or unset",
  199    199   
                    ));
  200    200   
                }
  201    201   
                ::std::write!(output, "/2015-03-31/functions/{FunctionName}/code", FunctionName = function_name).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::update_function_code::UpdateFunctionCodeInput,
  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 =
  218    218   
            ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_function_code::ser_update_function_code_input(&input)?);
  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 UpdateFunctionCodeEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateFunctionCodeEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "UpdateFunctionCodeEndpointParamsInterceptor"

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

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

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

@@ -201,201 +277,277 @@
  221    221   
                if let ::std::option::Option::Some(inner_2) = &_input.qualifier {
  222    222   
                    {
  223    223   
                        query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
  224    224   
                    }
  225    225   
                }
  226    226   
                ::std::result::Result::Ok(())
  227    227   
            }
  228    228   
            #[allow(clippy::unnecessary_wraps)]
  229    229   
            fn update_http_builder(
  230    230   
                input: &crate::operation::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigInput,
  231         -
                builder: ::http::request::Builder,
  232         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         231  +
                builder: ::http_1x::request::Builder,
         232  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  233    233   
                let mut uri = ::std::string::String::new();
  234    234   
                uri_base(input, &mut uri)?;
  235    235   
                uri_query(input, &mut uri)?;
  236    236   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  237    237   
            }
  238         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  239         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         238  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         239  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  240    240   
            builder
  241    241   
        };
  242    242   
        let body = ::aws_smithy_types::body::SdkBody::from(
  243    243   
            crate::protocol_serde::shape_update_function_event_invoke_config::ser_update_function_event_invoke_config_input(&input)?,
  244    244   
        );
  245    245   
        if let Some(content_length) = body.content_length() {
  246    246   
            let content_length = content_length.to_string();
  247         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         247  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  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 UpdateFunctionEventInvokeConfigEndpointParamsInterceptor;
  254    254   
  255    255   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateFunctionEventInvokeConfigEndpointParamsInterceptor {
  256    256   
    fn name(&self) -> &'static str {
  257    257   
        "UpdateFunctionEventInvokeConfigEndpointParamsInterceptor"

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

@@ -188,188 +264,264 @@
  208    208   
                if let ::std::option::Option::Some(inner_2) = &_input.qualifier {
  209    209   
                    {
  210    210   
                        query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
  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::update_function_url_config::UpdateFunctionUrlConfigInput,
  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("PUT").uri(uri))
  224    224   
            }
  225         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  226         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         225  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         226  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  227    227   
            builder
  228    228   
        };
  229    229   
        let body = ::aws_smithy_types::body::SdkBody::from(
  230    230   
            crate::protocol_serde::shape_update_function_url_config::ser_update_function_url_config_input(&input)?,
  231    231   
        );
  232    232   
        if let Some(content_length) = body.content_length() {
  233    233   
            let content_length = content_length.to_string();
  234         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         234  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  235    235   
        }
  236    236   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  237    237   
    }
  238    238   
}
  239    239   
#[derive(Debug)]
  240    240   
struct UpdateFunctionUrlConfigEndpointParamsInterceptor;
  241    241   
  242    242   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateFunctionUrlConfigEndpointParamsInterceptor {
  243    243   
    fn name(&self) -> &'static str {
  244    244   
        "UpdateFunctionUrlConfigEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_invoke.rs

@@ -498,498 +564,564 @@
  518    518   
        );
  519    519   
        output = output.set_payload(crate::protocol_serde::shape_invoke_output::de_payload_payload(_response_body)?);
  520    520   
        output = output.set_status_code(Some(_response_status as _));
  521    521   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  522    522   
        output.build()
  523    523   
    })
  524    524   
}
  525    525   
  526    526   
pub fn ser_invoke_headers(
  527    527   
    input: &crate::operation::invoke::InvokeInput,
  528         -
    mut builder: ::http::request::Builder,
  529         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         528  +
    mut builder: ::http_1x::request::Builder,
         529  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  530    530   
    if let ::std::option::Option::Some(inner_1) = &input.invocation_type {
  531    531   
        let formatted_2 = inner_1.as_str();
  532    532   
        let header_value = formatted_2;
  533         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         533  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  534    534   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  535    535   
                "invocation_type",
  536    536   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  537    537   
            )
  538    538   
        })?;
  539    539   
        builder = builder.header("X-Amz-Invocation-Type", header_value);
  540    540   
    }
  541    541   
    if let ::std::option::Option::Some(inner_3) = &input.log_type {
  542    542   
        let formatted_4 = inner_3.as_str();
  543    543   
        let header_value = formatted_4;
  544         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         544  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  545    545   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  546    546   
                "log_type",
  547    547   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  548    548   
            )
  549    549   
        })?;
  550    550   
        builder = builder.header("X-Amz-Log-Type", header_value);
  551    551   
    }
  552    552   
    if let ::std::option::Option::Some(inner_5) = &input.client_context {
  553    553   
        let formatted_6 = inner_5.as_str();
  554    554   
        let header_value = formatted_6;
  555         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         555  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  556    556   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  557    557   
                "client_context",
  558    558   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  559    559   
            )
  560    560   
        })?;
  561    561   
        builder = builder.header("X-Amz-Client-Context", header_value);
  562    562   
    }
  563    563   
    Ok(builder)
  564    564   
}