AWS SDK

AWS SDK

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5

Files changed:

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

@@ -10,10 +87,87 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::put_bucket_replication::builders::PutBucketReplicationOutputBuilder::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_put_bucket_replication_headers(
   39     39   
    input: &crate::operation::put_bucket_replication::PutBucketReplicationInput,
   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.content_md5 {
   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   
                "content_md5",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("Content-MD5", header_value);
   52     52   
    }
   53     53   
    if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
   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   
                "checksum_algorithm",
   59     59   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   60     60   
            )
   61     61   
        })?;
   62     62   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   63     63   
    }
   64     64   
    if let ::std::option::Option::Some(inner_5) = &input.token {
   65     65   
        let formatted_6 = inner_5.as_str();
   66     66   
        let header_value = formatted_6;
   67         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          67  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   68     68   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   69     69   
                "token",
   70     70   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   71     71   
            )
   72     72   
        })?;
   73     73   
        builder = builder.header("x-amz-bucket-object-lock-token", header_value);
   74     74   
    }
   75     75   
    if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
   76     76   
        let formatted_8 = inner_7.as_str();
   77     77   
        let header_value = formatted_8;
   78         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          78  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   79     79   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   80     80   
                "expected_bucket_owner",
   81     81   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   82     82   
            )
   83     83   
        })?;
   84     84   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   85     85   
    }
   86     86   
    Ok(builder)
   87     87   
}

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

@@ -12,12 +78,78 @@
   32     32   
        #[allow(unused_mut)]
   33     33   
        let mut output = crate::operation::put_bucket_request_payment::builders::PutBucketRequestPaymentOutputBuilder::default();
   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_put_bucket_request_payment_headers(
   41     41   
    input: &crate::operation::put_bucket_request_payment::PutBucketRequestPaymentInput,
   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.content_md5 {
   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   
                "content_md5",
   50     50   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   51     51   
            )
   52     52   
        })?;
   53     53   
        builder = builder.header("Content-MD5", header_value);
   54     54   
    }
   55     55   
    if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
   56     56   
        let formatted_4 = inner_3.as_str();
   57     57   
        let header_value = formatted_4;
   58         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          58  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   59     59   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   60     60   
                "checksum_algorithm",
   61     61   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   62     62   
            )
   63     63   
        })?;
   64     64   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   65     65   
    }
   66     66   
    if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
   67     67   
        let formatted_6 = inner_5.as_str();
   68     68   
        let header_value = formatted_6;
   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   
                "expected_bucket_owner",
   72     72   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     73   
            )
   74     74   
        })?;
   75     75   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   76     76   
    }
   77     77   
    Ok(builder)
   78     78   
}

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

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

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

@@ -10,10 +87,87 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::put_bucket_versioning::builders::PutBucketVersioningOutputBuilder::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_put_bucket_versioning_headers(
   39     39   
    input: &crate::operation::put_bucket_versioning::PutBucketVersioningInput,
   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.content_md5 {
   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   
                "content_md5",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("Content-MD5", header_value);
   52     52   
    }
   53     53   
    if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
   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   
                "checksum_algorithm",
   59     59   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   60     60   
            )
   61     61   
        })?;
   62     62   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   63     63   
    }
   64     64   
    if let ::std::option::Option::Some(inner_5) = &input.mfa {
   65     65   
        let formatted_6 = inner_5.as_str();
   66     66   
        let header_value = formatted_6;
   67         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          67  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   68     68   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   69     69   
                "mfa",
   70     70   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   71     71   
            )
   72     72   
        })?;
   73     73   
        builder = builder.header("x-amz-mfa", header_value);
   74     74   
    }
   75     75   
    if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
   76     76   
        let formatted_8 = inner_7.as_str();
   77     77   
        let header_value = formatted_8;
   78         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          78  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   79     79   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   80     80   
                "expected_bucket_owner",
   81     81   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   82     82   
            )
   83     83   
        })?;
   84     84   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   85     85   
    }
   86     86   
    Ok(builder)
   87     87   
}

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

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

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

@@ -165,165 +629,629 @@
  185    185   
                .map_err(|_| crate::operation::put_object::PutObjectError::unhandled("Failed to parse VersionId from header `x-amz-version-id"))?,
  186    186   
        );
  187    187   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
  188    188   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  189    189   
        output.build()
  190    190   
    })
  191    191   
}
  192    192   
  193    193   
