AWS SDK

AWS SDK

rev. 3c756f73b1f83a0eed4275d9d1e22df0b10b66fb

Files changed:

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

@@ -34,34 +126,126 @@
   54     54   
            })?,
   55     55   
        );
   56     56   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   57     57   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   58     58   
        output.build()
   59     59   
    })
   60     60   
}
   61     61   
   62     62   
pub fn ser_list_objects_headers(
   63     63   
    input: &crate::operation::list_objects::ListObjectsInput,
   64         -
    mut builder: ::http::request::Builder,
   65         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          64  +
    mut builder: ::http_1x::request::Builder,
          65  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   66     66   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   67     67   
        let formatted_2 = inner_1.as_str();
   68     68   
        let header_value = formatted_2;
   69         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          69  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   70     70   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   71     71   
                "request_payer",
   72     72   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     73   
            )
   74     74   
        })?;
   75     75   
        builder = builder.header("x-amz-request-payer", header_value);
   76     76   
    }
   77     77   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   78     78   
        let formatted_4 = inner_3.as_str();
   79     79   
        let header_value = formatted_4;
   80         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          80  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   81     81   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   82     82   
                "expected_bucket_owner",
   83     83   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   84     84   
            )
   85     85   
        })?;
   86     86   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   87     87   
    }
   88     88   
    if let ::std::option::Option::Some(inner_5) = &input.optional_object_attributes {
   89     89   
        // Empty vec in header is serialized as an empty string
   90     90   
        if inner_5.is_empty() {
   91     91   
            builder = builder.header("x-amz-optional-object-attributes", "");
   92     92   
        } else {
   93     93   
            for inner_6 in inner_5 {
   94     94   
                let formatted_7 = ::aws_smithy_http::header::quote_header_value(inner_6.as_str());
   95     95   
                let header_value = formatted_7;
   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   
                        "optional_object_attributes",
   99     99   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
  100    100   
                    )
  101    101   
                })?;
  102    102   
                builder = builder.header("x-amz-optional-object-attributes", header_value);
  103    103   
            }
  104    104   
        }
  105    105   
    }
  106    106   
    Ok(builder)

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

@@ -34,34 +126,126 @@
   54     54   
            })?,
   55     55   
        );
   56     56   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   57     57   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   58     58   
        output.build()
   59     59   
    })
   60     60   
}
   61     61   
   62     62   
pub fn ser_list_objects_v2_headers(
   63     63   
    input: &crate::operation::list_objects_v2::ListObjectsV2Input,
   64         -
    mut builder: ::http::request::Builder,
   65         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          64  +
    mut builder: ::http_1x::request::Builder,
          65  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   66     66   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   67     67   
        let formatted_2 = inner_1.as_str();
   68     68   
        let header_value = formatted_2;
   69         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          69  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   70     70   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   71     71   
                "request_payer",
   72     72   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     73   
            )
   74     74   
        })?;
   75     75   
        builder = builder.header("x-amz-request-payer", header_value);
   76     76   
    }
   77     77   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   78     78   
        let formatted_4 = inner_3.as_str();
   79     79   
        let header_value = formatted_4;
   80         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          80  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   81     81   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   82     82   
                "expected_bucket_owner",
   83     83   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   84     84   
            )
   85     85   
        })?;
   86     86   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   87     87   
    }
   88     88   
    if let ::std::option::Option::Some(inner_5) = &input.optional_object_attributes {
   89     89   
        // Empty vec in header is serialized as an empty string
   90     90   
        if inner_5.is_empty() {
   91     91   
            builder = builder.header("x-amz-optional-object-attributes", "");
   92     92   
        } else {
   93     93   
            for inner_6 in inner_5 {
   94     94   
                let formatted_7 = ::aws_smithy_http::header::quote_header_value(inner_6.as_str());
   95     95   
                let header_value = formatted_7;
   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   
                        "optional_object_attributes",
   99     99   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
  100    100   
                    )
  101    101   
                })?;
  102    102   
                builder = builder.header("x-amz-optional-object-attributes", header_value);
  103    103   
            }
  104    104   
        }
  105    105   
    }
  106    106   
    Ok(builder)

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

@@ -20,20 +129,129 @@
   40     40   
            })?,
   41     41   
        );
   42     42   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   43     43   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   44     44   
        output.build()
   45     45   
    })
   46     46   
}
   47     47   
   48     48   
