aws-sdk-elasticloadbalancing 0.24.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_tag(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1 = writer.prefix("Key");
    if let Some(var_2) = &input.key {
        scope_1.string(var_2);
    }
    #[allow(unused_mut)]
    let mut scope_3 = writer.prefix("Value");
    if let Some(var_4) = &input.value {
        scope_3.string(var_4);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_health_check(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::HealthCheck,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_5 = writer.prefix("Target");
    if let Some(var_6) = &input.target {
        scope_5.string(var_6);
    }
    #[allow(unused_mut)]
    let mut scope_7 = writer.prefix("Interval");
    {
        scope_7.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.interval).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_8 = writer.prefix("Timeout");
    {
        scope_8.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.timeout).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_9 = writer.prefix("UnhealthyThreshold");
    {
        scope_9.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.unhealthy_threshold).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_10 = writer.prefix("HealthyThreshold");
    {
        scope_10.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.healthy_threshold).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_listener(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Listener,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_11 = writer.prefix("Protocol");
    if let Some(var_12) = &input.protocol {
        scope_11.string(var_12);
    }
    #[allow(unused_mut)]
    let mut scope_13 = writer.prefix("LoadBalancerPort");
    {
        scope_13.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.load_balancer_port).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_14 = writer.prefix("InstanceProtocol");
    if let Some(var_15) = &input.instance_protocol {
        scope_14.string(var_15);
    }
    #[allow(unused_mut)]
    let mut scope_16 = writer.prefix("InstancePort");
    {
        scope_16.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.instance_port).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_17 = writer.prefix("SSLCertificateId");
    if let Some(var_18) = &input.ssl_certificate_id {
        scope_17.string(var_18);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_policy_attribute(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PolicyAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_19 = writer.prefix("AttributeName");
    if let Some(var_20) = &input.attribute_name {
        scope_19.string(var_20);
    }
    #[allow(unused_mut)]
    let mut scope_21 = writer.prefix("AttributeValue");
    if let Some(var_22) = &input.attribute_value {
        scope_21.string(var_22);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Instance,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_23 = writer.prefix("InstanceId");
    if let Some(var_24) = &input.instance_id {
        scope_23.string(var_24);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_load_balancer_attributes(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LoadBalancerAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_25 = writer.prefix("CrossZoneLoadBalancing");
    if let Some(var_26) = &input.cross_zone_load_balancing {
        crate::query_ser::serialize_structure_crate_model_cross_zone_load_balancing(
            scope_25, var_26,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_27 = writer.prefix("AccessLog");
    if let Some(var_28) = &input.access_log {
        crate::query_ser::serialize_structure_crate_model_access_log(scope_27, var_28)?;
    }
    #[allow(unused_mut)]
    let mut scope_29 = writer.prefix("ConnectionDraining");
    if let Some(var_30) = &input.connection_draining {
        crate::query_ser::serialize_structure_crate_model_connection_draining(scope_29, var_30)?;
    }
    #[allow(unused_mut)]
    let mut scope_31 = writer.prefix("ConnectionSettings");
    if let Some(var_32) = &input.connection_settings {
        crate::query_ser::serialize_structure_crate_model_connection_settings(scope_31, var_32)?;
    }
    #[allow(unused_mut)]
    let mut scope_33 = writer.prefix("AdditionalAttributes");
    if let Some(var_34) = &input.additional_attributes {
        let mut list_36 = scope_33.start_list(false, None);
        for item_35 in var_34 {
            #[allow(unused_mut)]
            let mut entry_37 = list_36.entry();
            crate::query_ser::serialize_structure_crate_model_additional_attribute(
                entry_37, item_35,
            )?;
        }
        list_36.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_tag_key_only(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::TagKeyOnly,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_38 = writer.prefix("Key");
    if let Some(var_39) = &input.key {
        scope_38.string(var_39);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_cross_zone_load_balancing(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CrossZoneLoadBalancing,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_40 = writer.prefix("Enabled");
    {
        scope_40.boolean(input.enabled);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_access_log(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AccessLog,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_41 = writer.prefix("Enabled");
    {
        scope_41.boolean(input.enabled);
    }
    #[allow(unused_mut)]
    let mut scope_42 = writer.prefix("S3BucketName");
    if let Some(var_43) = &input.s3_bucket_name {
        scope_42.string(var_43);
    }
    #[allow(unused_mut)]
    let mut scope_44 = writer.prefix("EmitInterval");
    if let Some(var_45) = &input.emit_interval {
        scope_44.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_45).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_46 = writer.prefix("S3BucketPrefix");
    if let Some(var_47) = &input.s3_bucket_prefix {
        scope_46.string(var_47);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_connection_draining(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ConnectionDraining,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_48 = writer.prefix("Enabled");
    {
        scope_48.boolean(input.enabled);
    }
    #[allow(unused_mut)]
    let mut scope_49 = writer.prefix("Timeout");
    if let Some(var_50) = &input.timeout {
        scope_49.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_50).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_connection_settings(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ConnectionSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_51 = writer.prefix("IdleTimeout");
    if let Some(var_52) = &input.idle_timeout {
        scope_51.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_52).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_additional_attribute(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AdditionalAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_53 = writer.prefix("Key");
    if let Some(var_54) = &input.key {
        scope_53.string(var_54);
    }
    #[allow(unused_mut)]
    let mut scope_55 = writer.prefix("Value");
    if let Some(var_56) = &input.value {
        scope_55.string(var_56);
    }
    Ok(())
}