AWS SDK

AWS SDK

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5

Files changed:

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_initiate_multipart_upload.rs

@@ -103,103 +158,158 @@
  123    123   
                )
  124    124   
            })?,
  125    125   
        );
  126    126   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  127    127   
        output.build()
  128    128   
    })
  129    129   
}
  130    130   
  131    131   
pub fn ser_initiate_multipart_upload_headers(
  132    132   
    input: &crate::operation::initiate_multipart_upload::InitiateMultipartUploadInput,
  133         -
    mut builder: ::http::request::Builder,
  134         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         133  +
    mut builder: ::http_1x::request::Builder,
         134  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  135    135   
    if let ::std::option::Option::Some(inner_1) = &input.archive_description {
  136    136   
        let formatted_2 = inner_1.as_str();
  137    137   
        let header_value = formatted_2;
  138         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         138  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  139    139   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  140    140   
                "archive_description",
  141    141   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  142    142   
            )
  143    143   
        })?;
  144    144   
        builder = builder.header("x-amz-archive-description", header_value);
  145    145   
    }
  146    146   
    if let ::std::option::Option::Some(inner_3) = &input.part_size {
  147    147   
        let formatted_4 = inner_3.as_str();
  148    148   
        let header_value = formatted_4;
  149         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         149  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  150    150   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  151    151   
                "part_size",
  152    152   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  153    153   
            )
  154    154   
        })?;
  155    155   
        builder = builder.header("x-amz-part-size", header_value);
  156    156   
    }
  157    157   
    Ok(builder)
  158    158   
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_upload_archive.rs

@@ -106,106 +161,161 @@
  126    126   
            crate::protocol_serde::shape_upload_archive_output::de_location_header(_response_headers)
  127    127   
                .map_err(|_| crate::operation::upload_archive::UploadArchiveError::unhandled("Failed to parse location from header `Location"))?,
  128    128   
        );
  129    129   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  130    130   
        output.build()
  131    131   
    })
  132    132   
}
  133    133   
  134    134   
pub fn ser_upload_archive_headers(
  135    135   
    input: &crate::operation::upload_archive::UploadArchiveInput,
  136         -
    mut builder: ::http::request::Builder,
  137         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         136  +
    mut builder: ::http_1x::request::Builder,
         137  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  138    138   
    if let ::std::option::Option::Some(inner_1) = &input.archive_description {
  139    139   
        let formatted_2 = inner_1.as_str();
  140    140   
        let header_value = formatted_2;
  141         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         141  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  142    142   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  143    143   
                "archive_description",
  144    144   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  145    145   
            )
  146    146   
        })?;
  147    147   
        builder = builder.header("x-amz-archive-description", header_value);
  148    148   
    }
  149    149   
    if let ::std::option::Option::Some(inner_3) = &input.checksum {
  150    150   
        let formatted_4 = inner_3.as_str();
  151    151   
        let header_value = formatted_4;
  152         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         152  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  153    153   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  154    154   
                "checksum",
  155    155   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  156    156   
            )
  157    157   
        })?;
  158    158   
        builder = builder.header("x-amz-sha256-tree-hash", header_value);
  159    159   
    }
  160    160   
    Ok(builder)
  161    161   
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_upload_multipart_part.rs

@@ -105,105 +160,160 @@
  125    125   
                )
  126    126   
            })?,
  127    127   
        );
  128    128   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  129    129   
        output.build()
  130    130   
    })
  131    131   
}
  132    132   
  133    133   
pub fn ser_upload_multipart_part_headers(
  134    134   
    input: &crate::operation::upload_multipart_part::UploadMultipartPartInput,
  135         -
    mut builder: ::http::request::Builder,
  136         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         135  +
    mut builder: ::http_1x::request::Builder,
         136  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  137    137   
    if let ::std::option::Option::Some(inner_1) = &input.checksum {
  138    138   
        let formatted_2 = inner_1.as_str();
  139    139   
        let header_value = formatted_2;
  140         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         140  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  141    141   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  142    142   
                "checksum",
  143    143   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  144    144   
            )
  145    145   
        })?;
  146    146   
        builder = builder.header("x-amz-sha256-tree-hash", header_value);
  147    147   
    }
  148    148   
    if let ::std::option::Option::Some(inner_3) = &input.range {
  149    149   
        let formatted_4 = inner_3.as_str();
  150    150   
        let header_value = formatted_4;
  151         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         151  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  152    152   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  153    153   
                "range",
  154    154   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  155    155   
            )
  156    156   
        })?;
  157    157   
        builder = builder.header("Content-Range", header_value);
  158    158   
    }
  159    159   
    Ok(builder)
  160    160   
}

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

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

