http_serde.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn deser_header_abort_multipart_upload_abort_multipart_upload_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_complete_multipart_upload_complete_multipart_upload_output_bucket_key_enabled(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-bucket-key-enabled")
        .iter();
    let var_1 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_1.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_1.len()),
        ))
    } else {
        let mut var_1 = var_1;
        Ok(var_1.pop())
    }
}

pub fn deser_header_complete_multipart_upload_complete_multipart_upload_output_expiration(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-expiration").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_complete_multipart_upload_complete_multipart_upload_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_complete_multipart_upload_complete_multipart_upload_output_ssekms_key_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-aws-kms-key-id")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_complete_multipart_upload_complete_multipart_upload_output_server_side_encryption(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ServerSideEncryption>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-server-side-encryption").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_complete_multipart_upload_complete_multipart_upload_output_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_copy_object_copy_object_output_bucket_key_enabled(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-bucket-key-enabled")
        .iter();
    let var_2 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_2.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_2.len()),
        ))
    } else {
        let mut var_2 = var_2;
        Ok(var_2.pop())
    }
}

pub fn deser_payload_copy_object_copy_object_output_copy_object_result(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::CopyObjectResult>,
    crate::error::CopyObjectError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_copy_object_output_copy_object_result(body).map_err(crate::error::CopyObjectError::unhandled)
    }).transpose()
}

pub fn deser_header_copy_object_copy_object_output_copy_source_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-copy-source-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_copy_object_copy_object_output_expiration(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-expiration").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_copy_object_copy_object_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_copy_object_copy_object_output_sse_customer_algorithm(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-algorithm")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_copy_object_copy_object_output_sse_customer_key_md5(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-key-MD5")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_copy_object_copy_object_output_ssekms_encryption_context(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-context")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_copy_object_copy_object_output_ssekms_key_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-aws-kms-key-id")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_copy_object_copy_object_output_server_side_encryption(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ServerSideEncryption>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-server-side-encryption").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_copy_object_copy_object_output_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub 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_header_create_multipart_upload_create_multipart_upload_output_abort_date(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<aws_smithy_types::Instant>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-abort-date").iter();
    let var_3: Vec<aws_smithy_types::Instant> =
        aws_smithy_http::header::many_dates(headers, aws_smithy_types::instant::Format::HttpDate)?;
    if var_3.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_3.len()),
        ))
    } else {
        let mut var_3 = var_3;
        Ok(var_3.pop())
    }
}

pub fn deser_header_create_multipart_upload_create_multipart_upload_output_abort_rule_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-abort-rule-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_create_multipart_upload_create_multipart_upload_output_bucket_key_enabled(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-bucket-key-enabled")
        .iter();
    let var_4 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_4.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_4.len()),
        ))
    } else {
        let mut var_4 = var_4;
        Ok(var_4.pop())
    }
}

pub fn deser_header_create_multipart_upload_create_multipart_upload_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_create_multipart_upload_create_multipart_upload_output_sse_customer_algorithm(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-algorithm")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_create_multipart_upload_create_multipart_upload_output_sse_customer_key_md5(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-key-MD5")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_create_multipart_upload_create_multipart_upload_output_ssekms_encryption_context(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-context")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_create_multipart_upload_create_multipart_upload_output_ssekms_key_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-aws-kms-key-id")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_create_multipart_upload_create_multipart_upload_output_server_side_encryption(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ServerSideEncryption>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-server-side-encryption").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_delete_object_delete_object_output_delete_marker(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("x-amz-delete-marker").iter();
    let var_5 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_5.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_5.len()),
        ))
    } else {
        let mut var_5 = var_5;
        Ok(var_5.pop())
    }
}

