AWS SDK

AWS SDK

rev. ee474c7509d7728618c23068f3741e8e5b339ef9

Files changed:

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

@@ -10,10 +54,54 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::delete_bucket_ownership_controls::builders::DeleteBucketOwnershipControlsOutputBuilder::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_delete_bucket_ownership_controls_headers(
   39     39   
    input: &crate::operation::delete_bucket_ownership_controls::DeleteBucketOwnershipControlsInput,
   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_delete_bucket_policy.rs

@@ -10,10 +54,54 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::delete_bucket_policy::builders::DeleteBucketPolicyOutputBuilder::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_delete_bucket_policy_headers(
   39     39   
    input: &crate::operation::delete_bucket_policy::DeleteBucketPolicyInput,
   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_delete_bucket_replication.rs

@@ -12,12 +56,56 @@
   32     32   
        #[allow(unused_mut)]
   33     33   
        let mut output = crate::operation::delete_bucket_replication::builders::DeleteBucketReplicationOutputBuilder::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_delete_bucket_replication_headers(
   41     41   
    input: &crate::operation::delete_bucket_replication::DeleteBucketReplicationInput,
   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_delete_bucket_tagging.rs

@@ -10,10 +54,54 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::delete_bucket_tagging::builders::DeleteBucketTaggingOutputBuilder::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_delete_bucket_tagging_headers(
   39     39   
    input: &crate::operation::delete_bucket_tagging::DeleteBucketTaggingInput,
   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_delete_bucket_website.rs

@@ -10,10 +54,54 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::delete_bucket_website::builders::DeleteBucketWebsiteOutputBuilder::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_delete_bucket_website_headers(
   39     39   
    input: &crate::operation::delete_bucket_website::DeleteBucketWebsiteInput,
   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_delete_object.rs

@@ -19,19 +131,131 @@
   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_delete_object_headers(
   48     48   
    input: &crate::operation::delete_object::DeleteObjectInput,
   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.mfa {
   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   
                "mfa",
   57     57   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   58     58   
            )
   59     59   
        })?;
   60     60   
        builder = builder.header("x-amz-mfa", header_value);
   61     61   
    }
   62     62   
    if let ::std::option::Option::Some(inner_3) = &input.request_payer {
   63     63   
        let formatted_4 = inner_3.as_str();
   64     64   
        let header_value = formatted_4;
   65         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          65  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   66     66   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   67     67   
                "request_payer",
   68     68   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   69     69   
            )
   70     70   
        })?;
   71     71   
        builder = builder.header("x-amz-request-payer", header_value);
   72     72   
    }
   73     73   
    if let ::std::option::Option::Some(inner_5) = &input.bypass_governance_retention {
   74     74   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
   75     75   
        let formatted_6 = encoder.encode();
   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   
                "bypass_governance_retention",
   80     80   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   81     81   
            )
   82     82   
        })?;
   83     83   
        builder = builder.header("x-amz-bypass-governance-retention", header_value);
   84     84   
    }
   85     85   
    if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
   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   
                "expected_bucket_owner",
   91     91   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   92     92   
            )
   93     93   
        })?;
   94     94   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   95     95   
    }
   96     96   
    if let ::std::option::Option::Some(inner_9) = &input.if_match {
   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   
                "if_match",
  102    102   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  103    103   
            )
  104    104   
        })?;
  105    105   
        builder = builder.header("If-Match", header_value);
  106    106   
    }
  107    107   
    if let ::std::option::Option::Some(inner_11) = &input.if_match_last_modified_time {
  108    108   
        let formatted_12 = inner_11.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  109    109   
        let header_value = formatted_12;
  110         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         110  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  111    111   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  112    112   
                "if_match_last_modified_time",
  113    113   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  114    114   
            )
  115    115   
        })?;
  116    116   
        builder = builder.header("x-amz-if-match-last-modified-time", header_value);
  117    117   
    }
  118    118   
    if let ::std::option::Option::Some(inner_13) = &input.if_match_size {
  119    119   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);
  120    120   
        let formatted_14 = encoder.encode();
  121    121   
        let header_value = formatted_14;
  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   
                "if_match_size",
  125    125   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  126    126   
            )
  127    127   
        })?;
  128    128   
        builder = builder.header("x-amz-if-match-size", header_value);
  129    129   
    }
  130    130   
    Ok(builder)
  131    131   
}

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

@@ -17,17 +61,61 @@
   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_delete_object_tagging_headers(
   46     46   
    input: &crate::operation::delete_object_tagging::DeleteObjectTaggingInput,
   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.expected_bucket_owner {
   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   
                "expected_bucket_owner",
   55     55   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   56     56   
            )
   57     57   
        })?;
   58     58   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   59     59   
    }
   60     60   
    Ok(builder)
   61     61   
}

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

