aws-sdk-cloudfront 0.12.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::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::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::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::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::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::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::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_ref());
    }
    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::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::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::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_request_policy_input_origin_request_policy_config(
    input: &crate::model::OriginRequestPolicyConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::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::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::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_ref());
            }
        }
    }
    if let Some(var_8) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_8.as_ref());
    }
    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::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::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::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::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_ref());
    }
    if let Some(var_11) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_11.as_ref());
    }
    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::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_ref());
    }
    if let Some(var_13) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_13.as_ref());
    }
    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::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_ref());
    }
    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_ref());
    }
    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_ref());
    }
    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::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::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::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::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::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::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::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::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::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::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_request_policy_input_origin_request_policy_config(
    input: &crate::model::OriginRequestPolicyConfig,
) -> std::result::Result<std::vec::Vec<u8>, aws_smithy_http::operation::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::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::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_ref());
    }
    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_ref());
            }
        }
    }
    if let Some(var_27) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_27.as_ref());
    }
    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::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::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::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_ref());
    }
    if let Some(var_30) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_30.as_ref());
    }
    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::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_ref());
    }
    if let Some(var_36) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_36.as_ref());
    }
    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::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_ref());
    }
    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_ref());
    }
    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_ref());
    }
    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_ref());
    }
    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::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::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_ref());
    }
    if let Some(var_57) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_57.as_ref());
    }
    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::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_ref());
    }
    if let Some(var_61) = &input.caller_reference {
        let mut inner_writer = scope.start_el("CallerReference").finish();
        inner_writer.data(var_61.as_ref());
    }
    if let Some(var_62) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_62.as_ref());
    }
    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::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_ref());
    }
    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::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_ref());
    }
    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::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_ref());
    }
    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_ref());
            }
        }
    }
    if let Some(var_71) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_71.as_ref());
    }
    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::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_request_policy_config(
    input: &crate::model::OriginRequestPolicyConfig,
    writer: aws_smithy_xml::encode::ElWriter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_73) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_73.as_ref());
    }
    if let Some(var_74) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_74.as_ref());
    }
    if let Some(var_75) = &input.headers_config {
        let inner_writer = scope.start_el("HeadersConfig");
        crate::xml_ser::serialize_structure_crate_model_origin_request_policy_headers_config(
            var_75,
            inner_writer,
        )?
    }
    if let Some(var_76) = &input.cookies_config {
        let inner_writer = scope.start_el("CookiesConfig");
        crate::xml_ser::serialize_structure_crate_model_origin_request_policy_cookies_config(
            var_76,
            inner_writer,
        )?
    }
    if let Some(var_77) = &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_77,
            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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_78) = &input.caller_reference {
        let mut inner_writer = scope.start_el("CallerReference").finish();
        inner_writer.data(var_78.as_ref());
    }
    if let Some(var_79) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_79.as_ref());
    }
    if let Some(var_80) = &input.encoded_key {
        let mut inner_writer = scope.start_el("EncodedKey").finish();
        inner_writer.data(var_80.as_ref());
    }
    if let Some(var_81) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_81.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_82) = &input.stream_type {
        let mut inner_writer = scope.start_el("StreamType").finish();
        inner_writer.data(var_82.as_ref());
    }
    if let Some(var_83) = &input.kinesis_stream_config {
        let inner_writer = scope.start_el("KinesisStreamConfig");
        crate::xml_ser::serialize_structure_crate_model_kinesis_stream_config(var_83, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_84) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_84.as_ref());
    }
    if let Some(var_85) = &input.name {
        let mut inner_writer = scope.start_el("Name").finish();
        inner_writer.data(var_85.as_ref());
    }
    if let Some(var_86) = &input.cors_config {
        let inner_writer = scope.start_el("CorsConfig");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_cors_config(
            var_86,
            inner_writer,
        )?
    }
    if let Some(var_87) = &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_87, inner_writer)?
    }
    if let Some(var_88) = &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_88, inner_writer)?
    }
    if let Some(var_89) = &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_89, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_90) = &input.caller_reference {
        let mut inner_writer = scope.start_el("CallerReference").finish();
        inner_writer.data(var_90.as_ref());
    }
    if let Some(var_91) = &input.s3_origin {
        let inner_writer = scope.start_el("S3Origin");
        crate::xml_ser::serialize_structure_crate_model_s3_origin(var_91, inner_writer)?
    }
    if let Some(var_92) = &input.aliases {
        let inner_writer = scope.start_el("Aliases");
        crate::xml_ser::serialize_structure_crate_model_aliases(var_92, inner_writer)?
    }
    if let Some(var_93) = &input.comment {
        let mut inner_writer = scope.start_el("Comment").finish();
        inner_writer.data(var_93.as_ref());
    }
    if let Some(var_94) = &input.logging {
        let inner_writer = scope.start_el("Logging");
        crate::xml_ser::serialize_structure_crate_model_streaming_logging_config(
            var_94,
            inner_writer,
        )?
    }
    if let Some(var_95) = &input.trusted_signers {
        let inner_writer = scope.start_el("TrustedSigners");
        crate::xml_ser::serialize_structure_crate_model_trusted_signers(var_95, inner_writer)?
    }
    if let Some(var_96) = &input.price_class {
        let mut inner_writer = scope.start_el("PriceClass").finish();
        inner_writer.data(var_96.as_str());
    }
    if let Some(var_97) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_97).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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_98) = &input.streaming_distribution_config {
        let inner_writer = scope.start_el("StreamingDistributionConfig");
        crate::xml_ser::serialize_structure_crate_model_streaming_distribution_config(
            var_98,
            inner_writer,
        )?
    }
    if let Some(var_99) = &input.tags {
        let inner_writer = scope.start_el("Tags");
        crate::xml_ser::serialize_structure_crate_model_tags(var_99, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_100) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_101 in var_100 {
            {
                let inner_writer = inner_writer.start_el("Tag");
                crate::xml_ser::serialize_structure_crate_model_tag(list_item_101, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_102) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_103 in var_102 {
            {
                let mut inner_writer = inner_writer.start_el("Key").finish();
                inner_writer.data(list_item_103.as_ref());
            }
        }
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_104) = &input.enable_accept_encoding_gzip {
        let mut inner_writer = scope.start_el("EnableAcceptEncodingGzip").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_104).encode());
    }
    if let Some(var_105) = &input.enable_accept_encoding_brotli {
        let mut inner_writer = scope.start_el("EnableAcceptEncodingBrotli").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_105).encode());
    }
    if let Some(var_106) = &input.headers_config {
        let inner_writer = scope.start_el("HeadersConfig");
        crate::xml_ser::serialize_structure_crate_model_cache_policy_headers_config(
            var_106,
            inner_writer,
        )?
    }
    if let Some(var_107) = &input.cookies_config {
        let inner_writer = scope.start_el("CookiesConfig");
        crate::xml_ser::serialize_structure_crate_model_cache_policy_cookies_config(
            var_107,
            inner_writer,
        )?
    }
    if let Some(var_108) = &input.query_strings_config {
        let inner_writer = scope.start_el("QueryStringsConfig");
        crate::xml_ser::serialize_structure_crate_model_cache_policy_query_strings_config(
            var_108,
            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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_109) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_109).encode());
    }
    if let Some(var_110) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_111 in var_110 {
            {
                let mut inner_writer = inner_writer.start_el("CNAME").finish();
                inner_writer.data(list_item_111.as_ref());
            }
        }
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_112) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_112).encode());
    }
    if let Some(var_113) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_114 in var_113 {
            {
                let inner_writer = inner_writer.start_el("Origin");
                crate::xml_ser::serialize_structure_crate_model_origin(list_item_114, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_115) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_115).encode());
    }
    if let Some(var_116) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_117 in var_116 {
            {
                let inner_writer = inner_writer.start_el("OriginGroup");
                crate::xml_ser::serialize_structure_crate_model_origin_group(
                    list_item_117,
                    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_118) = &input.target_origin_id {
        let mut inner_writer = scope.start_el("TargetOriginId").finish();
        inner_writer.data(var_118.as_ref());
    }
    if let Some(var_119) = &input.trusted_signers {
        let inner_writer = scope.start_el("TrustedSigners");
        crate::xml_ser::serialize_structure_crate_model_trusted_signers(var_119, inner_writer)?
    }
    if let Some(var_120) = &input.trusted_key_groups {
        let inner_writer = scope.start_el("TrustedKeyGroups");
        crate::xml_ser::serialize_structure_crate_model_trusted_key_groups(var_120, inner_writer)?
    }
    if let Some(var_121) = &input.viewer_protocol_policy {
        let mut inner_writer = scope.start_el("ViewerProtocolPolicy").finish();
        inner_writer.data(var_121.as_str());
    }
    if let Some(var_122) = &input.allowed_methods {
        let inner_writer = scope.start_el("AllowedMethods");
        crate::xml_ser::serialize_structure_crate_model_allowed_methods(var_122, inner_writer)?
    }
    if let Some(var_123) = &input.smooth_streaming {
        let mut inner_writer = scope.start_el("SmoothStreaming").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_123).encode());
    }
    if let Some(var_124) = &input.compress {
        let mut inner_writer = scope.start_el("Compress").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_124).encode());
    }
    if let Some(var_125) = &input.lambda_function_associations {
        let inner_writer = scope.start_el("LambdaFunctionAssociations");
        crate::xml_ser::serialize_structure_crate_model_lambda_function_associations(
            var_125,
            inner_writer,
        )?
    }
    if let Some(var_126) = &input.function_associations {
        let inner_writer = scope.start_el("FunctionAssociations");
        crate::xml_ser::serialize_structure_crate_model_function_associations(
            var_126,
            inner_writer,
        )?
    }
    if let Some(var_127) = &input.field_level_encryption_id {
        let mut inner_writer = scope.start_el("FieldLevelEncryptionId").finish();
        inner_writer.data(var_127.as_ref());
    }
    if let Some(var_128) = &input.realtime_log_config_arn {
        let mut inner_writer = scope.start_el("RealtimeLogConfigArn").finish();
        inner_writer.data(var_128.as_ref());
    }
    if let Some(var_129) = &input.cache_policy_id {
        let mut inner_writer = scope.start_el("CachePolicyId").finish();
        inner_writer.data(var_129.as_ref());
    }
    if let Some(var_130) = &input.origin_request_policy_id {
        let mut inner_writer = scope.start_el("OriginRequestPolicyId").finish();
        inner_writer.data(var_130.as_ref());
    }
    if let Some(var_131) = &input.response_headers_policy_id {
        let mut inner_writer = scope.start_el("ResponseHeadersPolicyId").finish();
        inner_writer.data(var_131.as_ref());
    }
    if let Some(var_132) = &input.forwarded_values {
        let inner_writer = scope.start_el("ForwardedValues");
        crate::xml_ser::serialize_structure_crate_model_forwarded_values(var_132, inner_writer)?
    }
    if let Some(var_133) = &input.min_ttl {
        let mut inner_writer = scope.start_el("MinTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_133).encode());
    }
    if let Some(var_134) = &input.default_ttl {
        let mut inner_writer = scope.start_el("DefaultTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_134).encode());
    }
    if let Some(var_135) = &input.max_ttl {
        let mut inner_writer = scope.start_el("MaxTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_135).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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_136) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_136).encode());
    }
    if let Some(var_137) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_138 in var_137 {
            {
                let inner_writer = inner_writer.start_el("CacheBehavior");
                crate::xml_ser::serialize_structure_crate_model_cache_behavior(
                    list_item_138,
                    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_139) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_139).encode());
    }
    if let Some(var_140) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_141 in var_140 {
            {
                let inner_writer = inner_writer.start_el("CustomErrorResponse");
                crate::xml_ser::serialize_structure_crate_model_custom_error_response(
                    list_item_141,
                    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_142) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_142).encode());
    }
    if let Some(var_143) = &input.include_cookies {
        let mut inner_writer = scope.start_el("IncludeCookies").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_143).encode());
    }
    if let Some(var_144) = &input.bucket {
        let mut inner_writer = scope.start_el("Bucket").finish();
        inner_writer.data(var_144.as_ref());
    }
    if let Some(var_145) = &input.prefix {
        let mut inner_writer = scope.start_el("Prefix").finish();
        inner_writer.data(var_145.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_146) = &input.cloud_front_default_certificate {
        let mut inner_writer = scope.start_el("CloudFrontDefaultCertificate").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_146).encode());
    }
    if let Some(var_147) = &input.iam_certificate_id {
        let mut inner_writer = scope.start_el("IAMCertificateId").finish();
        inner_writer.data(var_147.as_ref());
    }
    if let Some(var_148) = &input.acm_certificate_arn {
        let mut inner_writer = scope.start_el("ACMCertificateArn").finish();
        inner_writer.data(var_148.as_ref());
    }
    if let Some(var_149) = &input.ssl_support_method {
        let mut inner_writer = scope.start_el("SSLSupportMethod").finish();
        inner_writer.data(var_149.as_str());
    }
    if let Some(var_150) = &input.minimum_protocol_version {
        let mut inner_writer = scope.start_el("MinimumProtocolVersion").finish();
        inner_writer.data(var_150.as_str());
    }
    if let Some(var_151) = &input.certificate {
        let mut inner_writer = scope.start_el("Certificate").finish();
        inner_writer.data(var_151.as_ref());
    }
    if let Some(var_152) = &input.certificate_source {
        let mut inner_writer = scope.start_el("CertificateSource").finish();
        inner_writer.data(var_152.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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_153) = &input.geo_restriction {
        let inner_writer = scope.start_el("GeoRestriction");
        crate::xml_ser::serialize_structure_crate_model_geo_restriction(var_153, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_154) = &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_154).encode());
    }
    if let Some(var_155) = &input.query_arg_profiles {
        let inner_writer = scope.start_el("QueryArgProfiles");
        crate::xml_ser::serialize_structure_crate_model_query_arg_profiles(var_155, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_156) = &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_156).encode());
    }
    if let Some(var_157) = &input.content_type_profiles {
        let inner_writer = scope.start_el("ContentTypeProfiles");
        crate::xml_ser::serialize_structure_crate_model_content_type_profiles(
            var_157,
            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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_158) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_158).encode());
    }
    if let Some(var_159) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_160 in var_159 {
            {
                let inner_writer = inner_writer.start_el("EncryptionEntity");
                crate::xml_ser::serialize_structure_crate_model_encryption_entity(
                    list_item_160,
                    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_161) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_161).encode());
    }
    if let Some(var_162) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_163 in var_162 {
            {
                let mut inner_writer = inner_writer.start_el("Path").finish();
                inner_writer.data(list_item_163.as_ref());
            }
        }
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_164) = &input.realtime_metrics_subscription_status {
        let mut inner_writer = scope.start_el("RealtimeMetricsSubscriptionStatus").finish();
        inner_writer.data(var_164.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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_165) = &input.header_behavior {
        let mut inner_writer = scope.start_el("HeaderBehavior").finish();
        inner_writer.data(var_165.as_str());
    }
    if let Some(var_166) = &input.headers {
        let inner_writer = scope.start_el("Headers");
        crate::xml_ser::serialize_structure_crate_model_headers(var_166, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_167) = &input.cookie_behavior {
        let mut inner_writer = scope.start_el("CookieBehavior").finish();
        inner_writer.data(var_167.as_str());
    }
    if let Some(var_168) = &input.cookies {
        let inner_writer = scope.start_el("Cookies");
        crate::xml_ser::serialize_structure_crate_model_cookie_names(var_168, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_169) = &input.query_string_behavior {
        let mut inner_writer = scope.start_el("QueryStringBehavior").finish();
        inner_writer.data(var_169.as_str());
    }
    if let Some(var_170) = &input.query_strings {
        let inner_writer = scope.start_el("QueryStrings");
        crate::xml_ser::serialize_structure_crate_model_query_string_names(var_170, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_171) = &input.role_arn {
        let mut inner_writer = scope.start_el("RoleARN").finish();
        inner_writer.data(var_171.as_ref());
    }
    if let Some(var_172) = &input.stream_arn {
        let mut inner_writer = scope.start_el("StreamARN").finish();
        inner_writer.data(var_172.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_173) = &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_173, inner_writer)?
    }
    if let Some(var_174) = &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_174, inner_writer)?
    }
    if let Some(var_175) = &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_175, inner_writer)?
    }
    if let Some(var_176) = &input.access_control_allow_credentials {
        let mut inner_writer = scope.start_el("AccessControlAllowCredentials").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_176).encode());
    }
    if let Some(var_177) = &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_177, inner_writer)?
    }
    if let Some(var_178) = &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_178).encode());
    }
    if let Some(var_179) = &input.origin_override {
        let mut inner_writer = scope.start_el("OriginOverride").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_179).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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_180) = &input.xss_protection {
        let inner_writer = scope.start_el("XSSProtection");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_xss_protection(
            var_180,
            inner_writer,
        )?
    }
    if let Some(var_181) = &input.frame_options {
        let inner_writer = scope.start_el("FrameOptions");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_frame_options(
            var_181,
            inner_writer,
        )?
    }
    if let Some(var_182) = &input.referrer_policy {
        let inner_writer = scope.start_el("ReferrerPolicy");
        crate::xml_ser::serialize_structure_crate_model_response_headers_policy_referrer_policy(
            var_182,
            inner_writer,
        )?
    }
    if let Some(var_183) = &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_183, inner_writer)?
    }
    if let Some(var_184) = &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_184, inner_writer)?
    }
    if let Some(var_185) = &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_185, inner_writer)?
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_186) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_186).encode());
    }
    if let Some(var_187) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_188 in var_187 {
            {
                let inner_writer = inner_writer.start_el("ResponseHeadersPolicyCustomHeader");
                crate::xml_ser::serialize_structure_crate_model_response_headers_policy_custom_header(list_item_188, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_189) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_189).encode());
    }
    if let Some(var_190) = &input.sampling_rate {
        let mut inner_writer = scope.start_el("SamplingRate").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_190).encode());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_191) = &input.domain_name {
        let mut inner_writer = scope.start_el("DomainName").finish();
        inner_writer.data(var_191.as_ref());
    }
    if let Some(var_192) = &input.origin_access_identity {
        let mut inner_writer = scope.start_el("OriginAccessIdentity").finish();
        inner_writer.data(var_192.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_193) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_193).encode());
    }
    if let Some(var_194) = &input.bucket {
        let mut inner_writer = scope.start_el("Bucket").finish();
        inner_writer.data(var_194.as_ref());
    }
    if let Some(var_195) = &input.prefix {
        let mut inner_writer = scope.start_el("Prefix").finish();
        inner_writer.data(var_195.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_196) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_196).encode());
    }
    if let Some(var_197) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_197).encode());
    }
    if let Some(var_198) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_199 in var_198 {
            {
                let mut inner_writer = inner_writer.start_el("AwsAccountNumber").finish();
                inner_writer.data(list_item_199.as_ref());
            }
        }
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_200) = &input.key {
        let mut inner_writer = scope.start_el("Key").finish();
        inner_writer.data(var_200.as_ref());
    }
    if let Some(var_201) = &input.value {
        let mut inner_writer = scope.start_el("Value").finish();
        inner_writer.data(var_201.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_202) = &input.header_behavior {
        let mut inner_writer = scope.start_el("HeaderBehavior").finish();
        inner_writer.data(var_202.as_str());
    }
    if let Some(var_203) = &input.headers {
        let inner_writer = scope.start_el("Headers");
        crate::xml_ser::serialize_structure_crate_model_headers(var_203, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_204) = &input.cookie_behavior {
        let mut inner_writer = scope.start_el("CookieBehavior").finish();
        inner_writer.data(var_204.as_str());
    }
    if let Some(var_205) = &input.cookies {
        let inner_writer = scope.start_el("Cookies");
        crate::xml_ser::serialize_structure_crate_model_cookie_names(var_205, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_206) = &input.query_string_behavior {
        let mut inner_writer = scope.start_el("QueryStringBehavior").finish();
        inner_writer.data(var_206.as_str());
    }
    if let Some(var_207) = &input.query_strings {
        let inner_writer = scope.start_el("QueryStrings");
        crate::xml_ser::serialize_structure_crate_model_query_string_names(var_207, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_208) = &input.id {
        let mut inner_writer = scope.start_el("Id").finish();
        inner_writer.data(var_208.as_ref());
    }
    if let Some(var_209) = &input.domain_name {
        let mut inner_writer = scope.start_el("DomainName").finish();
        inner_writer.data(var_209.as_ref());
    }
    if let Some(var_210) = &input.origin_path {
        let mut inner_writer = scope.start_el("OriginPath").finish();
        inner_writer.data(var_210.as_ref());
    }
    if let Some(var_211) = &input.custom_headers {
        let inner_writer = scope.start_el("CustomHeaders");
        crate::xml_ser::serialize_structure_crate_model_custom_headers(var_211, inner_writer)?
    }
    if let Some(var_212) = &input.s3_origin_config {
        let inner_writer = scope.start_el("S3OriginConfig");
        crate::xml_ser::serialize_structure_crate_model_s3_origin_config(var_212, inner_writer)?
    }
    if let Some(var_213) = &input.custom_origin_config {
        let inner_writer = scope.start_el("CustomOriginConfig");
        crate::xml_ser::serialize_structure_crate_model_custom_origin_config(var_213, inner_writer)?
    }
    if let Some(var_214) = &input.connection_attempts {
        let mut inner_writer = scope.start_el("ConnectionAttempts").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_214).encode());
    }
    if let Some(var_215) = &input.connection_timeout {
        let mut inner_writer = scope.start_el("ConnectionTimeout").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_215).encode());
    }
    if let Some(var_216) = &input.origin_shield {
        let inner_writer = scope.start_el("OriginShield");
        crate::xml_ser::serialize_structure_crate_model_origin_shield(var_216, inner_writer)?
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_217) = &input.id {
        let mut inner_writer = scope.start_el("Id").finish();
        inner_writer.data(var_217.as_ref());
    }
    if let Some(var_218) = &input.failover_criteria {
        let inner_writer = scope.start_el("FailoverCriteria");
        crate::xml_ser::serialize_structure_crate_model_origin_group_failover_criteria(
            var_218,
            inner_writer,
        )?
    }
    if let Some(var_219) = &input.members {
        let inner_writer = scope.start_el("Members");
        crate::xml_ser::serialize_structure_crate_model_origin_group_members(var_219, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_220) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_220).encode());
    }
    if let Some(var_221) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_221).encode());
    }
    if let Some(var_222) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_223 in var_222 {
            {
                let mut inner_writer = inner_writer.start_el("KeyGroup").finish();
                inner_writer.data(list_item_223.as_ref());
            }
        }
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_224) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_224).encode());
    }
    if let Some(var_225) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_226 in var_225 {
            {
                let mut inner_writer = inner_writer.start_el("Method").finish();
                inner_writer.data(list_item_226.as_str());
            }
        }
    }
    if let Some(var_227) = &input.cached_methods {
        let inner_writer = scope.start_el("CachedMethods");
        crate::xml_ser::serialize_structure_crate_model_cached_methods(var_227, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_228) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_228).encode());
    }
    if let Some(var_229) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_230 in var_229 {
            {
                let inner_writer = inner_writer.start_el("LambdaFunctionAssociation");
                crate::xml_ser::serialize_structure_crate_model_lambda_function_association(
                    list_item_230,
                    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_231) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_231).encode());
    }
    if let Some(var_232) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_233 in var_232 {
            {
                let inner_writer = inner_writer.start_el("FunctionAssociation");
                crate::xml_ser::serialize_structure_crate_model_function_association(
                    list_item_233,
                    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_234) = &input.query_string {
        let mut inner_writer = scope.start_el("QueryString").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_234).encode());
    }
    if let Some(var_235) = &input.cookies {
        let inner_writer = scope.start_el("Cookies");
        crate::xml_ser::serialize_structure_crate_model_cookie_preference(var_235, inner_writer)?
    }
    if let Some(var_236) = &input.headers {
        let inner_writer = scope.start_el("Headers");
        crate::xml_ser::serialize_structure_crate_model_headers(var_236, inner_writer)?
    }
    if let Some(var_237) = &input.query_string_cache_keys {
        let inner_writer = scope.start_el("QueryStringCacheKeys");
        crate::xml_ser::serialize_structure_crate_model_query_string_cache_keys(
            var_237,
            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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_238) = &input.path_pattern {
        let mut inner_writer = scope.start_el("PathPattern").finish();
        inner_writer.data(var_238.as_ref());
    }
    if let Some(var_239) = &input.target_origin_id {
        let mut inner_writer = scope.start_el("TargetOriginId").finish();
        inner_writer.data(var_239.as_ref());
    }
    if let Some(var_240) = &input.trusted_signers {
        let inner_writer = scope.start_el("TrustedSigners");
        crate::xml_ser::serialize_structure_crate_model_trusted_signers(var_240, inner_writer)?
    }
    if let Some(var_241) = &input.trusted_key_groups {
        let inner_writer = scope.start_el("TrustedKeyGroups");
        crate::xml_ser::serialize_structure_crate_model_trusted_key_groups(var_241, inner_writer)?
    }
    if let Some(var_242) = &input.viewer_protocol_policy {
        let mut inner_writer = scope.start_el("ViewerProtocolPolicy").finish();
        inner_writer.data(var_242.as_str());
    }
    if let Some(var_243) = &input.allowed_methods {
        let inner_writer = scope.start_el("AllowedMethods");
        crate::xml_ser::serialize_structure_crate_model_allowed_methods(var_243, inner_writer)?
    }
    if let Some(var_244) = &input.smooth_streaming {
        let mut inner_writer = scope.start_el("SmoothStreaming").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_244).encode());
    }
    if let Some(var_245) = &input.compress {
        let mut inner_writer = scope.start_el("Compress").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_245).encode());
    }
    if let Some(var_246) = &input.lambda_function_associations {
        let inner_writer = scope.start_el("LambdaFunctionAssociations");
        crate::xml_ser::serialize_structure_crate_model_lambda_function_associations(
            var_246,
            inner_writer,
        )?
    }
    if let Some(var_247) = &input.function_associations {
        let inner_writer = scope.start_el("FunctionAssociations");
        crate::xml_ser::serialize_structure_crate_model_function_associations(
            var_247,
            inner_writer,
        )?
    }
    if let Some(var_248) = &input.field_level_encryption_id {
        let mut inner_writer = scope.start_el("FieldLevelEncryptionId").finish();
        inner_writer.data(var_248.as_ref());
    }
    if let Some(var_249) = &input.realtime_log_config_arn {
        let mut inner_writer = scope.start_el("RealtimeLogConfigArn").finish();
        inner_writer.data(var_249.as_ref());
    }
    if let Some(var_250) = &input.cache_policy_id {
        let mut inner_writer = scope.start_el("CachePolicyId").finish();
        inner_writer.data(var_250.as_ref());
    }
    if let Some(var_251) = &input.origin_request_policy_id {
        let mut inner_writer = scope.start_el("OriginRequestPolicyId").finish();
        inner_writer.data(var_251.as_ref());
    }
    if let Some(var_252) = &input.response_headers_policy_id {
        let mut inner_writer = scope.start_el("ResponseHeadersPolicyId").finish();
        inner_writer.data(var_252.as_ref());
    }
    if let Some(var_253) = &input.forwarded_values {
        let inner_writer = scope.start_el("ForwardedValues");
        crate::xml_ser::serialize_structure_crate_model_forwarded_values(var_253, inner_writer)?
    }
    if let Some(var_254) = &input.min_ttl {
        let mut inner_writer = scope.start_el("MinTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_254).encode());
    }
    if let Some(var_255) = &input.default_ttl {
        let mut inner_writer = scope.start_el("DefaultTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_255).encode());
    }
    if let Some(var_256) = &input.max_ttl {
        let mut inner_writer = scope.start_el("MaxTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_256).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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_257) = &input.error_code {
        let mut inner_writer = scope.start_el("ErrorCode").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_257).encode());
    }
    if let Some(var_258) = &input.response_page_path {
        let mut inner_writer = scope.start_el("ResponsePagePath").finish();
        inner_writer.data(var_258.as_ref());
    }
    if let Some(var_259) = &input.response_code {
        let mut inner_writer = scope.start_el("ResponseCode").finish();
        inner_writer.data(var_259.as_ref());
    }
    if let Some(var_260) = &input.error_caching_min_ttl {
        let mut inner_writer = scope.start_el("ErrorCachingMinTTL").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_260).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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_261) = &input.restriction_type {
        let mut inner_writer = scope.start_el("RestrictionType").finish();
        inner_writer.data(var_261.as_str());
    }
    if let Some(var_262) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_262).encode());
    }
    if let Some(var_263) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_264 in var_263 {
            {
                let mut inner_writer = inner_writer.start_el("Location").finish();
                inner_writer.data(list_item_264.as_ref());
            }
        }
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_265) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_265).encode());
    }
    if let Some(var_266) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_267 in var_266 {
            {
                let inner_writer = inner_writer.start_el("QueryArgProfile");
                crate::xml_ser::serialize_structure_crate_model_query_arg_profile(
                    list_item_267,
                    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    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 inner_writer = inner_writer.start_el("ContentTypeProfile");
                crate::xml_ser::serialize_structure_crate_model_content_type_profile(
                    list_item_270,
                    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_271) = &input.public_key_id {
        let mut inner_writer = scope.start_el("PublicKeyId").finish();
        inner_writer.data(var_271.as_ref());
    }
    if let Some(var_272) = &input.provider_id {
        let mut inner_writer = scope.start_el("ProviderId").finish();
        inner_writer.data(var_272.as_ref());
    }
    if let Some(var_273) = &input.field_patterns {
        let inner_writer = scope.start_el("FieldPatterns");
        crate::xml_ser::serialize_structure_crate_model_field_patterns(var_273, 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::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 mut inner_writer = inner_writer.start_el("Name").finish();
                inner_writer.data(list_item_276.as_ref());
            }
        }
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_277) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_277).encode());
    }
    if let Some(var_278) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_279 in var_278 {
            {
                let mut inner_writer = inner_writer.start_el("Name").finish();
                inner_writer.data(list_item_279.as_ref());
            }
        }
    }
    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::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_ref());
            }
        }
    }
    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::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("Origin").finish();
                inner_writer.data(list_item_285.as_ref());
            }
        }
    }
    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::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("Header").finish();
                inner_writer.data(list_item_288.as_ref());
            }
        }
    }
    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::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("Method").finish();
                inner_writer.data(list_item_291.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::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_ref());
            }
        }
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_295) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_295).encode());
    }
    if let Some(var_296) = &input.protection {
        let mut inner_writer = scope.start_el("Protection").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_296).encode());
    }
    if let Some(var_297) = &input.mode_block {
        let mut inner_writer = scope.start_el("ModeBlock").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_297).encode());
    }
    if let Some(var_298) = &input.report_uri {
        let mut inner_writer = scope.start_el("ReportUri").finish();
        inner_writer.data(var_298.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_299) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_299).encode());
    }
    if let Some(var_300) = &input.frame_option {
        let mut inner_writer = scope.start_el("FrameOption").finish();
        inner_writer.data(var_300.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::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.referrer_policy {
        let mut inner_writer = scope.start_el("ReferrerPolicy").finish();
        inner_writer.data(var_302.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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_303) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_303).encode());
    }
    if let Some(var_304) = &input.content_security_policy {
        let mut inner_writer = scope.start_el("ContentSecurityPolicy").finish();
        inner_writer.data(var_304.as_ref());
    }
    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::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());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_306) = &input.r#override {
        let mut inner_writer = scope.start_el("Override").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_306).encode());
    }
    if let Some(var_307) = &input.include_subdomains {
        let mut inner_writer = scope.start_el("IncludeSubdomains").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_307).encode());
    }
    if let Some(var_308) = &input.preload {
        let mut inner_writer = scope.start_el("Preload").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_308).encode());
    }
    if let Some(var_309) = &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_309).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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_310) = &input.header {
        let mut inner_writer = scope.start_el("Header").finish();
        inner_writer.data(var_310.as_ref());
    }
    if let Some(var_311) = &input.value {
        let mut inner_writer = scope.start_el("Value").finish();
        inner_writer.data(var_311.as_ref());
    }
    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());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_313) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_313).encode());
    }
    if let Some(var_314) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_315 in var_314 {
            {
                let inner_writer = inner_writer.start_el("OriginCustomHeader");
                crate::xml_ser::serialize_structure_crate_model_origin_custom_header(
                    list_item_315,
                    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_316) = &input.origin_access_identity {
        let mut inner_writer = scope.start_el("OriginAccessIdentity").finish();
        inner_writer.data(var_316.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_317) = &input.http_port {
        let mut inner_writer = scope.start_el("HTTPPort").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_317).encode());
    }
    if let Some(var_318) = &input.https_port {
        let mut inner_writer = scope.start_el("HTTPSPort").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_318).encode());
    }
    if let Some(var_319) = &input.origin_protocol_policy {
        let mut inner_writer = scope.start_el("OriginProtocolPolicy").finish();
        inner_writer.data(var_319.as_str());
    }
    if let Some(var_320) = &input.origin_ssl_protocols {
        let inner_writer = scope.start_el("OriginSslProtocols");
        crate::xml_ser::serialize_structure_crate_model_origin_ssl_protocols(var_320, inner_writer)?
    }
    if let Some(var_321) = &input.origin_read_timeout {
        let mut inner_writer = scope.start_el("OriginReadTimeout").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_321).encode());
    }
    if let Some(var_322) = &input.origin_keepalive_timeout {
        let mut inner_writer = scope.start_el("OriginKeepaliveTimeout").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_322).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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_323) = &input.enabled {
        let mut inner_writer = scope.start_el("Enabled").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_323).encode());
    }
    if let Some(var_324) = &input.origin_shield_region {
        let mut inner_writer = scope.start_el("OriginShieldRegion").finish();
        inner_writer.data(var_324.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_325) = &input.status_codes {
        let inner_writer = scope.start_el("StatusCodes");
        crate::xml_ser::serialize_structure_crate_model_status_codes(var_325, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_326) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_326).encode());
    }
    if let Some(var_327) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_328 in var_327 {
            {
                let inner_writer = inner_writer.start_el("OriginGroupMember");
                crate::xml_ser::serialize_structure_crate_model_origin_group_member(
                    list_item_328,
                    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_329) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_329).encode());
    }
    if let Some(var_330) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_331 in var_330 {
            {
                let mut inner_writer = inner_writer.start_el("Method").finish();
                inner_writer.data(list_item_331.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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_332) = &input.lambda_function_arn {
        let mut inner_writer = scope.start_el("LambdaFunctionARN").finish();
        inner_writer.data(var_332.as_ref());
    }
    if let Some(var_333) = &input.event_type {
        let mut inner_writer = scope.start_el("EventType").finish();
        inner_writer.data(var_333.as_str());
    }
    if let Some(var_334) = &input.include_body {
        let mut inner_writer = scope.start_el("IncludeBody").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_334).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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_335) = &input.function_arn {
        let mut inner_writer = scope.start_el("FunctionARN").finish();
        inner_writer.data(var_335.as_ref());
    }
    if let Some(var_336) = &input.event_type {
        let mut inner_writer = scope.start_el("EventType").finish();
        inner_writer.data(var_336.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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_337) = &input.forward {
        let mut inner_writer = scope.start_el("Forward").finish();
        inner_writer.data(var_337.as_str());
    }
    if let Some(var_338) = &input.whitelisted_names {
        let inner_writer = scope.start_el("WhitelistedNames");
        crate::xml_ser::serialize_structure_crate_model_cookie_names(var_338, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_339) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_339).encode());
    }
    if let Some(var_340) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_341 in var_340 {
            {
                let mut inner_writer = inner_writer.start_el("Name").finish();
                inner_writer.data(list_item_341.as_ref());
            }
        }
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_342) = &input.query_arg {
        let mut inner_writer = scope.start_el("QueryArg").finish();
        inner_writer.data(var_342.as_ref());
    }
    if let Some(var_343) = &input.profile_id {
        let mut inner_writer = scope.start_el("ProfileId").finish();
        inner_writer.data(var_343.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_344) = &input.format {
        let mut inner_writer = scope.start_el("Format").finish();
        inner_writer.data(var_344.as_str());
    }
    if let Some(var_345) = &input.profile_id {
        let mut inner_writer = scope.start_el("ProfileId").finish();
        inner_writer.data(var_345.as_ref());
    }
    if let Some(var_346) = &input.content_type {
        let mut inner_writer = scope.start_el("ContentType").finish();
        inner_writer.data(var_346.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_347) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_347).encode());
    }
    if let Some(var_348) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_349 in var_348 {
            {
                let mut inner_writer = inner_writer.start_el("FieldPattern").finish();
                inner_writer.data(list_item_349.as_ref());
            }
        }
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_350) = &input.header_name {
        let mut inner_writer = scope.start_el("HeaderName").finish();
        inner_writer.data(var_350.as_ref());
    }
    if let Some(var_351) = &input.header_value {
        let mut inner_writer = scope.start_el("HeaderValue").finish();
        inner_writer.data(var_351.as_ref());
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_352) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_352).encode());
    }
    if let Some(var_353) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_354 in var_353 {
            {
                let mut inner_writer = inner_writer.start_el("SslProtocol").finish();
                inner_writer.data(list_item_354.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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_355) = &input.quantity {
        let mut inner_writer = scope.start_el("Quantity").finish();
        inner_writer.data(aws_smithy_types::primitive::Encoder::from(*var_355).encode());
    }
    if let Some(var_356) = &input.items {
        let mut inner_writer = scope.start_el("Items").finish();
        for list_item_357 in var_356 {
            {
                let mut inner_writer = inner_writer.start_el("StatusCode").finish();
                inner_writer
                    .data(aws_smithy_types::primitive::Encoder::from(*list_item_357).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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope = writer.finish();
    if let Some(var_358) = &input.origin_id {
        let mut inner_writer = scope.start_el("OriginId").finish();
        inner_writer.data(var_358.as_ref());
    }
    scope.finish();
    Ok(())
}