pub fn deser_header_delete_object_delete_object_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_delete_object_delete_object_output_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_delete_objects_delete_objects_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_delete_object_tagging_delete_object_tagging_output_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_payload_get_bucket_analytics_configuration_get_bucket_analytics_configuration_output_analytics_configuration(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::AnalyticsConfiguration>,
    crate::error::GetBucketAnalyticsConfigurationError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_analytics_configuration_output_analytics_configuration(body).map_err(crate::error::GetBucketAnalyticsConfigurationError::unhandled)
    }).transpose()
}

pub fn deser_payload_get_bucket_encryption_get_bucket_encryption_output_server_side_encryption_configuration(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::ServerSideEncryptionConfiguration>,
    crate::error::GetBucketEncryptionError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_encryption_output_server_side_encryption_configuration(body).map_err(crate::error::GetBucketEncryptionError::unhandled)
    }).transpose()
}

pub fn deser_payload_get_bucket_intelligent_tiering_configuration_get_bucket_intelligent_tiering_configuration_output_intelligent_tiering_configuration(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::IntelligentTieringConfiguration>,
    crate::error::GetBucketIntelligentTieringConfigurationError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_intelligent_tiering_configuration_output_intelligent_tiering_configuration(body).map_err(crate::error::GetBucketIntelligentTieringConfigurationError::unhandled)
    }).transpose()
}

pub fn deser_payload_get_bucket_inventory_configuration_get_bucket_inventory_configuration_output_inventory_configuration(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::InventoryConfiguration>,
    crate::error::GetBucketInventoryConfigurationError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_inventory_configuration_output_inventory_configuration(body).map_err(crate::error::GetBucketInventoryConfigurationError::unhandled)
    }).transpose()
}

pub fn deser_payload_get_bucket_metrics_configuration_get_bucket_metrics_configuration_output_metrics_configuration(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::MetricsConfiguration>,
    crate::error::GetBucketMetricsConfigurationError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_metrics_configuration_output_metrics_configuration(body).map_err(crate::error::GetBucketMetricsConfigurationError::unhandled)
    }).transpose()
}

pub fn deser_payload_get_bucket_ownership_controls_get_bucket_ownership_controls_output_ownership_controls(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::OwnershipControls>,
    crate::error::GetBucketOwnershipControlsError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_ownership_controls_output_ownership_controls(body).map_err(crate::error::GetBucketOwnershipControlsError::unhandled)
    }).transpose()
}

pub fn deser_payload_get_bucket_policy_get_bucket_policy_output_policy(
    body: &[u8],
) -> std::result::Result<std::option::Option<std::string::String>, crate::error::GetBucketPolicyError>
{
    (!body.is_empty())
        .then(|| {
            let body_str = std::str::from_utf8(&body)
                .map_err(crate::error::GetBucketPolicyError::unhandled)?;
            Ok(body_str.to_string())
        })
        .transpose()
}

pub fn deser_payload_get_bucket_policy_status_get_bucket_policy_status_output_policy_status(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::PolicyStatus>,
    crate::error::GetBucketPolicyStatusError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_policy_status_output_policy_status(body).map_err(crate::error::GetBucketPolicyStatusError::unhandled)
    }).transpose()
}

pub fn deser_payload_get_bucket_replication_get_bucket_replication_output_replication_configuration(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::ReplicationConfiguration>,
    crate::error::GetBucketReplicationError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_replication_output_replication_configuration(body).map_err(crate::error::GetBucketReplicationError::unhandled)
    }).transpose()
}

pub fn deser_header_get_object_get_object_output_accept_ranges(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("accept-ranges").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_payload_get_object_get_object_output_body(
    body: &mut aws_smithy_http::body::SdkBody,
) -> std::result::Result<aws_smithy_http::byte_stream::ByteStream, crate::error::GetObjectError> {
    // replace the body with an empty body
    let body = std::mem::replace(body, aws_smithy_http::body::SdkBody::taken());
    Ok(aws_smithy_http::byte_stream::ByteStream::new(body))
}

pub fn deser_header_get_object_get_object_output_bucket_key_enabled(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-bucket-key-enabled")
        .iter();
    let var_6 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_6.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_6.len()),
        ))
    } else {
        let mut var_6 = var_6;
        Ok(var_6.pop())
    }
}