pub fn ser_list_parts_headers(
   49     49   
    input: &crate::operation::list_parts::ListPartsInput,
   50         -
    mut builder: ::http::request::Builder,
   51         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          50  +
    mut builder: ::http_1x::request::Builder,
          51  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   52     52   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   53     53   
        let formatted_2 = inner_1.as_str();
   54     54   
        let header_value = formatted_2;
   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   
                "request_payer",
   58     58   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   59     59   
            )
   60     60   
        })?;
   61     61   
        builder = builder.header("x-amz-request-payer", header_value);
   62     62   
    }
   63     63   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   64     64   
        let formatted_4 = inner_3.as_str();
   65     65   
        let header_value = formatted_4;
   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_5) = &input.sse_customer_algorithm {
   75     75   
        let formatted_6 = inner_5.as_str();
   76     76   
        let header_value = formatted_6;
   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   
                "sse_customer_algorithm",
   80     80   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   81     81   
            )
   82     82   
        })?;
   83     83   
        builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
   84     84   
    }
   85     85   
    if let ::std::option::Option::Some(inner_7) = &input.sse_customer_key {
   86     86   
        let formatted_8 = inner_7.as_str();
   87     87   
        let header_value = formatted_8;
   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   
                "sse_customer_key",
   91     91   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
   92     92   
            )
   93     93   
        })?;
   94     94   
        builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
   95     95   
    }
   96     96   
    if let ::std::option::Option::Some(inner_9) = &input.sse_customer_key_md5 {
   97     97   
        let formatted_10 = inner_9.as_str();
   98     98   
        let header_value = formatted_10;
   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   
                "sse_customer_key_md5",
  102    102   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  103    103   
            )
  104    104   
        })?;
  105    105   
        builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  106    106   
    }
  107    107   
    Ok(builder)
  108    108   
}
  109    109

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

@@ -10,10 +65,65 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::put_bucket_accelerate_configuration::builders::PutBucketAccelerateConfigurationOutputBuilder::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_accelerate_configuration_headers(
   39     39   
    input: &crate::operation::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationInput,
   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.expected_bucket_owner {
   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   
                "expected_bucket_owner",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("x-amz-expected-bucket-owner", 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   
    Ok(builder)
   65     65   
}

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

@@ -4,4 +136,136 @@
   24     24   
        #[allow(unused_mut)]
   25     25   
        let mut output = crate::operation::put_bucket_acl::builders::PutBucketAclOutputBuilder::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_acl_headers(
   33     33   
    input: &crate::operation::put_bucket_acl::PutBucketAclInput,
   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.acl {
   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   
                "acl",
   42     42   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   43     43   
            )
   44     44   
        })?;
   45     45   
        builder = builder.header("x-amz-acl", header_value);
   46     46   
    }
   47     47   
    if let ::std::option::Option::Some(inner_3) = &input.content_md5 {
   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   
                "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_5) = &input.checksum_algorithm {
   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   
                "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_7) = &input.grant_full_control {
   70     70   
        let formatted_8 = inner_7.as_str();
   71     71   
        let header_value = formatted_8;
   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   
                "grant_full_control",
   75     75   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   76     76   
            )
   77     77   
        })?;
   78     78   
        builder = builder.header("x-amz-grant-full-control", header_value);
   79     79   
    }
   80     80   
    if let ::std::option::Option::Some(inner_9) = &input.grant_read {
   81     81   
        let formatted_10 = inner_9.as_str();
   82     82   
        let header_value = formatted_10;
   83         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          83  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   84     84   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   85     85   
                "grant_read",
   86     86   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   87     87   
            )
   88     88   
        })?;
   89     89   
        builder = builder.header("x-amz-grant-read", header_value);
   90     90   
    }
   91     91   
    if let ::std::option::Option::Some(inner_11) = &input.grant_read_acp {
   92     92   
        let formatted_12 = inner_11.as_str();
   93     93   
        let header_value = formatted_12;
   94         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          94  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   95     95   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   96     96   
                "grant_read_acp",
   97     97   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   98     98   
            )
   99     99   
        })?;
  100    100   
        builder = builder.header("x-amz-grant-read-acp", header_value);
  101    101   
    }
  102    102   
    if let ::std::option::Option::Some(inner_13) = &input.grant_write {
  103    103   
        let formatted_14 = inner_13.as_str();
  104    104   
        let header_value = formatted_14;
  105         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         105  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  106    106   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  107    107   
                "grant_write",
  108    108   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  109    109   
            )
  110    110   
        })?;
  111    111   
        builder = builder.header("x-amz-grant-write", header_value);
  112    112   
    }
  113    113   
    if let ::std::option::Option::Some(inner_15) = &input.grant_write_acp {
  114    114   
        let formatted_16 = inner_15.as_str();
  115    115   
        let header_value = formatted_16;
  116         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         116  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  117    117   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  118    118   
                "grant_write_acp",
  119    119   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  120    120   
            )
  121    121   
        })?;
  122    122   
        builder = builder.header("x-amz-grant-write-acp", header_value);
  123    123   
    }
  124    124   
    if let ::std::option::Option::Some(inner_17) = &input.expected_bucket_owner {
  125    125   
        let formatted_18 = inner_17.as_str();
  126    126   
        let header_value = formatted_18;
  127         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         127  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  128    128   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  129    129   
                "expected_bucket_owner",
  130    130   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  131    131   
            )
  132    132   
        })?;
  133    133   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  134    134   
    }
  135    135   
    Ok(builder)
  136    136   
}

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