pub fn ser_put_object_headers(
  194    194   
    input: &crate::operation::put_object::PutObjectInput,
  195         -
    mut builder: ::http::request::Builder,
  196         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
    mut builder: ::http_1x::request::Builder,
         196  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
    if let ::std::option::Option::Some(inner_1) = &input.acl {
  198    198   
        let formatted_2 = inner_1.as_str();
  199    199   
        let header_value = formatted_2;
  200         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         200  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  201    201   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  202    202   
                "acl",
  203    203   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  204    204   
            )
  205    205   
        })?;
  206    206   
        builder = builder.header("x-amz-acl", header_value);
  207    207   
    }
  208    208   
    if let ::std::option::Option::Some(inner_3) = &input.cache_control {
  209    209   
        let formatted_4 = inner_3.as_str();
  210    210   
        let header_value = formatted_4;
  211         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         211  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  212    212   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  213    213   
                "cache_control",
  214    214   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  215    215   
            )
  216    216   
        })?;
  217    217   
        builder = builder.header("Cache-Control", header_value);
  218    218   
    }
  219    219   
    if let ::std::option::Option::Some(inner_5) = &input.content_disposition {
  220    220   
        let formatted_6 = inner_5.as_str();
  221    221   
        let header_value = formatted_6;
  222         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         222  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  223    223   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  224    224   
                "content_disposition",
  225    225   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  226    226   
            )
  227    227   
        })?;
  228    228   
        builder = builder.header("Content-Disposition", header_value);
  229    229   
    }
  230    230   
    if let ::std::option::Option::Some(inner_7) = &input.content_encoding {
  231    231   
        let formatted_8 = inner_7.as_str();
  232    232   
        let header_value = formatted_8;
  233         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         233  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  234    234   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  235    235   
                "content_encoding",
  236    236   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  237    237   
            )
  238    238   
        })?;
  239    239   
        builder = builder.header("Content-Encoding", header_value);
  240    240   
    }
  241    241   
    if let ::std::option::Option::Some(inner_9) = &input.content_language {
  242    242   
        let formatted_10 = inner_9.as_str();
  243    243   
        let header_value = formatted_10;
  244         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         244  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  245    245   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  246    246   
                "content_language",
  247    247   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  248    248   
            )
  249    249   
        })?;
  250    250   
        builder = builder.header("Content-Language", header_value);
  251    251   
    }
  252    252   
    if let ::std::option::Option::Some(inner_11) = &input.content_length {
  253    253   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_11);
  254    254   
        let formatted_12 = encoder.encode();
  255    255   
        let header_value = formatted_12;
  256         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         256  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  257    257   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  258    258   
                "content_length",
  259    259   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  260    260   
            )
  261    261   
        })?;
  262    262   
        builder = builder.header("Content-Length", header_value);
  263    263   
    }
  264    264   
    if let ::std::option::Option::Some(inner_13) = &input.content_md5 {
  265    265   
        let formatted_14 = inner_13.as_str();
  266    266   
        let header_value = formatted_14;
  267         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         267  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  268    268   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  269    269   
                "content_md5",
  270    270   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  271    271   
            )
  272    272   
        })?;
  273    273   
        builder = builder.header("Content-MD5", header_value);
  274    274   
    }
  275    275   
    if let ::std::option::Option::Some(inner_15) = &input.content_type {
  276    276   
        let formatted_16 = inner_15.as_str();
  277    277   
        let header_value = formatted_16;
  278         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         278  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  279    279   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  280    280   
                "content_type",
  281    281   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  282    282   
            )
  283    283   
        })?;
  284    284   
        builder = builder.header("Content-Type", header_value);
  285    285   
    }
  286    286   
    if let ::std::option::Option::Some(inner_17) = &input.checksum_algorithm {
  287    287   
        let formatted_18 = inner_17.as_str();
  288    288   
        let header_value = formatted_18;
  289         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         289  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  290    290   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  291    291   
                "checksum_algorithm",
  292    292   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  293    293   
            )
  294    294   
        })?;
  295    295   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
  296    296   
    }
  297    297   
    if let ::std::option::Option::Some(inner_19) = &input.checksum_crc32 {
  298    298   
        let formatted_20 = inner_19.as_str();
  299    299   
        let header_value = formatted_20;
  300         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         300  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  301    301   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  302    302   
                "checksum_crc32",
  303    303   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  304    304   
            )
  305    305   
        })?;
  306    306   
        builder = builder.header("x-amz-checksum-crc32", header_value);
  307    307   
    }
  308    308   
    if let ::std::option::Option::Some(inner_21) = &input.checksum_crc32_c {
  309    309   
        let formatted_22 = inner_21.as_str();
  310    310   
        let header_value = formatted_22;
  311         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         311  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  312    312   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  313    313   
                "checksum_crc32_c",
  314    314   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  315    315   
            )
  316    316   
        })?;
  317    317   
        builder = builder.header("x-amz-checksum-crc32c", header_value);
  318    318   
    }
  319    319   
    if let ::std::option::Option::Some(inner_23) = &input.checksum_crc64_nvme {
  320    320   
        let formatted_24 = inner_23.as_str();
  321    321   
        let header_value = formatted_24;
  322         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         322  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  323    323   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  324    324   
                "checksum_crc64_nvme",
  325    325   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  326    326   
            )
  327    327   
        })?;
  328    328   
        builder = builder.header("x-amz-checksum-crc64nvme", header_value);
  329    329   
    }
  330    330   
    if let ::std::option::Option::Some(inner_25) = &input.checksum_sha1 {
  331    331   
        let formatted_26 = inner_25.as_str();
  332    332   
        let header_value = formatted_26;
  333         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         333  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  334    334   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  335    335   
                "checksum_sha1",
  336    336   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  337    337   
            )
  338    338   
        })?;
  339    339   
        builder = builder.header("x-amz-checksum-sha1", header_value);
  340    340   
    }
  341    341   
    if let ::std::option::Option::Some(inner_27) = &input.checksum_sha256 {
  342    342   
        let formatted_28 = inner_27.as_str();
  343    343   
        let header_value = formatted_28;
  344         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         344  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  345    345   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  346    346   
                "checksum_sha256",
  347    347   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  348    348   
            )
  349    349   
        })?;
  350    350   
        builder = builder.header("x-amz-checksum-sha256", header_value);
  351    351   
    }
  352    352   
    if let ::std::option::Option::Some(inner_29) = &input.expires {
  353    353   
        let formatted_30 = inner_29.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  354    354   
        let header_value = formatted_30;
  355         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         355  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  356    356   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  357    357   
                "expires",
  358    358   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  359    359   
            )
  360    360   
        })?;
  361    361   
        builder = builder.header("Expires", header_value);
  362    362   
    }
  363    363   
    if let ::std::option::Option::Some(inner_31) = &input.if_match {
  364    364   
        let formatted_32 = inner_31.as_str();
  365    365   
        let header_value = formatted_32;
  366         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         366  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  367    367   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  368    368   
                "if_match",
  369    369   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  370    370   
            )
  371    371   
        })?;
  372    372   
        builder = builder.header("If-Match", header_value);
  373    373   
    }
  374    374   
    if let ::std::option::Option::Some(inner_33) = &input.if_none_match {
  375    375   
        let formatted_34 = inner_33.as_str();
  376    376   
        let header_value = formatted_34;
  377         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         377  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  378    378   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  379    379   
                "if_none_match",
  380    380   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  381    381   
            )
  382    382   
        })?;
  383    383   
        builder = builder.header("If-None-Match", header_value);
  384    384   
    }
  385    385   
    if let ::std::option::Option::Some(inner_35) = &input.grant_full_control {
  386    386   
        let formatted_36 = inner_35.as_str();
  387    387   
        let header_value = formatted_36;
  388         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         388  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  389    389   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  390    390   
                "grant_full_control",
  391    391   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  392    392   
            )
  393    393   
        })?;
  394    394   
        builder = builder.header("x-amz-grant-full-control", header_value);
  395    395   
    }
  396    396   
    if let ::std::option::Option::Some(inner_37) = &input.grant_read {
  397    397   
        let formatted_38 = inner_37.as_str();
  398    398   
        let header_value = formatted_38;
  399         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         399  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  400    400   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  401    401   
                "grant_read",
  402    402   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  403    403   
            )
  404    404   
        })?;
  405    405   
        builder = builder.header("x-amz-grant-read", header_value);
  406    406   
    }
  407    407   
    if let ::std::option::Option::Some(inner_39) = &input.grant_read_acp {
  408    408   
        let formatted_40 = inner_39.as_str();
  409    409   
        let header_value = formatted_40;
  410         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         410  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  411    411   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  412    412   
                "grant_read_acp",
  413    413   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  414    414   
            )
  415    415   
        })?;
  416    416   
        builder = builder.header("x-amz-grant-read-acp", header_value);
  417    417   
    }
  418    418   
    if let ::std::option::Option::Some(inner_41) = &input.grant_write_acp {
  419    419   
        let formatted_42 = inner_41.as_str();
  420    420   
        let header_value = formatted_42;
  421         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         421  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  422    422   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  423    423   
                "grant_write_acp",
  424    424   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  425    425   
            )
  426    426   
        })?;
  427    427   
        builder = builder.header("x-amz-grant-write-acp", header_value);
  428    428   
    }
  429    429   
    if let ::std::option::Option::Some(inner_43) = &input.write_offset_bytes {
  430    430   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_43);
  431    431   
        let formatted_44 = encoder.encode();
  432    432   
        let header_value = formatted_44;
  433         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         433  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  434    434   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  435    435   
                "write_offset_bytes",
  436    436   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  437    437   
            )
  438    438   
        })?;
  439    439   
        builder = builder.header("x-amz-write-offset-bytes", header_value);
  440    440   
    }
  441    441   
    if let ::std::option::Option::Some(inner_45) = &input.server_side_encryption {
  442    442   
        let formatted_46 = inner_45.as_str();
  443    443   
        let header_value = formatted_46;
  444         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         444  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  445    445   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  446    446   
                "server_side_encryption",
  447    447   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  448    448   
            )
  449    449   
        })?;
  450    450   
        builder = builder.header("x-amz-server-side-encryption", header_value);
  451    451   
    }
  452    452   
    if let ::std::option::Option::Some(inner_47) = &input.storage_class {
  453    453   
        let formatted_48 = inner_47.as_str();
  454    454   
        let header_value = formatted_48;
  455         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         455  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  456    456   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  457    457   
                "storage_class",
  458    458   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  459    459   
            )
  460    460   
        })?;
  461    461   
        builder = builder.header("x-amz-storage-class", header_value);
  462    462   
    }
  463    463   
    if let ::std::option::Option::Some(inner_49) = &input.website_redirect_location {
  464    464   
        let formatted_50 = inner_49.as_str();
  465    465   
        let header_value = formatted_50;
  466         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         466  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  467    467   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  468    468   
                "website_redirect_location",
  469    469   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  470    470   
            )
  471    471   
        })?;
  472    472   
        builder = builder.header("x-amz-website-redirect-location", header_value);
  473    473   
    }
  474    474   
    if let ::std::option::Option::Some(inner_51) = &input.sse_customer_algorithm {
  475    475   
        let formatted_52 = inner_51.as_str();
  476    476   
        let header_value = formatted_52;
  477         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         477  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  478    478   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  479    479   
                "sse_customer_algorithm",
  480    480   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  481    481   
            )
  482    482   
        })?;
  483    483   
        builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
  484    484   
    }
  485    485   
    if let ::std::option::Option::Some(inner_53) = &input.sse_customer_key {
  486    486   
        let formatted_54 = inner_53.as_str();
  487    487   
        let header_value = formatted_54;
  488         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         488  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  489    489   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  490    490   
                "sse_customer_key",
  491    491   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  492    492   
            )
  493    493   
        })?;
  494    494   
        builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
  495    495   
    }
  496    496   
    if let ::std::option::Option::Some(inner_55) = &input.sse_customer_key_md5 {
  497    497   
        let formatted_56 = inner_55.as_str();
  498    498   
        let header_value = formatted_56;
  499         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         499  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  500    500   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  501    501   
                "sse_customer_key_md5",
  502    502   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  503    503   
            )
  504    504   
        })?;
  505    505   
        builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  506    506   
    }
  507    507   
    if let ::std::option::Option::Some(inner_57) = &input.ssekms_key_id {
  508    508   
        let formatted_58 = inner_57.as_str();
  509    509   
        let header_value = formatted_58;
  510         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         510  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  511    511   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  512    512   
                "ssekms_key_id",
  513    513   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  514    514   
            )
  515    515   
        })?;
  516    516   
        builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
  517    517   
    }
  518    518   
    if let ::std::option::Option::Some(inner_59) = &input.ssekms_encryption_context {
  519    519   
        let formatted_60 = inner_59.as_str();
  520    520   
        let header_value = formatted_60;
  521         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         521  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  522    522   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  523    523   
                "ssekms_encryption_context",
  524    524   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  525    525   
            )
  526    526   
        })?;
  527    527   
        builder = builder.header("x-amz-server-side-encryption-context", header_value);
  528    528   
    }
  529    529   
    if let ::std::option::Option::Some(inner_61) = &input.bucket_key_enabled {
  530    530   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_61);
  531    531   
        let formatted_62 = encoder.encode();
  532    532   
        let header_value = formatted_62;
  533         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         533  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  534    534   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  535    535   
                "bucket_key_enabled",
  536    536   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  537    537   
            )
  538    538   
        })?;
  539    539   
        builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
  540    540   
    }
  541    541   
    if let ::std::option::Option::Some(inner_63) = &input.request_payer {
  542    542   
        let formatted_64 = inner_63.as_str();
  543    543   
        let header_value = formatted_64;
  544         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         544  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  545    545   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  546    546   
                "request_payer",
  547    547   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  548    548   
            )
  549    549   
        })?;
  550    550   
        builder = builder.header("x-amz-request-payer", header_value);
  551    551   
    }
  552    552   
    if let ::std::option::Option::Some(inner_65) = &input.tagging {
  553    553   
        let formatted_66 = inner_65.as_str();
  554    554   
        let header_value = formatted_66;
  555         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         555  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  556    556   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  557    557   
                "tagging",
  558    558   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  559    559   
            )
  560    560   
        })?;
  561    561   
        builder = builder.header("x-amz-tagging", header_value);
  562    562   
    }
  563    563   
    if let ::std::option::Option::Some(inner_67) = &input.object_lock_mode {
  564    564   
        let formatted_68 = inner_67.as_str();
  565    565   
        let header_value = formatted_68;
  566         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         566  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  567    567   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  568    568   
                "object_lock_mode",
  569    569   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  570    570   
            )
  571    571   
        })?;
  572    572   
        builder = builder.header("x-amz-object-lock-mode", header_value);
  573    573   
    }
  574    574   
    if let ::std::option::Option::Some(inner_69) = &input.object_lock_retain_until_date {
  575    575   
        let formatted_70 = inner_69.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
  576    576   
        let header_value = formatted_70;
  577         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         577  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  578    578   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  579    579   
                "object_lock_retain_until_date",
  580    580   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  581    581   
            )
  582    582   
        })?;
  583    583   
        builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
  584    584   
    }
  585    585   
    if let ::std::option::Option::Some(inner_71) = &input.object_lock_legal_hold_status {
  586    586   
        let formatted_72 = inner_71.as_str();
  587    587   
        let header_value = formatted_72;
  588         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         588  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  589    589   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  590    590   
                "object_lock_legal_hold_status",
  591    591   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  592    592   
            )
  593    593   
        })?;
  594    594   
        builder = builder.header("x-amz-object-lock-legal-hold", header_value);
  595    595   
    }
  596    596   
    if let ::std::option::Option::Some(inner_73) = &input.expected_bucket_owner {
  597    597   
        let formatted_74 = inner_73.as_str();
  598    598   
        let header_value = formatted_74;
  599         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         599  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  600    600   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  601    601   
                "expected_bucket_owner",
  602    602   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  603    603   
            )
  604    604   
        })?;
  605    605   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  606    606   
    }
  607    607   
    if let ::std::option::Option::Some(inner_75) = &input.metadata {
  608    608   
        {
  609    609   
            for (k, v) in inner_75 {
  610    610   
                use std::str::FromStr;
  611         -
                let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
         611  +
                let header_name = ::http_1x::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
  612    612   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  613    613   
                        "metadata",
  614    614   
                        format!("`{k}` cannot be used as a header name: {err}"),
  615    615   
                    )
  616    616   
                })?;
  617    617   
                let header_value = v.as_str();
  618         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         618  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  619    619   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  620    620   
                        "metadata",
  621    621   
                        format!("`{v}` cannot be used as a header value: {err}"),
  622    622   
                    )
  623    623   
                })?;
  624    624   
                builder = builder.header(header_name, header_value);
  625    625   
            }
  626    626   
        }
  627    627   
    }
  628    628   
    Ok(builder)

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