pub fn deser_header_get_object_get_object_output_cache_control(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Cache-Control").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_content_disposition(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Content-Disposition").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_content_encoding(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Content-Encoding").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_content_language(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Content-Language").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_content_length(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i64>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Content-Length").iter();
    let var_7 = aws_smithy_http::header::read_many_primitive::<i64>(headers)?;
    if var_7.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_7.len()),
        ))
    } else {
        let mut var_7 = var_7;
        Ok(var_7.pop())
    }
}

pub fn deser_header_get_object_get_object_output_content_range(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Content-Range").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_content_type(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Content-Type").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_delete_marker(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("x-amz-delete-marker").iter();
    let var_8 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_8.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_8.len()),
        ))
    } else {
        let mut var_8 = var_8;
        Ok(var_8.pop())
    }
}

pub fn deser_header_get_object_get_object_output_e_tag(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("ETag").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_expiration(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-expiration").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_expires(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<aws_smithy_types::Instant>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Expires").iter();
    let var_9: Vec<aws_smithy_types::Instant> =
        aws_smithy_http::header::many_dates(headers, aws_smithy_types::instant::Format::HttpDate)?;
    if var_9.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_9.len()),
        ))
    } else {
        let mut var_9 = var_9;
        Ok(var_9.pop())
    }
}

pub fn deser_header_get_object_get_object_output_last_modified(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<aws_smithy_types::Instant>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Last-Modified").iter();
    let var_10: Vec<aws_smithy_types::Instant> =
        aws_smithy_http::header::many_dates(headers, aws_smithy_types::instant::Format::HttpDate)?;
    if var_10.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_10.len()),
        ))
    } else {
        let mut var_10 = var_10;
        Ok(var_10.pop())
    }
}

pub fn deser_prefix_header_get_object_get_object_output_metadata(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
    aws_smithy_http::header::ParseError,
> {
    let headers = aws_smithy_http::header::headers_for_prefix(&header_map, "x-amz-meta-");
    let out: std::result::Result<_, _> = headers
        .map(|(key, header_name)| {
            let values = header_map.get_all(header_name);
            crate::http_serde::deser_prefix_header_get_object_get_object_output_metadata_inner(
                values.iter(),
            )
            .map(|v| (key.to_string(), v.unwrap()))
        })
        .collect();
    out.map(Some)
}

pub fn deser_header_get_object_get_object_output_missing_meta(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("x-amz-missing-meta").iter();
    let var_11 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_11.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_11.len()),
        ))
    } else {
        let mut var_11 = var_11;
        Ok(var_11.pop())
    }
}

pub fn deser_header_get_object_get_object_output_object_lock_legal_hold_status(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ObjectLockLegalHoldStatus>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-object-lock-legal-hold").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_object_lock_mode(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ObjectLockMode>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-object-lock-mode").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_object_lock_retain_until_date(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<aws_smithy_types::Instant>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-object-lock-retain-until-date")
        .iter();
    let var_12: Vec<aws_smithy_types::Instant> =
        aws_smithy_http::header::many_dates(headers, aws_smithy_types::instant::Format::DateTime)?;
    if var_12.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_12.len()),
        ))
    } else {
        let mut var_12 = var_12;
        Ok(var_12.pop())
    }
}

pub fn deser_header_get_object_get_object_output_parts_count(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("x-amz-mp-parts-count").iter();
    let var_13 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_13.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_13.len()),
        ))
    } else {
        let mut var_13 = var_13;
        Ok(var_13.pop())
    }
}

