aws-sdk-cloudfront 0.22.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_cache_policy_input_cache_policy_config(
    input: &crate::model::CachePolicyConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("CachePolicyConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_cache_policy_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_cloud_front_origin_access_identity_input_cloud_front_origin_access_identity_config(
    input: &crate::model::CloudFrontOriginAccessIdentityConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("CloudFrontOriginAccessIdentityConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_cloud_front_origin_access_identity_config(
            input, root,
        )?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_distribution_input_distribution_config(
    input: &crate::model::DistributionConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("DistributionConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_distribution_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_distribution_with_tags_input_distribution_config_with_tags(
    input: &crate::model::DistributionConfigWithTags,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("DistributionConfigWithTags")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_distribution_config_with_tags(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_field_level_encryption_config_input_field_level_encryption_config(
    input: &crate::model::FieldLevelEncryptionConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("FieldLevelEncryptionConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_field_level_encryption_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_field_level_encryption_profile_input_field_level_encryption_profile_config(
    input: &crate::model::FieldLevelEncryptionProfileConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("FieldLevelEncryptionProfileConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_field_level_encryption_profile_config(
            input, root,
        )?
    }
    Ok(out.into_bytes())
}

pub fn serialize_structure_crate_input_create_function_input(
    input: &crate::input::CreateFunctionInput,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_1) = &input.function_code {
        let mut inner_writer = scope.start_el("FunctionCode").finish();
        inner_writer.data(aws_smithy_types::base64::encode(var_1.as_ref()).as_ref());
    }
    if let Some(var_2) = &input.function_config {
        let inner_writer = scope.start_el("FunctionConfig");
        crate::xml_ser::serialize_structure_crate_model_function_config(var_2, inner_writer)?
    }
    if let Some(var_3) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_3.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_invalidation_input_invalidation_batch(
    input: &crate::model::InvalidationBatch,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("InvalidationBatch")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_invalidation_batch(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_key_group_input_key_group_config(
    input: &crate::model::KeyGroupConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("KeyGroupConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_key_group_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_monitoring_subscription_input_monitoring_subscription(
    input: &crate::model::MonitoringSubscription,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("MonitoringSubscription")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_monitoring_subscription(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_origin_access_control_input_origin_access_control_config(
    input: &crate::model::OriginAccessControlConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("OriginAccessControlConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_origin_access_control_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_origin_request_policy_input_origin_request_policy_config(
    input: &crate::model::OriginRequestPolicyConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("OriginRequestPolicyConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_origin_request_policy_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_public_key_input_public_key_config(
    input: &crate::model::PublicKeyConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("PublicKeyConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_public_key_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_structure_crate_input_create_realtime_log_config_input(
    input: &crate::input::CreateRealtimeLogConfigInput,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_4) = &input.end_points {
        let mut inner_writer = scope.start_el("EndPoints").finish();
        for list_item_5 in var_4 {
            {
                let inner_writer = inner_writer.start_el("member");
                crate::xml_ser::serialize_structure_crate_model_end_point(
                    list_item_5,
                    inner_writer,
                )?
            }
        }
    }
    if let Some(var_6) = &input.fields {
        let mut inner_writer = scope.start_el("Fields").finish();
        for list_item_7 in var_6 {
            {
                let mut inner_writer = inner_writer.start_el("Field").finish();
                inner_writer.data(list_item_7.as_str());
            }
        }
    }
    if let Some(var_8) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_8.as_str());
    }
    if let Some(var_9) = &input.sampling_rate {
        let mut inner_writer = scope.start_el("SamplingRate").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_9).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_response_headers_policy_input_response_headers_policy_config(
    input: &crate::model::ResponseHeadersPolicyConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("ResponseHeadersPolicyConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_streaming_distribution_input_streaming_distribution_config(
    input: &crate::model::StreamingDistributionConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("StreamingDistributionConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_streaming_distribution_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_create_streaming_distribution_with_tags_input_streaming_distribution_config_with_tags(
    input: &crate::model::StreamingDistributionConfigWithTags,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("StreamingDistributionConfigWithTags")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_streaming_distribution_config_with_tags(
            input, root,
        )?
    }
    Ok(out.into_bytes())
}

pub fn serialize_structure_crate_input_delete_realtime_log_config_input(
    input: &crate::input::DeleteRealtimeLogConfigInput,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_10) = &input.arn {
        let mut inner_writer = scope.start_el("ARN").finish();
        inner_writer.data(var_10.as_str());
    }
    if let Some(var_11) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_11.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_input_get_realtime_log_config_input(
    input: &crate::input::GetRealtimeLogConfigInput,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_12) = &input.arn {
        let mut inner_writer = scope.start_el("ARN").finish();
        inner_writer.data(var_12.as_str());
    }
    if let Some(var_13) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_13.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_input_list_distributions_by_realtime_log_config_input(
    input: &crate::input::ListDistributionsByRealtimeLogConfigInput,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_14) = &input.marker {
        let mut inner_writer = scope.start_el("Marker").finish();
        inner_writer.data(var_14.as_str());
    }
    if let Some(var_15) = &input.max_items {
        let mut inner_writer = scope.start_el("MaxItems").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_15).encode());
    }
    if let Some(var_16) = &input.realtime_log_config_arn {
        let mut inner_writer = scope.start_el("RealtimeLogConfigArn").finish();
        inner_writer.data(var_16.as_str());
    }
    if let Some(var_17) = &input.realtime_log_config_name {
        let mut inner_writer = scope.start_el("RealtimeLogConfigName").finish();
        inner_writer.data(var_17.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_tag_resource_input_tags(
    input: &crate::model::Tags,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("Tags")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_tags(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_structure_crate_input_test_function_input(
    input: &crate::input::TestFunctionInput,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_18) = &input.event_object {
        let mut inner_writer = scope.start_el("EventObject").finish();
        inner_writer.data(aws_smithy_types::base64::encode(var_18.as_ref()).as_ref());
    }
    if let Some(var_19) = &input.stage {
        let mut inner_writer = scope.start_el("Stage").finish();
        inner_writer.data(var_19.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_untag_resource_input_tag_keys(
    input: &crate::model::TagKeys,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("TagKeys")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_tag_keys(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_cache_policy_input_cache_policy_config(
    input: &crate::model::CachePolicyConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("CachePolicyConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_cache_policy_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_cloud_front_origin_access_identity_input_cloud_front_origin_access_identity_config(
    input: &crate::model::CloudFrontOriginAccessIdentityConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("CloudFrontOriginAccessIdentityConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_cloud_front_origin_access_identity_config(
            input, root,
        )?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_distribution_input_distribution_config(
    input: &crate::model::DistributionConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("DistributionConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_distribution_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_field_level_encryption_config_input_field_level_encryption_config(
    input: &crate::model::FieldLevelEncryptionConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("FieldLevelEncryptionConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_field_level_encryption_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_field_level_encryption_profile_input_field_level_encryption_profile_config(
    input: &crate::model::FieldLevelEncryptionProfileConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("FieldLevelEncryptionProfileConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_field_level_encryption_profile_config(
            input, root,
        )?
    }
    Ok(out.into_bytes())
}

pub fn serialize_structure_crate_input_update_function_input(
    input: &crate::input::UpdateFunctionInput,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_20) = &input.function_code {
        let mut inner_writer = scope.start_el("FunctionCode").finish();
        inner_writer.data(aws_smithy_types::base64::encode(var_20.as_ref()).as_ref());
    }
    if let Some(var_21) = &input.function_config {
        let inner_writer = scope.start_el("FunctionConfig");
        crate::xml_ser::serialize_structure_crate_model_function_config(var_21, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_key_group_input_key_group_config(
    input: &crate::model::KeyGroupConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("KeyGroupConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_key_group_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_origin_access_control_input_origin_access_control_config(
    input: &crate::model::OriginAccessControlConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("OriginAccessControlConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_origin_access_control_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_origin_request_policy_input_origin_request_policy_config(
    input: &crate::model::OriginRequestPolicyConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("OriginRequestPolicyConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_origin_request_policy_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_public_key_input_public_key_config(
    input: &crate::model::PublicKeyConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("PublicKeyConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_public_key_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_structure_crate_input_update_realtime_log_config_input(
    input: &crate::input::UpdateRealtimeLogConfigInput,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_22) = &input.arn {
        let mut inner_writer = scope.start_el("ARN").finish();
        inner_writer.data(var_22.as_str());
    }
    if let Some(var_23) = &input.end_points {
        let mut inner_writer = scope.start_el("EndPoints").finish();
        for list_item_24 in var_23 {
            {
                let inner_writer = inner_writer.start_el("member");
                crate::xml_ser::serialize_structure_crate_model_end_point(
                    list_item_24,
                    inner_writer,
                )?
            }
        }
    }
    if let Some(var_25) = &input.fields {
        let mut inner_writer = scope.start_el("Fields").finish();
        for list_item_26 in var_25 {
            {
                let mut inner_writer = inner_writer.start_el("Field").finish();
                inner_writer.data(list_item_26.as_str());
            }
        }
    }
    if let Some(var_27) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_27.as_str());
    }
    if let Some(var_28) = &input.sampling_rate {
        let mut inner_writer = scope.start_el("SamplingRate").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_28).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_response_headers_policy_input_response_headers_policy_config(
    input: &crate::model::ResponseHeadersPolicyConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("ResponseHeadersPolicyConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_member_com_amazonaws_cloudfront_synthetic_update_streaming_distribution_input_streaming_distribution_config(
    input: &crate::model::StreamingDistributionConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    {
        let mut writer = aws_smithy_xml::encode::XmlWriter::new(&mut out);
        #[allow(unused_mut)]
        let mut root = writer
            .start_el("StreamingDistributionConfig")
            .write_ns("http://cloudfront.amazonaws.com/doc/2020-05-31/", None);
        crate::xml_ser::serialize_structure_crate_model_streaming_distribution_config(input, root)?
    }
    Ok(out.into_bytes())
}

pub fn serialize_structure_crate_model_cache_policy_config(
    input: &crate::model::CachePolicyConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_29) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_29.as_str());
    }
    if let Some(var_30) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_30.as_str());
    }
    if let Some(var_31) = &input.default_ttl {
        let mut inner_writer = scope.start_el("DefaultTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_31).encode());
    }
    if let Some(var_32) = &input.max_ttl {
        let mut inner_writer = scope.start_el("MaxTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_32).encode());
    }
    if let Some(var_33) = &input.min_ttl {
        let mut inner_writer = scope.start_el("MinTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_33).encode());
    }
    if let Some(var_34) = &input.parameters_in_cache_key_and_forwarded_to_origin {
        let inner_writer = scope.start_el("ParametersInCacheKeyAndForwardedToOrigin");
        crate::xml_ser::serialize_structure_crate_model_parameters_in_cache_key_and_forwarded_to_origin(var_34, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_cloud_front_origin_access_identity_config(
    input: &crate::model::CloudFrontOriginAccessIdentityConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_35) = &input.caller_reference {
        let mut inner_writer = scope.start_el("CallerReference").finish();
        inner_writer.data(var_35.as_str());
    }
    if let Some(var_36) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_36.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_distribution_config(
    input: &crate::model::DistributionConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_37) = &input.caller_reference {
        let mut inner_writer = scope.start_el("CallerReference").finish();
        inner_writer.data(var_37.as_str());
    }
    if let Some(var_38) = &input.aliases {
        let inner_writer = scope.start_el("Aliases");
        crate::xml_ser::serialize_structure_crate_model_aliases(var_38, inner_writer)?
    }
    if let Some(var_39) = &input.default_root_object {
        let mut inner_writer = scope.start_el("DefaultRootObject").finish();
        inner_writer.data(var_39.as_str());
    }
    if let Some(var_40) = &input.origins {
        let inner_writer = scope.start_el("Origins");
        crate::xml_ser::serialize_structure_crate_model_origins(var_40, inner_writer)?
    }
    if let Some(var_41) = &input.origin_groups {
        let inner_writer = scope.start_el("OriginGroups");
        crate::xml_ser::serialize_structure_crate_model_origin_groups(var_41, inner_writer)?
    }
    if let Some(var_42) = &input.default_cache_behavior {
        let inner_writer = scope.start_el("DefaultCacheBehavior");
        crate::xml_ser::serialize_structure_crate_model_default_cache_behavior(
            var_42,
            inner_writer,
        )?
    }
    if let Some(var_43) = &input.cache_behaviors {
        let inner_writer = scope.start_el("CacheBehaviors");
        crate::xml_ser::serialize_structure_crate_model_cache_behaviors(var_43, inner_writer)?
    }
    if let Some(var_44) = &input.custom_error_responses {
        let inner_writer = scope.start_el("CustomErrorResponses");
        crate::xml_ser::serialize_structure_crate_model_custom_error_responses(
            var_44,
            inner_writer,
        )?
    }
    if let Some(var_45) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_45.as_str());
    }
    if let Some(var_46) = &input.logging {
        let inner_writer = scope.start_el("Logging");
        crate::xml_ser::serialize_structure_crate_model_logging_config(var_46, inner_writer)?
    }
    if let Some(var_47) = &input.price_class {
        let mut inner_writer = scope.start_el("PriceClass").finish();
        inner_writer.data(var_47.as_str());
    }
    if let Some(var_48) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_48).encode());
    }
    if let Some(var_49) = &input.viewer_certificate {
        let inner_writer = scope.start_el("ViewerCertificate");
        crate::xml_ser::serialize_structure_crate_model_viewer_certificate(var_49, inner_writer)?
    }
    if let Some(var_50) = &input.restrictions {
        let inner_writer = scope.start_el("Restrictions");
        crate::xml_ser::serialize_structure_crate_model_restrictions(var_50, inner_writer)?
    }
    if let Some(var_51) = &input.web_acl_id {
        let mut inner_writer = scope.start_el("WebACLId").finish();
        inner_writer.data(var_51.as_str());
    }
    if let Some(var_52) = &input.http_version {
        let mut inner_writer = scope.start_el("HttpVersion").finish();
        inner_writer.data(var_52.as_str());
    }
    if let Some(var_53) = &input.is_ipv6_enabled {
        let mut inner_writer = scope.start_el("IsIPV6Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_53).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_distribution_config_with_tags(
    input: &crate::model::DistributionConfigWithTags,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_54) = &input.distribution_config {
        let inner_writer = scope.start_el("DistributionConfig");
        crate::xml_ser::serialize_structure_crate_model_distribution_config(var_54, inner_writer)?
    }
    if let Some(var_55) = &input.tags {
        let inner_writer = scope.start_el("Tags");
        crate::xml_ser::serialize_structure_crate_model_tags(var_55, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_field_level_encryption_config(
    input: &crate::model::FieldLevelEncryptionConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_56) = &input.caller_reference {
        let mut inner_writer = scope.start_el("CallerReference").finish();
        inner_writer.data(var_56.as_str());
    }
    if let Some(var_57) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_57.as_str());
    }
    if let Some(var_58) = &input.query_arg_profile_config {
        let inner_writer = scope.start_el("QueryArgProfileConfig");
        crate::xml_ser::serialize_structure_crate_model_query_arg_profile_config(
            var_58,
            inner_writer,
        )?
    }
    if let Some(var_59) = &input.content_type_profile_config {
        let inner_writer = scope.start_el("ContentTypeProfileConfig");
        crate::xml_ser::serialize_structure_crate_model_content_type_profile_config(
            var_59,
            inner_writer,
        )?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_field_level_encryption_profile_config(
    input: &crate::model::FieldLevelEncryptionProfileConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_60) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_60.as_str());
    }
    if let Some(var_61) = &input.caller_reference {
        let mut inner_writer = scope.start_el("CallerReference").finish();
        inner_writer.data(var_61.as_str());
    }
    if let Some(var_62) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_62.as_str());
    }
    if let Some(var_63) = &input.encryption_entities {
        let inner_writer = scope.start_el("EncryptionEntities");
        crate::xml_ser::serialize_structure_crate_model_encryption_entities(var_63, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_function_config(
    input: &crate::model::FunctionConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_64) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_64.as_str());
    }
    if let Some(var_65) = &input.runtime {
        let mut inner_writer = scope.start_el("Runtime").finish();
        inner_writer.data(var_65.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_invalidation_batch(
    input: &crate::model::InvalidationBatch,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_66) = &input.paths {
        let inner_writer = scope.start_el("Paths");
        crate::xml_ser::serialize_structure_crate_model_paths(var_66, inner_writer)?
    }
    if let Some(var_67) = &input.caller_reference {
        let mut inner_writer = scope.start_el("CallerReference").finish();
        inner_writer.data(var_67.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_key_group_config(
    input: &crate::model::KeyGroupConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_68) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_68.as_str());
    }
    if let Some(var_69) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_70 in var_69 {
            {
                let mut inner_writer = inner_writer.start_el("PublicKey").finish();
                inner_writer.data(list_item_70.as_str());
            }
        }
    }
    if let Some(var_71) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_71.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_monitoring_subscription(
    input: &crate::model::MonitoringSubscription,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_72) = &input.realtime_metrics_subscription_config {
        let inner_writer = scope.start_el("RealtimeMetricsSubscriptionConfig");
        crate::xml_ser::serialize_structure_crate_model_realtime_metrics_subscription_config(
            var_72,
            inner_writer,
        )?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_access_control_config(
    input: &crate::model::OriginAccessControlConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_73) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_73.as_str());
    }
    if let Some(var_74) = &input.description {
        let mut inner_writer = scope.start_el("Description").finish();
        inner_writer.data(var_74.as_str());
    }
    if let Some(var_75) = &input.signing_protocol {
        let mut inner_writer = scope.start_el("SigningProtocol").finish();
        inner_writer.data(var_75.as_str());
    }
    if let Some(var_76) = &input.signing_behavior {
        let mut inner_writer = scope.start_el("SigningBehavior").finish();
        inner_writer.data(var_76.as_str());
    }
    if let Some(var_77) = &input.origin_access_control_origin_type {
        let mut inner_writer = scope.start_el("OriginAccessControlOriginType").finish();
        inner_writer.data(var_77.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_request_policy_config(
    input: &crate::model::OriginRequestPolicyConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_78) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_78.as_str());
    }
    if let Some(var_79) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_79.as_str());
    }
    if let Some(var_80) = &input.headers_config {
        let inner_writer = scope.start_el("HeadersConfig");
        crate::xml_ser::serialize_structure_crate_model_origin_request_policy_headers_config(
            var_80,
            inner_writer,
        )?
    }
    if let Some(var_81) = &input.cookies_config {
        let inner_writer = scope.start_el("CookiesConfig");
        crate::xml_ser::serialize_structure_crate_model_origin_request_policy_cookies_config(
            var_81,
            inner_writer,
        )?
    }
    if let Some(var_82) = &input.query_strings_config {
        let inner_writer = scope.start_el("QueryStringsConfig");
        crate::xml_ser::serialize_structure_crate_model_origin_request_policy_query_strings_config(
            var_82,
            inner_writer,
        )?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_public_key_config(
    input: &crate::model::PublicKeyConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_83) = &input.caller_reference {
        let mut inner_writer = scope.start_el("CallerReference").finish();
        inner_writer.data(var_83.as_str());
    }
    if let Some(var_84) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_84.as_str());
    }
    if let Some(var_85) = &input.encoded_key {
        let mut inner_writer = scope.start_el("EncodedKey").finish();
        inner_writer.data(var_85.as_str());
    }
    if let Some(var_86) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_86.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_end_point(
    input: &crate::model::EndPoint,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_87) = &input.stream_type {
        let mut inner_writer = scope.start_el("StreamType").finish();
        inner_writer.data(var_87.as_str());
    }
    if let Some(var_88) = &input.kinesis_stream_config {
        let inner_writer = scope.start_el("KinesisStreamConfig");
        crate::xml_ser::serialize_structure_crate_model_kinesis_stream_config(var_88, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_config(
    input: &crate::model::ResponseHeadersPolicyConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_89) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_89.as_str());
    }
    if let Some(var_90) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_90.as_str());
    }
    if let Some(var_91) = &input.cors_config {
        let inner_writer = scope.start_el("CorsConfig");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_cors_config(
            var_91,
            inner_writer,
        )?
    }
    if let Some(var_92) = &input.security_headers_config {
        let inner_writer = scope.start_el("SecurityHeadersConfig");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_security_headers_config(var_92, inner_writer)?
    }
    if let Some(var_93) = &input.server_timing_headers_config {
        let inner_writer = scope.start_el("ServerTimingHeadersConfig");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_server_timing_headers_config(var_93, inner_writer)?
    }
    if let Some(var_94) = &input.custom_headers_config {
        let inner_writer = scope.start_el("CustomHeadersConfig");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_custom_headers_config(var_94, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_streaming_distribution_config(
    input: &crate::model::StreamingDistributionConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_95) = &input.caller_reference {
        let mut inner_writer = scope.start_el("CallerReference").finish();
        inner_writer.data(var_95.as_str());
    }
    if let Some(var_96) = &input.s3_origin {
        let inner_writer = scope.start_el("S3Origin");
        crate::xml_ser::serialize_structure_crate_model_s3_origin(var_96, inner_writer)?
    }
    if let Some(var_97) = &input.aliases {
        let inner_writer = scope.start_el("Aliases");
        crate::xml_ser::serialize_structure_crate_model_aliases(var_97, inner_writer)?
    }
    if let Some(var_98) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_98.as_str());
    }
    if let Some(var_99) = &input.logging {
        let inner_writer = scope.start_el("Logging");
        crate::xml_ser::serialize_structure_crate_model_streaming_logging_config(
            var_99,
            inner_writer,
        )?
    }
    if let Some(var_100) = &input.trusted_signers {
        let inner_writer = scope.start_el("TrustedSigners");
        crate::xml_ser::serialize_structure_crate_model_trusted_signers(var_100, inner_writer)?
    }
    if let Some(var_101) = &input.price_class {
        let mut inner_writer = scope.start_el("PriceClass").finish();
        inner_writer.data(var_101.as_str());
    }
    if let Some(var_102) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_102).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_streaming_distribution_config_with_tags(
    input: &crate::model::StreamingDistributionConfigWithTags,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_103) = &input.streaming_distribution_config {
        let inner_writer = scope.start_el("StreamingDistributionConfig");
        crate::xml_ser::serialize_structure_crate_model_streaming_distribution_config(
            var_103,
            inner_writer,
        )?
    }
    if let Some(var_104) = &input.tags {
        let inner_writer = scope.start_el("Tags");
        crate::xml_ser::serialize_structure_crate_model_tags(var_104, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_tags(
    input: &crate::model::Tags,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_105) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_106 in var_105 {
            {
                let inner_writer = inner_writer.start_el("Tag");
                crate::xml_ser::serialize_structure_crate_model_tag(list_item_106, inner_writer)?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_tag_keys(
    input: &crate::model::TagKeys,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_107) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_108 in var_107 {
            {
                let mut inner_writer = inner_writer.start_el("Key").finish();
                inner_writer.data(list_item_108.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_parameters_in_cache_key_and_forwarded_to_origin(
    input: &crate::model::ParametersInCacheKeyAndForwardedToOrigin,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_109) = &input.enable_accept_encoding_gzip {
        let mut inner_writer = scope.start_el("EnableAcceptEncodingGzip").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_109).encode());
    }
    if let Some(var_110) = &input.enable_accept_encoding_brotli {
        let mut inner_writer = scope.start_el("EnableAcceptEncodingBrotli").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_110).encode());
    }
    if let Some(var_111) = &input.headers_config {
        let inner_writer = scope.start_el("HeadersConfig");
        crate::xml_ser::serialize_structure_crate_model_cache_policy_headers_config(
            var_111,
            inner_writer,
        )?
    }
    if let Some(var_112) = &input.cookies_config {
        let inner_writer = scope.start_el("CookiesConfig");
        crate::xml_ser::serialize_structure_crate_model_cache_policy_cookies_config(
            var_112,
            inner_writer,
        )?
    }
    if let Some(var_113) = &input.query_strings_config {
        let inner_writer = scope.start_el("QueryStringsConfig");
        crate::xml_ser::serialize_structure_crate_model_cache_policy_query_strings_config(
            var_113,
            inner_writer,
        )?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_aliases(
    input: &crate::model::Aliases,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_114) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_114).encode());
    }
    if let Some(var_115) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_116 in var_115 {
            {
                let mut inner_writer = inner_writer.start_el("CNAME").finish();
                inner_writer.data(list_item_116.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origins(
    input: &crate::model::Origins,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_117) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_117).encode());
    }
    if let Some(var_118) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_119 in var_118 {
            {
                let inner_writer = inner_writer.start_el("Origin");
                crate::xml_ser::serialize_structure_crate_model_origin(list_item_119, inner_writer)?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_groups(
    input: &crate::model::OriginGroups,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_120) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_120).encode());
    }
    if let Some(var_121) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_122 in var_121 {
            {
                let inner_writer = inner_writer.start_el("OriginGroup");
                crate::xml_ser::serialize_structure_crate_model_origin_group(
                    list_item_122,
                    inner_writer,
                )?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_default_cache_behavior(
    input: &crate::model::DefaultCacheBehavior,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_123) = &input.target_origin_id {
        let mut inner_writer = scope.start_el("TargetOriginId").finish();
        inner_writer.data(var_123.as_str());
    }
    if let Some(var_124) = &input.trusted_signers {
        let inner_writer = scope.start_el("TrustedSigners");
        crate::xml_ser::serialize_structure_crate_model_trusted_signers(var_124, inner_writer)?
    }
    if let Some(var_125) = &input.trusted_key_groups {
        let inner_writer = scope.start_el("TrustedKeyGroups");
        crate::xml_ser::serialize_structure_crate_model_trusted_key_groups(var_125, inner_writer)?
    }
    if let Some(var_126) = &input.viewer_protocol_policy {
        let mut inner_writer = scope.start_el("ViewerProtocolPolicy").finish();
        inner_writer.data(var_126.as_str());
    }
    if let Some(var_127) = &input.allowed_methods {
        let inner_writer = scope.start_el("AllowedMethods");
        crate::xml_ser::serialize_structure_crate_model_allowed_methods(var_127, inner_writer)?
    }
    if let Some(var_128) = &input.smooth_streaming {
        let mut inner_writer = scope.start_el("SmoothStreaming").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_128).encode());
    }
    if let Some(var_129) = &input.compress {
        let mut inner_writer = scope.start_el("Compress").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_129).encode());
    }
    if let Some(var_130) = &input.lambda_function_associations {
        let inner_writer = scope.start_el("LambdaFunctionAssociations");
        crate::xml_ser::serialize_structure_crate_model_lambda_function_associations(
            var_130,
            inner_writer,
        )?
    }
    if let Some(var_131) = &input.function_associations {
        let inner_writer = scope.start_el("FunctionAssociations");
        crate::xml_ser::serialize_structure_crate_model_function_associations(
            var_131,
            inner_writer,
        )?
    }
    if let Some(var_132) = &input.field_level_encryption_id {
        let mut inner_writer = scope.start_el("FieldLevelEncryptionId").finish();
        inner_writer.data(var_132.as_str());
    }
    if let Some(var_133) = &input.realtime_log_config_arn {
        let mut inner_writer = scope.start_el("RealtimeLogConfigArn").finish();
        inner_writer.data(var_133.as_str());
    }
    if let Some(var_134) = &input.cache_policy_id {
        let mut inner_writer = scope.start_el("CachePolicyId").finish();
        inner_writer.data(var_134.as_str());
    }
    if let Some(var_135) = &input.origin_request_policy_id {
        let mut inner_writer = scope.start_el("OriginRequestPolicyId").finish();
        inner_writer.data(var_135.as_str());
    }
    if let Some(var_136) = &input.response_headers_policy_id {
        let mut inner_writer = scope.start_el("ResponseHeadersPolicyId").finish();
        inner_writer.data(var_136.as_str());
    }
    if let Some(var_137) = &input.forwarded_values {
        let inner_writer = scope.start_el("ForwardedValues");
        crate::xml_ser::serialize_structure_crate_model_forwarded_values(var_137, inner_writer)?
    }
    if let Some(var_138) = &input.min_ttl {
        let mut inner_writer = scope.start_el("MinTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_138).encode());
    }
    if let Some(var_139) = &input.default_ttl {
        let mut inner_writer = scope.start_el("DefaultTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_139).encode());
    }
    if let Some(var_140) = &input.max_ttl {
        let mut inner_writer = scope.start_el("MaxTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_140).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_cache_behaviors(
    input: &crate::model::CacheBehaviors,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_141) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_141).encode());
    }
    if let Some(var_142) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_143 in var_142 {
            {
                let inner_writer = inner_writer.start_el("CacheBehavior");
                crate::xml_ser::serialize_structure_crate_model_cache_behavior(
                    list_item_143,
                    inner_writer,
                )?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_custom_error_responses(
    input: &crate::model::CustomErrorResponses,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_144) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_144).encode());
    }
    if let Some(var_145) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_146 in var_145 {
            {
                let inner_writer = inner_writer.start_el("CustomErrorResponse");
                crate::xml_ser::serialize_structure_crate_model_custom_error_response(
                    list_item_146,
                    inner_writer,
                )?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_logging_config(
    input: &crate::model::LoggingConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_147) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_147).encode());
    }
    if let Some(var_148) = &input.include_cookies {
        let mut inner_writer = scope.start_el("IncludeCookies").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_148).encode());
    }
    if let Some(var_149) = &input.bucket {
        let mut inner_writer = scope.start_el("Bucket").finish();
        inner_writer.data(var_149.as_str());
    }
    if let Some(var_150) = &input.prefix {
        let mut inner_writer = scope.start_el("Prefix").finish();
        inner_writer.data(var_150.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_viewer_certificate(
    input: &crate::model::ViewerCertificate,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_151) = &input.cloud_front_default_certificate {
        let mut inner_writer = scope.start_el("CloudFrontDefaultCertificate").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_151).encode());
    }
    if let Some(var_152) = &input.iam_certificate_id {
        let mut inner_writer = scope.start_el("IAMCertificateId").finish();
        inner_writer.data(var_152.as_str());
    }
    if let Some(var_153) = &input.acm_certificate_arn {
        let mut inner_writer = scope.start_el("ACMCertificateArn").finish();
        inner_writer.data(var_153.as_str());
    }
    if let Some(var_154) = &input.ssl_support_method {
        let mut inner_writer = scope.start_el("SSLSupportMethod").finish();
        inner_writer.data(var_154.as_str());
    }
    if let Some(var_155) = &input.minimum_protocol_version {
        let mut inner_writer = scope.start_el("MinimumProtocolVersion").finish();
        inner_writer.data(var_155.as_str());
    }
    if let Some(var_156) = &input.certificate {
        let mut inner_writer = scope.start_el("Certificate").finish();
        inner_writer.data(var_156.as_str());
    }
    if let Some(var_157) = &input.certificate_source {
        let mut inner_writer = scope.start_el("CertificateSource").finish();
        inner_writer.data(var_157.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_restrictions(
    input: &crate::model::Restrictions,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_158) = &input.geo_restriction {
        let inner_writer = scope.start_el("GeoRestriction");
        crate::xml_ser::serialize_structure_crate_model_geo_restriction(var_158, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_query_arg_profile_config(
    input: &crate::model::QueryArgProfileConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_159) = &input.forward_when_query_arg_profile_is_unknown {
        let mut inner_writer = scope
            .start_el("ForwardWhenQueryArgProfileIsUnknown")
            .finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_159).encode());
    }
    if let Some(var_160) = &input.query_arg_profiles {
        let inner_writer = scope.start_el("QueryArgProfiles");
        crate::xml_ser::serialize_structure_crate_model_query_arg_profiles(var_160, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_content_type_profile_config(
    input: &crate::model::ContentTypeProfileConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_161) = &input.forward_when_content_type_is_unknown {
        let mut inner_writer = scope.start_el("ForwardWhenContentTypeIsUnknown").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_161).encode());
    }
    if let Some(var_162) = &input.content_type_profiles {
        let inner_writer = scope.start_el("ContentTypeProfiles");
        crate::xml_ser::serialize_structure_crate_model_content_type_profiles(
            var_162,
            inner_writer,
        )?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_encryption_entities(
    input: &crate::model::EncryptionEntities,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_163) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_163).encode());
    }
    if let Some(var_164) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_165 in var_164 {
            {
                let inner_writer = inner_writer.start_el("EncryptionEntity");
                crate::xml_ser::serialize_structure_crate_model_encryption_entity(
                    list_item_165,
                    inner_writer,
                )?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_paths(
    input: &crate::model::Paths,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_166) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_166).encode());
    }
    if let Some(var_167) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_168 in var_167 {
            {
                let mut inner_writer = inner_writer.start_el("Path").finish();
                inner_writer.data(list_item_168.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_realtime_metrics_subscription_config(
    input: &crate::model::RealtimeMetricsSubscriptionConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_169) = &input.realtime_metrics_subscription_status {
        let mut inner_writer = scope.start_el("RealtimeMetricsSubscriptionStatus").finish();
        inner_writer.data(var_169.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_request_policy_headers_config(
    input: &crate::model::OriginRequestPolicyHeadersConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_170) = &input.header_behavior {
        let mut inner_writer = scope.start_el("HeaderBehavior").finish();
        inner_writer.data(var_170.as_str());
    }
    if let Some(var_171) = &input.headers {
        let inner_writer = scope.start_el("Headers");
        crate::xml_ser::serialize_structure_crate_model_headers(var_171, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_request_policy_cookies_config(
    input: &crate::model::OriginRequestPolicyCookiesConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_172) = &input.cookie_behavior {
        let mut inner_writer = scope.start_el("CookieBehavior").finish();
        inner_writer.data(var_172.as_str());
    }
    if let Some(var_173) = &input.cookies {
        let inner_writer = scope.start_el("Cookies");
        crate::xml_ser::serialize_structure_crate_model_cookie_names(var_173, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_request_policy_query_strings_config(
    input: &crate::model::OriginRequestPolicyQueryStringsConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_174) = &input.query_string_behavior {
        let mut inner_writer = scope.start_el("QueryStringBehavior").finish();
        inner_writer.data(var_174.as_str());
    }
    if let Some(var_175) = &input.query_strings {
        let inner_writer = scope.start_el("QueryStrings");
        crate::xml_ser::serialize_structure_crate_model_query_string_names(var_175, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_kinesis_stream_config(
    input: &crate::model::KinesisStreamConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_176) = &input.role_arn {
        let mut inner_writer = scope.start_el("RoleARN").finish();
        inner_writer.data(var_176.as_str());
    }
    if let Some(var_177) = &input.stream_arn {
        let mut inner_writer = scope.start_el("StreamARN").finish();
        inner_writer.data(var_177.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_cors_config(
    input: &crate::model::ResponseHeadersPolicyCorsConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_178) = &input.access_control_allow_origins {
        let inner_writer = scope.start_el("AccessControlAllowOrigins");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_access_control_allow_origins(var_178, inner_writer)?
    }
    if let Some(var_179) = &input.access_control_allow_headers {
        let inner_writer = scope.start_el("AccessControlAllowHeaders");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_access_control_allow_headers(var_179, inner_writer)?
    }
    if let Some(var_180) = &input.access_control_allow_methods {
        let inner_writer = scope.start_el("AccessControlAllowMethods");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_access_control_allow_methods(var_180, inner_writer)?
    }
    if let Some(var_181) = &input.access_control_allow_credentials {
        let mut inner_writer = scope.start_el("AccessControlAllowCredentials").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_181).encode());
    }
    if let Some(var_182) = &input.access_control_expose_headers {
        let inner_writer = scope.start_el("AccessControlExposeHeaders");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_access_control_expose_headers(var_182, inner_writer)?
    }
    if let Some(var_183) = &input.access_control_max_age_sec {
        let mut inner_writer = scope.start_el("AccessControlMaxAgeSec").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_183).encode());
    }
    if let Some(var_184) = &input.origin_override {
        let mut inner_writer = scope.start_el("OriginOverride").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_184).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_security_headers_config(
    input: &crate::model::ResponseHeadersPolicySecurityHeadersConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_185) = &input.xss_protection {
        let inner_writer = scope.start_el("XSSProtection");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_xss_protection(
            var_185,
            inner_writer,
        )?
    }
    if let Some(var_186) = &input.frame_options {
        let inner_writer = scope.start_el("FrameOptions");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_frame_options(
            var_186,
            inner_writer,
        )?
    }
    if let Some(var_187) = &input.referrer_policy {
        let inner_writer = scope.start_el("ReferrerPolicy");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_referrer_policy(
            var_187,
            inner_writer,
        )?
    }
    if let Some(var_188) = &input.content_security_policy {
        let inner_writer = scope.start_el("ContentSecurityPolicy");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_content_security_policy(var_188, inner_writer)?
    }
    if let Some(var_189) = &input.content_type_options {
        let inner_writer = scope.start_el("ContentTypeOptions");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_content_type_options(var_189, inner_writer)?
    }
    if let Some(var_190) = &input.strict_transport_security {
        let inner_writer = scope.start_el("StrictTransportSecurity");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_strict_transport_security(var_190, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_server_timing_headers_config(
    input: &crate::model::ResponseHeadersPolicyServerTimingHeadersConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_191) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_191).encode());
    }
    if let Some(var_192) = &input.sampling_rate {
        let mut inner_writer = scope.start_el("SamplingRate").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_192).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_custom_headers_config(
    input: &crate::model::ResponseHeadersPolicyCustomHeadersConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_193) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_193).encode());
    }
    if let Some(var_194) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_195 in var_194 {
            {
                let inner_writer = inner_writer.start_el("ResponseHeadersPolicyCustomHeader");
                crate::xml_ser::serialize_structure_crate_model_response_headers_policy_custom_header(list_item_195, inner_writer)?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_s3_origin(
    input: &crate::model::S3Origin,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_196) = &input.domain_name {
        let mut inner_writer = scope.start_el("DomainName").finish();
        inner_writer.data(var_196.as_str());
    }
    if let Some(var_197) = &input.origin_access_identity {
        let mut inner_writer = scope.start_el("OriginAccessIdentity").finish();
        inner_writer.data(var_197.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_streaming_logging_config(
    input: &crate::model::StreamingLoggingConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_198) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_198).encode());
    }
    if let Some(var_199) = &input.bucket {
        let mut inner_writer = scope.start_el("Bucket").finish();
        inner_writer.data(var_199.as_str());
    }
    if let Some(var_200) = &input.prefix {
        let mut inner_writer = scope.start_el("Prefix").finish();
        inner_writer.data(var_200.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_trusted_signers(
    input: &crate::model::TrustedSigners,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_201) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_201).encode());
    }
    if let Some(var_202) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_202).encode());
    }
    if let Some(var_203) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_204 in var_203 {
            {
                let mut inner_writer = inner_writer.start_el("AwsAccountNumber").finish();
                inner_writer.data(list_item_204.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_tag(
    input: &crate::model::Tag,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_205) = &input.key {
        let mut inner_writer = scope.start_el("Key").finish();
        inner_writer.data(var_205.as_str());
    }
    if let Some(var_206) = &input.value {
        let mut inner_writer = scope.start_el("Value").finish();
        inner_writer.data(var_206.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_cache_policy_headers_config(
    input: &crate::model::CachePolicyHeadersConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_207) = &input.header_behavior {
        let mut inner_writer = scope.start_el("HeaderBehavior").finish();
        inner_writer.data(var_207.as_str());
    }
    if let Some(var_208) = &input.headers {
        let inner_writer = scope.start_el("Headers");
        crate::xml_ser::serialize_structure_crate_model_headers(var_208, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_cache_policy_cookies_config(
    input: &crate::model::CachePolicyCookiesConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_209) = &input.cookie_behavior {
        let mut inner_writer = scope.start_el("CookieBehavior").finish();
        inner_writer.data(var_209.as_str());
    }
    if let Some(var_210) = &input.cookies {
        let inner_writer = scope.start_el("Cookies");
        crate::xml_ser::serialize_structure_crate_model_cookie_names(var_210, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_cache_policy_query_strings_config(
    input: &crate::model::CachePolicyQueryStringsConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_211) = &input.query_string_behavior {
        let mut inner_writer = scope.start_el("QueryStringBehavior").finish();
        inner_writer.data(var_211.as_str());
    }
    if let Some(var_212) = &input.query_strings {
        let inner_writer = scope.start_el("QueryStrings");
        crate::xml_ser::serialize_structure_crate_model_query_string_names(var_212, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin(
    input: &crate::model::Origin,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_213) = &input.id {
        let mut inner_writer = scope.start_el("Id").finish();
        inner_writer.data(var_213.as_str());
    }
    if let Some(var_214) = &input.domain_name {
        let mut inner_writer = scope.start_el("DomainName").finish();
        inner_writer.data(var_214.as_str());
    }
    if let Some(var_215) = &input.origin_path {
        let mut inner_writer = scope.start_el("OriginPath").finish();
        inner_writer.data(var_215.as_str());
    }
    if let Some(var_216) = &input.custom_headers {
        let inner_writer = scope.start_el("CustomHeaders");
        crate::xml_ser::serialize_structure_crate_model_custom_headers(var_216, inner_writer)?
    }
    if let Some(var_217) = &input.s3_origin_config {
        let inner_writer = scope.start_el("S3OriginConfig");
        crate::xml_ser::serialize_structure_crate_model_s3_origin_config(var_217, inner_writer)?
    }
    if let Some(var_218) = &input.custom_origin_config {
        let inner_writer = scope.start_el("CustomOriginConfig");
        crate::xml_ser::serialize_structure_crate_model_custom_origin_config(var_218, inner_writer)?
    }
    if let Some(var_219) = &input.connection_attempts {
        let mut inner_writer = scope.start_el("ConnectionAttempts").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_219).encode());
    }
    if let Some(var_220) = &input.connection_timeout {
        let mut inner_writer = scope.start_el("ConnectionTimeout").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_220).encode());
    }
    if let Some(var_221) = &input.origin_shield {
        let inner_writer = scope.start_el("OriginShield");
        crate::xml_ser::serialize_structure_crate_model_origin_shield(var_221, inner_writer)?
    }
    if let Some(var_222) = &input.origin_access_control_id {
        let mut inner_writer = scope.start_el("OriginAccessControlId").finish();
        inner_writer.data(var_222.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_group(
    input: &crate::model::OriginGroup,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_223) = &input.id {
        let mut inner_writer = scope.start_el("Id").finish();
        inner_writer.data(var_223.as_str());
    }
    if let Some(var_224) = &input.failover_criteria {
        let inner_writer = scope.start_el("FailoverCriteria");
        crate::xml_ser::serialize_structure_crate_model_origin_group_failover_criteria(
            var_224,
            inner_writer,
        )?
    }
    if let Some(var_225) = &input.members {
        let inner_writer = scope.start_el("Members");
        crate::xml_ser::serialize_structure_crate_model_origin_group_members(var_225, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_trusted_key_groups(
    input: &crate::model::TrustedKeyGroups,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_226) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_226).encode());
    }
    if let Some(var_227) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_227).encode());
    }
    if let Some(var_228) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_229 in var_228 {
            {
                let mut inner_writer = inner_writer.start_el("KeyGroup").finish();
                inner_writer.data(list_item_229.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_allowed_methods(
    input: &crate::model::AllowedMethods,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_230) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_230).encode());
    }
    if let Some(var_231) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_232 in var_231 {
            {
                let mut inner_writer = inner_writer.start_el("Method").finish();
                inner_writer.data(list_item_232.as_str());
            }
        }
    }
    if let Some(var_233) = &input.cached_methods {
        let inner_writer = scope.start_el("CachedMethods");
        crate::xml_ser::serialize_structure_crate_model_cached_methods(var_233, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_lambda_function_associations(
    input: &crate::model::LambdaFunctionAssociations,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_234) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_234).encode());
    }
    if let Some(var_235) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_236 in var_235 {
            {
                let inner_writer = inner_writer.start_el("LambdaFunctionAssociation");
                crate::xml_ser::serialize_structure_crate_model_lambda_function_association(
                    list_item_236,
                    inner_writer,
                )?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_function_associations(
    input: &crate::model::FunctionAssociations,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_237) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_237).encode());
    }
    if let Some(var_238) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_239 in var_238 {
            {
                let inner_writer = inner_writer.start_el("FunctionAssociation");
                crate::xml_ser::serialize_structure_crate_model_function_association(
                    list_item_239,
                    inner_writer,
                )?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_forwarded_values(
    input: &crate::model::ForwardedValues,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_240) = &input.query_string {
        let mut inner_writer = scope.start_el("QueryString").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_240).encode());
    }
    if let Some(var_241) = &input.cookies {
        let inner_writer = scope.start_el("Cookies");
        crate::xml_ser::serialize_structure_crate_model_cookie_preference(var_241, inner_writer)?
    }
    if let Some(var_242) = &input.headers {
        let inner_writer = scope.start_el("Headers");
        crate::xml_ser::serialize_structure_crate_model_headers(var_242, inner_writer)?
    }
    if let Some(var_243) = &input.query_string_cache_keys {
        let inner_writer = scope.start_el("QueryStringCacheKeys");
        crate::xml_ser::serialize_structure_crate_model_query_string_cache_keys(
            var_243,
            inner_writer,
        )?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_cache_behavior(
    input: &crate::model::CacheBehavior,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_244) = &input.path_pattern {
        let mut inner_writer = scope.start_el("PathPattern").finish();
        inner_writer.data(var_244.as_str());
    }
    if let Some(var_245) = &input.target_origin_id {
        let mut inner_writer = scope.start_el("TargetOriginId").finish();
        inner_writer.data(var_245.as_str());
    }
    if let Some(var_246) = &input.trusted_signers {
        let inner_writer = scope.start_el("TrustedSigners");
        crate::xml_ser::serialize_structure_crate_model_trusted_signers(var_246, inner_writer)?
    }
    if let Some(var_247) = &input.trusted_key_groups {
        let inner_writer = scope.start_el("TrustedKeyGroups");
        crate::xml_ser::serialize_structure_crate_model_trusted_key_groups(var_247, inner_writer)?
    }
    if let Some(var_248) = &input.viewer_protocol_policy {
        let mut inner_writer = scope.start_el("ViewerProtocolPolicy").finish();
        inner_writer.data(var_248.as_str());
    }
    if let Some(var_249) = &input.allowed_methods {
        let inner_writer = scope.start_el("AllowedMethods");
        crate::xml_ser::serialize_structure_crate_model_allowed_methods(var_249, inner_writer)?
    }
    if let Some(var_250) = &input.smooth_streaming {
        let mut inner_writer = scope.start_el("SmoothStreaming").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_250).encode());
    }
    if let Some(var_251) = &input.compress {
        let mut inner_writer = scope.start_el("Compress").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_251).encode());
    }
    if let Some(var_252) = &input.lambda_function_associations {
        let inner_writer = scope.start_el("LambdaFunctionAssociations");
        crate::xml_ser::serialize_structure_crate_model_lambda_function_associations(
            var_252,
            inner_writer,
        )?
    }
    if let Some(var_253) = &input.function_associations {
        let inner_writer = scope.start_el("FunctionAssociations");
        crate::xml_ser::serialize_structure_crate_model_function_associations(
            var_253,
            inner_writer,
        )?
    }
    if let Some(var_254) = &input.field_level_encryption_id {
        let mut inner_writer = scope.start_el("FieldLevelEncryptionId").finish();
        inner_writer.data(var_254.as_str());
    }
    if let Some(var_255) = &input.realtime_log_config_arn {
        let mut inner_writer = scope.start_el("RealtimeLogConfigArn").finish();
        inner_writer.data(var_255.as_str());
    }
    if let Some(var_256) = &input.cache_policy_id {
        let mut inner_writer = scope.start_el("CachePolicyId").finish();
        inner_writer.data(var_256.as_str());
    }
    if let Some(var_257) = &input.origin_request_policy_id {
        let mut inner_writer = scope.start_el("OriginRequestPolicyId").finish();
        inner_writer.data(var_257.as_str());
    }
    if let Some(var_258) = &input.response_headers_policy_id {
        let mut inner_writer = scope.start_el("ResponseHeadersPolicyId").finish();
        inner_writer.data(var_258.as_str());
    }
    if let Some(var_259) = &input.forwarded_values {
        let inner_writer = scope.start_el("ForwardedValues");
        crate::xml_ser::serialize_structure_crate_model_forwarded_values(var_259, inner_writer)?
    }
    if let Some(var_260) = &input.min_ttl {
        let mut inner_writer = scope.start_el("MinTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_260).encode());
    }
    if let Some(var_261) = &input.default_ttl {
        let mut inner_writer = scope.start_el("DefaultTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_261).encode());
    }
    if let Some(var_262) = &input.max_ttl {
        let mut inner_writer = scope.start_el("MaxTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_262).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_custom_error_response(
    input: &crate::model::CustomErrorResponse,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_263) = &input.error_code {
        let mut inner_writer = scope.start_el("ErrorCode").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_263).encode());
    }
    if let Some(var_264) = &input.response_page_path {
        let mut inner_writer = scope.start_el("ResponsePagePath").finish();
        inner_writer.data(var_264.as_str());
    }
    if let Some(var_265) = &input.response_code {
        let mut inner_writer = scope.start_el("ResponseCode").finish();
        inner_writer.data(var_265.as_str());
    }
    if let Some(var_266) = &input.error_caching_min_ttl {
        let mut inner_writer = scope.start_el("ErrorCachingMinTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_266).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_geo_restriction(
    input: &crate::model::GeoRestriction,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_267) = &input.restriction_type {
        let mut inner_writer = scope.start_el("RestrictionType").finish();
        inner_writer.data(var_267.as_str());
    }
    if let Some(var_268) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_268).encode());
    }
    if let Some(var_269) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_270 in var_269 {
            {
                let mut inner_writer = inner_writer.start_el("Location").finish();
                inner_writer.data(list_item_270.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_query_arg_profiles(
    input: &crate::model::QueryArgProfiles,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_271) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_271).encode());
    }
    if let Some(var_272) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_273 in var_272 {
            {
                let inner_writer = inner_writer.start_el("QueryArgProfile");
                crate::xml_ser::serialize_structure_crate_model_query_arg_profile(
                    list_item_273,
                    inner_writer,
                )?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_content_type_profiles(
    input: &crate::model::ContentTypeProfiles,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_274) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_274).encode());
    }
    if let Some(var_275) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_276 in var_275 {
            {
                let inner_writer = inner_writer.start_el("ContentTypeProfile");
                crate::xml_ser::serialize_structure_crate_model_content_type_profile(
                    list_item_276,
                    inner_writer,
                )?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_encryption_entity(
    input: &crate::model::EncryptionEntity,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_277) = &input.public_key_id {
        let mut inner_writer = scope.start_el("PublicKeyId").finish();
        inner_writer.data(var_277.as_str());
    }
    if let Some(var_278) = &input.provider_id {
        let mut inner_writer = scope.start_el("ProviderId").finish();
        inner_writer.data(var_278.as_str());
    }
    if let Some(var_279) = &input.field_patterns {
        let inner_writer = scope.start_el("FieldPatterns");
        crate::xml_ser::serialize_structure_crate_model_field_patterns(var_279, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_headers(
    input: &crate::model::Headers,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_280) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_280).encode());
    }
    if let Some(var_281) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_282 in var_281 {
            {
                let mut inner_writer = inner_writer.start_el("Name").finish();
                inner_writer.data(list_item_282.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_cookie_names(
    input: &crate::model::CookieNames,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_283) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_283).encode());
    }
    if let Some(var_284) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_285 in var_284 {
            {
                let mut inner_writer = inner_writer.start_el("Name").finish();
                inner_writer.data(list_item_285.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_query_string_names(
    input: &crate::model::QueryStringNames,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_286) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_286).encode());
    }
    if let Some(var_287) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_288 in var_287 {
            {
                let mut inner_writer = inner_writer.start_el("Name").finish();
                inner_writer.data(list_item_288.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_access_control_allow_origins(
    input: &crate::model::ResponseHeadersPolicyAccessControlAllowOrigins,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_289) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_289).encode());
    }
    if let Some(var_290) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_291 in var_290 {
            {
                let mut inner_writer = inner_writer.start_el("Origin").finish();
                inner_writer.data(list_item_291.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_access_control_allow_headers(
    input: &crate::model::ResponseHeadersPolicyAccessControlAllowHeaders,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_292) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_292).encode());
    }
    if let Some(var_293) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_294 in var_293 {
            {
                let mut inner_writer = inner_writer.start_el("Header").finish();
                inner_writer.data(list_item_294.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_access_control_allow_methods(
    input: &crate::model::ResponseHeadersPolicyAccessControlAllowMethods,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_295) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_295).encode());
    }
    if let Some(var_296) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_297 in var_296 {
            {
                let mut inner_writer = inner_writer.start_el("Method").finish();
                inner_writer.data(list_item_297.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_access_control_expose_headers(
    input: &crate::model::ResponseHeadersPolicyAccessControlExposeHeaders,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_298) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_298).encode());
    }
    if let Some(var_299) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_300 in var_299 {
            {
                let mut inner_writer = inner_writer.start_el("Header").finish();
                inner_writer.data(list_item_300.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_xss_protection(
    input: &crate::model::ResponseHeadersPolicyXssProtection,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_301) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_301).encode());
    }
    if let Some(var_302) = &input.protection {
        let mut inner_writer = scope.start_el("Protection").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_302).encode());
    }
    if let Some(var_303) = &input.mode_block {
        let mut inner_writer = scope.start_el("ModeBlock").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_303).encode());
    }
    if let Some(var_304) = &input.report_uri {
        let mut inner_writer = scope.start_el("ReportUri").finish();
        inner_writer.data(var_304.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_frame_options(
    input: &crate::model::ResponseHeadersPolicyFrameOptions,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_305) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_305).encode());
    }
    if let Some(var_306) = &input.frame_option {
        let mut inner_writer = scope.start_el("FrameOption").finish();
        inner_writer.data(var_306.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_referrer_policy(
    input: &crate::model::ResponseHeadersPolicyReferrerPolicy,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_307) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_307).encode());
    }
    if let Some(var_308) = &input.referrer_policy {
        let mut inner_writer = scope.start_el("ReferrerPolicy").finish();
        inner_writer.data(var_308.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_content_security_policy(
    input: &crate::model::ResponseHeadersPolicyContentSecurityPolicy,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_309) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_309).encode());
    }
    if let Some(var_310) = &input.content_security_policy {
        let mut inner_writer = scope.start_el("ContentSecurityPolicy").finish();
        inner_writer.data(var_310.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_content_type_options(
    input: &crate::model::ResponseHeadersPolicyContentTypeOptions,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_311) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_311).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_strict_transport_security(
    input: &crate::model::ResponseHeadersPolicyStrictTransportSecurity,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_312) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_312).encode());
    }
    if let Some(var_313) = &input.include_subdomains {
        let mut inner_writer = scope.start_el("IncludeSubdomains").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_313).encode());
    }
    if let Some(var_314) = &input.preload {
        let mut inner_writer = scope.start_el("Preload").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_314).encode());
    }
    if let Some(var_315) = &input.access_control_max_age_sec {
        let mut inner_writer = scope.start_el("AccessControlMaxAgeSec").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_315).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_response_headers_policy_custom_header(
    input: &crate::model::ResponseHeadersPolicyCustomHeader,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_316) = &input.header {
        let mut inner_writer = scope.start_el("Header").finish();
        inner_writer.data(var_316.as_str());
    }
    if let Some(var_317) = &input.value {
        let mut inner_writer = scope.start_el("Value").finish();
        inner_writer.data(var_317.as_str());
    }
    if let Some(var_318) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_318).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_custom_headers(
    input: &crate::model::CustomHeaders,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_319) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_319).encode());
    }
    if let Some(var_320) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_321 in var_320 {
            {
                let inner_writer = inner_writer.start_el("OriginCustomHeader");
                crate::xml_ser::serialize_structure_crate_model_origin_custom_header(
                    list_item_321,
                    inner_writer,
                )?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_s3_origin_config(
    input: &crate::model::S3OriginConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_322) = &input.origin_access_identity {
        let mut inner_writer = scope.start_el("OriginAccessIdentity").finish();
        inner_writer.data(var_322.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_custom_origin_config(
    input: &crate::model::CustomOriginConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_323) = &input.http_port {
        let mut inner_writer = scope.start_el("HTTPPort").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_323).encode());
    }
    if let Some(var_324) = &input.https_port {
        let mut inner_writer = scope.start_el("HTTPSPort").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_324).encode());
    }
    if let Some(var_325) = &input.origin_protocol_policy {
        let mut inner_writer = scope.start_el("OriginProtocolPolicy").finish();
        inner_writer.data(var_325.as_str());
    }
    if let Some(var_326) = &input.origin_ssl_protocols {
        let inner_writer = scope.start_el("OriginSslProtocols");
        crate::xml_ser::serialize_structure_crate_model_origin_ssl_protocols(var_326, inner_writer)?
    }
    if let Some(var_327) = &input.origin_read_timeout {
        let mut inner_writer = scope.start_el("OriginReadTimeout").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_327).encode());
    }
    if let Some(var_328) = &input.origin_keepalive_timeout {
        let mut inner_writer = scope.start_el("OriginKeepaliveTimeout").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_328).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_shield(
    input: &crate::model::OriginShield,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_329) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_329).encode());
    }
    if let Some(var_330) = &input.origin_shield_region {
        let mut inner_writer = scope.start_el("OriginShieldRegion").finish();
        inner_writer.data(var_330.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_group_failover_criteria(
    input: &crate::model::OriginGroupFailoverCriteria,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_331) = &input.status_codes {
        let inner_writer = scope.start_el("StatusCodes");
        crate::xml_ser::serialize_structure_crate_model_status_codes(var_331, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_group_members(
    input: &crate::model::OriginGroupMembers,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_332) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_332).encode());
    }
    if let Some(var_333) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_334 in var_333 {
            {
                let inner_writer = inner_writer.start_el("OriginGroupMember");
                crate::xml_ser::serialize_structure_crate_model_origin_group_member(
                    list_item_334,
                    inner_writer,
                )?
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_cached_methods(
    input: &crate::model::CachedMethods,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_335) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_335).encode());
    }
    if let Some(var_336) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_337 in var_336 {
            {
                let mut inner_writer = inner_writer.start_el("Method").finish();
                inner_writer.data(list_item_337.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_lambda_function_association(
    input: &crate::model::LambdaFunctionAssociation,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_338) = &input.lambda_function_arn {
        let mut inner_writer = scope.start_el("LambdaFunctionARN").finish();
        inner_writer.data(var_338.as_str());
    }
    if let Some(var_339) = &input.event_type {
        let mut inner_writer = scope.start_el("EventType").finish();
        inner_writer.data(var_339.as_str());
    }
    if let Some(var_340) = &input.include_body {
        let mut inner_writer = scope.start_el("IncludeBody").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_340).encode());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_function_association(
    input: &crate::model::FunctionAssociation,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_341) = &input.function_arn {
        let mut inner_writer = scope.start_el("FunctionARN").finish();
        inner_writer.data(var_341.as_str());
    }
    if let Some(var_342) = &input.event_type {
        let mut inner_writer = scope.start_el("EventType").finish();
        inner_writer.data(var_342.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_cookie_preference(
    input: &crate::model::CookiePreference,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_343) = &input.forward {
        let mut inner_writer = scope.start_el("Forward").finish();
        inner_writer.data(var_343.as_str());
    }
    if let Some(var_344) = &input.whitelisted_names {
        let inner_writer = scope.start_el("WhitelistedNames");
        crate::xml_ser::serialize_structure_crate_model_cookie_names(var_344, inner_writer)?
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_query_string_cache_keys(
    input: &crate::model::QueryStringCacheKeys,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_345) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_345).encode());
    }
    if let Some(var_346) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_347 in var_346 {
            {
                let mut inner_writer = inner_writer.start_el("Name").finish();
                inner_writer.data(list_item_347.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_query_arg_profile(
    input: &crate::model::QueryArgProfile,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_348) = &input.query_arg {
        let mut inner_writer = scope.start_el("QueryArg").finish();
        inner_writer.data(var_348.as_str());
    }
    if let Some(var_349) = &input.profile_id {
        let mut inner_writer = scope.start_el("ProfileId").finish();
        inner_writer.data(var_349.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_content_type_profile(
    input: &crate::model::ContentTypeProfile,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_350) = &input.format {
        let mut inner_writer = scope.start_el("Format").finish();
        inner_writer.data(var_350.as_str());
    }
    if let Some(var_351) = &input.profile_id {
        let mut inner_writer = scope.start_el("ProfileId").finish();
        inner_writer.data(var_351.as_str());
    }
    if let Some(var_352) = &input.content_type {
        let mut inner_writer = scope.start_el("ContentType").finish();
        inner_writer.data(var_352.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_field_patterns(
    input: &crate::model::FieldPatterns,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_353) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_353).encode());
    }
    if let Some(var_354) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_355 in var_354 {
            {
                let mut inner_writer = inner_writer.start_el("FieldPattern").finish();
                inner_writer.data(list_item_355.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_custom_header(
    input: &crate::model::OriginCustomHeader,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_356) = &input.header_name {
        let mut inner_writer = scope.start_el("HeaderName").finish();
        inner_writer.data(var_356.as_str());
    }
    if let Some(var_357) = &input.header_value {
        let mut inner_writer = scope.start_el("HeaderValue").finish();
        inner_writer.data(var_357.as_str());
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_ssl_protocols(
    input: &crate::model::OriginSslProtocols,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_358) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_358).encode());
    }
    if let Some(var_359) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_360 in var_359 {
            {
                let mut inner_writer = inner_writer.start_el("SslProtocol").finish();
                inner_writer.data(list_item_360.as_str());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_status_codes(
    input: &crate::model::StatusCodes,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_361) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_361).encode());
    }
    if let Some(var_362) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_363 in var_362 {
            {
                let mut inner_writer = inner_writer.start_el("StatusCode").finish();
                inner_writer
                    .data(aws_smithy_types::primitive::Encoder::from(*list_item_363).encode());
            }
        }
    }
    scope.finish();
    Ok(())
}

pub fn serialize_structure_crate_model_origin_group_member(
    input: &crate::model::OriginGroupMember,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_364) = &input.origin_id {
        let mut inner_writer = scope.start_el("OriginId").finish();
        inner_writer.data(var_364.as_str());
    }
    scope.finish();
    Ok(())
}