@@ -32,32 +175,175 @@
   52     52   
            })?,
   53     53   
        );
   54     54   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   55     55   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   56     56   
        output.build()
   57     57   
    })
   58     58   
}
   59     59   
   60     60   
pub fn ser_put_object_acl_headers(
   61     61   
    input: &crate::operation::put_object_acl::PutObjectAclInput,
   62         -
    mut builder: ::http::request::Builder,
   63         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          62  +
    mut builder: ::http_1x::request::Builder,
          63  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   64     64   
    if let ::std::option::Option::Some(inner_1) = &input.acl {
   65     65   
        let formatted_2 = inner_1.as_str();
   66     66   
        let header_value = formatted_2;
   67         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          67  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   68     68   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   69     69   
                "acl",
   70     70   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   71     71   
            )
   72     72   
        })?;
   73     73   
        builder = builder.header("x-amz-acl", header_value);
   74     74   
    }
   75     75   
    if let ::std::option::Option::Some(inner_3) = &input.content_md5 {
   76     76   
        let formatted_4 = inner_3.as_str();
   77     77   
        let header_value = formatted_4;
   78         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          78  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   79     79   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   80     80   
                "content_md5",
   81     81   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   82     82   
            )
   83     83   
        })?;
   84     84   
        builder = builder.header("Content-MD5", header_value);
   85     85   
    }
   86     86   
    if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
   87     87   
        let formatted_6 = inner_5.as_str();
   88     88   
        let header_value = formatted_6;
   89         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          89  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   90     90   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   91     91   
                "checksum_algorithm",
   92     92   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   93     93   
            )
   94     94   
        })?;
   95     95   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   96     96   
    }
   97     97   
    if let ::std::option::Option::Some(inner_7) = &input.grant_full_control {
   98     98   
        let formatted_8 = inner_7.as_str();
   99     99   
        let header_value = formatted_8;
  100         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         100  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  101    101   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  102    102   
                "grant_full_control",
  103    103   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  104    104   
            )
  105    105   
        })?;
  106    106   
        builder = builder.header("x-amz-grant-full-control", header_value);
  107    107   
    }
  108    108   
    if let ::std::option::Option::Some(inner_9) = &input.grant_read {
  109    109   
        let formatted_10 = inner_9.as_str();
  110    110   
        let header_value = formatted_10;
  111         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         111  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  112    112   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  113    113   
                "grant_read",
  114    114   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  115    115   
            )
  116    116   
        })?;
  117    117   
        builder = builder.header("x-amz-grant-read", header_value);
  118    118   
    }
  119    119   
    if let ::std::option::Option::Some(inner_11) = &input.grant_read_acp {
  120    120   
        let formatted_12 = inner_11.as_str();
  121    121   
        let header_value = formatted_12;
  122         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         122  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  123    123   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  124    124   
                "grant_read_acp",
  125    125   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  126    126   
            )
  127    127   
        })?;
  128    128   
        builder = builder.header("x-amz-grant-read-acp", header_value);
  129    129   
    }
  130    130   
    if let ::std::option::Option::Some(inner_13) = &input.grant_write {
  131    131   
        let formatted_14 = inner_13.as_str();
  132    132   
        let header_value = formatted_14;
  133         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         133  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  134    134   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  135    135   
                "grant_write",
  136    136   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  137    137   
            )
  138    138   
        })?;
  139    139   
        builder = builder.header("x-amz-grant-write", header_value);
  140    140   
    }
  141    141   
    if let ::std::option::Option::Some(inner_15) = &input.grant_write_acp {
  142    142   
        let formatted_16 = inner_15.as_str();
  143    143   
        let header_value = formatted_16;
  144         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         144  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  145    145   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  146    146   
                "grant_write_acp",
  147    147   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  148    148   
            )
  149    149   
        })?;
  150    150   
        builder = builder.header("x-amz-grant-write-acp", header_value);
  151    151   
    }
  152    152   
    if let ::std::option::Option::Some(inner_17) = &input.request_payer {
  153    153   
        let formatted_18 = inner_17.as_str();
  154    154   
        let header_value = formatted_18;
  155         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         155  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  156    156   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  157    157   
                "request_payer",
  158    158   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  159    159   
            )
  160    160   
        })?;
  161    161   
        builder = builder.header("x-amz-request-payer", header_value);
  162    162   
    }
  163    163   
    if let ::std::option::Option::Some(inner_19) = &input.expected_bucket_owner {
  164    164   
        let formatted_20 = inner_19.as_str();
  165    165   
        let header_value = formatted_20;
  166         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         166  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  167    167   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  168    168   
                "expected_bucket_owner",
  169    169   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  170    170   
            )
  171    171   
        })?;
  172    172   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  173    173   
    }
  174    174   
    Ok(builder)
  175    175   
}

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