pub fn deser_header_get_object_get_object_output_replication_status(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ReplicationStatus>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-replication-status").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_restore(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-restore").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_sse_customer_algorithm(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-algorithm")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_sse_customer_key_md5(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-key-MD5")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_ssekms_key_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-aws-kms-key-id")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_server_side_encryption(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ServerSideEncryption>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-server-side-encryption").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_storage_class(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::StorageClass>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-storage-class").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_tag_count(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("x-amz-tagging-count").iter();
    let var_14 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_14.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_14.len()),
        ))
    } else {
        let mut var_14 = var_14;
        Ok(var_14.pop())
    }
}

pub fn deser_header_get_object_get_object_output_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_get_object_output_website_redirect_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("x-amz-website-redirect-location").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_get_object_acl_get_object_acl_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_payload_get_object_legal_hold_get_object_legal_hold_output_legal_hold(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::ObjectLockLegalHold>,
    crate::error::GetObjectLegalHoldError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_object_legal_hold_output_legal_hold(body).map_err(crate::error::GetObjectLegalHoldError::unhandled)
    }).transpose()
}

pub fn deser_payload_get_object_lock_configuration_get_object_lock_configuration_output_object_lock_configuration(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::ObjectLockConfiguration>,
    crate::error::GetObjectLockConfigurationError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_object_lock_configuration_output_object_lock_configuration(body).map_err(crate::error::GetObjectLockConfigurationError::unhandled)
    }).transpose()
}

pub fn deser_payload_get_object_retention_get_object_retention_output_retention(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::ObjectLockRetention>,
    crate::error::GetObjectRetentionError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_object_retention_output_retention(body).map_err(crate::error::GetObjectRetentionError::unhandled)
    }).transpose()
}

pub fn deser_header_get_object_tagging_get_object_tagging_output_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_payload_get_object_torrent_get_object_torrent_output_body(
    body: &mut aws_smithy_http::body::SdkBody,
) -> std::result::Result<
    aws_smithy_http::byte_stream::ByteStream,
    crate::error::GetObjectTorrentError,
> {
    // replace the body with an empty body
    let body = std::mem::replace(body, aws_smithy_http::body::SdkBody::taken());
    Ok(aws_smithy_http::byte_stream::ByteStream::new(body))
}

pub fn deser_header_get_object_torrent_get_object_torrent_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").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_s3_synthetic_get_public_access_block_output_public_access_block_configuration(body).map_err(crate::error::GetPublicAccessBlockError::unhandled)
    }).transpose()
}

pub fn deser_header_head_object_head_object_output_accept_ranges(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("accept-ranges").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_archive_status(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ArchiveStatus>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-archive-status").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_bucket_key_enabled(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-bucket-key-enabled")
        .iter();
    let var_15 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_15.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_15.len()),
        ))
    } else {
        let mut var_15 = var_15;
        Ok(var_15.pop())
    }
}

pub fn deser_header_head_object_head_object_output_cache_control(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Cache-Control").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_content_disposition(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Content-Disposition").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_content_encoding(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Content-Encoding").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_content_language(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Content-Language").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_content_length(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i64>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Content-Length").iter();
    let var_16 = aws_smithy_http::header::read_many_primitive::<i64>(headers)?;
    if var_16.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_16.len()),
        ))
    } else {
        let mut var_16 = var_16;
        Ok(var_16.pop())
    }
}

pub fn deser_header_head_object_head_object_output_content_type(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Content-Type").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_delete_marker(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("x-amz-delete-marker").iter();
    let var_17 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_17.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_17.len()),
        ))
    } else {
        let mut var_17 = var_17;
        Ok(var_17.pop())
    }
}

pub fn deser_header_head_object_head_object_output_e_tag(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("ETag").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_expiration(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-expiration").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_expires(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<aws_smithy_types::Instant>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Expires").iter();
    let var_18: Vec<aws_smithy_types::Instant> =
        aws_smithy_http::header::many_dates(headers, aws_smithy_types::instant::Format::HttpDate)?;
    if var_18.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_18.len()),
        ))
    } else {
        let mut var_18 = var_18;
        Ok(var_18.pop())
    }
}