@@ -10,10 +54,54 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::put_bucket_analytics_configuration::builders::PutBucketAnalyticsConfigurationOutputBuilder::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_analytics_configuration_headers(
   39     39   
    input: &crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationInput,
   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.expected_bucket_owner {
   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   
                "expected_bucket_owner",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   52     52   
    }
   53     53   
    Ok(builder)
   54     54   
}

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

@@ -4,4 +70,70 @@
   24     24   
        #[allow(unused_mut)]
   25     25   
        let mut output = crate::operation::put_bucket_cors::builders::PutBucketCorsOutputBuilder::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_cors_headers(
   33     33   
    input: &crate::operation::put_bucket_cors::PutBucketCorsInput,
   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_encryption.rs

@@ -10,10 +76,76 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::put_bucket_encryption::builders::PutBucketEncryptionOutputBuilder::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_encryption_headers(
   39     39   
    input: &crate::operation::put_bucket_encryption::PutBucketEncryptionInput,
   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_put_bucket_intelligent_tiering_configuration.rs

@@ -12,12 +56,56 @@
   32     32   
            crate::operation::put_bucket_intelligent_tiering_configuration::builders::PutBucketIntelligentTieringConfigurationOutputBuilder::default(
   33     33   
            );
   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_intelligent_tiering_configuration_headers(
   41     41   
    input: &crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput,
   42         -
    mut builder: ::http::request::Builder,
   43         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          42  +
    mut builder: ::http_1x::request::Builder,
          43  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   44     44   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   45     45   
        let formatted_2 = inner_1.as_str();
   46     46   
        let header_value = formatted_2;
   47         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          47  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   48     48   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   49     49   
                "expected_bucket_owner",
   50     50   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   51     51   
            )
   52     52   
        })?;
   53     53   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   54     54   
    }
   55     55   
    Ok(builder)
   56     56   
}

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

@@ -10,10 +54,54 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::put_bucket_inventory_configuration::builders::PutBucketInventoryConfigurationOutputBuilder::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_inventory_configuration_headers(
   39     39   
    input: &crate::operation::put_bucket_inventory_configuration::PutBucketInventoryConfigurationInput,
   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.expected_bucket_owner {
   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   
                "expected_bucket_owner",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   52     52   
    }
   53     53   
    Ok(builder)
   54     54   
}

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

@@ -20,20 +86,86 @@
   40     40   
            })?,
   41     41   
        );
   42     42   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   43     43   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   44     44   
        output.build()
   45     45   
    })
   46     46   
}
   47     47   
   48     48   
pub fn ser_put_bucket_lifecycle_configuration_headers(
   49     49   
    input: &crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationInput,
   50         -
    mut builder: ::http::request::Builder,
   51         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          50  +
    mut builder: ::http_1x::request::Builder,
          51  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   52     52   
    if let ::std::option::Option::Some(inner_1) = &input.checksum_algorithm {
   53     53   
        let formatted_2 = inner_1.as_str();
   54     54   
        let header_value = formatted_2;
   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_3) = &input.expected_bucket_owner {
   64     64   
        let formatted_4 = inner_3.as_str();
   65     65   
        let header_value = formatted_4;
   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_5) = &input.transition_default_minimum_object_size {
   75     75   
        let formatted_6 = inner_5.as_str();
   76     76   
        let header_value = formatted_6;
   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   
                "transition_default_minimum_object_size",
   80     80   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   81     81   
            )
   82     82   
        })?;
   83     83   
        builder = builder.header("x-amz-transition-default-minimum-object-size", header_value);
   84     84   
    }
   85     85   
    Ok(builder)
   86     86   
}

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

