AWS SDK

AWS SDK

rev. 03e6e47f15dfd569240d570d98975ebba692c405

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_update_bucket_metadata_journal_table_configuration.rs

@@ -11,11 +77,77 @@
   31     31   
        #[allow(unused_mut)]
   32     32   
        let mut output = crate::operation::update_bucket_metadata_journal_table_configuration::builders::UpdateBucketMetadataJournalTableConfigurationOutputBuilder::default();
   33     33   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   34     34   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   35     35   
        output.build()
   36     36   
    })
   37     37   
}
   38     38   
   39     39   
pub fn ser_update_bucket_metadata_journal_table_configuration_headers(
   40     40   
    input: &crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationInput,
   41         -
    mut builder: ::http::request::Builder,
   42         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          41  +
    mut builder: ::http_1x::request::Builder,
          42  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   43     43   
    if let ::std::option::Option::Some(inner_1) = &input.content_md5 {
   44     44   
        let formatted_2 = inner_1.as_str();
   45     45   
        let header_value = formatted_2;
   46         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          46  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   47     47   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   48     48   
                "content_md5",
   49     49   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   50     50   
            )
   51     51   
        })?;
   52     52   
        builder = builder.header("Content-MD5", header_value);
   53     53   
    }
   54     54   
    if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
   55     55   
        let formatted_4 = inner_3.as_str();
   56     56   
        let header_value = formatted_4;
   57         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          57  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   58     58   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   59     59   
                "checksum_algorithm",
   60     60   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   61     61   
            )
   62     62   
        })?;
   63     63   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   64     64   
    }
   65     65   
    if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
   66     66   
        let formatted_6 = inner_5.as_str();
   67     67   
        let header_value = formatted_6;
   68         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          68  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   69     69   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   70     70   
                "expected_bucket_owner",
   71     71   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   72     72   
            )
   73     73   
        })?;
   74     74   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   75     75   
    }
   76     76   
    Ok(builder)
   77     77   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_upload_part.rs

@@ -73,73 +250,250 @@
   93     93   
            })?,
   94     94   
        );
   95     95   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   96     96   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   97     97   
        output.build()
   98     98   
    })
   99     99   
}
  100    100   
  101    101   
pub fn ser_upload_part_headers(
  102    102   
    input: &crate::operation::upload_part::UploadPartInput,
  103         -
    mut builder: ::http::request::Builder,
  104         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         103  +
    mut builder: ::http_1x::request::Builder,
         104  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  105    105   
    if let ::std::option::Option::Some(inner_1) = &input.content_length {
  106    106   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
  107    107   
        let formatted_2 = encoder.encode();
  108    108   
        let header_value = formatted_2;
  109         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         109  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  110    110   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  111    111   
                "content_length",
  112    112   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  113    113   
            )
  114    114   
        })?;
  115    115   
        builder = builder.header("Content-Length", header_value);
  116    116   
    }
  117    117   
    if let ::std::option::Option::Some(inner_3) = &input.content_md5 {
  118    118   
        let formatted_4 = inner_3.as_str();
  119    119   
        let header_value = formatted_4;
  120         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         120  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  121    121   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  122    122   
                "content_md5",
  123    123   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  124    124   
            )
  125    125   
        })?;
  126    126   
        builder = builder.header("Content-MD5", header_value);
  127    127   
    }
  128    128   
    if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
  129    129   
        let formatted_6 = inner_5.as_str();
  130    130   
        let header_value = formatted_6;
  131         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         131  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  132    132   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  133    133   
                "checksum_algorithm",
  134    134   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  135    135   
            )
  136    136   
        })?;
  137    137   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
  138    138   
    }
  139    139   
    if let ::std::option::Option::Some(inner_7) = &input.checksum_crc32 {
  140    140   
        let formatted_8 = inner_7.as_str();
  141    141   
        let header_value = formatted_8;
  142         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         142  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  143    143   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  144    144   
                "checksum_crc32",
  145    145   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  146    146   
            )
  147    147   
        })?;
  148    148   
        builder = builder.header("x-amz-checksum-crc32", header_value);
  149    149   
    }
  150    150   
    if let ::std::option::Option::Some(inner_9) = &input.checksum_crc32_c {
  151    151   
        let formatted_10 = inner_9.as_str();
  152    152   
        let header_value = formatted_10;
  153         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         153  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  154    154   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  155    155   
                "checksum_crc32_c",
  156    156   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  157    157   
            )
  158    158   
        })?;
  159    159   
        builder = builder.header("x-amz-checksum-crc32c", header_value);
  160    160   
    }
  161    161   
    if let ::std::option::Option::Some(inner_11) = &input.checksum_crc64_nvme {
  162    162   
        let formatted_12 = inner_11.as_str();
  163    163   
        let header_value = formatted_12;
  164         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         164  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  165    165   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  166    166   
                "checksum_crc64_nvme",
  167    167   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  168    168   
            )
  169    169   
        })?;
  170    170   
        builder = builder.header("x-amz-checksum-crc64nvme", header_value);
  171    171   
    }
  172    172   
    if let ::std::option::Option::Some(inner_13) = &input.checksum_sha1 {
  173    173   
        let formatted_14 = inner_13.as_str();
  174    174   
        let header_value = formatted_14;
  175         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         175  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  176    176   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  177    177   
                "checksum_sha1",
  178    178   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  179    179   
            )
  180    180   
        })?;
  181    181   
        builder = builder.header("x-amz-checksum-sha1", header_value);
  182    182   
    }
  183    183   
    if let ::std::option::Option::Some(inner_15) = &input.checksum_sha256 {
  184    184   
        let formatted_16 = inner_15.as_str();
  185    185   
        let header_value = formatted_16;
  186         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         186  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  187    187   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  188    188   
                "checksum_sha256",
  189    189   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  190    190   
            )
  191    191   
        })?;
  192    192   
        builder = builder.header("x-amz-checksum-sha256", header_value);
  193    193   
    }
  194    194   
    if let ::std::option::Option::Some(inner_17) = &input.sse_customer_algorithm {
  195    195   
        let formatted_18 = inner_17.as_str();
  196    196   
        let header_value = formatted_18;
  197         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         197  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  198    198   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  199    199   
                "sse_customer_algorithm",
  200    200   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  201    201   
            )
  202    202   
        })?;
  203    203   
        builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
  204    204   
    }
  205    205   
    if let ::std::option::Option::Some(inner_19) = &input.sse_customer_key {
  206    206   
        let formatted_20 = inner_19.as_str();
  207    207   
        let header_value = formatted_20;
  208         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         208  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  209    209   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  210    210   
                "sse_customer_key",
  211    211   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  212    212   
            )
  213    213   
        })?;
  214    214   
        builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
  215    215   
    }
  216    216   
    if let ::std::option::Option::Some(inner_21) = &input.sse_customer_key_md5 {
  217    217   
        let formatted_22 = inner_21.as_str();
  218    218   
        let header_value = formatted_22;
  219         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         219  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  220    220   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  221    221   
                "sse_customer_key_md5",
  222    222   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  223    223   
            )
  224    224   
        })?;
  225    225   
        builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  226    226   
    }
  227    227   
    if let ::std::option::Option::Some(inner_23) = &input.request_payer {
  228    228   
        let formatted_24 = inner_23.as_str();
  229    229   
        let header_value = formatted_24;
  230         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         230  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  231    231   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  232    232   
                "request_payer",
  233    233   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  234    234   
            )
  235    235   
        })?;
  236    236   
        builder = builder.header("x-amz-request-payer", header_value);
  237    237   
    }
  238    238   
    if let ::std::option::Option::Some(inner_25) = &input.expected_bucket_owner {
  239    239   
        let formatted_26 = inner_25.as_str();
  240    240   
        let header_value = formatted_26;
  241         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         241  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  242    242   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  243    243   
                "expected_bucket_owner",
  244    244   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  245    245   
            )
  246    246   
        })?;
  247    247   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  248    248   
    }
  249    249   
    Ok(builder)
  250    250   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_upload_part_copy.rs