@@ -17,17 +94,94 @@
   37     37   
            })?,
   38     38   
        );
   39     39   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   40     40   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   41     41   
        output.build()
   42     42   
    })
   43     43   
}
   44     44   
   45     45   
pub fn ser_put_object_legal_hold_headers(
   46     46   
    input: &crate::operation::put_object_legal_hold::PutObjectLegalHoldInput,
   47         -
    mut builder: ::http::request::Builder,
   48         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          47  +
    mut builder: ::http_1x::request::Builder,
          48  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   49     49   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   50     50   
        let formatted_2 = inner_1.as_str();
   51     51   
        let header_value = formatted_2;
   52         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          52  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   53     53   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   54     54   
                "request_payer",
   55     55   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   56     56   
            )
   57     57   
        })?;
   58     58   
        builder = builder.header("x-amz-request-payer", header_value);
   59     59   
    }
   60     60   
    if let ::std::option::Option::Some(inner_3) = &input.content_md5 {
   61     61   
        let formatted_4 = inner_3.as_str();
   62     62   
        let header_value = formatted_4;
   63         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          63  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   64     64   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   65     65   
                "content_md5",
   66     66   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   67     67   
            )
   68     68   
        })?;
   69     69   
        builder = builder.header("Content-MD5", header_value);
   70     70   
    }
   71     71   
    if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
   72     72   
        let formatted_6 = inner_5.as_str();
   73     73   
        let header_value = formatted_6;
   74         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          74  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   75     75   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   76     76   
                "checksum_algorithm",
   77     77   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   78     78   
            )
   79     79   
        })?;
   80     80   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   81     81   
    }
   82     82   
    if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
   83     83   
        let formatted_8 = inner_7.as_str();
   84     84   
        let header_value = formatted_8;
   85         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          85  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   86     86   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   87     87   
                "expected_bucket_owner",
   88     88   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   89     89   
            )
   90     90   
        })?;
   91     91   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   92     92   
    }
   93     93   
    Ok(builder)
   94     94   
}

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

