AWS SDK

AWS SDK

rev. 3c756f73b1f83a0eed4275d9d1e22df0b10b66fb

Files changed:

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

@@ -22,22 +87,87 @@
   42     42   
            })?,
   43     43   
        );
   44     44   
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
   45     45   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
   46     46   
        output.build()
   47     47   
    })
   48     48   
}
   49     49   
   50     50   
pub fn ser_get_bucket_lifecycle_configuration_headers(
   51     51   
    input: &crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationInput,
   52         -
    mut builder: ::http::request::Builder,
   53         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          52  +
    mut builder: ::http_1x::request::Builder,
          53  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   54     54   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   55     55   
        let formatted_2 = inner_1.as_str();
   56     56   
        let header_value = formatted_2;
   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   
                "expected_bucket_owner",
   60     60   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   61     61   
            )
   62     62   
        })?;
   63     63   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
   64     64   
    }
   65     65   
    Ok(builder)
   66     66   
}
   67     67

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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