@@ -56,56 +254,254 @@
   76     76   
            })?,
   77     77   
        );
   78     78   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   79     79   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   80     80   
        output.build()
   81     81   
    })
   82     82   
}
   83     83   
   84     84   
pub fn ser_upload_part_copy_headers(
   85     85   
    input: &crate::operation::upload_part_copy::UploadPartCopyInput,
   86         -
    mut builder: ::http::request::Builder,
   87         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          86  +
    mut builder: ::http_1x::request::Builder,
          87  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   88     88   
    if let ::std::option::Option::Some(inner_1) = &input.copy_source {
   89     89   
        let formatted_2 = inner_1.as_str();
   90     90   
        let header_value = formatted_2;
   91         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          91  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   92     92   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   93     93   
                "copy_source",
   94     94   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   95     95   
            )
   96     96   
        })?;
   97     97   
        builder = builder.header("x-amz-copy-source", header_value);
   98     98   
    }
   99     99   
    if let ::std::option::Option::Some(inner_3) = &input.copy_source_if_match {
  100    100   
        let formatted_4 = inner_3.as_str();
  101    101   
        let header_value = formatted_4;
  102         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         102  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  103    103   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  104    104   
                "copy_source_if_match",
  105    105   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  106    106   
            )
  107    107   
        })?;
  108    108   
        builder = builder.header("x-amz-copy-source-if-match", header_value);
  109    109   
    }
  110    110   
    if let ::std::option::Option::Some(inner_5) = &input.copy_source_if_modified_since {
  111    111   
        let formatted_6 = inner_5.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  112    112   
        let header_value = formatted_6;
  113         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         113  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  114    114   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  115    115   
                "copy_source_if_modified_since",
  116    116   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  117    117   
            )
  118    118   
        })?;
  119    119   
        builder = builder.header("x-amz-copy-source-if-modified-since", header_value);
  120    120   
    }
  121    121   
    if let ::std::option::Option::Some(inner_7) = &input.copy_source_if_none_match {
  122    122   
        let formatted_8 = inner_7.as_str();
  123    123   
        let header_value = formatted_8;
  124         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         124  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  125    125   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  126    126   
                "copy_source_if_none_match",
  127    127   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  128    128   
            )
  129    129   
        })?;
  130    130   
        builder = builder.header("x-amz-copy-source-if-none-match", header_value);
  131    131   
    }
  132    132   
    if let ::std::option::Option::Some(inner_9) = &input.copy_source_if_unmodified_since {
  133    133   
        let formatted_10 = inner_9.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  134    134   
        let header_value = formatted_10;
  135         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         135  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  136    136   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  137    137   
                "copy_source_if_unmodified_since",
  138    138   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  139    139   
            )
  140    140   
        })?;
  141    141   
        builder = builder.header("x-amz-copy-source-if-unmodified-since", header_value);
  142    142   
    }
  143    143   
    if let ::std::option::Option::Some(inner_11) = &input.copy_source_range {
  144    144   
        let formatted_12 = inner_11.as_str();
  145    145   
        let header_value = formatted_12;
  146         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         146  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  147    147   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  148    148   
                "copy_source_range",
  149    149   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  150    150   
            )
  151    151   
        })?;
  152    152   
        builder = builder.header("x-amz-copy-source-range", header_value);
  153    153   
    }
  154    154   
    if let ::std::option::Option::Some(inner_13) = &input.sse_customer_algorithm {
  155    155   
        let formatted_14 = inner_13.as_str();
  156    156   
        let header_value = formatted_14;
  157         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         157  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  158    158   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  159    159   
                "sse_customer_algorithm",
  160    160   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  161    161   
            )
  162    162   
        })?;
  163    163   
        builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
  164    164   
    }
  165    165   
    if let ::std::option::Option::Some(inner_15) = &input.sse_customer_key {
  166    166   
        let formatted_16 = inner_15.as_str();
  167    167   
        let header_value = formatted_16;
  168         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         168  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  169    169   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  170    170   
                "sse_customer_key",
  171    171   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  172    172   
            )
  173    173   
        })?;
  174    174   
        builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
  175    175   
    }
  176    176   
    if let ::std::option::Option::Some(inner_17) = &input.sse_customer_key_md5 {
  177    177   
        let formatted_18 = inner_17.as_str();
  178    178   
        let header_value = formatted_18;
  179         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         179  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  180    180   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  181    181   
                "sse_customer_key_md5",
  182    182   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  183    183   
            )
  184    184   
        })?;
  185    185   
        builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  186    186   
    }
  187    187   
    if let ::std::option::Option::Some(inner_19) = &input.copy_source_sse_customer_algorithm {
  188    188   
        let formatted_20 = inner_19.as_str();
  189    189   
        let header_value = formatted_20;
  190         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         190  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  191    191   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  192    192   
                "copy_source_sse_customer_algorithm",
  193    193   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  194    194   
            )
  195    195   
        })?;
  196    196   
        builder = builder.header("x-amz-copy-source-server-side-encryption-customer-algorithm", header_value);
  197    197   
    }
  198    198   
    if let ::std::option::Option::Some(inner_21) = &input.copy_source_sse_customer_key {
  199    199   
        let formatted_22 = inner_21.as_str();
  200    200   
        let header_value = formatted_22;
  201         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         201  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  202    202   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  203    203   
                "copy_source_sse_customer_key",
  204    204   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  205    205   
            )
  206    206   
        })?;
  207    207   
        builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key", header_value);
  208    208   
    }
  209    209   
    if let ::std::option::Option::Some(inner_23) = &input.copy_source_sse_customer_key_md5 {
  210    210   
        let formatted_24 = inner_23.as_str();
  211    211   
        let header_value = formatted_24;
  212         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         212  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  213    213   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  214    214   
                "copy_source_sse_customer_key_md5",
  215    215   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  216    216   
            )
  217    217   
        })?;
  218    218   
        builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key-MD5", header_value);
  219    219   
    }
  220    220   
    if let ::std::option::Option::Some(inner_25) = &input.request_payer {
  221    221   
        let formatted_26 = inner_25.as_str();
  222    222   
        let header_value = formatted_26;
  223         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         223  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  224    224   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  225    225   
                "request_payer",
  226    226   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  227    227   
            )
  228    228   
        })?;
  229    229   
        builder = builder.header("x-amz-request-payer", header_value);
  230    230   
    }
  231    231   
    if let ::std::option::Option::Some(inner_27) = &input.expected_bucket_owner {
  232    232   
        let formatted_28 = inner_27.as_str();
  233    233   
        let header_value = formatted_28;
  234         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         234  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  235    235   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  236    236   
                "expected_bucket_owner",
  237    237   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  238    238   
            )
  239    239   
        })?;
  240    240   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  241    241   
    }
  242    242   
    if let ::std::option::Option::Some(inner_29) = &input.expected_source_bucket_owner {
  243    243   
        let formatted_30 = inner_29.as_str();
  244    244   
        let header_value = formatted_30;
  245         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         245  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  246    246   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  247    247   
                "expected_source_bucket_owner",
  248    248   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  249    249   
            )
  250    250   
        })?;
  251    251   
        builder = builder.header("x-amz-source-expected-bucket-owner", header_value);
  252    252   
    }
  253    253   
    Ok(builder)
  254    254   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_write_get_object_response.rs