@@ -19,19 +107,107 @@
   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_put_object_lock_configuration_headers(
   48     48   
    input: &crate::operation::put_object_lock_configuration::PutObjectLockConfigurationInput,
   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.request_payer {
   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   
                "request_payer",
   57     57   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   58     58   
            )
   59     59   
        })?;
   60     60   
        builder = builder.header("x-amz-request-payer", header_value);
   61     61   
    }
   62     62   
    if let ::std::option::Option::Some(inner_3) = &input.token {
   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   
                "token",
   68     68   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   69     69   
            )
   70     70   
        })?;
   71     71   
        builder = builder.header("x-amz-bucket-object-lock-token", header_value);
   72     72   
    }
   73     73   
    if let ::std::option::Option::Some(inner_5) = &input.content_md5 {
   74     74   
        let formatted_6 = inner_5.as_str();
   75     75   
        let header_value = formatted_6;
   76         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          76  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   77     77   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   78     78   
                "content_md5",
   79     79   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   80     80   
            )
   81     81   
        })?;
   82     82   
        builder = builder.header("Content-MD5", header_value);
   83     83   
    }
   84     84   
    if let ::std::option::Option::Some(inner_7) = &input.checksum_algorithm {
   85     85   
        let formatted_8 = inner_7.as_str();
   86     86   
        let header_value = formatted_8;
   87         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          87  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   88     88   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   89     89   
                "checksum_algorithm",
   90     90   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   91     91   
            )
   92     92   
        })?;
   93     93   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   94     94   
    }
   95     95   
    if let ::std::option::Option::Some(inner_9) = &input.expected_bucket_owner {
   96     96   
        let formatted_10 = inner_9.as_str();
   97     97   
        let header_value = formatted_10;
   98         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          98  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   99     99   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  100    100   
                "expected_bucket_owner",
  101    101   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  102    102   
            )
  103    103   
        })?;
  104    104   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  105    105   
    }
  106    106   
    Ok(builder)
  107    107   
}

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

