AWS SDK

AWS SDK

rev. 3c756f73b1f83a0eed4275d9d1e22df0b10b66fb (ignoring whitespace)

Files changed:

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

@@ -13,13 +57,57 @@
   33     33   
            _response_body,
   34     34   
        )?);
   35     35   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   36     36   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   37     37   
        output.build()
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_get_bucket_policy_status_headers(
   42     42   
    input: &crate::operation::get_bucket_policy_status::GetBucketPolicyStatusInput,
   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_replication.rs

@@ -13,13 +57,57 @@
   33     33   
            crate::protocol_serde::shape_get_bucket_replication_output::de_replication_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_replication_headers(
   42     42   
    input: &crate::operation::get_bucket_replication::GetBucketReplicationInput,
   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_request_payment.rs

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

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

@@ -8,8 +73,73 @@
   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   
        crate::serde_util::get_bucket_tagging_output_output_correct_errors(output)
   31     31   
            .build()
   32     32   
            .map_err(crate::operation::get_bucket_tagging::GetBucketTaggingError::unhandled)?
   33     33   
    })
   34     34   
}
   35     35   
   36     36   
pub fn ser_get_bucket_tagging_headers(
   37     37   
    input: &crate::operation::get_bucket_tagging::GetBucketTaggingInput,
   38         -
    mut builder: ::http::request::Builder,
   39         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          38  +
    mut builder: ::http_1x::request::Builder,
          39  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   40     40   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   41     41   
        let formatted_2 = inner_1.as_str();
   42     42   
        let header_value = formatted_2;
   43         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          43  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   44     44   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   45     45   
                "expected_bucket_owner",
   46     46   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   47     47   
            )
   48     48   
        })?;
   49     49   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   50     50   
    }
   51     51   
    Ok(builder)
   52     52   
}
   53     53

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

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

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

@@ -6,6 +71,71 @@
   26     26   
        output = crate::protocol_serde::shape_get_bucket_website::de_get_bucket_website(_response_body, output)
   27     27   
            .map_err(crate::operation::get_bucket_website::GetBucketWebsiteError::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_website_headers(
   35     35   
    input: &crate::operation::get_bucket_website::GetBucketWebsiteInput,
   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_object.rs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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