@@ -10,10 +500,500 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::write_get_object_response::builders::WriteGetObjectResponseOutputBuilder::default();
   32     32   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   33     33   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   34     34   
        output.build()
   35     35   
    })
   36     36   
}
   37     37   
   38     38   
pub fn ser_write_get_object_response_headers(
   39     39   
    input: &crate::operation::write_get_object_response::WriteGetObjectResponseInput,
   40         -
    mut builder: ::http::request::Builder,
   41         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          40  +
    mut builder: ::http_1x::request::Builder,
          41  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   42     42   
    if let ::std::option::Option::Some(inner_1) = &input.request_route {
   43     43   
        let formatted_2 = inner_1.as_str();
   44     44   
        let header_value = formatted_2;
   45         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          45  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   46     46   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   47     47   
                "request_route",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("x-amz-request-route", header_value);
   52     52   
    }
   53     53   
    if let ::std::option::Option::Some(inner_3) = &input.request_token {
   54     54   
        let formatted_4 = inner_3.as_str();
   55     55   
        let header_value = formatted_4;
   56         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          56  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   57     57   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   58     58   
                "request_token",
   59     59   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   60     60   
            )
   61     61   
        })?;
   62     62   
        builder = builder.header("x-amz-request-token", header_value);
   63     63   
    }
   64     64   
    if let ::std::option::Option::Some(inner_5) = &input.status_code {
   65     65   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
   66     66   
        let formatted_6 = encoder.encode();
   67     67   
        let header_value = formatted_6;
   68         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          68  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   69     69   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   70     70   
                "status_code",
   71     71   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   72     72   
            )
   73     73   
        })?;
   74     74   
        builder = builder.header("x-amz-fwd-status", header_value);
   75     75   
    }
   76     76   
    if let ::std::option::Option::Some(inner_7) = &input.error_code {
   77     77   
        let formatted_8 = inner_7.as_str();
   78     78   
        let header_value = formatted_8;
   79         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          79  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   80     80   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   81     81   
                "error_code",
   82     82   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   83     83   
            )
   84     84   
        })?;
   85     85   
        builder = builder.header("x-amz-fwd-error-code", header_value);
   86     86   
    }
   87     87   
    if let ::std::option::Option::Some(inner_9) = &input.error_message {
   88     88   
        let formatted_10 = inner_9.as_str();
   89     89   
        let header_value = formatted_10;
   90         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          90  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   91     91   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   92     92   
                "error_message",
   93     93   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   94     94   
            )
   95     95   
        })?;
   96     96   
        builder = builder.header("x-amz-fwd-error-message", header_value);
   97     97   
    }
   98     98   
    if let ::std::option::Option::Some(inner_11) = &input.accept_ranges {
   99     99   
        let formatted_12 = inner_11.as_str();
  100    100   
        let header_value = formatted_12;
  101         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         101  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  102    102   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  103    103   
                "accept_ranges",
  104    104   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  105    105   
            )
  106    106   
        })?;
  107    107   
        builder = builder.header("x-amz-fwd-header-accept-ranges", header_value);
  108    108   
    }
  109    109   
    if let ::std::option::Option::Some(inner_13) = &input.cache_control {
  110    110   
        let formatted_14 = inner_13.as_str();
  111    111   
        let header_value = formatted_14;
  112         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         112  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  113    113   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  114    114   
                "cache_control",
  115    115   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  116    116   
            )
  117    117   
        })?;
  118    118   
        builder = builder.header("x-amz-fwd-header-Cache-Control", header_value);
  119    119   
    }
  120    120   
    if let ::std::option::Option::Some(inner_15) = &input.content_disposition {
  121    121   
        let formatted_16 = inner_15.as_str();
  122    122   
        let header_value = formatted_16;
  123         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         123  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  124    124   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  125    125   
                "content_disposition",
  126    126   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  127    127   
            )
  128    128   
        })?;
  129    129   
        builder = builder.header("x-amz-fwd-header-Content-Disposition", header_value);
  130    130   
    }
  131    131   
    if let ::std::option::Option::Some(inner_17) = &input.content_encoding {
  132    132   
        let formatted_18 = inner_17.as_str();
  133    133   
        let header_value = formatted_18;
  134         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         134  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  135    135   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  136    136   
                "content_encoding",
  137    137   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  138    138   
            )
  139    139   
        })?;
  140    140   
        builder = builder.header("x-amz-fwd-header-Content-Encoding", header_value);
  141    141   
    }
  142    142   
    if let ::std::option::Option::Some(inner_19) = &input.content_language {
  143    143   
        let formatted_20 = inner_19.as_str();
  144    144   
        let header_value = formatted_20;
  145         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         145  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  146    146   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  147    147   
                "content_language",
  148    148   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  149    149   
            )
  150    150   
        })?;
  151    151   
        builder = builder.header("x-amz-fwd-header-Content-Language", header_value);
  152    152   
    }
  153    153   
    if let ::std::option::Option::Some(inner_21) = &input.content_length {
  154    154   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_21);
  155    155   
        let formatted_22 = encoder.encode();
  156    156   
        let header_value = formatted_22;
  157         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         157  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  158    158   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  159    159   
                "content_length",
  160    160   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  161    161   
            )
  162    162   
        })?;
  163    163   
        builder = builder.header("Content-Length", header_value);
  164    164   
    }
  165    165   
    if let ::std::option::Option::Some(inner_23) = &input.content_range {
  166    166   
        let formatted_24 = inner_23.as_str();
  167    167   
        let header_value = formatted_24;
  168         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         168  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  169    169   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  170    170   
                "content_range",
  171    171   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  172    172   
            )
  173    173   
        })?;
  174    174   
        builder = builder.header("x-amz-fwd-header-Content-Range", header_value);
  175    175   
    }
  176    176   
    if let ::std::option::Option::Some(inner_25) = &input.content_type {
  177    177   
        let formatted_26 = inner_25.as_str();
  178    178   
        let header_value = formatted_26;
  179         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         179  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  180    180   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  181    181   
                "content_type",
  182    182   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  183    183   
            )
  184    184   
        })?;
  185    185   
        builder = builder.header("x-amz-fwd-header-Content-Type", header_value);
  186    186   
    }
  187    187   
    if let ::std::option::Option::Some(inner_27) = &input.checksum_crc32 {
  188    188   
        let formatted_28 = inner_27.as_str();
  189    189   
        let header_value = formatted_28;
  190         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         190  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  191    191   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  192    192   
                "checksum_crc32",
  193    193   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  194    194   
            )
  195    195   
        })?;
  196    196   
        builder = builder.header("x-amz-fwd-header-x-amz-checksum-crc32", header_value);
  197    197   
    }
  198    198   
    if let ::std::option::Option::Some(inner_29) = &input.checksum_crc32_c {
  199    199   
        let formatted_30 = inner_29.as_str();
  200    200   
        let header_value = formatted_30;
  201         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         201  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  202    202   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  203    203   
                "checksum_crc32_c",
  204    204   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  205    205   
            )
  206    206   
        })?;
  207    207   
        builder = builder.header("x-amz-fwd-header-x-amz-checksum-crc32c", header_value);
  208    208   
    }
  209    209   
    if let ::std::option::Option::Some(inner_31) = &input.checksum_crc64_nvme {
  210    210   
        let formatted_32 = inner_31.as_str();
  211    211   
        let header_value = formatted_32;
  212         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         212  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  213    213   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  214    214   
                "checksum_crc64_nvme",
  215    215   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  216    216   
            )
  217    217   
        })?;
  218    218   
        builder = builder.header("x-amz-fwd-header-x-amz-checksum-crc64nvme", header_value);
  219    219   
    }
  220    220   
    if let ::std::option::Option::Some(inner_33) = &input.checksum_sha1 {
  221    221   
        let formatted_34 = inner_33.as_str();
  222    222   
        let header_value = formatted_34;
  223         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         223  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  224    224   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  225    225   
                "checksum_sha1",
  226    226   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  227    227   
            )
  228    228   
        })?;
  229    229   
        builder = builder.header("x-amz-fwd-header-x-amz-checksum-sha1", header_value);
  230    230   
    }
  231    231   
    if let ::std::option::Option::Some(inner_35) = &input.checksum_sha256 {
  232    232   
        let formatted_36 = inner_35.as_str();
  233    233   
        let header_value = formatted_36;
  234         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         234  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  235    235   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  236    236   
                "checksum_sha256",
  237    237   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  238    238   
            )
  239    239   
        })?;
  240    240   
        builder = builder.header("x-amz-fwd-header-x-amz-checksum-sha256", header_value);
  241    241   
    }
  242    242   
    if let ::std::option::Option::Some(inner_37) = &input.delete_marker {
  243    243   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_37);
  244    244   
        let formatted_38 = encoder.encode();
  245    245   
        let header_value = formatted_38;
  246         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         246  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  247    247   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  248    248   
                "delete_marker",
  249    249   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  250    250   
            )
  251    251   
        })?;
  252    252   
        builder = builder.header("x-amz-fwd-header-x-amz-delete-marker", header_value);
  253    253   
    }
  254    254   
    if let ::std::option::Option::Some(inner_39) = &input.e_tag {
  255    255   
        let formatted_40 = inner_39.as_str();
  256    256   
        let header_value = formatted_40;
  257         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         257  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  258    258   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  259    259   
                "e_tag",
  260    260   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  261    261   
            )
  262    262   
        })?;
  263    263   
        builder = builder.header("x-amz-fwd-header-ETag", header_value);
  264    264   
    }
  265    265   
    if let ::std::option::Option::Some(inner_41) = &input.expires {
  266    266   
        let formatted_42 = inner_41.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  267    267   
        let header_value = formatted_42;
  268         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         268  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  269    269   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  270    270   
                "expires",
  271    271   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  272    272   
            )
  273    273   
        })?;
  274    274   
        builder = builder.header("x-amz-fwd-header-Expires", header_value);
  275    275   
    }
  276    276   
    if let ::std::option::Option::Some(inner_43) = &input.expiration {
  277    277   
        let formatted_44 = inner_43.as_str();
  278    278   
        let header_value = formatted_44;
  279         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         279  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  280    280   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  281    281   
                "expiration",
  282    282   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  283    283   
            )
  284    284   
        })?;
  285    285   
        builder = builder.header("x-amz-fwd-header-x-amz-expiration", header_value);
  286    286   
    }
  287    287   
    if let ::std::option::Option::Some(inner_45) = &input.last_modified {
  288    288   
        let formatted_46 = inner_45.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  289    289   
        let header_value = formatted_46;
  290         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         290  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  291    291   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  292    292   
                "last_modified",
  293    293   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  294    294   
            )
  295    295   
        })?;
  296    296   
        builder = builder.header("x-amz-fwd-header-Last-Modified", header_value);
  297    297   
    }
  298    298   
    if let ::std::option::Option::Some(inner_47) = &input.missing_meta {
  299    299   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_47);
  300    300   
        let formatted_48 = encoder.encode();
  301    301   
        let header_value = formatted_48;
  302         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         302  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  303    303   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  304    304   
                "missing_meta",
  305    305   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  306    306   
            )
  307    307   
        })?;
  308    308   
        builder = builder.header("x-amz-fwd-header-x-amz-missing-meta", header_value);
  309    309   
    }
  310    310   
    if let ::std::option::Option::Some(inner_49) = &input.object_lock_mode {
  311    311   
        let formatted_50 = inner_49.as_str();
  312    312   
        let header_value = formatted_50;
  313         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         313  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  314    314   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  315    315   
                "object_lock_mode",
  316    316   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  317    317   
            )
  318    318   
        })?;
  319    319   
        builder = builder.header("x-amz-fwd-header-x-amz-object-lock-mode", header_value);
  320    320   
    }
  321    321   
    if let ::std::option::Option::Some(inner_51) = &input.object_lock_legal_hold_status {
  322    322   
        let formatted_52 = inner_51.as_str();
  323    323   
        let header_value = formatted_52;
  324         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         324  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  325    325   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  326    326   
                "object_lock_legal_hold_status",
  327    327   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  328    328   
            )
  329    329   
        })?;
  330    330   
        builder = builder.header("x-amz-fwd-header-x-amz-object-lock-legal-hold", header_value);
  331    331   
    }
  332    332   
    if let ::std::option::Option::Some(inner_53) = &input.object_lock_retain_until_date {
  333    333   
        let formatted_54 = inner_53.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
  334    334   
        let header_value = formatted_54;
  335         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         335  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  336    336   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  337    337   
                "object_lock_retain_until_date",
  338    338   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  339    339   
            )
  340    340   
        })?;
  341    341   
        builder = builder.header("x-amz-fwd-header-x-amz-object-lock-retain-until-date", header_value);
  342    342   
    }
  343    343   
    if let ::std::option::Option::Some(inner_55) = &input.parts_count {
  344    344   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_55);
  345    345   
        let formatted_56 = encoder.encode();
  346    346   
        let header_value = formatted_56;
  347         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         347  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  348    348   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  349    349   
                "parts_count",
  350    350   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  351    351   
            )
  352    352   
        })?;
  353    353   
        builder = builder.header("x-amz-fwd-header-x-amz-mp-parts-count", header_value);
  354    354   
    }
  355    355   
    if let ::std::option::Option::Some(inner_57) = &input.replication_status {
  356    356   
        let formatted_58 = inner_57.as_str();
  357    357   
        let header_value = formatted_58;
  358         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         358  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  359    359   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  360    360   
                "replication_status",
  361    361   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  362    362   
            )
  363    363   
        })?;
  364    364   
        builder = builder.header("x-amz-fwd-header-x-amz-replication-status", header_value);
  365    365   
    }
  366    366   
    if let ::std::option::Option::Some(inner_59) = &input.request_charged {
  367    367   
        let formatted_60 = inner_59.as_str();
  368    368   
        let header_value = formatted_60;
  369         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         369  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  370    370   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  371    371   
                "request_charged",
  372    372   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  373    373   
            )
  374    374   
        })?;
  375    375   
        builder = builder.header("x-amz-fwd-header-x-amz-request-charged", header_value);
  376    376   
    }
  377    377   
    if let ::std::option::Option::Some(inner_61) = &input.restore {
  378    378   
        let formatted_62 = inner_61.as_str();
  379    379   
        let header_value = formatted_62;
  380         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         380  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  381    381   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  382    382   
                "restore",
  383    383   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  384    384   
            )
  385    385   
        })?;
  386    386   
        builder = builder.header("x-amz-fwd-header-x-amz-restore", header_value);
  387    387   
    }
  388    388   
    if let ::std::option::Option::Some(inner_63) = &input.server_side_encryption {
  389    389   
        let formatted_64 = inner_63.as_str();
  390    390   
        let header_value = formatted_64;
  391         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         391  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  392    392   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  393    393   
                "server_side_encryption",
  394    394   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  395    395   
            )
  396    396   
        })?;
  397    397   
        builder = builder.header("x-amz-fwd-header-x-amz-server-side-encryption", header_value);
  398    398   
    }
  399    399   
    if let ::std::option::Option::Some(inner_65) = &input.sse_customer_algorithm {
  400    400   
        let formatted_66 = inner_65.as_str();
  401    401   
        let header_value = formatted_66;
  402         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         402  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  403    403   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  404    404   
                "sse_customer_algorithm",
  405    405   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  406    406   
            )
  407    407   
        })?;
  408    408   
        builder = builder.header("x-amz-fwd-header-x-amz-server-side-encryption-customer-algorithm", header_value);
  409    409   
    }
  410    410   
    if let ::std::option::Option::Some(inner_67) = &input.ssekms_key_id {
  411    411   
        let formatted_68 = inner_67.as_str();
  412    412   
        let header_value = formatted_68;
  413         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         413  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  414    414   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  415    415   
                "ssekms_key_id",
  416    416   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  417    417   
            )
  418    418   
        })?;
  419    419   
        builder = builder.header("x-amz-fwd-header-x-amz-server-side-encryption-aws-kms-key-id", header_value);
  420    420   
    }
  421    421   
    if let ::std::option::Option::Some(inner_69) = &input.sse_customer_key_md5 {
  422    422   
        let formatted_70 = inner_69.as_str();
  423    423   
        let header_value = formatted_70;
  424         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         424  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  425    425   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  426    426   
                "sse_customer_key_md5",
  427    427   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  428    428   
            )
  429    429   
        })?;
  430    430   
        builder = builder.header("x-amz-fwd-header-x-amz-server-side-encryption-customer-key-MD5", header_value);
  431    431   
    }
  432    432   
    if let ::std::option::Option::Some(inner_71) = &input.storage_class {
  433    433   
        let formatted_72 = inner_71.as_str();
  434    434   
        let header_value = formatted_72;
  435         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         435  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  436    436   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  437    437   
                "storage_class",
  438    438   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  439    439   
            )
  440    440   
        })?;
  441    441   
        builder = builder.header("x-amz-fwd-header-x-amz-storage-class", header_value);
  442    442   
    }
  443    443   
    if let ::std::option::Option::Some(inner_73) = &input.tag_count {
  444    444   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_73);
  445    445   
        let formatted_74 = encoder.encode();
  446    446   
        let header_value = formatted_74;
  447         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         447  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  448    448   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  449    449   
                "tag_count",
  450    450   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  451    451   
            )
  452    452   
        })?;
  453    453   
        builder = builder.header("x-amz-fwd-header-x-amz-tagging-count", header_value);
  454    454   
    }
  455    455   
    if let ::std::option::Option::Some(inner_75) = &input.version_id {
  456    456   
        let formatted_76 = inner_75.as_str();
  457    457   
        let header_value = formatted_76;
  458         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         458  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  459    459   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  460    460   
                "version_id",
  461    461   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  462    462   
            )
  463    463   
        })?;
  464    464   
        builder = builder.header("x-amz-fwd-header-x-amz-version-id", header_value);
  465    465   
    }
  466    466   
    if let ::std::option::Option::Some(inner_77) = &input.bucket_key_enabled {
  467    467   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_77);
  468    468   
        let formatted_78 = encoder.encode();
  469    469   
        let header_value = formatted_78;
  470         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         470  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  471    471   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  472    472   
                "bucket_key_enabled",
  473    473   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  474    474   
            )
  475    475   
        })?;
  476    476   
        builder = builder.header("x-amz-fwd-header-x-amz-server-side-encryption-bucket-key-enabled", header_value);
  477    477   
    }
  478    478   
    if let ::std::option::Option::Some(inner_79) = &input.metadata {
  479    479   
        {
  480    480   
            for (k, v) in inner_79 {
  481    481   
                use std::str::FromStr;
  482         -
                let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
         482  +
                let header_name = ::http_1x::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
  483    483   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  484    484   
                        "metadata",
  485    485   
                        format!("`{k}` cannot be used as a header name: {err}"),
  486    486   
                    )
  487    487   
                })?;
  488    488   
                let header_value = v.as_str();
  489         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         489  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  490    490   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  491    491   
                        "metadata",
  492    492   
                        format!("`{v}` cannot be used as a header value: {err}"),
  493    493   
                    )
  494    494   
                })?;
  495    495   
                builder = builder.header(header_name, header_value);
  496    496   
            }
  497    497   
        }
  498    498   
    }
  499    499   
    Ok(builder)