@@ -17,17 +106,106 @@
   37     37   
            })?,
   38     38   
        );
   39     39   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   40     40   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   41     41   
        output.build()
   42     42   
    })
   43     43   
}
   44     44   
   45     45   
pub fn ser_put_object_retention_headers(
   46     46   
    input: &crate::operation::put_object_retention::PutObjectRetentionInput,
   47         -
    mut builder: ::http::request::Builder,
   48         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          47  +
    mut builder: ::http_1x::request::Builder,
          48  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   49     49   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   50     50   
        let formatted_2 = inner_1.as_str();
   51     51   
        let header_value = formatted_2;
   52         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          52  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   53     53   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   54     54   
                "request_payer",
   55     55   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   56     56   
            )
   57     57   
        })?;
   58     58   
        builder = builder.header("x-amz-request-payer", header_value);
   59     59   
    }
   60     60   
    if let ::std::option::Option::Some(inner_3) = &input.bypass_governance_retention {
   61     61   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_3);
   62     62   
        let formatted_4 = encoder.encode();
   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   
                "bypass_governance_retention",
   67     67   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   68     68   
            )
   69     69   
        })?;
   70     70   
        builder = builder.header("x-amz-bypass-governance-retention", header_value);
   71     71   
    }
   72     72   
    if let ::std::option::Option::Some(inner_5) = &input.content_md5 {
   73     73   
        let formatted_6 = inner_5.as_str();
   74     74   
        let header_value = formatted_6;
   75         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          75  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   76     76   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   77     77   
                "content_md5",
   78     78   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   79     79   
            )
   80     80   
        })?;
   81     81   
        builder = builder.header("Content-MD5", header_value);
   82     82   
    }
   83     83   
    if let ::std::option::Option::Some(inner_7) = &input.checksum_algorithm {
   84     84   
        let formatted_8 = inner_7.as_str();
   85     85   
        let header_value = formatted_8;
   86         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          86  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   87     87   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   88     88   
                "checksum_algorithm",
   89     89   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   90     90   
            )
   91     91   
        })?;
   92     92   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   93     93   
    }
   94     94   
    if let ::std::option::Option::Some(inner_9) = &input.expected_bucket_owner {
   95     95   
        let formatted_10 = inner_9.as_str();
   96     96   
        let header_value = formatted_10;
   97         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          97  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   98     98   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   99     99   
                "expected_bucket_owner",
  100    100   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  101    101   
            )
  102    102   
        })?;
  103    103   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  104    104   
    }
  105    105   
    Ok(builder)
  106    106   
}

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

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

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

