// 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_log_delivery_configuration_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LogDeliveryConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_5 = writer.prefix("LogType");
    if let Some(var_6) = &input.log_type {
        scope_5.string(var_6.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_7 = writer.prefix("DestinationType");
    if let Some(var_8) = &input.destination_type {
        scope_7.string(var_8.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_9 = writer.prefix("DestinationDetails");
    if let Some(var_10) = &input.destination_details {
        crate::query_ser::serialize_structure_crate_model_destination_details(scope_9, var_10)?;
    }
    #[allow(unused_mut)]
    let mut scope_11 = writer.prefix("LogFormat");
    if let Some(var_12) = &input.log_format {
        scope_11.string(var_12.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_13 = writer.prefix("Enabled");
    if let Some(var_14) = &input.enabled {
        scope_13.boolean(*var_14);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_node_group_configuration(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::NodeGroupConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_15 = writer.prefix("NodeGroupId");
    if let Some(var_16) = &input.node_group_id {
        scope_15.string(var_16);
    }
    #[allow(unused_mut)]
    let mut scope_17 = writer.prefix("Slots");
    if let Some(var_18) = &input.slots {
        scope_17.string(var_18);
    }
    #[allow(unused_mut)]
    let mut scope_19 = writer.prefix("ReplicaCount");
    if let Some(var_20) = &input.replica_count {
        scope_19.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_20).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_21 = writer.prefix("PrimaryAvailabilityZone");
    if let Some(var_22) = &input.primary_availability_zone {
        scope_21.string(var_22);
    }
    #[allow(unused_mut)]
    let mut scope_23 = writer.prefix("ReplicaAvailabilityZones");
    if let Some(var_24) = &input.replica_availability_zones {
        let mut list_26 = scope_23.start_list(false, Some("AvailabilityZone"));
        for item_25 in var_24 {
            #[allow(unused_mut)]
            let mut entry_27 = list_26.entry();
            entry_27.string(item_25);
        }
        list_26.finish();
    }
    #[allow(unused_mut)]
    let mut scope_28 = writer.prefix("PrimaryOutpostArn");
    if let Some(var_29) = &input.primary_outpost_arn {
        scope_28.string(var_29);
    }
    #[allow(unused_mut)]
    let mut scope_30 = writer.prefix("ReplicaOutpostArns");
    if let Some(var_31) = &input.replica_outpost_arns {
        let mut list_33 = scope_30.start_list(false, Some("OutpostArn"));
        for item_32 in var_31 {
            #[allow(unused_mut)]
            let mut entry_34 = list_33.entry();
            entry_34.string(item_32);
        }
        list_33.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_authentication_mode(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AuthenticationMode,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_35 = writer.prefix("Type");
    if let Some(var_36) = &input.r#type {
        scope_35.string(var_36.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_37 = writer.prefix("Passwords");
    if let Some(var_38) = &input.passwords {
        let mut list_40 = scope_37.start_list(false, None);
        for item_39 in var_38 {
            #[allow(unused_mut)]
            let mut entry_41 = list_40.entry();
            entry_41.string(item_39);
        }
        list_40.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_configure_shard(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ConfigureShard,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_42 = writer.prefix("NodeGroupId");
    if let Some(var_43) = &input.node_group_id {
        scope_42.string(var_43);
    }
    #[allow(unused_mut)]
    let mut scope_44 = writer.prefix("NewReplicaCount");
    {
        scope_44.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.new_replica_count).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_45 = writer.prefix("PreferredAvailabilityZones");
    if let Some(var_46) = &input.preferred_availability_zones {
        let mut list_48 = scope_45.start_list(false, Some("PreferredAvailabilityZone"));
        for item_47 in var_46 {
            #[allow(unused_mut)]
            let mut entry_49 = list_48.entry();
            entry_49.string(item_47);
        }
        list_48.finish();
    }
    #[allow(unused_mut)]
    let mut scope_50 = writer.prefix("PreferredOutpostArns");
    if let Some(var_51) = &input.preferred_outpost_arns {
        let mut list_53 = scope_50.start_list(false, Some("PreferredOutpostArn"));
        for item_52 in var_51 {
            #[allow(unused_mut)]
            let mut entry_54 = list_53.entry();
            entry_54.string(item_52);
        }
        list_53.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_time_range_filter(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::TimeRangeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_55 = writer.prefix("StartTime");
    if let Some(var_56) = &input.start_time {
        scope_55.date_time(var_56, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_57 = writer.prefix("EndTime");
    if let Some(var_58) = &input.end_time {
        scope_57.date_time(var_58, aws_smithy_types::date_time::Format::DateTime)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_filter(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_59 = writer.prefix("Name");
    if let Some(var_60) = &input.name {
        scope_59.string(var_60);
    }
    #[allow(unused_mut)]
    let mut scope_61 = writer.prefix("Values");
    if let Some(var_62) = &input.values {
        let mut list_64 = scope_61.start_list(false, None);
        for item_63 in var_62 {
            #[allow(unused_mut)]
            let mut entry_65 = list_64.entry();
            entry_65.string(item_63);
        }
        list_64.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_regional_configuration(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::RegionalConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_66 = writer.prefix("ReplicationGroupId");
    if let Some(var_67) = &input.replication_group_id {
        scope_66.string(var_67);
    }
    #[allow(unused_mut)]
    let mut scope_68 = writer.prefix("ReplicationGroupRegion");
    if let Some(var_69) = &input.replication_group_region {
        scope_68.string(var_69);
    }
    #[allow(unused_mut)]
    let mut scope_70 = writer.prefix("ReshardingConfiguration");
    if let Some(var_71) = &input.resharding_configuration {
        let mut list_73 = scope_70.start_list(false, Some("ReshardingConfiguration"));
        for item_72 in var_71 {
            #[allow(unused_mut)]
            let mut entry_74 = list_73.entry();
            crate::query_ser::serialize_structure_crate_model_resharding_configuration(
                entry_74, item_72,
            )?;
        }
        list_73.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_parameter_name_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ParameterNameValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_75 = writer.prefix("ParameterName");
    if let Some(var_76) = &input.parameter_name {
        scope_75.string(var_76);
    }
    #[allow(unused_mut)]
    let mut scope_77 = writer.prefix("ParameterValue");
    if let Some(var_78) = &input.parameter_value {
        scope_77.string(var_78);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_resharding_configuration(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ReshardingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_79 = writer.prefix("NodeGroupId");
    if let Some(var_80) = &input.node_group_id {
        scope_79.string(var_80);
    }
    #[allow(unused_mut)]
    let mut scope_81 = writer.prefix("PreferredAvailabilityZones");
    if let Some(var_82) = &input.preferred_availability_zones {
        let mut list_84 = scope_81.start_list(false, Some("AvailabilityZone"));
        for item_83 in var_82 {
            #[allow(unused_mut)]
            let mut entry_85 = list_84.entry();
            entry_85.string(item_83);
        }
        list_84.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_customer_node_endpoint(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CustomerNodeEndpoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_86 = writer.prefix("Address");
    if let Some(var_87) = &input.address {
        scope_86.string(var_87);
    }
    #[allow(unused_mut)]
    let mut scope_88 = writer.prefix("Port");
    if let Some(var_89) = &input.port {
        scope_88.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_89).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_destination_details(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::DestinationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_90 = writer.prefix("CloudWatchLogsDetails");
    if let Some(var_91) = &input.cloud_watch_logs_details {
        crate::query_ser::serialize_structure_crate_model_cloud_watch_logs_destination_details(
            scope_90, var_91,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_92 = writer.prefix("KinesisFirehoseDetails");
    if let Some(var_93) = &input.kinesis_firehose_details {
        crate::query_ser::serialize_structure_crate_model_kinesis_firehose_destination_details(
            scope_92, var_93,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_cloud_watch_logs_destination_details(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CloudWatchLogsDestinationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_94 = writer.prefix("LogGroup");
    if let Some(var_95) = &input.log_group {
        scope_94.string(var_95);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_kinesis_firehose_destination_details(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::KinesisFirehoseDestinationDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_96 = writer.prefix("DeliveryStream");
    if let Some(var_97) = &input.delivery_stream {
        scope_96.string(var_97);
    }
    Ok(())
}