tmp-codegen-diff/aws-sdk/sdk/s3/src/s3_request_id.rs

@@ -49,49 +120,120 @@
   69     69   
}
   70     70   
   71     71   
#[cfg(test)]
   72     72   
mod test {
   73     73   
    use super::*;
   74     74   
    use aws_smithy_runtime_api::client::result::SdkError;
   75     75   
    use aws_smithy_types::body::SdkBody;
   76     76   
   77     77   
    #[test]
   78     78   
    fn handle_missing_header() {
   79         -
        let resp = Response::try_from(http::Response::builder().status(400).body("").unwrap()).unwrap();
          79  +
        let resp = Response::try_from(http_1x::Response::builder().status(400).body("").unwrap()).unwrap();
   80     80   
        let mut builder = ErrorMetadata::builder().message("123");
   81     81   
        builder = apply_extended_request_id(builder, resp.headers());
   82     82   
        assert_eq!(builder.build().extended_request_id(), None);
   83     83   
    }
   84     84   
   85     85   
    #[test]
   86     86   
    fn test_extended_request_id_sdk_error() {
   87         -
        let without_extended_request_id = || Response::try_from(http::Response::builder().body(SdkBody::empty()).unwrap()).unwrap();
          87  +
        let without_extended_request_id = || Response::try_from(http_1x::Response::builder().body(SdkBody::empty()).unwrap()).unwrap();
   88     88   
        let with_extended_request_id = || {
   89     89   
            Response::try_from(
   90         -
                http::Response::builder()
          90  +
                http_1x::Response::builder()
   91     91   
                    .header("x-amz-id-2", "some-request-id")
   92     92   
                    .body(SdkBody::empty())
   93     93   
                    .unwrap(),
   94     94   
            )
   95     95   
            .unwrap()
   96     96   
        };
   97     97   
        assert_eq!(
   98     98   
            None,
   99     99   
            SdkError::<(), _>::response_error("test", without_extended_request_id()).extended_request_id()
  100    100   
        );

tmp-codegen-diff/aws-sdk/sdk/s3/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/s3control/Cargo.toml

@@ -1,1 +154,155 @@
   14     14   
protocol = "aws.protocols#restXml"
   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-runtime]
   43     43   
path = "../aws-smithy-runtime"
   44     44   
features = ["client"]
   45         -
version = "1.9.8"
          45  +
version = "1.10.0"
   46     46   
   47     47   
[dependencies.aws-smithy-runtime-api]
   48     48   
path = "../aws-smithy-runtime-api"
   49         -
features = ["client", "http-02x"]
   50         -
version = "1.10.0"
          49  +
features = ["client", "http-1x"]
          50  +
version = "1.11.0"
   51     51   
   52     52   
[dependencies.aws-smithy-types]
   53     53   
path = "../aws-smithy-types"
   54         -
version = "1.3.6"
          54  +
features = ["http-body-1-x"]
          55  +
version = "1.4.0"
   55     56   
   56     57   
[dependencies.aws-smithy-xml]
   57     58   
path = "../aws-smithy-xml"
   58     59   
version = "0.60.13"
   59     60   
   60     61   
[dependencies.aws-types]
   61     62   
path = "../aws-types"
   62     63   
version = "1.3.11"
   63     64   
   64     65   
[dependencies.fastrand]
   65     66   
version = "2.0.0"
   66     67   
   67     68   
[dependencies.http]
   68     69   
version = "0.2.9"
   69     70   
          71  +
[dependencies.http-1x]
          72  +
version = "1"
          73  +
package = "http"
          74  +
   70     75   
[dependencies.md-5]
   71     76   
version = "0.10.0"
   72     77   
   73     78   
[dependencies.regex-lite]
   74     79   
version = "0.1.5"
   75     80   
   76     81   
[dependencies.tracing]
   77     82   
version = "0.1"
   78     83   
   79     84   
[dependencies.url]
   80     85   
version = "2.3.1"
   81     86   
[dev-dependencies.aws-config]
   82     87   
path = "../aws-config"
   83     88   
version = "1.8.12"
   84     89   
   85     90   
[dev-dependencies.aws-credential-types]
   86     91   
path = "../aws-credential-types"
   87     92   
features = ["test-util"]
   88     93   
version = "1.2.11"
   89     94   
   90     95   
[dev-dependencies.aws-runtime]
   91     96   
path = "../aws-runtime"
   92     97   
features = ["test-util"]
   93         -
version = "1.5.18"
          98  +
version = "1.6.0"
   94     99   
   95    100   
[dev-dependencies.aws-smithy-async]
   96    101   
path = "../aws-smithy-async"
   97    102   
features = ["test-util"]
   98         -
version = "1.2.7"
         103  +
version = "1.2.8"
   99    104   
  100    105   
[dev-dependencies.aws-smithy-http-client]
  101    106   
path = "../aws-smithy-http-client"
  102    107   
features = ["test-util", "wire-mock"]
  103         -
version = "1.1.5"
         108  +
version = "1.1.6"
  104    109   
  105    110   
[dev-dependencies.aws-smithy-protocol-test]
  106    111   
path = "../aws-smithy-protocol-test"
  107         -
version = "0.63.7"
         112  +
version = "0.63.8"
  108    113   
  109    114   
[dev-dependencies.aws-smithy-runtime]
  110    115   
path = "../aws-smithy-runtime"
  111    116   
features = ["test-util"]
  112         -
version = "1.9.8"
         117  +
version = "1.10.0"
  113    118   
  114    119   
[dev-dependencies.aws-smithy-runtime-api]
  115    120   
path = "../aws-smithy-runtime-api"
  116    121   
features = ["test-util"]
  117         -
version = "1.10.0"
         122  +
version = "1.11.0"
  118    123   
  119    124   
[dev-dependencies.aws-smithy-types]
  120    125   
path = "../aws-smithy-types"
  121         -
features = ["test-util"]
  122         -
version = "1.3.6"
         126  +
features = ["http-body-1-x", "test-util"]
         127  +
version = "1.4.0"
  123    128   
  124    129   
[dev-dependencies.futures-util]
  125    130   
version = "0.3.25"
  126    131   
features = ["alloc"]
  127    132   
default-features = false
  128    133   
  129         -
[dev-dependencies.http-1x]
  130         -
version = "1"
  131         -
package = "http"
  132         -
  133    134   
[dev-dependencies.proptest]
  134    135   
version = "1"
  135    136   
  136    137   
[dev-dependencies.serde_json]
  137    138   
version = "1.0.0"
  138    139   
  139    140   
[dev-dependencies.tokio]
  140    141   
version = "1.23.1"
  141    142   
features = ["macros", "test-util", "rt-multi-thread"]
  142    143

tmp-codegen-diff/aws-sdk/sdk/s3control/src/endpoint_lib/parse_url.rs

@@ -1,1 +38,38 @@
    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   
use crate::endpoint_lib::diagnostic::DiagnosticCollector;
    8         -
use http::Uri;
           8  +
use http_1x::Uri;
    9      9   
use url::{Host, Url as ParsedUrl};
   10     10   
   11     11   
#[derive(PartialEq, Debug)]
   12     12   
pub(crate) struct Url<'a> {
   13     13   
    uri: Uri,
   14     14   
    url: ParsedUrl,
   15     15   
    raw: &'a str,
   16     16   
}
   17     17   
   18     18   