tmp-codegen-diff/aws-sdk/sdk/iam/Cargo.toml

@@ -1,1 +152,153 @@
   14     14   
protocol = "aws.protocols#awsQuery"
   15     15   
[package.metadata.docs.rs]
   16     16   
all-features = true
   17     17   
targets = ["x86_64-unknown-linux-gnu"]
   18     18   
[dependencies.aws-credential-types]
   19     19   
path = "../aws-credential-types"
   20     20   
version = "1.2.11"
   21     21   
   22     22   
[dependencies.aws-runtime]
   23     23   
path = "../aws-runtime"
   24         -
version = "1.5.18"
          24  +
version = "1.6.0"
   25     25   
   26     26   
[dependencies.aws-smithy-async]
   27     27   
path = "../aws-smithy-async"
   28         -
version = "1.2.7"
          28  +
version = "1.2.8"
   29     29   
   30     30   
[dependencies.aws-smithy-http]
   31     31   
path = "../aws-smithy-http"
   32         -
version = "0.62.6"
          32  +
version = "0.63.0"
   33     33   
   34     34   
[dependencies.aws-smithy-json]
   35     35   
path = "../aws-smithy-json"
   36         -
version = "0.61.9"
          36  +
version = "0.62.0"
   37     37   
   38     38   
[dependencies.aws-smithy-observability]
   39     39   
path = "../aws-smithy-observability"
   40         -
version = "0.2.0"
          40  +
version = "0.2.1"
   41     41   
   42     42   
[dependencies.aws-smithy-query]
   43     43   
path = "../aws-smithy-query"
   44         -
version = "0.60.9"
          44  +
version = "0.60.10"
   45     45   
   46     46   
[dependencies.aws-smithy-runtime]
   47     47   
path = "../aws-smithy-runtime"
   48     48   
features = ["client"]
   49         -
version = "1.9.8"
          49  +
version = "1.10.0"
   50     50   
   51     51   
[dependencies.aws-smithy-runtime-api]
   52     52   
path = "../aws-smithy-runtime-api"
   53         -
features = ["client", "http-02x"]
   54         -
version = "1.10.0"
          53  +
features = ["client", "http-1x"]
          54  +
version = "1.11.0"
   55     55   
   56     56   
[dependencies.aws-smithy-types]
   57     57   
path = "../aws-smithy-types"
   58         -
version = "1.3.6"
          58  +
features = ["http-body-1-x"]
          59  +
version = "1.4.0"
   59     60   
   60     61   
[dependencies.aws-smithy-xml]
   61     62   
path = "../aws-smithy-xml"
   62     63   
version = "0.60.13"
   63     64   
   64     65   
[dependencies.aws-types]
   65     66   
path = "../aws-types"
   66     67   
version = "1.3.11"
   67     68   
   68     69   
[dependencies.fastrand]
   69     70   
version = "2.0.0"
   70     71   
   71     72   
[dependencies.http]
   72     73   
version = "0.2.9"
   73     74   
          75  +
[dependencies.http-1x]
          76  +
version = "1"
          77  +
package = "http"
          78  +
   74     79   
[dependencies.regex-lite]
   75     80   
version = "0.1.5"
   76     81   
   77     82   
[dependencies.tracing]
   78     83   
version = "0.1"
   79     84   
[dev-dependencies.aws-config]
   80     85   
path = "../aws-config"
   81     86   
version = "1.8.12"
   82     87   
   83     88   
[dev-dependencies.aws-credential-types]
   84     89   
path = "../aws-credential-types"
   85     90   
features = ["test-util"]
   86     91   