pub fn deser_header_head_object_head_object_output_last_modified(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<aws_smithy_types::Instant>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("Last-Modified").iter();
    let var_19: Vec<aws_smithy_types::Instant> =
        aws_smithy_http::header::many_dates(headers, aws_smithy_types::instant::Format::HttpDate)?;
    if var_19.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_19.len()),
        ))
    } else {
        let mut var_19 = var_19;
        Ok(var_19.pop())
    }
}

pub fn deser_prefix_header_head_object_head_object_output_metadata(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
    aws_smithy_http::header::ParseError,
> {
    let headers = aws_smithy_http::header::headers_for_prefix(&header_map, "x-amz-meta-");
    let out: std::result::Result<_, _> = headers
        .map(|(key, header_name)| {
            let values = header_map.get_all(header_name);
            crate::http_serde::deser_prefix_header_head_object_head_object_output_metadata_inner(
                values.iter(),
            )
            .map(|v| (key.to_string(), v.unwrap()))
        })
        .collect();
    out.map(Some)
}

pub fn deser_header_head_object_head_object_output_missing_meta(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("x-amz-missing-meta").iter();
    let var_20 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_20.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_20.len()),
        ))
    } else {
        let mut var_20 = var_20;
        Ok(var_20.pop())
    }
}

pub fn deser_header_head_object_head_object_output_object_lock_legal_hold_status(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ObjectLockLegalHoldStatus>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-object-lock-legal-hold").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_object_lock_mode(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ObjectLockMode>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-object-lock-mode").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_object_lock_retain_until_date(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<aws_smithy_types::Instant>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-object-lock-retain-until-date")
        .iter();
    let var_21: Vec<aws_smithy_types::Instant> =
        aws_smithy_http::header::many_dates(headers, aws_smithy_types::instant::Format::DateTime)?;
    if var_21.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_21.len()),
        ))
    } else {
        let mut var_21 = var_21;
        Ok(var_21.pop())
    }
}

pub fn deser_header_head_object_head_object_output_parts_count(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("x-amz-mp-parts-count").iter();
    let var_22 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_22.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_22.len()),
        ))
    } else {
        let mut var_22 = var_22;
        Ok(var_22.pop())
    }
}

pub fn deser_header_head_object_head_object_output_replication_status(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ReplicationStatus>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-replication-status").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_restore(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-restore").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_sse_customer_algorithm(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-algorithm")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_sse_customer_key_md5(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-key-MD5")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_ssekms_key_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-aws-kms-key-id")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_server_side_encryption(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ServerSideEncryption>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-server-side-encryption").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_storage_class(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::StorageClass>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-storage-class").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_head_object_head_object_output_website_redirect_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("x-amz-website-redirect-location").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_list_parts_list_parts_output_abort_date(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<aws_smithy_types::Instant>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-abort-date").iter();
    let var_23: Vec<aws_smithy_types::Instant> =
        aws_smithy_http::header::many_dates(headers, aws_smithy_types::instant::Format::HttpDate)?;
    if var_23.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_23.len()),
        ))
    } else {
        let mut var_23 = var_23;
        Ok(var_23.pop())
    }
}

pub fn deser_header_list_parts_list_parts_output_abort_rule_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-abort-rule-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_list_parts_list_parts_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_put_object_output_bucket_key_enabled(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-bucket-key-enabled")
        .iter();
    let var_24 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_24.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_24.len()),
        ))
    } else {
        let mut var_24 = var_24;
        Ok(var_24.pop())
    }
}