// individual methods on parse_url might not be used (although the [`parse_url`] itself _MUST_ be used

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/associate_access_grants_identity_center.rs

@@ -175,175 +254,254 @@
  195    195   
                _input: &crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterInput,
  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, "/v20180820/accessgrantsinstance/identitycenter").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::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterInput,
  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   
                let builder =
  210    210   
                    crate::protocol_serde::shape_associate_access_grants_identity_center::ser_associate_access_grants_identity_center_headers(
  211    211   
                        input, builder,
  212    212   
                    )?;
  213    213   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  214    214   
            }
  215         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  216         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         215  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         216  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  217    217   
            builder
  218    218   
        };
  219    219   
        let body = ::aws_smithy_types::body::SdkBody::from(
  220    220   
            crate::protocol_serde::shape_associate_access_grants_identity_center::ser_associate_access_grants_identity_center_op_input(&input)?,
  221    221   
        );
  222    222   
        if let Some(content_length) = body.content_length() {
  223    223   
            let content_length = content_length.to_string();
  224         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         224  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  225    225   
        }
  226    226   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  227    227   
    }
  228    228   
}
  229    229   
#[derive(Debug)]
  230    230   
struct AssociateAccessGrantsIdentityCenterEndpointParamsInterceptor;
  231    231   
  232    232   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for AssociateAccessGrantsIdentityCenterEndpointParamsInterceptor {
  233    233   
    fn name(&self) -> &'static str {
  234    234   
        "AssociateAccessGrantsIdentityCenterEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_grant.rs

@@ -165,165 +241,241 @@
  185    185   
                _input: &crate::operation::create_access_grant::CreateAccessGrantInput,
  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, "/v20180820/accessgrantsinstance/grant").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_access_grant::CreateAccessGrantInput,
  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   
                let builder = crate::protocol_serde::shape_create_access_grant::ser_create_access_grant_headers(input, builder)?;
  200    200   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  201    201   
            }
  202         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  203         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         202  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         203  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  204    204   
            builder
  205    205   
        };
  206    206   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_access_grant::ser_create_access_grant_op_input(
  207    207   
            &input,
  208    208   
        )?);
  209    209   
        if let Some(content_length) = body.content_length() {
  210    210   
            let content_length = content_length.to_string();
  211         -
            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);
  212    212   
        }
  213    213   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  214    214   
    }
  215    215   
}
  216    216   
