AWS SDK

AWS SDK

rev. ee474c7509d7728618c23068f3741e8e5b339ef9

Files changed:

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

@@ -34,34 +110,110 @@
   54     54   
            })?,
   55     55   
        );
   56     56   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   57     57   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   58     58   
        output.build()
   59     59   
    })
   60     60   
}
   61     61   
   62     62   
pub fn ser_get_object_acl_headers(
   63     63   
    input: &crate::operation::get_object_acl::GetObjectAclInput,
   64         -
    mut builder: ::http::request::Builder,
   65         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          64  +
    mut builder: ::http_1x::request::Builder,
          65  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   66     66   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   67     67   
        let formatted_2 = inner_1.as_str();
   68     68   
        let header_value = formatted_2;
   69         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          69  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   70     70   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   71     71   
                "request_payer",
   72     72   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     73   
            )
   74     74   
        })?;
   75     75   
        builder = builder.header("x-amz-request-payer", header_value);
   76     76   
    }
   77     77   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   78     78   
        let formatted_4 = inner_3.as_str();
   79     79   
        let header_value = formatted_4;
   80         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          80  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   81     81   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   82     82   
                "expected_bucket_owner",
   83     83   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   84     84   
            )
   85     85   
        })?;
   86     86   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   87     87   
    }
   88     88   
    Ok(builder)
   89     89   
}
   90     90

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

@@ -63,63 +211,211 @@
   83     83   
            })?,
   84     84   
        );
   85     85   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   86     86   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   87     87   
        output.build()
   88     88   
    })
   89     89   
}
   90     90   
   91     91   
pub fn ser_get_object_attributes_headers(
   92     92   
    input: &crate::operation::get_object_attributes::GetObjectAttributesInput,
   93         -
    mut builder: ::http::request::Builder,
   94         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          93  +
    mut builder: ::http_1x::request::Builder,
          94  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   95     95   
    if let ::std::option::Option::Some(inner_1) = &input.max_parts {
   96     96   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
   97     97   
        let formatted_2 = encoder.encode();
   98     98   
        let header_value = formatted_2;
   99         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          99  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  100    100   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  101    101   
                "max_parts",
  102    102   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  103    103   
            )
  104    104   
        })?;
  105    105   
        builder = builder.header("x-amz-max-parts", header_value);
  106    106   
    }
  107    107   
    if let ::std::option::Option::Some(inner_3) = &input.part_number_marker {
  108    108   
        let formatted_4 = inner_3.as_str();
  109    109   
        let header_value = formatted_4;
  110         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         110  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  111    111   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  112    112   
                "part_number_marker",
  113    113   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  114    114   
            )
  115    115   
        })?;
  116    116   
        builder = builder.header("x-amz-part-number-marker", header_value);
  117    117   
    }
  118    118   
    if let ::std::option::Option::Some(inner_5) = &input.sse_customer_algorithm {
  119    119   
        let formatted_6 = inner_5.as_str();
  120    120   
        let header_value = formatted_6;
  121         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         121  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  122    122   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  123    123   
                "sse_customer_algorithm",
  124    124   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  125    125   
            )
  126    126   
        })?;
  127    127   
        builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
  128    128   
    }
  129    129   
    if let ::std::option::Option::Some(inner_7) = &input.sse_customer_key {
  130    130   
        let formatted_8 = inner_7.as_str();
  131    131   
        let header_value = formatted_8;
  132         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         132  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  133    133   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  134    134   
                "sse_customer_key",
  135    135   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  136    136   
            )
  137    137   
        })?;
  138    138   
        builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
  139    139   
    }
  140    140   
    if let ::std::option::Option::Some(inner_9) = &input.sse_customer_key_md5 {
  141    141   
        let formatted_10 = inner_9.as_str();
  142    142   
        let header_value = formatted_10;
  143         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         143  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  144    144   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  145    145   
                "sse_customer_key_md5",
  146    146   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  147    147   
            )
  148    148   
        })?;
  149    149   
        builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  150    150   
    }
  151    151   
    if let ::std::option::Option::Some(inner_11) = &input.request_payer {
  152    152   
        let formatted_12 = inner_11.as_str();
  153    153   
        let header_value = formatted_12;
  154         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         154  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  155    155   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  156    156   
                "request_payer",
  157    157   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  158    158   
            )
  159    159   
        })?;
  160    160   
        builder = builder.header("x-amz-request-payer", header_value);
  161    161   
    }
  162    162   
    if let ::std::option::Option::Some(inner_13) = &input.expected_bucket_owner {
  163    163   
        let formatted_14 = inner_13.as_str();
  164    164   
        let header_value = formatted_14;
  165         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         165  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  166    166   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  167    167   
                "expected_bucket_owner",
  168    168   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  169    169   
            )
  170    170   
        })?;
  171    171   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  172    172   
    }
  173    173   
    if let ::std::option::Option::Some(inner_15) = &input.object_attributes {
  174    174   
        // Empty vec in header is serialized as an empty string
  175    175   
        if inner_15.is_empty() {
  176    176   
            builder = builder.header("x-amz-object-attributes", "");
  177    177   
        } else {
  178    178   
            for inner_16 in inner_15 {
  179    179   
                let formatted_17 = ::aws_smithy_http::header::quote_header_value(inner_16.as_str());
  180    180   
                let header_value = formatted_17;
  181         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         181  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  182    182   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  183    183   
                        "object_attributes",
  184    184   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
  185    185   
                    )
  186    186   
                })?;
  187    187   
                builder = builder.header("x-amz-object-attributes", header_value);
  188    188   
            }
  189    189   
        }
  190    190   
    }
  191    191   
    Ok(builder)

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