pub fn deser_header_put_object_put_object_output_e_tag(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("ETag").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_put_object_output_expiration(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-expiration").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_put_object_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_put_object_output_sse_customer_algorithm(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-algorithm")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_put_object_output_sse_customer_key_md5(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-key-MD5")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_put_object_output_ssekms_encryption_context(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-context")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_put_object_output_ssekms_key_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-aws-kms-key-id")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_put_object_output_server_side_encryption(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ServerSideEncryption>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-server-side-encryption").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_put_object_output_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_acl_put_object_acl_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_legal_hold_put_object_legal_hold_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_lock_configuration_put_object_lock_configuration_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_retention_put_object_retention_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_put_object_tagging_put_object_tagging_output_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_restore_object_restore_object_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_restore_object_restore_object_output_restore_output_path(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-restore-output-path").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_payload_select_object_content_select_object_content_output_payload(
    body: &mut aws_smithy_http::body::SdkBody,
) -> std::result::Result<
    aws_smithy_http::event_stream::Receiver<
        crate::model::SelectObjectContentEventStream,
        crate::error::SelectObjectContentError,
    >,
    crate::error::SelectObjectContentError,
> {
    let unmarshaller = crate::event_stream_serde::SelectObjectContentEventStreamUnmarshaller::new();
    let body = std::mem::replace(body, aws_smithy_http::body::SdkBody::taken());
    Ok(aws_smithy_http::event_stream::Receiver::new(
        unmarshaller,
        body,
    ))
}

pub fn deser_header_upload_part_upload_part_output_bucket_key_enabled(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-bucket-key-enabled")
        .iter();
    let var_25 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_25.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_25.len()),
        ))
    } else {
        let mut var_25 = var_25;
        Ok(var_25.pop())
    }
}

pub fn deser_header_upload_part_upload_part_output_e_tag(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("ETag").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_upload_part_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_upload_part_output_sse_customer_algorithm(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-algorithm")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_upload_part_output_sse_customer_key_md5(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-key-MD5")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_upload_part_output_ssekms_key_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-aws-kms-key-id")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_upload_part_output_server_side_encryption(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ServerSideEncryption>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-server-side-encryption").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_copy_upload_part_copy_output_bucket_key_enabled(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-bucket-key-enabled")
        .iter();
    let var_26 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
    if var_26.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new_with_message(
            format!("expected one item but found {}", var_26.len()),
        ))
    } else {
        let mut var_26 = var_26;
        Ok(var_26.pop())
    }
}

pub fn deser_payload_upload_part_copy_upload_part_copy_output_copy_part_result(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::CopyPartResult>,
    crate::error::UploadPartCopyError,
> {
    (!body.is_empty()).then(||{
        crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_upload_part_copy_output_copy_part_result(body).map_err(crate::error::UploadPartCopyError::unhandled)
    }).transpose()
}

pub fn deser_header_upload_part_copy_upload_part_copy_output_copy_source_version_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-copy-source-version-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_copy_upload_part_copy_output_request_charged(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::RequestCharged>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-request-charged").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_copy_upload_part_copy_output_sse_customer_algorithm(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-algorithm")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_copy_upload_part_copy_output_sse_customer_key_md5(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-customer-key-MD5")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_copy_upload_part_copy_output_ssekms_key_id(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<std::string::String>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map
        .get_all("x-amz-server-side-encryption-aws-kms-key-id")
        .iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_header_upload_part_copy_upload_part_copy_output_server_side_encryption(
    header_map: &http::HeaderMap,
) -> std::result::Result<
    std::option::Option<crate::model::ServerSideEncryption>,
    aws_smithy_http::header::ParseError,
> {
    let headers = header_map.get_all("x-amz-server-side-encryption").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_prefix_header_get_object_get_object_output_metadata_inner(
    headers: http::header::ValueIter<http::HeaderValue>,
) -> std::result::Result<Option<std::string::String>, aws_smithy_http::header::ParseError> {
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_prefix_header_head_object_head_object_output_metadata_inner(
    headers: http::header::ValueIter<http::HeaderValue>,
) -> std::result::Result<Option<std::string::String>, aws_smithy_http::header::ParseError> {
    aws_smithy_http::header::one_or_none(headers)
}