// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_update_group_action_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ScheduledUpdateGroupActionRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1 = writer.prefix("ScheduledActionName");
    if let Some(var_2) = &input.scheduled_action_name {
        scope_1.string(var_2);
    }
    #[allow(unused_mut)]
    let mut scope_3 = writer.prefix("StartTime");
    if let Some(var_4) = &input.start_time {
        scope_3.date_time(var_4, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_5 = writer.prefix("EndTime");
    if let Some(var_6) = &input.end_time {
        scope_5.date_time(var_6, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_7 = writer.prefix("Recurrence");
    if let Some(var_8) = &input.recurrence {
        scope_7.string(var_8);
    }
    #[allow(unused_mut)]
    let mut scope_9 = writer.prefix("MinSize");
    if let Some(var_10) = &input.min_size {
        scope_9.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_10).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_11 = writer.prefix("MaxSize");
    if let Some(var_12) = &input.max_size {
        scope_11.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_12).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_13 = writer.prefix("DesiredCapacity");
    if let Some(var_14) = &input.desired_capacity {
        scope_13.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_14).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_15 = writer.prefix("TimeZone");
    if let Some(var_16) = &input.time_zone {
        scope_15.string(var_16);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_17 = writer.prefix("LaunchTemplateId");
    if let Some(var_18) = &input.launch_template_id {
        scope_17.string(var_18);
    }
    #[allow(unused_mut)]
    let mut scope_19 = writer.prefix("LaunchTemplateName");
    if let Some(var_20) = &input.launch_template_name {
        scope_19.string(var_20);
    }
    #[allow(unused_mut)]
    let mut scope_21 = writer.prefix("Version");
    if let Some(var_22) = &input.version {
        scope_21.string(var_22);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_mixed_instances_policy(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::MixedInstancesPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_23 = writer.prefix("LaunchTemplate");
    if let Some(var_24) = &input.launch_template {
        crate::query_ser::serialize_structure_crate_model_launch_template(scope_23, var_24)?;
    }
    #[allow(unused_mut)]
    let mut scope_25 = writer.prefix("InstancesDistribution");
    if let Some(var_26) = &input.instances_distribution {
        crate::query_ser::serialize_structure_crate_model_instances_distribution(scope_25, var_26)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_lifecycle_hook_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LifecycleHookSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_27 = writer.prefix("LifecycleHookName");
    if let Some(var_28) = &input.lifecycle_hook_name {
        scope_27.string(var_28);
    }
    #[allow(unused_mut)]
    let mut scope_29 = writer.prefix("LifecycleTransition");
    if let Some(var_30) = &input.lifecycle_transition {
        scope_29.string(var_30);
    }
    #[allow(unused_mut)]
    let mut scope_31 = writer.prefix("NotificationMetadata");
    if let Some(var_32) = &input.notification_metadata {
        scope_31.string(var_32);
    }
    #[allow(unused_mut)]
    let mut scope_33 = writer.prefix("HeartbeatTimeout");
    if let Some(var_34) = &input.heartbeat_timeout {
        scope_33.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_34).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_35 = writer.prefix("DefaultResult");
    if let Some(var_36) = &input.default_result {
        scope_35.string(var_36);
    }
    #[allow(unused_mut)]
    let mut scope_37 = writer.prefix("NotificationTargetARN");
    if let Some(var_38) = &input.notification_target_arn {
        scope_37.string(var_38);
    }
    #[allow(unused_mut)]
    let mut scope_39 = writer.prefix("RoleARN");
    if let Some(var_40) = &input.role_arn {
        scope_39.string(var_40);
    }
    Ok(())
}

#[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_41 = writer.prefix("ResourceId");
    if let Some(var_42) = &input.resource_id {
        scope_41.string(var_42);
    }
    #[allow(unused_mut)]
    let mut scope_43 = writer.prefix("ResourceType");
    if let Some(var_44) = &input.resource_type {
        scope_43.string(var_44);
    }
    #[allow(unused_mut)]
    let mut scope_45 = writer.prefix("Key");
    if let Some(var_46) = &input.key {
        scope_45.string(var_46);
    }
    #[allow(unused_mut)]
    let mut scope_47 = writer.prefix("Value");
    if let Some(var_48) = &input.value {
        scope_47.string(var_48);
    }
    #[allow(unused_mut)]
    let mut scope_49 = writer.prefix("PropagateAtLaunch");
    if let Some(var_50) = &input.propagate_at_launch {
        scope_49.boolean(*var_50);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_block_device_mapping(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::BlockDeviceMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_51 = writer.prefix("VirtualName");
    if let Some(var_52) = &input.virtual_name {
        scope_51.string(var_52);
    }
    #[allow(unused_mut)]
    let mut scope_53 = writer.prefix("DeviceName");
    if let Some(var_54) = &input.device_name {
        scope_53.string(var_54);
    }
    #[allow(unused_mut)]
    let mut scope_55 = writer.prefix("Ebs");
    if let Some(var_56) = &input.ebs {
        crate::query_ser::serialize_structure_crate_model_ebs(scope_55, var_56)?;
    }
    #[allow(unused_mut)]
    let mut scope_57 = writer.prefix("NoDevice");
    if let Some(var_58) = &input.no_device {
        scope_57.boolean(*var_58);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_monitoring(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceMonitoring,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_59 = writer.prefix("Enabled");
    if let Some(var_60) = &input.enabled {
        scope_59.boolean(*var_60);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_metadata_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceMetadataOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_61 = writer.prefix("HttpTokens");
    if let Some(var_62) = &input.http_tokens {
        scope_61.string(var_62.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_63 = writer.prefix("HttpPutResponseHopLimit");
    if let Some(var_64) = &input.http_put_response_hop_limit {
        scope_63.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_64).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_65 = writer.prefix("HttpEndpoint");
    if let Some(var_66) = &input.http_endpoint {
        scope_65.string(var_66.as_str());
    }
    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_67 = writer.prefix("Name");
    if let Some(var_68) = &input.name {
        scope_67.string(var_68);
    }
    #[allow(unused_mut)]
    let mut scope_69 = writer.prefix("Values");
    if let Some(var_70) = &input.values {
        let mut list_72 = scope_69.start_list(false, None);
        for item_71 in var_70 {
            #[allow(unused_mut)]
            let mut entry_73 = list_72.entry();
            entry_73.string(item_71);
        }
        list_72.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_step_adjustment(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::StepAdjustment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_74 = writer.prefix("MetricIntervalLowerBound");
    if let Some(var_75) = &input.metric_interval_lower_bound {
        scope_74.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_75).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_76 = writer.prefix("MetricIntervalUpperBound");
    if let Some(var_77) = &input.metric_interval_upper_bound {
        scope_76.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_77).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_78 = writer.prefix("ScalingAdjustment");
    if let Some(var_79) = &input.scaling_adjustment {
        scope_78.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_79).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_tracking_configuration(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::TargetTrackingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_80 = writer.prefix("PredefinedMetricSpecification");
    if let Some(var_81) = &input.predefined_metric_specification {
        crate::query_ser::serialize_structure_crate_model_predefined_metric_specification(
            scope_80, var_81,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_82 = writer.prefix("CustomizedMetricSpecification");
    if let Some(var_83) = &input.customized_metric_specification {
        crate::query_ser::serialize_structure_crate_model_customized_metric_specification(
            scope_82, var_83,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_84 = writer.prefix("TargetValue");
    if let Some(var_85) = &input.target_value {
        scope_84.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_85).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_86 = writer.prefix("DisableScaleIn");
    if let Some(var_87) = &input.disable_scale_in {
        scope_86.boolean(*var_87);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_configuration(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PredictiveScalingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_88 = writer.prefix("MetricSpecifications");
    if let Some(var_89) = &input.metric_specifications {
        let mut list_91 = scope_88.start_list(false, None);
        for item_90 in var_89 {
            #[allow(unused_mut)]
            let mut entry_92 = list_91.entry();
            crate::query_ser::serialize_structure_crate_model_predictive_scaling_metric_specification(entry_92, item_90)?;
        }
        list_91.finish();
    }
    #[allow(unused_mut)]
    let mut scope_93 = writer.prefix("Mode");
    if let Some(var_94) = &input.mode {
        scope_93.string(var_94.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_95 = writer.prefix("SchedulingBufferTime");
    if let Some(var_96) = &input.scheduling_buffer_time {
        scope_95.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_96).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_97 = writer.prefix("MaxCapacityBreachBehavior");
    if let Some(var_98) = &input.max_capacity_breach_behavior {
        scope_97.string(var_98.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_99 = writer.prefix("MaxCapacityBuffer");
    if let Some(var_100) = &input.max_capacity_buffer {
        scope_99.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_100).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_reuse_policy(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceReusePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_101 = writer.prefix("ReuseOnScaleIn");
    if let Some(var_102) = &input.reuse_on_scale_in {
        scope_101.boolean(*var_102);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_desired_configuration(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::DesiredConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_103 = writer.prefix("LaunchTemplate");
    if let Some(var_104) = &input.launch_template {
        crate::query_ser::serialize_structure_crate_model_launch_template_specification(
            scope_103, var_104,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_105 = writer.prefix("MixedInstancesPolicy");
    if let Some(var_106) = &input.mixed_instances_policy {
        crate::query_ser::serialize_structure_crate_model_mixed_instances_policy(
            scope_105, var_106,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_refresh_preferences(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::RefreshPreferences,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_107 = writer.prefix("MinHealthyPercentage");
    if let Some(var_108) = &input.min_healthy_percentage {
        scope_107.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_108).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_109 = writer.prefix("InstanceWarmup");
    if let Some(var_110) = &input.instance_warmup {
        scope_109.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_110).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_111 = writer.prefix("CheckpointPercentages");
    if let Some(var_112) = &input.checkpoint_percentages {
        let mut list_114 = scope_111.start_list(false, None);
        for item_113 in var_112 {
            #[allow(unused_mut)]
            let mut entry_115 = list_114.entry();
            entry_115.number(
                #[allow(clippy::useless_conversion)]
                aws_smithy_types::Number::NegInt((*item_113).into()),
            );
        }
        list_114.finish();
    }
    #[allow(unused_mut)]
    let mut scope_116 = writer.prefix("CheckpointDelay");
    if let Some(var_117) = &input.checkpoint_delay {
        scope_116.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_117).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_118 = writer.prefix("SkipMatching");
    if let Some(var_119) = &input.skip_matching {
        scope_118.boolean(*var_119);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_120 = writer.prefix("LaunchTemplateSpecification");
    if let Some(var_121) = &input.launch_template_specification {
        crate::query_ser::serialize_structure_crate_model_launch_template_specification(
            scope_120, var_121,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_122 = writer.prefix("Overrides");
    if let Some(var_123) = &input.overrides {
        let mut list_125 = scope_122.start_list(false, None);
        for item_124 in var_123 {
            #[allow(unused_mut)]
            let mut entry_126 = list_125.entry();
            crate::query_ser::serialize_structure_crate_model_launch_template_overrides(
                entry_126, item_124,
            )?;
        }
        list_125.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instances_distribution(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstancesDistribution,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_127 = writer.prefix("OnDemandAllocationStrategy");
    if let Some(var_128) = &input.on_demand_allocation_strategy {
        scope_127.string(var_128);
    }
    #[allow(unused_mut)]
    let mut scope_129 = writer.prefix("OnDemandBaseCapacity");
    if let Some(var_130) = &input.on_demand_base_capacity {
        scope_129.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_130).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_131 = writer.prefix("OnDemandPercentageAboveBaseCapacity");
    if let Some(var_132) = &input.on_demand_percentage_above_base_capacity {
        scope_131.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_132).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_133 = writer.prefix("SpotAllocationStrategy");
    if let Some(var_134) = &input.spot_allocation_strategy {
        scope_133.string(var_134);
    }
    #[allow(unused_mut)]
    let mut scope_135 = writer.prefix("SpotInstancePools");
    if let Some(var_136) = &input.spot_instance_pools {
        scope_135.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_136).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_137 = writer.prefix("SpotMaxPrice");
    if let Some(var_138) = &input.spot_max_price {
        scope_137.string(var_138);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ebs(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Ebs,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_139 = writer.prefix("SnapshotId");
    if let Some(var_140) = &input.snapshot_id {
        scope_139.string(var_140);
    }
    #[allow(unused_mut)]
    let mut scope_141 = writer.prefix("VolumeSize");
    if let Some(var_142) = &input.volume_size {
        scope_141.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_142).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_143 = writer.prefix("VolumeType");
    if let Some(var_144) = &input.volume_type {
        scope_143.string(var_144);
    }
    #[allow(unused_mut)]
    let mut scope_145 = writer.prefix("DeleteOnTermination");
    if let Some(var_146) = &input.delete_on_termination {
        scope_145.boolean(*var_146);
    }
    #[allow(unused_mut)]
    let mut scope_147 = writer.prefix("Iops");
    if let Some(var_148) = &input.iops {
        scope_147.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_148).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_149 = writer.prefix("Encrypted");
    if let Some(var_150) = &input.encrypted {
        scope_149.boolean(*var_150);
    }
    #[allow(unused_mut)]
    let mut scope_151 = writer.prefix("Throughput");
    if let Some(var_152) = &input.throughput {
        scope_151.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_152).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predefined_metric_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PredefinedMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_153 = writer.prefix("PredefinedMetricType");
    if let Some(var_154) = &input.predefined_metric_type {
        scope_153.string(var_154.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_155 = writer.prefix("ResourceLabel");
    if let Some(var_156) = &input.resource_label {
        scope_155.string(var_156);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_customized_metric_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CustomizedMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_157 = writer.prefix("MetricName");
    if let Some(var_158) = &input.metric_name {
        scope_157.string(var_158);
    }
    #[allow(unused_mut)]
    let mut scope_159 = writer.prefix("Namespace");
    if let Some(var_160) = &input.namespace {
        scope_159.string(var_160);
    }
    #[allow(unused_mut)]
    let mut scope_161 = writer.prefix("Dimensions");
    if let Some(var_162) = &input.dimensions {
        let mut list_164 = scope_161.start_list(false, None);
        for item_163 in var_162 {
            #[allow(unused_mut)]
            let mut entry_165 = list_164.entry();
            crate::query_ser::serialize_structure_crate_model_metric_dimension(
                entry_165, item_163,
            )?;
        }
        list_164.finish();
    }
    #[allow(unused_mut)]
    let mut scope_166 = writer.prefix("Statistic");
    if let Some(var_167) = &input.statistic {
        scope_166.string(var_167.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_168 = writer.prefix("Unit");
    if let Some(var_169) = &input.unit {
        scope_168.string(var_169);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_metric_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PredictiveScalingMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_170 = writer.prefix("TargetValue");
    if let Some(var_171) = &input.target_value {
        scope_170.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_171).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_172 = writer.prefix("PredefinedMetricPairSpecification");
    if let Some(var_173) = &input.predefined_metric_pair_specification {
        crate::query_ser::serialize_structure_crate_model_predictive_scaling_predefined_metric_pair(scope_172, var_173)?;
    }
    #[allow(unused_mut)]
    let mut scope_174 = writer.prefix("PredefinedScalingMetricSpecification");
    if let Some(var_175) = &input.predefined_scaling_metric_specification {
        crate::query_ser::serialize_structure_crate_model_predictive_scaling_predefined_scaling_metric(scope_174, var_175)?;
    }
    #[allow(unused_mut)]
    let mut scope_176 = writer.prefix("PredefinedLoadMetricSpecification");
    if let Some(var_177) = &input.predefined_load_metric_specification {
        crate::query_ser::serialize_structure_crate_model_predictive_scaling_predefined_load_metric(scope_176, var_177)?;
    }
    #[allow(unused_mut)]
    let mut scope_178 = writer.prefix("CustomizedScalingMetricSpecification");
    if let Some(var_179) = &input.customized_scaling_metric_specification {
        crate::query_ser::serialize_structure_crate_model_predictive_scaling_customized_scaling_metric(scope_178, var_179)?;
    }
    #[allow(unused_mut)]
    let mut scope_180 = writer.prefix("CustomizedLoadMetricSpecification");
    if let Some(var_181) = &input.customized_load_metric_specification {
        crate::query_ser::serialize_structure_crate_model_predictive_scaling_customized_load_metric(scope_180, var_181)?;
    }
    #[allow(unused_mut)]
    let mut scope_182 = writer.prefix("CustomizedCapacityMetricSpecification");
    if let Some(var_183) = &input.customized_capacity_metric_specification {
        crate::query_ser::serialize_structure_crate_model_predictive_scaling_customized_capacity_metric(scope_182, var_183)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_overrides(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_184 = writer.prefix("InstanceType");
    if let Some(var_185) = &input.instance_type {
        scope_184.string(var_185);
    }
    #[allow(unused_mut)]
    let mut scope_186 = writer.prefix("WeightedCapacity");
    if let Some(var_187) = &input.weighted_capacity {
        scope_186.string(var_187);
    }
    #[allow(unused_mut)]
    let mut scope_188 = writer.prefix("LaunchTemplateSpecification");
    if let Some(var_189) = &input.launch_template_specification {
        crate::query_ser::serialize_structure_crate_model_launch_template_specification(
            scope_188, var_189,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_190 = writer.prefix("InstanceRequirements");
    if let Some(var_191) = &input.instance_requirements {
        crate::query_ser::serialize_structure_crate_model_instance_requirements(
            scope_190, var_191,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_dimension(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::MetricDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_192 = writer.prefix("Name");
    if let Some(var_193) = &input.name {
        scope_192.string(var_193);
    }
    #[allow(unused_mut)]
    let mut scope_194 = writer.prefix("Value");
    if let Some(var_195) = &input.value {
        scope_194.string(var_195);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_predefined_metric_pair(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PredictiveScalingPredefinedMetricPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_196 = writer.prefix("PredefinedMetricType");
    if let Some(var_197) = &input.predefined_metric_type {
        scope_196.string(var_197.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_198 = writer.prefix("ResourceLabel");
    if let Some(var_199) = &input.resource_label {
        scope_198.string(var_199);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_predefined_scaling_metric(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PredictiveScalingPredefinedScalingMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_200 = writer.prefix("PredefinedMetricType");
    if let Some(var_201) = &input.predefined_metric_type {
        scope_200.string(var_201.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_202 = writer.prefix("ResourceLabel");
    if let Some(var_203) = &input.resource_label {
        scope_202.string(var_203);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_predefined_load_metric(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PredictiveScalingPredefinedLoadMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_204 = writer.prefix("PredefinedMetricType");
    if let Some(var_205) = &input.predefined_metric_type {
        scope_204.string(var_205.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_206 = writer.prefix("ResourceLabel");
    if let Some(var_207) = &input.resource_label {
        scope_206.string(var_207);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_customized_scaling_metric(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PredictiveScalingCustomizedScalingMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_208 = writer.prefix("MetricDataQueries");
    if let Some(var_209) = &input.metric_data_queries {
        let mut list_211 = scope_208.start_list(false, None);
        for item_210 in var_209 {
            #[allow(unused_mut)]
            let mut entry_212 = list_211.entry();
            crate::query_ser::serialize_structure_crate_model_metric_data_query(
                entry_212, item_210,
            )?;
        }
        list_211.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_customized_load_metric(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PredictiveScalingCustomizedLoadMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_213 = writer.prefix("MetricDataQueries");
    if let Some(var_214) = &input.metric_data_queries {
        let mut list_216 = scope_213.start_list(false, None);
        for item_215 in var_214 {
            #[allow(unused_mut)]
            let mut entry_217 = list_216.entry();
            crate::query_ser::serialize_structure_crate_model_metric_data_query(
                entry_217, item_215,
            )?;
        }
        list_216.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_customized_capacity_metric(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PredictiveScalingCustomizedCapacityMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_218 = writer.prefix("MetricDataQueries");
    if let Some(var_219) = &input.metric_data_queries {
        let mut list_221 = scope_218.start_list(false, None);
        for item_220 in var_219 {
            #[allow(unused_mut)]
            let mut entry_222 = list_221.entry();
            crate::query_ser::serialize_structure_crate_model_metric_data_query(
                entry_222, item_220,
            )?;
        }
        list_221.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_requirements(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceRequirements,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_223 = writer.prefix("VCpuCount");
    if let Some(var_224) = &input.v_cpu_count {
        crate::query_ser::serialize_structure_crate_model_v_cpu_count_request(scope_223, var_224)?;
    }
    #[allow(unused_mut)]
    let mut scope_225 = writer.prefix("MemoryMiB");
    if let Some(var_226) = &input.memory_mi_b {
        crate::query_ser::serialize_structure_crate_model_memory_mi_b_request(scope_225, var_226)?;
    }
    #[allow(unused_mut)]
    let mut scope_227 = writer.prefix("CpuManufacturers");
    if let Some(var_228) = &input.cpu_manufacturers {
        let mut list_230 = scope_227.start_list(false, None);
        for item_229 in var_228 {
            #[allow(unused_mut)]
            let mut entry_231 = list_230.entry();
            entry_231.string(item_229.as_str());
        }
        list_230.finish();
    }
    #[allow(unused_mut)]
    let mut scope_232 = writer.prefix("MemoryGiBPerVCpu");
    if let Some(var_233) = &input.memory_gi_b_per_v_cpu {
        crate::query_ser::serialize_structure_crate_model_memory_gi_b_per_v_cpu_request(
            scope_232, var_233,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_234 = writer.prefix("ExcludedInstanceTypes");
    if let Some(var_235) = &input.excluded_instance_types {
        let mut list_237 = scope_234.start_list(false, None);
        for item_236 in var_235 {
            #[allow(unused_mut)]
            let mut entry_238 = list_237.entry();
            entry_238.string(item_236);
        }
        list_237.finish();
    }
    #[allow(unused_mut)]
    let mut scope_239 = writer.prefix("InstanceGenerations");
    if let Some(var_240) = &input.instance_generations {
        let mut list_242 = scope_239.start_list(false, None);
        for item_241 in var_240 {
            #[allow(unused_mut)]
            let mut entry_243 = list_242.entry();
            entry_243.string(item_241.as_str());
        }
        list_242.finish();
    }
    #[allow(unused_mut)]
    let mut scope_244 = writer.prefix("SpotMaxPricePercentageOverLowestPrice");
    if let Some(var_245) = &input.spot_max_price_percentage_over_lowest_price {
        scope_244.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_245).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_246 = writer.prefix("OnDemandMaxPricePercentageOverLowestPrice");
    if let Some(var_247) = &input.on_demand_max_price_percentage_over_lowest_price {
        scope_246.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_247).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_248 = writer.prefix("BareMetal");
    if let Some(var_249) = &input.bare_metal {
        scope_248.string(var_249.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_250 = writer.prefix("BurstablePerformance");
    if let Some(var_251) = &input.burstable_performance {
        scope_250.string(var_251.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_252 = writer.prefix("RequireHibernateSupport");
    if let Some(var_253) = &input.require_hibernate_support {
        scope_252.boolean(*var_253);
    }
    #[allow(unused_mut)]
    let mut scope_254 = writer.prefix("NetworkInterfaceCount");
    if let Some(var_255) = &input.network_interface_count {
        crate::query_ser::serialize_structure_crate_model_network_interface_count_request(
            scope_254, var_255,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_256 = writer.prefix("LocalStorage");
    if let Some(var_257) = &input.local_storage {
        scope_256.string(var_257.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_258 = writer.prefix("LocalStorageTypes");
    if let Some(var_259) = &input.local_storage_types {
        let mut list_261 = scope_258.start_list(false, None);
        for item_260 in var_259 {
            #[allow(unused_mut)]
            let mut entry_262 = list_261.entry();
            entry_262.string(item_260.as_str());
        }
        list_261.finish();
    }
    #[allow(unused_mut)]
    let mut scope_263 = writer.prefix("TotalLocalStorageGB");
    if let Some(var_264) = &input.total_local_storage_gb {
        crate::query_ser::serialize_structure_crate_model_total_local_storage_gb_request(
            scope_263, var_264,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_265 = writer.prefix("BaselineEbsBandwidthMbps");
    if let Some(var_266) = &input.baseline_ebs_bandwidth_mbps {
        crate::query_ser::serialize_structure_crate_model_baseline_ebs_bandwidth_mbps_request(
            scope_265, var_266,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_267 = writer.prefix("AcceleratorTypes");
    if let Some(var_268) = &input.accelerator_types {
        let mut list_270 = scope_267.start_list(false, None);
        for item_269 in var_268 {
            #[allow(unused_mut)]
            let mut entry_271 = list_270.entry();
            entry_271.string(item_269.as_str());
        }
        list_270.finish();
    }
    #[allow(unused_mut)]
    let mut scope_272 = writer.prefix("AcceleratorCount");
    if let Some(var_273) = &input.accelerator_count {
        crate::query_ser::serialize_structure_crate_model_accelerator_count_request(
            scope_272, var_273,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_274 = writer.prefix("AcceleratorManufacturers");
    if let Some(var_275) = &input.accelerator_manufacturers {
        let mut list_277 = scope_274.start_list(false, None);
        for item_276 in var_275 {
            #[allow(unused_mut)]
            let mut entry_278 = list_277.entry();
            entry_278.string(item_276.as_str());
        }
        list_277.finish();
    }
    #[allow(unused_mut)]
    let mut scope_279 = writer.prefix("AcceleratorNames");
    if let Some(var_280) = &input.accelerator_names {
        let mut list_282 = scope_279.start_list(false, None);
        for item_281 in var_280 {
            #[allow(unused_mut)]
            let mut entry_283 = list_282.entry();
            entry_283.string(item_281.as_str());
        }
        list_282.finish();
    }
    #[allow(unused_mut)]
    let mut scope_284 = writer.prefix("AcceleratorTotalMemoryMiB");
    if let Some(var_285) = &input.accelerator_total_memory_mi_b {
        crate::query_ser::serialize_structure_crate_model_accelerator_total_memory_mi_b_request(
            scope_284, var_285,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_data_query(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::MetricDataQuery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_286 = writer.prefix("Id");
    if let Some(var_287) = &input.id {
        scope_286.string(var_287);
    }
    #[allow(unused_mut)]
    let mut scope_288 = writer.prefix("Expression");
    if let Some(var_289) = &input.expression {
        scope_288.string(var_289);
    }
    #[allow(unused_mut)]
    let mut scope_290 = writer.prefix("MetricStat");
    if let Some(var_291) = &input.metric_stat {
        crate::query_ser::serialize_structure_crate_model_metric_stat(scope_290, var_291)?;
    }
    #[allow(unused_mut)]
    let mut scope_292 = writer.prefix("Label");
    if let Some(var_293) = &input.label {
        scope_292.string(var_293);
    }
    #[allow(unused_mut)]
    let mut scope_294 = writer.prefix("ReturnData");
    if let Some(var_295) = &input.return_data {
        scope_294.boolean(*var_295);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_v_cpu_count_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::VCpuCountRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_296 = writer.prefix("Min");
    if let Some(var_297) = &input.min {
        scope_296.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_297).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_298 = writer.prefix("Max");
    if let Some(var_299) = &input.max {
        scope_298.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_299).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_memory_mi_b_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::MemoryMiBRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_300 = writer.prefix("Min");
    if let Some(var_301) = &input.min {
        scope_300.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_301).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_302 = writer.prefix("Max");
    if let Some(var_303) = &input.max {
        scope_302.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_303).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_memory_gi_b_per_v_cpu_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::MemoryGiBPerVCpuRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_304 = writer.prefix("Min");
    if let Some(var_305) = &input.min {
        scope_304.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_305).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_306 = writer.prefix("Max");
    if let Some(var_307) = &input.max {
        scope_306.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_307).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_network_interface_count_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::NetworkInterfaceCountRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_308 = writer.prefix("Min");
    if let Some(var_309) = &input.min {
        scope_308.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_309).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_310 = writer.prefix("Max");
    if let Some(var_311) = &input.max {
        scope_310.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_311).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_total_local_storage_gb_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::TotalLocalStorageGbRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_312 = writer.prefix("Min");
    if let Some(var_313) = &input.min {
        scope_312.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_313).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_314 = writer.prefix("Max");
    if let Some(var_315) = &input.max {
        scope_314.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_315).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_baseline_ebs_bandwidth_mbps_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::BaselineEbsBandwidthMbpsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_316 = writer.prefix("Min");
    if let Some(var_317) = &input.min {
        scope_316.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_317).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_318 = writer.prefix("Max");
    if let Some(var_319) = &input.max {
        scope_318.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_319).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_accelerator_count_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AcceleratorCountRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_320 = writer.prefix("Min");
    if let Some(var_321) = &input.min {
        scope_320.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_321).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_322 = writer.prefix("Max");
    if let Some(var_323) = &input.max {
        scope_322.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_323).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_accelerator_total_memory_mi_b_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AcceleratorTotalMemoryMiBRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_324 = writer.prefix("Min");
    if let Some(var_325) = &input.min {
        scope_324.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_325).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_326 = writer.prefix("Max");
    if let Some(var_327) = &input.max {
        scope_326.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_327).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_stat(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::MetricStat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_328 = writer.prefix("Metric");
    if let Some(var_329) = &input.metric {
        crate::query_ser::serialize_structure_crate_model_metric(scope_328, var_329)?;
    }
    #[allow(unused_mut)]
    let mut scope_330 = writer.prefix("Stat");
    if let Some(var_331) = &input.stat {
        scope_330.string(var_331);
    }
    #[allow(unused_mut)]
    let mut scope_332 = writer.prefix("Unit");
    if let Some(var_333) = &input.unit {
        scope_332.string(var_333);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Metric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_334 = writer.prefix("Namespace");
    if let Some(var_335) = &input.namespace {
        scope_334.string(var_335);
    }
    #[allow(unused_mut)]
    let mut scope_336 = writer.prefix("MetricName");
    if let Some(var_337) = &input.metric_name {
        scope_336.string(var_337);
    }
    #[allow(unused_mut)]
    let mut scope_338 = writer.prefix("Dimensions");
    if let Some(var_339) = &input.dimensions {
        let mut list_341 = scope_338.start_list(false, None);
        for item_340 in var_339 {
            #[allow(unused_mut)]
            let mut entry_342 = list_341.entry();
            crate::query_ser::serialize_structure_crate_model_metric_dimension(
                entry_342, item_340,
            )?;
        }
        list_341.finish();
    }
    Ok(())
}