@@ -13,13 +68,68 @@
   33     33   
            _response_body,
   34     34   
        )?);
   35     35   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   36     36   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   37     37   
        output.build()
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_get_object_legal_hold_headers(
   42     42   
    input: &crate::operation::get_object_legal_hold::GetObjectLegalHoldInput,
   43         -
    mut builder: ::http::request::Builder,
   44         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          43  +
    mut builder: ::http_1x::request::Builder,
          44  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   45     45   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   46     46   
        let formatted_2 = inner_1.as_str();
   47     47   
        let header_value = formatted_2;
   48         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          48  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   49     49   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   50     50   
                "request_payer",
   51     51   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   52     52   
            )
   53     53   
        })?;
   54     54   
        builder = builder.header("x-amz-request-payer", header_value);
   55     55   
    }
   56     56   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   57     57   
        let formatted_4 = inner_3.as_str();
   58     58   
        let header_value = formatted_4;
   59         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          59  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   60     60   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   61     61   
                "expected_bucket_owner",
   62     62   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   63     63   
            )
   64     64   
        })?;
   65     65   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   66     66   
    }
   67     67   
    Ok(builder)
   68     68   
}

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

@@ -15,15 +59,59 @@
   35     35   
            crate::protocol_serde::shape_get_object_lock_configuration_output::de_object_lock_configuration_payload(_response_body)?,
   36     36   
        );
   37     37   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   38     38   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   39     39   
        output.build()
   40     40   
    })
   41     41   
}
   42     42   
   43     43   
pub fn ser_get_object_lock_configuration_headers(
   44     44   
    input: &crate::operation::get_object_lock_configuration::GetObjectLockConfigurationInput,
   45         -
    mut builder: ::http::request::Builder,
   46         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          45  +
    mut builder: ::http_1x::request::Builder,
          46  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   47     47   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   48     48   
        let formatted_2 = inner_1.as_str();
   49     49   
        let header_value = formatted_2;
   50         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          50  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   51     51   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   52     52   
                "expected_bucket_owner",
   53     53   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   54     54   
            )
   55     55   
        })?;
   56     56   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   57     57   
    }
   58     58   
    Ok(builder)
   59     59   
}

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

@@ -13,13 +68,68 @@
   33     33   
            _response_body,
   34     34   
        )?);
   35     35   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   36     36   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   37     37   
        output.build()
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_get_object_retention_headers(
   42     42   
    input: &crate::operation::get_object_retention::GetObjectRetentionInput,
   43         -
    mut builder: ::http::request::Builder,
   44         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          43  +
    mut builder: ::http_1x::request::Builder,
          44  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   45     45   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   46     46   
        let formatted_2 = inner_1.as_str();
   47     47   
        let header_value = formatted_2;
   48         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          48  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   49     49   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   50     50   
                "request_payer",
   51     51   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   52     52   
            )
   53     53   
        })?;
   54     54   
        builder = builder.header("x-amz-request-payer", header_value);
   55     55   
    }
   56     56   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   57     57   
        let formatted_4 = inner_3.as_str();
   58     58   
        let header_value = formatted_4;
   59         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          59  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   60     60   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   61     61   
                "expected_bucket_owner",
   62     62   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   63     63   
            )
   64     64   
        })?;
   65     65   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   66     66   
    }
   67     67   
    Ok(builder)
   68     68   
}

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