version = "1.2.11"
   87     92   
   88     93   
[dev-dependencies.aws-runtime]
   89     94   
path = "../aws-runtime"
   90     95   
features = ["test-util"]
   91         -
version = "1.5.18"
          96  +
version = "1.6.0"
   92     97   
   93     98   
[dev-dependencies.aws-smithy-async]
   94     99   
path = "../aws-smithy-async"
   95    100   
features = ["test-util"]
   96         -
version = "1.2.7"
         101  +
version = "1.2.8"
   97    102   
   98    103   
[dev-dependencies.aws-smithy-http-client]
   99    104   
path = "../aws-smithy-http-client"
  100    105   
features = ["test-util", "wire-mock"]
  101         -
version = "1.1.5"
         106  +
version = "1.1.6"
  102    107   
  103    108   
[dev-dependencies.aws-smithy-protocol-test]
  104    109   
path = "../aws-smithy-protocol-test"
  105         -
version = "0.63.7"
         110  +
version = "0.63.8"
  106    111   
  107    112   
[dev-dependencies.aws-smithy-runtime]
  108    113   
path = "../aws-smithy-runtime"
  109    114   
features = ["test-util"]
  110         -
version = "1.9.8"
         115  +
version = "1.10.0"
  111    116   
  112    117   
[dev-dependencies.aws-smithy-runtime-api]
  113    118   
path = "../aws-smithy-runtime-api"
  114    119   
features = ["test-util"]
  115         -
version = "1.10.0"
         120  +
version = "1.11.0"
  116    121   
  117    122   
[dev-dependencies.aws-smithy-types]
  118    123   
path = "../aws-smithy-types"
  119         -
features = ["test-util"]
  120         -
version = "1.3.6"
         124  +
features = ["http-body-1-x", "test-util"]
         125  +
version = "1.4.0"
  121    126   
  122    127   
[dev-dependencies.futures-util]
  123    128   
version = "0.3.25"
  124    129   
features = ["alloc"]
  125    130   
default-features = false
  126    131   
  127         -
[dev-dependencies.http-1x]
  128         -
version = "1"
  129         -
package = "http"
  130         -
  131    132   
[dev-dependencies.proptest]
  132    133   
version = "1"
  133    134   
  134    135   
[dev-dependencies.serde_json]
  135    136   
version = "1.0.0"
  136    137   
  137    138   
[dev-dependencies.tokio]
  138    139   
version = "1.23.1"
  139    140   
features = ["macros", "test-util", "rt-multi-thread"]
  140    141

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/add_client_id_to_open_id_connect_provider.rs

@@ -175,175 +248,249 @@
  195    195   
                _input: &crate::operation::add_client_id_to_open_id_connect_provider::AddClientIdToOpenIdConnectProviderInput,
  196    196   
                output: &mut ::std::string::String,
  197    197   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  198    198   
                use ::std::fmt::Write as _;
  199    199   
                ::std::write!(output, "/").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::add_client_id_to_open_id_connect_provider::AddClientIdToOpenIdConnectProviderInput,
  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/x-www-form-urlencoded");
         211  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         212  +
            builder =
         213  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  213    214   
            builder
  214    215   
        };
  215    216   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_add_client_id_to_open_id_connect_provider_input::ser_add_client_id_to_open_id_connect_provider_input_input_input(&input)?);
  216    217   
        if let Some(content_length) = body.content_length() {
  217    218   
            let content_length = content_length.to_string();
  218         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         219  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  219    220   
        }
  220    221   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  221    222   
    }
  222    223   
}
  223    224   
#[derive(Debug)]
  224    225   
struct AddClientIDToOpenIDConnectProviderEndpointParamsInterceptor;
  225    226   
  226    227   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for AddClientIDToOpenIDConnectProviderEndpointParamsInterceptor {
  227    228   
    fn name(&self) -> &'static str {
  228    229   
        "AddClientIDToOpenIDConnectProviderEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/add_role_to_instance_profile.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/add_user_to_group.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/attach_group_policy.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/attach_role_policy.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/attach_user_policy.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/change_password.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/create_access_key.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/create_account_alias.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/create_group.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/create_instance_profile.rs

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