AWS SDK

AWS SDK

rev. 03e6e47f15dfd569240d570d98975ebba692c405 (ignoring whitespace)

Files changed:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -10,10 +65,65 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::put_bucket_accelerate_configuration::builders::PutBucketAccelerateConfigurationOutputBuilder::default();
   32     32   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   33     33   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   34     34   
        output.build()
   35     35   
    })
   36     36   
}
   37     37   
   38     38   
pub fn ser_put_bucket_accelerate_configuration_headers(
   39     39   
    input: &crate::operation::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationInput,
   40         -
    mut builder: ::http::request::Builder,
   41         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          40  +
    mut builder: ::http_1x::request::Builder,
          41  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   42     42   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   43     43   
        let formatted_2 = inner_1.as_str();
   44     44   
        let header_value = formatted_2;
   45         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          45  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   46     46   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   47     47   
                "expected_bucket_owner",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   52     52   
    }
   53     53   
    if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
   54     54   
        let formatted_4 = inner_3.as_str();
   55     55   
        let header_value = formatted_4;
   56         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          56  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   57     57   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   58     58   
                "checksum_algorithm",
   59     59   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   60     60   
            )
   61     61   
        })?;
   62     62   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   63     63   
    }
   64     64   
    Ok(builder)
   65     65   
}

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

@@ -4,4 +136,136 @@
   24     24   
        #[allow(unused_mut)]
   25     25   
        let mut output = crate::operation::put_bucket_acl::builders::PutBucketAclOutputBuilder::default();
   26     26   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   27     27   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   28     28   
        output.build()
   29     29   
    })
   30     30   
}
   31     31   
   32     32   
pub fn ser_put_bucket_acl_headers(
   33     33   
    input: &crate::operation::put_bucket_acl::PutBucketAclInput,
   34         -
    mut builder: ::http::request::Builder,
   35         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          34  +
    mut builder: ::http_1x::request::Builder,
          35  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   36     36   
    if let ::std::option::Option::Some(inner_1) = &input.acl {
   37     37   
        let formatted_2 = inner_1.as_str();
   38     38   
        let header_value = formatted_2;
   39         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          39  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   40     40   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   41     41   
                "acl",
   42     42   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   43     43   
            )
   44     44   
        })?;
   45     45   
        builder = builder.header("x-amz-acl", header_value);
   46     46   
    }
   47     47   
    if let ::std::option::Option::Some(inner_3) = &input.content_md5 {
   48     48   
        let formatted_4 = inner_3.as_str();
   49     49   
        let header_value = formatted_4;
   50         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          50  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   51     51   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   52     52   
                "content_md5",
   53     53   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   54     54   
            )
   55     55   
        })?;
   56     56   
        builder = builder.header("Content-MD5", header_value);
   57     57   
    }
   58     58   
    if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
   59     59   
        let formatted_6 = inner_5.as_str();
   60     60   
        let header_value = formatted_6;
   61         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          61  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   62     62   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   63     63   
                "checksum_algorithm",
   64     64   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   65     65   
            )
   66     66   
        })?;
   67     67   
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
   68     68   
    }
   69     69   
    if let ::std::option::Option::Some(inner_7) = &input.grant_full_control {
   70     70   
        let formatted_8 = inner_7.as_str();
   71     71   
        let header_value = formatted_8;
   72         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          72  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   73     73   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   74     74   
                "grant_full_control",
   75     75   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   76     76   
            )
   77     77   
        })?;
   78     78   
        builder = builder.header("x-amz-grant-full-control", header_value);
   79     79   
    }
   80     80   
    if let ::std::option::Option::Some(inner_9) = &input.grant_read {
   81     81   
        let formatted_10 = inner_9.as_str();
   82     82   
        let header_value = formatted_10;
   83         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          83  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   84     84   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   85     85   
                "grant_read",
   86     86   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   87     87   
            )
   88     88   
        })?;
   89     89   
        builder = builder.header("x-amz-grant-read", header_value);
   90     90   
    }
   91     91   
    if let ::std::option::Option::Some(inner_11) = &input.grant_read_acp {
   92     92   
        let formatted_12 = inner_11.as_str();
   93     93   
        let header_value = formatted_12;
   94         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          94  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   95     95   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   96     96   
                "grant_read_acp",
   97     97   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   98     98   
            )
   99     99   
        })?;
  100    100   
        builder = builder.header("x-amz-grant-read-acp", header_value);
  101    101   
    }
  102    102   
    if let ::std::option::Option::Some(inner_13) = &input.grant_write {
  103    103   
        let formatted_14 = inner_13.as_str();
  104    104   
        let header_value = formatted_14;
  105         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         105  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  106    106   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  107    107   
                "grant_write",
  108    108   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  109    109   
            )
  110    110   
        })?;
  111    111   
        builder = builder.header("x-amz-grant-write", header_value);
  112    112   
    }
  113    113   
    if let ::std::option::Option::Some(inner_15) = &input.grant_write_acp {
  114    114   
        let formatted_16 = inner_15.as_str();
  115    115   
        let header_value = formatted_16;
  116         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         116  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  117    117   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  118    118   
                "grant_write_acp",
  119    119   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  120    120   
            )
  121    121   
        })?;
  122    122   
        builder = builder.header("x-amz-grant-write-acp", header_value);
  123    123   
    }
  124    124   
    if let ::std::option::Option::Some(inner_17) = &input.expected_bucket_owner {
  125    125   
        let formatted_18 = inner_17.as_str();
  126    126   
        let header_value = formatted_18;
  127         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         127  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  128    128   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  129    129   
                "expected_bucket_owner",
  130    130   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  131    131   
            )
  132    132   
        })?;
  133    133   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  134    134   
    }
  135    135   
    Ok(builder)
  136    136   
}

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

@@ -10,10 +54,54 @@
   30     30   
        #[allow(unused_mut)]
   31     31   
        let mut output = crate::operation::put_bucket_analytics_configuration::builders::PutBucketAnalyticsConfigurationOutputBuilder::default();
   32     32   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   33     33   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   34     34   
        output.build()
   35     35   
    })
   36     36   
}
   37     37   
   38     38   
pub fn ser_put_bucket_analytics_configuration_headers(
   39     39   
    input: &crate::operation::put_bucket_analytics_configuration::PutBucketAnalyticsConfigurationInput,
   40         -
    mut builder: ::http::request::Builder,
   41         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          40  +
    mut builder: ::http_1x::request::Builder,
          41  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   42     42   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   43     43   
        let formatted_2 = inner_1.as_str();
   44     44   
        let header_value = formatted_2;
   45         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          45  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   46     46   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   47     47   
                "expected_bucket_owner",
   48     48   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   49     49   
            )
   50     50   
        })?;
   51     51   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   52     52   
    }
   53     53   
    Ok(builder)
   54     54   
}

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

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

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

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

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

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