@@ -13,13 +89,89 @@
   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   
        crate::serde_util::get_object_tagging_output_output_correct_errors(output)
   36     36   
            .build()
   37     37   
            .map_err(crate::operation::get_object_tagging::GetObjectTaggingError::unhandled)?
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_get_object_tagging_headers(
   42     42   
    input: &crate::operation::get_object_tagging::GetObjectTaggingInput,
   43         -
    mut builder: ::http::request::Builder,
   44         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          43  +
    mut builder: ::http_1x::request::Builder,
          44  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   45     45   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   46     46   
        let formatted_2 = inner_1.as_str();
   47     47   
        let header_value = formatted_2;
   48         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          48  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   49     49   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   50     50   
                "expected_bucket_owner",
   51     51   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   52     52   
            )
   53     53   
        })?;
   54     54   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   55     55   
    }
   56     56   
    if let ::std::option::Option::Some(inner_3) = &input.request_payer {
   57     57   
        let formatted_4 = inner_3.as_str();
   58     58   
        let header_value = formatted_4;
   59         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          59  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   60     60   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   61     61   
                "request_payer",
   62     62   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   63     63   
            )
   64     64   
        })?;
   65     65   
        builder = builder.header("x-amz-request-payer", header_value);
   66     66   
    }
   67     67   
    Ok(builder)
   68     68   
}
   69     69

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

@@ -18,18 +73,73 @@
   38     38   
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
   39     39   
        .map_err(crate::operation::get_object_torrent::GetObjectTorrentError::unhandled)?;
   40     40   
    generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
   41     41   
    generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
   42     42   
    let generic = generic_builder.build();
   43     43   
    Err(crate::operation::get_object_torrent::GetObjectTorrentError::generic(generic))
   44     44   
}
   45     45   
   46     46   
pub fn ser_get_object_torrent_headers(
   47     47   
    input: &crate::operation::get_object_torrent::GetObjectTorrentInput,
   48         -
    mut builder: ::http::request::Builder,
   49         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          48  +
    mut builder: ::http_1x::request::Builder,
          49  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   50     50   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   51     51   
        let formatted_2 = inner_1.as_str();
   52     52   
        let header_value = formatted_2;
   53         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          53  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   54     54   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   55     55   
                "request_payer",
   56     56   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   57     57   
            )
   58     58   
        })?;
   59     59   
        builder = builder.header("x-amz-request-payer", header_value);
   60     60   
    }
   61     61   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   62     62   
        let formatted_4 = inner_3.as_str();
   63     63   
        let header_value = formatted_4;
   64         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          64  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   65     65   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   66     66   
                "expected_bucket_owner",
   67     67   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   68     68   
            )
   69     69   
        })?;
   70     70   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   71     71   
    }
   72     72   
    Ok(builder)
   73     73   
}

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

@@ -13,13 +57,57 @@
   33     33   
            crate::protocol_serde::shape_get_public_access_block_output::de_public_access_block_configuration_payload(_response_body)?,
   34     34   
        );
   35     35   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   36     36   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   37     37   
        output.build()
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_get_public_access_block_headers(
   42     42   
    input: &crate::operation::get_public_access_block::GetPublicAccessBlockInput,
   43         -
    mut builder: ::http::request::Builder,
   44         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          43  +
    mut builder: ::http_1x::request::Builder,
          44  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   45     45   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   46     46   
        let formatted_2 = inner_1.as_str();
   47     47   
        let header_value = formatted_2;
   48         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          48  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   49     49   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   50     50   
                "expected_bucket_owner",
   51     51   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   52     52   
            )
   53     53   
        })?;
   54     54   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   55     55   
    }
   56     56   
    Ok(builder)
   57     57   
}

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

@@ -55,55 +99,99 @@
   75     75   
            })?,
   76     76   
        );
   77     77   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   78     78   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   79     79   
        output.build()
   80     80   
    })
   81     81   
}
   82     82   
   83     83   