@@ -11,11 +121,121 @@
   31     31   
            })?,
   32     32   
        );
   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_delete_objects_headers(
   40     40   
    input: &crate::operation::delete_objects::DeleteObjectsInput,
   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.mfa {
   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   
                "mfa",
   49     49   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   50     50   
            )
   51     51   
        })?;
   52     52   
        builder = builder.header("x-amz-mfa", header_value);
   53     53   
    }
   54     54   
    if let ::std::option::Option::Some(inner_3) = &input.request_payer {
   55     55   
        let formatted_4 = inner_3.as_str();
   56     56   
        let header_value = formatted_4;
   57         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          57  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   58     58   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   59     59   
                "request_payer",
   60     60   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   61     61   
            )
   62     62   
        })?;
   63     63   
        builder = builder.header("x-amz-request-payer", header_value);
   64     64   
    }
   65     65   
    if let ::std::option::Option::Some(inner_5) = &input.bypass_governance_retention {
   66     66   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
   67     67   
        let formatted_6 = encoder.encode();
   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   
                "bypass_governance_retention",
   72     72   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     73   
            )
   74     74   
        })?;
   75     75   
        builder = builder.header("x-amz-bypass-governance-retention", header_value);
   76     76   
    }
   77     77   
    if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
   78     78   
        let formatted_8 = inner_7.as_str();
   79     79   
        let header_value = formatted_8;
   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_9) = &input.checksum_algorithm {
   89     89   
        let formatted_10 = inner_9.as_str();
   90     90   
        let header_value = formatted_10;
   91         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          91  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   92     92   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   93     93   
                "checksum_algorithm",
   94     94   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   95     95   
            )
   96     96   
        })?;
   97     97   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   98     98   
    }
   99     99   
    Ok(builder)
  100    100   
}
  101    101

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

@@ -12,12 +56,56 @@
   32     32   
        #[allow(unused_mut)]
   33     33   
        let mut output = crate::operation::delete_public_access_block::builders::DeletePublicAccessBlockOutputBuilder::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_delete_public_access_block_headers(
   41     41   
    input: &crate::operation::delete_public_access_block::DeletePublicAccessBlockInput,
   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_get_bucket_accelerate_configuration.rs

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

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

@@ -6,6 +71,71 @@
   26     26   
        output = crate::protocol_serde::shape_get_bucket_acl::de_get_bucket_acl(_response_body, output)
   27     27   
            .map_err(crate::operation::get_bucket_acl::GetBucketAclError::unhandled)?;
   28     28   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   29     29   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   30     30   
        output.build()
   31     31   
    })
   32     32   
}
   33     33   
   34     34   
pub fn ser_get_bucket_acl_headers(
   35     35   
    input: &crate::operation::get_bucket_acl::GetBucketAclInput,
   36         -
    mut builder: ::http::request::Builder,
   37         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          36  +
    mut builder: ::http_1x::request::Builder,
          37  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   38     38   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   39     39   
        let formatted_2 = inner_1.as_str();
   40     40   
        let header_value = formatted_2;
   41         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          41  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   42     42   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   43     43   
                "expected_bucket_owner",
   44     44   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   45     45   
            )
   46     46   
        })?;
   47     47   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   48     48   
    }
   49     49   
    Ok(builder)
   50     50   
}
   51     51

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

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

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

@@ -6,6 +71,71 @@
   26     26   
        output = crate::protocol_serde::shape_get_bucket_cors::de_get_bucket_cors(_response_body, output)
   27     27   
            .map_err(crate::operation::get_bucket_cors::GetBucketCorsError::unhandled)?;
   28     28   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   29     29   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   30     30   
        output.build()
   31     31   
    })
   32     32   
}
   33     33   
   34     34   
pub fn ser_get_bucket_cors_headers(
   35     35   
    input: &crate::operation::get_bucket_cors::GetBucketCorsInput,
   36         -
    mut builder: ::http::request::Builder,
   37         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          36  +
    mut builder: ::http_1x::request::Builder,
          37  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   38     38   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   39     39   
        let formatted_2 = inner_1.as_str();
   40     40   
        let header_value = formatted_2;
   41         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          41  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   42     42   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   43     43   
                "expected_bucket_owner",
   44     44   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   45     45   
            )
   46     46   
        })?;
   47     47   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   48     48   
    }
   49     49   
    Ok(builder)
   50     50   
}
   51     51

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

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

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

@@ -17,17 +61,61 @@
   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_get_bucket_intelligent_tiering_configuration_headers(
   46     46   
    input: &crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationInput,
   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.expected_bucket_owner {
   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   
                "expected_bucket_owner",
   55     55   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   56     56   
            )
   57     57   
        })?;
   58     58   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   59     59   
    }
   60     60   
    Ok(builder)
   61     61   
}

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

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