@@ -10,10 +76,76 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::put_public_access_block::builders::PutPublicAccessBlockOutputBuilder::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_put_public_access_block_headers(
   39     39   
    input: &crate::operation::put_public_access_block::PutPublicAccessBlockInput,
   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.content_md5 {
   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   
                "content_md5",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("Content-MD5", header_value);
   52     52   
    }
   53     53   
    if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
   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   
                "checksum_algorithm",
   59     59   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   60     60   
            )
   61     61   
        })?;
   62     62   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   63     63   
    }
   64     64   
    if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
   65     65   
        let formatted_6 = inner_5.as_str();
   66     66   
        let header_value = formatted_6;
   67         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          67  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   68     68   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   69     69   
                "expected_bucket_owner",
   70     70   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   71     71   
            )
   72     72   
        })?;
   73     73   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   74     74   
    }
   75     75   
    Ok(builder)
   76     76   
}

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

@@ -28,28 +171,171 @@
   48     48   
        #[allow(unused_mut)]
   49     49   
        let mut output = crate::operation::rename_object::builders::RenameObjectOutputBuilder::default();
   50     50   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   51     51   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   52     52   
        output.build()
   53     53   
    })
   54     54   
}
   55     55   
   56     56   
pub fn ser_rename_object_headers(
   57     57   
    input: &crate::operation::rename_object::RenameObjectInput,
   58         -
    mut builder: ::http::request::Builder,
   59         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          58  +
    mut builder: ::http_1x::request::Builder,
          59  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   60     60   
    if let ::std::option::Option::Some(inner_1) = &input.rename_source {
   61     61   
        let formatted_2 = inner_1.as_str();
   62     62   
        let header_value = formatted_2;
   63         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          63  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   64     64   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   65     65   
                "rename_source",
   66     66   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   67     67   
            )
   68     68   
        })?;
   69     69   
        builder = builder.header("x-amz-rename-source", header_value);
   70     70   
    }
   71     71   
    if let ::std::option::Option::Some(inner_3) = &input.destination_if_match {
   72     72   
        let formatted_4 = inner_3.as_str();
   73     73   
        let header_value = formatted_4;
   74         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          74  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   75     75   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   76     76   
                "destination_if_match",
   77     77   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   78     78   
            )
   79     79   
        })?;
   80     80   
        builder = builder.header("If-Match", header_value);
   81     81   
    }
   82     82   
    if let ::std::option::Option::Some(inner_5) = &input.destination_if_none_match {
   83     83   
        let formatted_6 = inner_5.as_str();
   84     84   
        let header_value = formatted_6;
   85         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          85  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   86     86   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   87     87   
                "destination_if_none_match",
   88     88   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   89     89   
            )
   90     90   
        })?;
   91     91   
        builder = builder.header("If-None-Match", header_value);
   92     92   
    }
   93     93   
    if let ::std::option::Option::Some(inner_7) = &input.destination_if_modified_since {
   94     94   
        let formatted_8 = inner_7.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
   95     95   
        let header_value = formatted_8;
   96         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          96  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   97     97   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   98     98   
                "destination_if_modified_since",
   99     99   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  100    100   
            )
  101    101   
        })?;
  102    102   
        builder = builder.header("If-Modified-Since", header_value);
  103    103   
    }
  104    104   
    if let ::std::option::Option::Some(inner_9) = &input.destination_if_unmodified_since {
  105    105   
        let formatted_10 = inner_9.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  106    106   
        let header_value = formatted_10;
  107         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         107  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  108    108   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  109    109   
                "destination_if_unmodified_since",
  110    110   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  111    111   
            )
  112    112   
        })?;
  113    113   
        builder = builder.header("If-Unmodified-Since", header_value);
  114    114   
    }
  115    115   
    if let ::std::option::Option::Some(inner_11) = &input.source_if_match {
  116    116   
        let formatted_12 = inner_11.as_str();
  117    117   
        let header_value = formatted_12;
  118         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         118  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  119    119   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  120    120   
                "source_if_match",
  121    121   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  122    122   
            )
  123    123   
        })?;
  124    124   
        builder = builder.header("x-amz-rename-source-if-match", header_value);
  125    125   
    }
  126    126   
    if let ::std::option::Option::Some(inner_13) = &input.source_if_none_match {
  127    127   
        let formatted_14 = inner_13.as_str();
  128    128   
        let header_value = formatted_14;
  129         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         129  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  130    130   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  131    131   
                "source_if_none_match",
  132    132   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  133    133   
            )
  134    134   
        })?;
  135    135   
        builder = builder.header("x-amz-rename-source-if-none-match", header_value);
  136    136   
    }
  137    137   
    if let ::std::option::Option::Some(inner_15) = &input.source_if_modified_since {
  138    138   
        let formatted_16 = inner_15.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  139    139   
        let header_value = formatted_16;
  140         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         140  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  141    141   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  142    142   
                "source_if_modified_since",
  143    143   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  144    144   
            )
  145    145   
        })?;
  146    146   
        builder = builder.header("x-amz-rename-source-if-modified-since", header_value);
  147    147   
    }
  148    148   
    if let ::std::option::Option::Some(inner_17) = &input.source_if_unmodified_since {
  149    149   
        let formatted_18 = inner_17.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  150    150   
        let header_value = formatted_18;
  151         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         151  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  152    152   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  153    153   
                "source_if_unmodified_since",
  154    154   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  155    155   
            )
  156    156   
        })?;
  157    157   
        builder = builder.header("x-amz-rename-source-if-unmodified-since", header_value);
  158    158   
    }
  159    159   
    if let ::std::option::Option::Some(inner_19) = &input.client_token {
  160    160   
        let formatted_20 = inner_19.as_str();
  161    161   
        let header_value = formatted_20;
  162         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         162  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  163    163   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  164    164   
                "client_token",
  165    165   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  166    166   
            )
  167    167   
        })?;
  168    168   
        builder = builder.header("x-amz-client-token", header_value);
  169    169   
    }
  170    170   
    Ok(builder)
  171    171   
}

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