pub fn ser_head_bucket_headers(
   84     84   
    input: &crate::operation::head_bucket::HeadBucketInput,
   85         -
    mut builder: ::http::request::Builder,
   86         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          85  +
    mut builder: ::http_1x::request::Builder,
          86  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   87     87   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   88     88   
        let formatted_2 = inner_1.as_str();
   89     89   
        let header_value = formatted_2;
   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   
                "expected_bucket_owner",
   93     93   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   94     94   
            )
   95     95   
        })?;
   96     96   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   97     97   
    }
   98     98   
    Ok(builder)
   99     99   
}

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

@@ -226,226 +380,380 @@
  246    246   
            })?,
  247    247   
        );
  248    248   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
  249    249   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  250    250   
        output.build()
  251    251   
    })
  252    252   
}
  253    253   
  254    254   
pub fn ser_head_object_headers(
  255    255   
    input: &crate::operation::head_object::HeadObjectInput,
  256         -
    mut builder: ::http::request::Builder,
  257         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         256  +
    mut builder: ::http_1x::request::Builder,
         257  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  258    258   
    if let ::std::option::Option::Some(inner_1) = &input.if_match {
  259    259   
        let formatted_2 = inner_1.as_str();
  260    260   
        let header_value = formatted_2;
  261         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         261  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  262    262   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  263    263   
                "if_match",
  264    264   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  265    265   
            )
  266    266   
        })?;
  267    267   
        builder = builder.header("If-Match", header_value);
  268    268   
    }
  269    269   
    if let ::std::option::Option::Some(inner_3) = &input.if_modified_since {
  270    270   
        let formatted_4 = inner_3.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  271    271   
        let header_value = formatted_4;
  272         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         272  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  273    273   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  274    274   
                "if_modified_since",
  275    275   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  276    276   
            )
  277    277   
        })?;
  278    278   
        builder = builder.header("If-Modified-Since", header_value);
  279    279   
    }
  280    280   
    if let ::std::option::Option::Some(inner_5) = &input.if_none_match {
  281    281   
        let formatted_6 = inner_5.as_str();
  282    282   
        let header_value = formatted_6;
  283         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         283  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  284    284   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  285    285   
                "if_none_match",
  286    286   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  287    287   
            )
  288    288   
        })?;
  289    289   
        builder = builder.header("If-None-Match", header_value);
  290    290   
    }
  291    291   
    if let ::std::option::Option::Some(inner_7) = &input.if_unmodified_since {
  292    292   
        let formatted_8 = inner_7.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  293    293   
        let header_value = formatted_8;
  294         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         294  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  295    295   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  296    296   
                "if_unmodified_since",
  297    297   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  298    298   
            )
  299    299   
        })?;
  300    300   
        builder = builder.header("If-Unmodified-Since", header_value);
  301    301   
    }
  302    302   
    if let ::std::option::Option::Some(inner_9) = &input.range {
  303    303   
        let formatted_10 = inner_9.as_str();
  304    304   
        let header_value = formatted_10;
  305         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         305  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  306    306   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  307    307   
                "range",
  308    308   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  309    309   
            )
  310    310   
        })?;
  311    311   
        builder = builder.header("Range", header_value);
  312    312   
    }
  313    313   
    if let ::std::option::Option::Some(inner_11) = &input.sse_customer_algorithm {
  314    314   
        let formatted_12 = inner_11.as_str();
  315    315   
        let header_value = formatted_12;
  316         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         316  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  317    317   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  318    318   
                "sse_customer_algorithm",
  319    319   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  320    320   
            )
  321    321   
        })?;
  322    322   
        builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
  323    323   
    }
  324    324   
    if let ::std::option::Option::Some(inner_13) = &input.sse_customer_key {
  325    325   
        let formatted_14 = inner_13.as_str();
  326    326   
        let header_value = formatted_14;
  327         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         327  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  328    328   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  329    329   
                "sse_customer_key",
  330    330   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  331    331   
            )
  332    332   
        })?;
  333    333   
        builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
  334    334   
    }
  335    335   
    if let ::std::option::Option::Some(inner_15) = &input.sse_customer_key_md5 {
  336    336   
        let formatted_16 = inner_15.as_str();
  337    337   
        let header_value = formatted_16;
  338         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         338  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  339    339   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  340    340   
                "sse_customer_key_md5",
  341    341   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  342    342   
            )
  343    343   
        })?;
  344    344   
        builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  345    345   
    }
  346    346   
    if let ::std::option::Option::Some(inner_17) = &input.request_payer {
  347    347   
        let formatted_18 = inner_17.as_str();
  348    348   
        let header_value = formatted_18;
  349         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         349  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  350    350   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  351    351   
                "request_payer",
  352    352   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  353    353   
            )
  354    354   
        })?;
  355    355   
        builder = builder.header("x-amz-request-payer", header_value);
  356    356   
    }
  357    357   
    if let ::std::option::Option::Some(inner_19) = &input.expected_bucket_owner {
  358    358   
        let formatted_20 = inner_19.as_str();
  359    359   
        let header_value = formatted_20;
  360         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         360  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  361    361   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  362    362   
                "expected_bucket_owner",
  363    363   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  364    364   
            )
  365    365   
        })?;
  366    366   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  367    367   
    }
  368    368   
    if let ::std::option::Option::Some(inner_21) = &input.checksum_mode {
  369    369   
        let formatted_22 = inner_21.as_str();
  370    370   
        let header_value = formatted_22;
  371         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         371  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  372    372   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  373    373   
                "checksum_mode",
  374    374   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  375    375   
            )
  376    376   
        })?;
  377    377   
        builder = builder.header("x-amz-checksum-mode", header_value);
  378    378   
    }
  379    379   
    Ok(builder)
  380    380   
}

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