@@ -4,4 +70,70 @@
   24     24   
        #[allow(unused_mut)]
   25     25   
        let mut output = crate::operation::put_bucket_logging::builders::PutBucketLoggingOutputBuilder::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_logging_headers(
   33     33   
    input: &crate::operation::put_bucket_logging::PutBucketLoggingInput,
   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_metrics_configuration.rs

@@ -10,10 +54,54 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::put_bucket_metrics_configuration::builders::PutBucketMetricsConfigurationOutputBuilder::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_metrics_configuration_headers(
   39     39   
    input: &crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfigurationInput,
   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.expected_bucket_owner {
   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   
                "expected_bucket_owner",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   52     52   
    }
   53     53   
    Ok(builder)
   54     54   
}

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

@@ -11,11 +67,67 @@
   31     31   
        let mut output =
   32     32   
            crate::operation::put_bucket_notification_configuration::builders::PutBucketNotificationConfigurationOutputBuilder::default();
   33     33   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   34     34   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   35     35   
        output.build()
   36     36   
    })
   37     37   
}
   38     38   
   39     39   
pub fn ser_put_bucket_notification_configuration_headers(
   40     40   
    input: &crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationInput,
   41         -
    mut builder: ::http::request::Builder,
   42         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          41  +
    mut builder: ::http_1x::request::Builder,
          42  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   43     43   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   44     44   
        let formatted_2 = inner_1.as_str();
   45     45   
        let header_value = formatted_2;
   46         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          46  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   47     47   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   48     48   
                "expected_bucket_owner",
   49     49   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   50     50   
            )
   51     51   
        })?;
   52     52   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   53     53   
    }
   54     54   
    if let ::std::option::Option::Some(inner_3) = &input.skip_destination_validation {
   55     55   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_3);
   56     56   
        let formatted_4 = encoder.encode();
   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   
                "skip_destination_validation",
   61     61   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   62     62   
            )
   63     63   
        })?;
   64     64   
        builder = builder.header("x-amz-skip-destination-validation", header_value);
   65     65   
    }
   66     66   
    Ok(builder)
   67     67   
}

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

@@ -12,12 +78,78 @@
   32     32   
        #[allow(unused_mut)]
   33     33   
        let mut output = crate::operation::put_bucket_ownership_controls::builders::PutBucketOwnershipControlsOutputBuilder::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_ownership_controls_headers(
   41     41   
    input: &crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsInput,
   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.expected_bucket_owner {
   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   
                "expected_bucket_owner",
   61     61   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   62     62   
            )
   63     63   
        })?;
   64     64   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   65     65   
    }
   66     66   
    if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
   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   
                "checksum_algorithm",
   72     72   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     73   
            )
   74     74   
        })?;
   75     75   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   76     76   
    }
   77     77   
    Ok(builder)
   78     78   
}

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

@@ -4,4 +82,82 @@
   24     24   
        #[allow(unused_mut)]
   25     25   
        let mut output = crate::operation::put_bucket_policy::builders::PutBucketPolicyOutputBuilder::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_policy_headers(
   33     33   
    input: &crate::operation::put_bucket_policy::PutBucketPolicyInput,
   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.confirm_remove_self_bucket_access {
   59     59   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
   60     60   
        let formatted_6 = encoder.encode();
   61     61   
        let header_value = formatted_6;
   62         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          62  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   63     63   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   64     64   
                "confirm_remove_self_bucket_access",
   65     65   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   66     66   
            )
   67     67   
        })?;
   68     68   
        builder = builder.header("x-amz-confirm-remove-self-bucket-access", header_value);
   69     69   
    }
   70     70   
    if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
   71     71   
        let formatted_8 = inner_7.as_str();
   72     72   
        let header_value = formatted_8;
   73         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          73  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   74     74   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   75     75   
                "expected_bucket_owner",
   76     76   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   77     77   
            )
   78     78   
        })?;
   79     79   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   80     80   
    }
   81     81   
    Ok(builder)
   82     82   
}