@@ -42,42 +108,108 @@
   62     62   
            })?,
   63     63   
        );
   64     64   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   65     65   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   66     66   
        output.build()
   67     67   
    })
   68     68   
}
   69     69   
   70     70   
pub fn ser_restore_object_headers(
   71     71   
    input: &crate::operation::restore_object::RestoreObjectInput,
   72         -
    mut builder: ::http::request::Builder,
   73         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          72  +
    mut builder: ::http_1x::request::Builder,
          73  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   74     74   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   75     75   
        let formatted_2 = inner_1.as_str();
   76     76   
        let header_value = formatted_2;
   77         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          77  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   78     78   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   79     79   
                "request_payer",
   80     80   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   81     81   
            )
   82     82   
        })?;
   83     83   
        builder = builder.header("x-amz-request-payer", header_value);
   84     84   
    }
   85     85   
    if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
   86     86   
        let formatted_4 = inner_3.as_str();
   87     87   
        let header_value = formatted_4;
   88         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          88  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   89     89   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   90     90   
                "checksum_algorithm",
   91     91   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   92     92   
            )
   93     93   
        })?;
   94     94   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   95     95   
    }
   96     96   
    if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
   97     97   
        let formatted_6 = inner_5.as_str();
   98     98   
        let header_value = formatted_6;
   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   
                "expected_bucket_owner",
  102    102   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  103    103   
            )
  104    104   
        })?;
  105    105   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  106    106   
    }
  107    107   
    Ok(builder)
  108    108   
}

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

@@ -19,19 +111,111 @@
   39     39   
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
   40     40   
        .map_err(crate::operation::select_object_content::SelectObjectContentError::unhandled)?;
   41     41   
    generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
   42     42   
    generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
   43     43   
    let generic = generic_builder.build();
   44     44   
    Err(crate::operation::select_object_content::SelectObjectContentError::generic(generic))
   45     45   
}
   46     46   
   47     47   
pub fn ser_select_object_content_headers(
   48     48   
    input: &crate::operation::select_object_content::SelectObjectContentInput,
   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.sse_customer_algorithm {
   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   
                "sse_customer_algorithm",
   57     57   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   58     58   
            )
   59     59   
        })?;
   60     60   
        builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
   61     61   
    }
   62     62   
    if let ::std::option::Option::Some(inner_3) = &input.sse_customer_key {
   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   
                "sse_customer_key",
   68     68   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
   69     69   
            )
   70     70   
        })?;
   71     71   
        builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
   72     72   
    }
   73     73   
    if let ::std::option::Option::Some(inner_5) = &input.sse_customer_key_md5 {
   74     74   
        let formatted_6 = inner_5.as_str();
   75     75   
        let header_value = formatted_6;
   76         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          76  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   77     77   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   78     78   
                "sse_customer_key_md5",
   79     79   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   80     80   
            )
   81     81   
        })?;
   82     82   
        builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
   83     83   
    }
   84     84   
    if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
   85     85   
        let formatted_8 = inner_7.as_str();
   86     86   
        let header_value = formatted_8;
   87         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          87  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   88     88   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   89     89   
                "expected_bucket_owner",
   90     90   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   91     91   
            )
   92     92   
        })?;
   93     93   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   94     94   
    }
   95     95   
    Ok(builder)
   96     96   
}
   97     97

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

@@ -15,15 +81,81 @@
   35     35   
        #[allow(unused_mut)]
   36     36   
        let mut output = crate::operation::update_bucket_metadata_inventory_table_configuration::builders::UpdateBucketMetadataInventoryTableConfigurationOutputBuilder::default();
   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_update_bucket_metadata_inventory_table_configuration_headers(
   44     44   
    input: &crate::operation::update_bucket_metadata_inventory_table_configuration::UpdateBucketMetadataInventoryTableConfigurationInput,
   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.content_md5 {
   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   
                "content_md5",
   53     53   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   54     54   
            )
   55     55   
        })?;
   56     56   
        builder = builder.header("Content-MD5", header_value);
   57     57   
    }
   58     58   
    if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
   59     59   
        let formatted_4 = inner_3.as_str();
   60     60   
        let header_value = formatted_4;
   61         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          61  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   62     62   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   63     63   
                "checksum_algorithm",
   64     64   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   65     65   
            )
   66     66   
        })?;
   67     67   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   68     68   
    }
   69     69   
    if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
   70     70   
        let formatted_6 = inner_5.as_str();
   71     71   
        let header_value = formatted_6;
   72         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          72  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   73     73   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   74     74   
                "expected_bucket_owner",
   75     75   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   76     76   
            )
   77     77   
        })?;
   78     78   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   79     79   
    }
   80     80   
    Ok(builder)
   81     81   
}