@@ -12,12 +77,77 @@
   32     32   
        output = crate::protocol_serde::shape_list_bucket_analytics_configurations::de_list_bucket_analytics_configurations(_response_body, output)
   33     33   
            .map_err(crate::operation::list_bucket_analytics_configurations::ListBucketAnalyticsConfigurationsError::unhandled)?;
   34     34   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   35     35   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   36     36   
        output.build()
   37     37   
    })
   38     38   
}
   39     39   
   40     40   
pub fn ser_list_bucket_analytics_configurations_headers(
   41     41   
    input: &crate::operation::list_bucket_analytics_configurations::ListBucketAnalyticsConfigurationsInput,
   42         -
    mut builder: ::http::request::Builder,
   43         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          42  +
    mut builder: ::http_1x::request::Builder,
          43  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   44     44   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   45     45   
        let formatted_2 = inner_1.as_str();
   46     46   
        let header_value = formatted_2;
   47         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          47  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   48     48   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   49     49   
                "expected_bucket_owner",
   50     50   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   51     51   
            )
   52     52   
        })?;
   53     53   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   54     54   
    }
   55     55   
    Ok(builder)
   56     56   
}
   57     57

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

@@ -15,15 +80,80 @@
   35     35   
        )
   36     36   
        .map_err(crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsError::unhandled)?;
   37     37   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   38     38   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   39     39   
        output.build()
   40     40   
    })
   41     41   
}
   42     42   
   43     43   
pub fn ser_list_bucket_intelligent_tiering_configurations_headers(
   44     44   
    input: &crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsInput,
   45         -
    mut builder: ::http::request::Builder,
   46         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          45  +
    mut builder: ::http_1x::request::Builder,
          46  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   47     47   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   48     48   
        let formatted_2 = inner_1.as_str();
   49     49   
        let header_value = formatted_2;
   50         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          50  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   51     51   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   52     52   
                "expected_bucket_owner",
   53     53   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   54     54   
            )
   55     55   
        })?;
   56     56   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   57     57   
    }
   58     58   
    Ok(builder)
   59     59   
}
   60     60

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

@@ -12,12 +77,77 @@
   32     32   
        output = crate::protocol_serde::shape_list_bucket_inventory_configurations::de_list_bucket_inventory_configurations(_response_body, output)
   33     33   
            .map_err(crate::operation::list_bucket_inventory_configurations::ListBucketInventoryConfigurationsError::unhandled)?;
   34     34   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   35     35   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   36     36   
        output.build()
   37     37   
    })
   38     38   
}
   39     39   
   40     40   
pub fn ser_list_bucket_inventory_configurations_headers(
   41     41   
    input: &crate::operation::list_bucket_inventory_configurations::ListBucketInventoryConfigurationsInput,
   42         -
    mut builder: ::http::request::Builder,
   43         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          42  +
    mut builder: ::http_1x::request::Builder,
          43  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   44     44   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   45     45   
        let formatted_2 = inner_1.as_str();
   46     46   
        let header_value = formatted_2;
   47         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          47  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   48     48   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   49     49   
                "expected_bucket_owner",
   50     50   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   51     51   
            )
   52     52   
        })?;
   53     53   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   54     54   
    }
   55     55   
    Ok(builder)
   56     56   
}
   57     57

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

