pub fn add_headers_create_access_point(
input: &crate::input::CreateAccessPointInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_1) = &input.account_id {
let formatted_2 = inner_1.as_str();
if !formatted_2.is_empty() {
let header_value = formatted_2;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_create_access_point_for_object_lambda(
input: &crate::input::CreateAccessPointForObjectLambdaInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_3) = &input.account_id {
let formatted_4 = inner_3.as_str();
if !formatted_4.is_empty() {
let header_value = formatted_4;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_create_bucket(
input: &crate::input::CreateBucketInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_5) = &input.acl {
let formatted_6 = inner_5.as_str();
if !formatted_6.is_empty() {
let header_value = formatted_6;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"acl",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-acl", header_value);
}
}
if let Some(inner_7) = &input.grant_full_control {
let formatted_8 = inner_7.as_str();
if !formatted_8.is_empty() {
let header_value = formatted_8;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_full_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-full-control", header_value);
}
}
if let Some(inner_9) = &input.grant_read {
let formatted_10 = inner_9.as_str();
if !formatted_10.is_empty() {
let header_value = formatted_10;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read", header_value);
}
}
if let Some(inner_11) = &input.grant_read_acp {
let formatted_12 = inner_11.as_str();
if !formatted_12.is_empty() {
let header_value = formatted_12;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read-acp", header_value);
}
}
if let Some(inner_13) = &input.grant_write {
let formatted_14 = inner_13.as_str();
if !formatted_14.is_empty() {
let header_value = formatted_14;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write", header_value);
}
}
if let Some(inner_15) = &input.grant_write_acp {
let formatted_16 = inner_15.as_str();
if !formatted_16.is_empty() {
let header_value = formatted_16;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write-acp", header_value);
}
}
if input.object_lock_enabled_for_bucket {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.object_lock_enabled_for_bucket);
let formatted_17 = encoder.encode();
if !formatted_17.is_empty() {
let header_value = formatted_17;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_enabled_for_bucket",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-bucket-object-lock-enabled", header_value);
}
}
if let Some(inner_18) = &input.outpost_id {
let formatted_19 = inner_18.as_str();
if !formatted_19.is_empty() {
let header_value = formatted_19;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"outpost_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-outpost-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_create_job(
input: &crate::input::CreateJobInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_20) = &input.account_id {
let formatted_21 = inner_20.as_str();
if !formatted_21.is_empty() {
let header_value = formatted_21;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_create_multi_region_access_point(
input: &crate::input::CreateMultiRegionAccessPointInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_22) = &input.account_id {
let formatted_23 = inner_22.as_str();
if !formatted_23.is_empty() {
let header_value = formatted_23;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_access_point(
input: &crate::input::DeleteAccessPointInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_24) = &input.account_id {
let formatted_25 = inner_24.as_str();
if !formatted_25.is_empty() {
let header_value = formatted_25;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_access_point_for_object_lambda(
input: &crate::input::DeleteAccessPointForObjectLambdaInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_26) = &input.account_id {
let formatted_27 = inner_26.as_str();
if !formatted_27.is_empty() {
let header_value = formatted_27;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_access_point_policy(
input: &crate::input::DeleteAccessPointPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_28) = &input.account_id {
let formatted_29 = inner_28.as_str();
if !formatted_29.is_empty() {
let header_value = formatted_29;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_access_point_policy_for_object_lambda(
input: &crate::input::DeleteAccessPointPolicyForObjectLambdaInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_30) = &input.account_id {
let formatted_31 = inner_30.as_str();
if !formatted_31.is_empty() {
let header_value = formatted_31;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket(
input: &crate::input::DeleteBucketInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_32) = &input.account_id {
let formatted_33 = inner_32.as_str();
if !formatted_33.is_empty() {
let header_value = formatted_33;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_lifecycle_configuration(
input: &crate::input::DeleteBucketLifecycleConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_34) = &input.account_id {
let formatted_35 = inner_34.as_str();
if !formatted_35.is_empty() {
let header_value = formatted_35;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_policy(
input: &crate::input::DeleteBucketPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_36) = &input.account_id {
let formatted_37 = inner_36.as_str();
if !formatted_37.is_empty() {
let header_value = formatted_37;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_tagging(
input: &crate::input::DeleteBucketTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_38) = &input.account_id {
let formatted_39 = inner_38.as_str();
if !formatted_39.is_empty() {
let header_value = formatted_39;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_job_tagging(
input: &crate::input::DeleteJobTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_40) = &input.account_id {
let formatted_41 = inner_40.as_str();
if !formatted_41.is_empty() {
let header_value = formatted_41;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_multi_region_access_point(
input: &crate::input::DeleteMultiRegionAccessPointInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_42) = &input.account_id {
let formatted_43 = inner_42.as_str();
if !formatted_43.is_empty() {
let header_value = formatted_43;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_public_access_block(
input: &crate::input::DeletePublicAccessBlockInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_44) = &input.account_id {
let formatted_45 = inner_44.as_str();
if !formatted_45.is_empty() {
let header_value = formatted_45;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_storage_lens_configuration(
input: &crate::input::DeleteStorageLensConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_46) = &input.account_id {
let formatted_47 = inner_46.as_str();
if !formatted_47.is_empty() {
let header_value = formatted_47;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_storage_lens_configuration_tagging(
input: &crate::input::DeleteStorageLensConfigurationTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_48) = &input.account_id {
let formatted_49 = inner_48.as_str();
if !formatted_49.is_empty() {
let header_value = formatted_49;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_describe_job(
input: &crate::input::DescribeJobInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_50) = &input.account_id {
let formatted_51 = inner_50.as_str();
if !formatted_51.is_empty() {
let header_value = formatted_51;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_describe_multi_region_access_point_operation(
input: &crate::input::DescribeMultiRegionAccessPointOperationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_52) = &input.account_id {
let formatted_53 = inner_52.as_str();
if !formatted_53.is_empty() {
let header_value = formatted_53;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_access_point(
input: &crate::input::GetAccessPointInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_54) = &input.account_id {
let formatted_55 = inner_54.as_str();
if !formatted_55.is_empty() {
let header_value = formatted_55;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_access_point_configuration_for_object_lambda(
input: &crate::input::GetAccessPointConfigurationForObjectLambdaInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_56) = &input.account_id {
let formatted_57 = inner_56.as_str();
if !formatted_57.is_empty() {
let header_value = formatted_57;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_access_point_for_object_lambda(
input: &crate::input::GetAccessPointForObjectLambdaInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_58) = &input.account_id {
let formatted_59 = inner_58.as_str();
if !formatted_59.is_empty() {
let header_value = formatted_59;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_access_point_policy(
input: &crate::input::GetAccessPointPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_60) = &input.account_id {
let formatted_61 = inner_60.as_str();
if !formatted_61.is_empty() {
let header_value = formatted_61;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_access_point_policy_for_object_lambda(
input: &crate::input::GetAccessPointPolicyForObjectLambdaInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_62) = &input.account_id {
let formatted_63 = inner_62.as_str();
if !formatted_63.is_empty() {
let header_value = formatted_63;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_access_point_policy_status(
input: &crate::input::GetAccessPointPolicyStatusInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_64) = &input.account_id {
let formatted_65 = inner_64.as_str();
if !formatted_65.is_empty() {
let header_value = formatted_65;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_access_point_policy_status_for_object_lambda(
input: &crate::input::GetAccessPointPolicyStatusForObjectLambdaInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_66) = &input.account_id {
let formatted_67 = inner_66.as_str();
if !formatted_67.is_empty() {
let header_value = formatted_67;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket(
input: &crate::input::GetBucketInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_68) = &input.account_id {
let formatted_69 = inner_68.as_str();
if !formatted_69.is_empty() {
let header_value = formatted_69;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_lifecycle_configuration(
input: &crate::input::GetBucketLifecycleConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_70) = &input.account_id {
let formatted_71 = inner_70.as_str();
if !formatted_71.is_empty() {
let header_value = formatted_71;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_policy(
input: &crate::input::GetBucketPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_72) = &input.account_id {
let formatted_73 = inner_72.as_str();
if !formatted_73.is_empty() {
let header_value = formatted_73;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_tagging(
input: &crate::input::GetBucketTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_74) = &input.account_id {
let formatted_75 = inner_74.as_str();
if !formatted_75.is_empty() {
let header_value = formatted_75;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_versioning(
input: &crate::input::GetBucketVersioningInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_76) = &input.account_id {
let formatted_77 = inner_76.as_str();
if !formatted_77.is_empty() {
let header_value = formatted_77;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_job_tagging(
input: &crate::input::GetJobTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_78) = &input.account_id {
let formatted_79 = inner_78.as_str();
if !formatted_79.is_empty() {
let header_value = formatted_79;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_multi_region_access_point(
input: &crate::input::GetMultiRegionAccessPointInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_80) = &input.account_id {
let formatted_81 = inner_80.as_str();
if !formatted_81.is_empty() {
let header_value = formatted_81;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_multi_region_access_point_policy(
input: &crate::input::GetMultiRegionAccessPointPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_82) = &input.account_id {
let formatted_83 = inner_82.as_str();
if !formatted_83.is_empty() {
let header_value = formatted_83;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_multi_region_access_point_policy_status(
input: &crate::input::GetMultiRegionAccessPointPolicyStatusInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_84) = &input.account_id {
let formatted_85 = inner_84.as_str();
if !formatted_85.is_empty() {
let header_value = formatted_85;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_multi_region_access_point_routes(
input: &crate::input::GetMultiRegionAccessPointRoutesInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_86) = &input.account_id {
let formatted_87 = inner_86.as_str();
if !formatted_87.is_empty() {
let header_value = formatted_87;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_public_access_block(
input: &crate::input::GetPublicAccessBlockInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_88) = &input.account_id {
let formatted_89 = inner_88.as_str();
if !formatted_89.is_empty() {
let header_value = formatted_89;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_storage_lens_configuration(
input: &crate::input::GetStorageLensConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_90) = &input.account_id {
let formatted_91 = inner_90.as_str();
if !formatted_91.is_empty() {
let header_value = formatted_91;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_storage_lens_configuration_tagging(
input: &crate::input::GetStorageLensConfigurationTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_92) = &input.account_id {
let formatted_93 = inner_92.as_str();
if !formatted_93.is_empty() {
let header_value = formatted_93;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_access_points(
input: &crate::input::ListAccessPointsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_94) = &input.account_id {
let formatted_95 = inner_94.as_str();
if !formatted_95.is_empty() {
let header_value = formatted_95;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_access_points_for_object_lambda(
input: &crate::input::ListAccessPointsForObjectLambdaInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_96) = &input.account_id {
let formatted_97 = inner_96.as_str();
if !formatted_97.is_empty() {
let header_value = formatted_97;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_jobs(
input: &crate::input::ListJobsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_98) = &input.account_id {
let formatted_99 = inner_98.as_str();
if !formatted_99.is_empty() {
let header_value = formatted_99;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_multi_region_access_points(
input: &crate::input::ListMultiRegionAccessPointsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_100) = &input.account_id {
let formatted_101 = inner_100.as_str();
if !formatted_101.is_empty() {
let header_value = formatted_101;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_regional_buckets(
input: &crate::input::ListRegionalBucketsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_102) = &input.account_id {
let formatted_103 = inner_102.as_str();
if !formatted_103.is_empty() {
let header_value = formatted_103;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
if let Some(inner_104) = &input.outpost_id {
let formatted_105 = inner_104.as_str();
if !formatted_105.is_empty() {
let header_value = formatted_105;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"outpost_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-outpost-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_storage_lens_configurations(
input: &crate::input::ListStorageLensConfigurationsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_106) = &input.account_id {
let formatted_107 = inner_106.as_str();
if !formatted_107.is_empty() {
let header_value = formatted_107;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_access_point_configuration_for_object_lambda(
input: &crate::input::PutAccessPointConfigurationForObjectLambdaInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_108) = &input.account_id {
let formatted_109 = inner_108.as_str();
if !formatted_109.is_empty() {
let header_value = formatted_109;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_access_point_policy(
input: &crate::input::PutAccessPointPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_110) = &input.account_id {
let formatted_111 = inner_110.as_str();
if !formatted_111.is_empty() {
let header_value = formatted_111;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_access_point_policy_for_object_lambda(
input: &crate::input::PutAccessPointPolicyForObjectLambdaInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_112) = &input.account_id {
let formatted_113 = inner_112.as_str();
if !formatted_113.is_empty() {
let header_value = formatted_113;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_lifecycle_configuration(
input: &crate::input::PutBucketLifecycleConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_114) = &input.account_id {
let formatted_115 = inner_114.as_str();
if !formatted_115.is_empty() {
let header_value = formatted_115;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_policy(
input: &crate::input::PutBucketPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_116) = &input.account_id {
let formatted_117 = inner_116.as_str();
if !formatted_117.is_empty() {
let header_value = formatted_117;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
if input.confirm_remove_self_bucket_access {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.confirm_remove_self_bucket_access);
let formatted_118 = encoder.encode();
if !formatted_118.is_empty() {
let header_value = formatted_118;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"confirm_remove_self_bucket_access",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-confirm-remove-self-bucket-access", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_tagging(
input: &crate::input::PutBucketTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_119) = &input.account_id {
let formatted_120 = inner_119.as_str();
if !formatted_120.is_empty() {
let header_value = formatted_120;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_versioning(
input: &crate::input::PutBucketVersioningInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_121) = &input.account_id {
let formatted_122 = inner_121.as_str();
if !formatted_122.is_empty() {
let header_value = formatted_122;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
if let Some(inner_123) = &input.mfa {
let formatted_124 = inner_123.as_str();
if !formatted_124.is_empty() {
let header_value = formatted_124;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"mfa",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-mfa", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_job_tagging(
input: &crate::input::PutJobTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_125) = &input.account_id {
let formatted_126 = inner_125.as_str();
if !formatted_126.is_empty() {
let header_value = formatted_126;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_multi_region_access_point_policy(
input: &crate::input::PutMultiRegionAccessPointPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_127) = &input.account_id {
let formatted_128 = inner_127.as_str();
if !formatted_128.is_empty() {
let header_value = formatted_128;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_public_access_block(
input: &crate::input::PutPublicAccessBlockInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_129) = &input.account_id {
let formatted_130 = inner_129.as_str();
if !formatted_130.is_empty() {
let header_value = formatted_130;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_storage_lens_configuration(
input: &crate::input::PutStorageLensConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_131) = &input.account_id {
let formatted_132 = inner_131.as_str();
if !formatted_132.is_empty() {
let header_value = formatted_132;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_storage_lens_configuration_tagging(
input: &crate::input::PutStorageLensConfigurationTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_133) = &input.account_id {
let formatted_134 = inner_133.as_str();
if !formatted_134.is_empty() {
let header_value = formatted_134;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_submit_multi_region_access_point_routes(
input: &crate::input::SubmitMultiRegionAccessPointRoutesInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_135) = &input.account_id {
let formatted_136 = inner_135.as_str();
if !formatted_136.is_empty() {
let header_value = formatted_136;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_update_job_priority(
input: &crate::input::UpdateJobPriorityInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_137) = &input.account_id {
let formatted_138 = inner_137.as_str();
if !formatted_138.is_empty() {
let header_value = formatted_138;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub fn add_headers_update_job_status(
input: &crate::input::UpdateJobStatusInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_139) = &input.account_id {
let formatted_140 = inner_139.as_str();
if !formatted_140.is_empty() {
let header_value = formatted_140;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"account_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-account-id", header_value);
}
}
Ok(builder)
}
pub(crate) fn deser_header_create_bucket_create_bucket_output_location(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Location").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub fn deser_payload_get_public_access_block_get_public_access_block_output_public_access_block_configuration(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::PublicAccessBlockConfiguration>,
crate::error::GetPublicAccessBlockError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3control_synthetic_get_public_access_block_output_public_access_block_configuration(body).map_err(crate::error::GetPublicAccessBlockError::unhandled)
}).transpose()
}
pub fn deser_payload_get_storage_lens_configuration_get_storage_lens_configuration_output_storage_lens_configuration(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::StorageLensConfiguration>,
crate::error::GetStorageLensConfigurationError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3control_synthetic_get_storage_lens_configuration_output_storage_lens_configuration(body).map_err(crate::error::GetStorageLensConfigurationError::unhandled)
}).transpose()
}