#[derive(Debug)]
  217    217   
struct CreateAccessGrantEndpointParamsInterceptor;
  218    218   
  219    219   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateAccessGrantEndpointParamsInterceptor {
  220    220   
    fn name(&self) -> &'static str {
  221    221   
        "CreateAccessGrantEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_grants_instance.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_grants_location.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_point.rs

@@ -176,176 +252,252 @@
  196    196   
                        "name",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/v20180820/accesspoint/{Name}", Name = name).expect("formatting should succeed");
  201    201   
                ::std::result::Result::Ok(())
  202    202   
            }
  203    203   
            #[allow(clippy::unnecessary_wraps)]
  204    204   
            fn update_http_builder(
  205    205   
                input: &crate::operation::create_access_point::CreateAccessPointInput,
  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   
                let builder = crate::protocol_serde::shape_create_access_point::ser_create_access_point_headers(input, builder)?;
  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/xml");
         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/xml");
  215    215   
            builder
  216    216   
        };
  217    217   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_access_point::ser_create_access_point_op_input(
  218    218   
            &input,
  219    219   
        )?);
  220    220   
        if let Some(content_length) = body.content_length() {
  221    221   
            let content_length = content_length.to_string();
  222         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         222  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  223    223   
        }
  224    224   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  225    225   
    }
  226    226   
}
  227    227   