@@ -12,12 +77,77 @@
   32     32   
        output = crate::protocol_serde::shape_list_bucket_metrics_configurations::de_list_bucket_metrics_configurations(_response_body, output)
   33     33   
            .map_err(crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsError::unhandled)?;
   34     34   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   35     35   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   36     36   
        output.build()
   37     37   
    })
   38     38   
}
   39     39   
   40     40   
pub fn ser_list_bucket_metrics_configurations_headers(
   41     41   
    input: &crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsInput,
   42         -
    mut builder: ::http::request::Builder,
   43         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          42  +
    mut builder: ::http_1x::request::Builder,
          43  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   44     44   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   45     45   
        let formatted_2 = inner_1.as_str();
   46     46   
        let header_value = formatted_2;
   47         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          47  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   48     48   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   49     49   
                "expected_bucket_owner",
   50     50   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   51     51   
            )
   52     52   
        })?;
   53     53   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   54     54   
    }
   55     55   
    Ok(builder)
   56     56   
}
   57     57

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

@@ -19,19 +95,95 @@
   39     39   
            })?,
   40     40   
        );
   41     41   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   42     42   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   43     43   
        output.build()
   44     44   
    })
   45     45   
}
   46     46   
   47     47   
pub fn ser_list_multipart_uploads_headers(
   48     48   
    input: &crate::operation::list_multipart_uploads::ListMultipartUploadsInput,
   49         -
    mut builder: ::http::request::Builder,
   50         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          49  +
    mut builder: ::http_1x::request::Builder,
          50  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   51     51   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   52     52   
        let formatted_2 = inner_1.as_str();
   53     53   
        let header_value = formatted_2;
   54         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          54  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   55     55   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   56     56   
                "expected_bucket_owner",
   57     57   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   58     58   
            )
   59     59   
        })?;
   60     60   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   61     61   
    }
   62     62   
    if let ::std::option::Option::Some(inner_3) = &input.request_payer {
   63     63   
        let formatted_4 = inner_3.as_str();
   64     64   
        let header_value = formatted_4;
   65         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          65  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   66     66   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   67     67   
                "request_payer",
   68     68   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   69     69   
            )
   70     70   
        })?;
   71     71   
        builder = builder.header("x-amz-request-payer", header_value);
   72     72   
    }
   73     73   
    Ok(builder)
   74     74   
}
   75     75

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

@@ -19,19 +111,111 @@
   39     39   
            })?,
   40     40   
        );
   41     41   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   42     42   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   43     43   
        output.build()
   44     44   
    })
   45     45   
}
   46     46   
   47     47   
pub fn ser_list_object_versions_headers(
   48     48   
    input: &crate::operation::list_object_versions::ListObjectVersionsInput,
   49         -
    mut builder: ::http::request::Builder,
   50         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          49  +
    mut builder: ::http_1x::request::Builder,
          50  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   51     51   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   52     52   
        let formatted_2 = inner_1.as_str();
   53     53   
        let header_value = formatted_2;
   54         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          54  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   55     55   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   56     56   
                "expected_bucket_owner",
   57     57   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   58     58   
            )
   59     59   
        })?;
   60     60   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   61     61   
    }
   62     62   
    if let ::std::option::Option::Some(inner_3) = &input.request_payer {
   63     63   
        let formatted_4 = inner_3.as_str();
   64     64   
        let header_value = formatted_4;
   65         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          65  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   66     66   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   67     67   
                "request_payer",
   68     68   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   69     69   
            )
   70     70   
        })?;
   71     71   
        builder = builder.header("x-amz-request-payer", header_value);
   72     72   
    }
   73     73   
    if let ::std::option::Option::Some(inner_5) = &input.optional_object_attributes {
   74     74   
        // Empty vec in header is serialized as an empty string
   75     75   
        if inner_5.is_empty() {
   76     76   
            builder = builder.header("x-amz-optional-object-attributes", "");
   77     77   
        } else {
   78     78   
            for inner_6 in inner_5 {
   79     79   
                let formatted_7 = ::aws_smithy_http::header::quote_header_value(inner_6.as_str());
   80     80   
                let header_value = formatted_7;
   81         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          81  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   82     82   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
   83     83   
                        "optional_object_attributes",
   84     84   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
   85     85   
                    )
   86     86   
                })?;
   87     87   
                builder = builder.header("x-amz-optional-object-attributes", header_value);
   88     88   
            }
   89     89   
        }
   90     90   
    }
   91     91   
    Ok(builder)