AWS SDK

AWS SDK

rev. 03e6e47f15dfd569240d570d98975ebba692c405 (ignoring whitespace)

Files changed:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -19,19 +131,131 @@
   39     39   
            })?,
   40     40   
        );
   41     41   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   42     42   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   43     43   
        output.build()
   44     44   
    })
   45     45   
}
   46     46   
   47     47   
pub fn ser_delete_object_headers(
   48     48   
    input: &crate::operation::delete_object::DeleteObjectInput,
   49         -
    mut builder: ::http::request::Builder,
   50         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          49  +
    mut builder: ::http_1x::request::Builder,
          50  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   51     51   
    if let ::std::option::Option::Some(inner_1) = &input.mfa {
   52     52   
        let formatted_2 = inner_1.as_str();
   53     53   
        let header_value = formatted_2;
   54         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          54  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   55     55   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   56     56   
                "mfa",
   57     57   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   58     58   
            )
   59     59   
        })?;
   60     60   
        builder = builder.header("x-amz-mfa", header_value);
   61     61   
    }
   62     62   
    if let ::std::option::Option::Some(inner_3) = &input.request_payer {
   63     63   
        let formatted_4 = inner_3.as_str();
   64     64   
        let header_value = formatted_4;
   65         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          65  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   66     66   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   67     67   
                "request_payer",
   68     68   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   69     69   
            )
   70     70   
        })?;
   71     71   
        builder = builder.header("x-amz-request-payer", header_value);
   72     72   
    }
   73     73   
    if let ::std::option::Option::Some(inner_5) = &input.bypass_governance_retention {
   74     74   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
   75     75   
        let formatted_6 = encoder.encode();
   76     76   
        let header_value = formatted_6;
   77         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          77  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   78     78   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   79     79   
                "bypass_governance_retention",
   80     80   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   81     81   
            )
   82     82   
        })?;
   83     83   
        builder = builder.header("x-amz-bypass-governance-retention", header_value);
   84     84   
    }
   85     85   
    if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
   86     86   
        let formatted_8 = inner_7.as_str();
   87     87   
        let header_value = formatted_8;
   88         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          88  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   89     89   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   90     90   
                "expected_bucket_owner",
   91     91   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   92     92   
            )
   93     93   
        })?;
   94     94   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   95     95   
    }
   96     96   
    if let ::std::option::Option::Some(inner_9) = &input.if_match {
   97     97   
        let formatted_10 = inner_9.as_str();
   98     98   
        let header_value = formatted_10;
   99         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          99  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  100    100   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  101    101   
                "if_match",
  102    102   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  103    103   
            )
  104    104   
        })?;
  105    105   
        builder = builder.header("If-Match", header_value);
  106    106   
    }
  107    107   
    if let ::std::option::Option::Some(inner_11) = &input.if_match_last_modified_time {
  108    108   
        let formatted_12 = inner_11.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  109    109   
        let header_value = formatted_12;
  110         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         110  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  111    111   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  112    112   
                "if_match_last_modified_time",
  113    113   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  114    114   
            )
  115    115   
        })?;
  116    116   
        builder = builder.header("x-amz-if-match-last-modified-time", header_value);
  117    117   
    }
  118    118   
    if let ::std::option::Option::Some(inner_13) = &input.if_match_size {
  119    119   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);
  120    120   
        let formatted_14 = encoder.encode();
  121    121   
        let header_value = formatted_14;
  122         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         122  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  123    123   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  124    124   
                "if_match_size",
  125    125   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  126    126   
            )
  127    127   
        })?;
  128    128   
        builder = builder.header("x-amz-if-match-size", header_value);
  129    129   
    }
  130    130   
    Ok(builder)
  131    131   
}

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

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

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

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

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

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