#[derive(Debug)]
  228    228   
struct CreateAccessPointEndpointParamsInterceptor;
  229    229   
  230    230   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateAccessPointEndpointParamsInterceptor {
  231    231   
    fn name(&self) -> &'static str {
  232    232   
        "CreateAccessPointEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_point_for_object_lambda.rs

@@ -186,186 +264,264 @@
  206    206   
                        "name",
  207    207   
                        "cannot be empty or unset",
  208    208   
                    ));
  209    209   
                }
  210    210   
                ::std::write!(output, "/v20180820/accesspointforobjectlambda/{Name}", Name = name).expect("formatting should succeed");
  211    211   
                ::std::result::Result::Ok(())
  212    212   
            }
  213    213   
            #[allow(clippy::unnecessary_wraps)]
  214    214   
            fn update_http_builder(
  215    215   
                input: &crate::operation::create_access_point_for_object_lambda::CreateAccessPointForObjectLambdaInput,
  216         -
                builder: ::http::request::Builder,
  217         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         216  +
                builder: ::http_1x::request::Builder,
         217  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  218    218   
                let mut uri = ::std::string::String::new();
  219    219   
                uri_base(input, &mut uri)?;
  220    220   
                let builder = crate::protocol_serde::shape_create_access_point_for_object_lambda::ser_create_access_point_for_object_lambda_headers(
  221    221   
                    input, builder,
  222    222   
                )?;
  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/xml");
         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/xml");
  227    227   
            builder
  228    228   
        };
  229    229   
        let body = ::aws_smithy_types::body::SdkBody::from(
  230    230   
            crate::protocol_serde::shape_create_access_point_for_object_lambda::ser_create_access_point_for_object_lambda_op_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 CreateAccessPointForObjectLambdaEndpointParamsInterceptor;
  241    241   
  242    242   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateAccessPointForObjectLambdaEndpointParamsInterceptor {
  243    243   
    fn name(&self) -> &'static str {
  244    244   
        "CreateAccessPointForObjectLambdaEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_bucket.rs

@@ -176,176 +252,252 @@
  196    196   
                        "bucket",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/v20180820/bucket/{Bucket}", Bucket = bucket).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::create_bucket::CreateBucketInput,
  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   
                let builder = crate::protocol_serde::shape_create_bucket::ser_create_bucket_headers(input, builder)?;
  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/xml");
         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/xml");
  215    215   
            builder
  216    216   
        };
  217    217   
        let body = ::aws_smithy_types::body::SdkBody::from(
  218    218   
            crate::protocol_serde::shape_create_bucket_input::ser_create_bucket_configuration_http_payload(&input.create_bucket_configuration)?,
  219    219   
        );
  220    220   
        if let Some(content_length) = body.content_length() {
  221    221   
            let content_length = content_length.to_string();
  222         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         222  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  223    223   
        }
  224    224   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  225    225   
    }
  226    226   
}
  227    227   
#[derive(Debug)]
  228    228   
struct CreateBucketEndpointParamsInterceptor;
  229    229   
  230    230   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateBucketEndpointParamsInterceptor {
  231    231   
    fn name(&self) -> &'static str {
  232    232   
        "CreateBucketEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_job.rs

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