Enum aws_sdk_ec2::model::LocalStorageType

#[non_exhaustive]
pub enum LocalStorageType {
    Hdd,
    Ssd,
    Unknown(UnknownVariantValue),
}

When writing a match expression against LocalStorageType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Here is an example of how you can make a match expression forward-compatible:

# let localstoragetype = unimplemented!();
match localstoragetype {
    LocalStorageType::Hdd => { /* ... */ },
    LocalStorageType::Ssd => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

The above code demonstrates that when localstoragetype represents NewFeature, the execution path will lead to the second last match arm, even though the enum does not contain a variant LocalStorageType::NewFeature in the current version of SDK. The reason is that the variable other, created by the @ operator, is bound to LocalStorageType::Unknown(UnknownVariantValue("NewFeature".to_owned())) and calling as_str on it yields "NewFeature". This match expression is forward-compatible when executed with a newer version of SDK where the variant LocalStorageType::NewFeature is defined. Specifically, when localstoragetype represents NewFeature, the execution path will hit the second last match arm as before by virtue of calling as_str on LocalStorageType::NewFeature also yielding "NewFeature".

Explicitly matching on the Unknown variant should be avoided for two reasons:

• The inner data UnknownVariantValue is opaque, and no further information can be extracted.
• It might inadvertently shadow other intended match arms.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Hdd

Ssd

Unknown(UnknownVariantValue)

Unknown contains new variants that have been added since this code was generated.

Implementations

impl LocalStorageType

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 27592)

    fn as_ref(&self) -> &str {
        self.as_str()
    }

src/query_ser.rs (line 1767)

pub fn serialize_structure_crate_model_instance_requirements_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceRequirementsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_460 = writer.prefix("VCpuCount");
    if let Some(var_461) = &input.v_cpu_count {
        crate::query_ser::serialize_structure_crate_model_v_cpu_count_range_request(
            scope_460, var_461,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_462 = writer.prefix("MemoryMiB");
    if let Some(var_463) = &input.memory_mi_b {
        crate::query_ser::serialize_structure_crate_model_memory_mi_b_request(scope_462, var_463)?;
    }
    #[allow(unused_mut)]
    let mut scope_464 = writer.prefix("CpuManufacturer");
    if let Some(var_465) = &input.cpu_manufacturers {
        let mut list_467 = scope_464.start_list(true, Some("item"));
        for item_466 in var_465 {
            #[allow(unused_mut)]
            let mut entry_468 = list_467.entry();
            entry_468.string(item_466.as_str());
        }
        list_467.finish();
    }
    #[allow(unused_mut)]
    let mut scope_469 = writer.prefix("MemoryGiBPerVCpu");
    if let Some(var_470) = &input.memory_gi_b_per_v_cpu {
        crate::query_ser::serialize_structure_crate_model_memory_gi_b_per_v_cpu_request(
            scope_469, var_470,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_471 = writer.prefix("ExcludedInstanceType");
    if let Some(var_472) = &input.excluded_instance_types {
        let mut list_474 = scope_471.start_list(true, Some("item"));
        for item_473 in var_472 {
            #[allow(unused_mut)]
            let mut entry_475 = list_474.entry();
            entry_475.string(item_473);
        }
        list_474.finish();
    }
    #[allow(unused_mut)]
    let mut scope_476 = writer.prefix("InstanceGeneration");
    if let Some(var_477) = &input.instance_generations {
        let mut list_479 = scope_476.start_list(true, Some("item"));
        for item_478 in var_477 {
            #[allow(unused_mut)]
            let mut entry_480 = list_479.entry();
            entry_480.string(item_478.as_str());
        }
        list_479.finish();
    }
    #[allow(unused_mut)]
    let mut scope_481 = writer.prefix("SpotMaxPricePercentageOverLowestPrice");
    if let Some(var_482) = &input.spot_max_price_percentage_over_lowest_price {
        scope_481.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_482).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_483 = writer.prefix("OnDemandMaxPricePercentageOverLowestPrice");
    if let Some(var_484) = &input.on_demand_max_price_percentage_over_lowest_price {
        scope_483.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_484).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_485 = writer.prefix("BareMetal");
    if let Some(var_486) = &input.bare_metal {
        scope_485.string(var_486.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_487 = writer.prefix("BurstablePerformance");
    if let Some(var_488) = &input.burstable_performance {
        scope_487.string(var_488.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_489 = writer.prefix("RequireHibernateSupport");
    if let Some(var_490) = &input.require_hibernate_support {
        scope_489.boolean(*var_490);
    }
    #[allow(unused_mut)]
    let mut scope_491 = writer.prefix("NetworkInterfaceCount");
    if let Some(var_492) = &input.network_interface_count {
        crate::query_ser::serialize_structure_crate_model_network_interface_count_request(
            scope_491, var_492,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_493 = writer.prefix("LocalStorage");
    if let Some(var_494) = &input.local_storage {
        scope_493.string(var_494.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_495 = writer.prefix("LocalStorageType");
    if let Some(var_496) = &input.local_storage_types {
        let mut list_498 = scope_495.start_list(true, Some("item"));
        for item_497 in var_496 {
            #[allow(unused_mut)]
            let mut entry_499 = list_498.entry();
            entry_499.string(item_497.as_str());
        }
        list_498.finish();
    }
    #[allow(unused_mut)]
    let mut scope_500 = writer.prefix("TotalLocalStorageGB");
    if let Some(var_501) = &input.total_local_storage_gb {
        crate::query_ser::serialize_structure_crate_model_total_local_storage_gb_request(
            scope_500, var_501,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_502 = writer.prefix("BaselineEbsBandwidthMbps");
    if let Some(var_503) = &input.baseline_ebs_bandwidth_mbps {
        crate::query_ser::serialize_structure_crate_model_baseline_ebs_bandwidth_mbps_request(
            scope_502, var_503,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_504 = writer.prefix("AcceleratorType");
    if let Some(var_505) = &input.accelerator_types {
        let mut list_507 = scope_504.start_list(true, Some("item"));
        for item_506 in var_505 {
            #[allow(unused_mut)]
            let mut entry_508 = list_507.entry();
            entry_508.string(item_506.as_str());
        }
        list_507.finish();
    }
    #[allow(unused_mut)]
    let mut scope_509 = writer.prefix("AcceleratorCount");
    if let Some(var_510) = &input.accelerator_count {
        crate::query_ser::serialize_structure_crate_model_accelerator_count_request(
            scope_509, var_510,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_511 = writer.prefix("AcceleratorManufacturer");
    if let Some(var_512) = &input.accelerator_manufacturers {
        let mut list_514 = scope_511.start_list(true, Some("item"));
        for item_513 in var_512 {
            #[allow(unused_mut)]
            let mut entry_515 = list_514.entry();
            entry_515.string(item_513.as_str());
        }
        list_514.finish();
    }
    #[allow(unused_mut)]
    let mut scope_516 = writer.prefix("AcceleratorName");
    if let Some(var_517) = &input.accelerator_names {
        let mut list_519 = scope_516.start_list(true, Some("item"));
        for item_518 in var_517 {
            #[allow(unused_mut)]
            let mut entry_520 = list_519.entry();
            entry_520.string(item_518.as_str());
        }
        list_519.finish();
    }
    #[allow(unused_mut)]
    let mut scope_521 = writer.prefix("AcceleratorTotalMemoryMiB");
    if let Some(var_522) = &input.accelerator_total_memory_mi_b {
        crate::query_ser::serialize_structure_crate_model_accelerator_total_memory_mi_b_request(
            scope_521, var_522,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_requirements_with_metadata_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceRequirementsWithMetadataRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_523 = writer.prefix("ArchitectureType");
    if let Some(var_524) = &input.architecture_types {
        let mut list_526 = scope_523.start_list(true, Some("item"));
        for item_525 in var_524 {
            #[allow(unused_mut)]
            let mut entry_527 = list_526.entry();
            entry_527.string(item_525.as_str());
        }
        list_526.finish();
    }
    #[allow(unused_mut)]
    let mut scope_528 = writer.prefix("VirtualizationType");
    if let Some(var_529) = &input.virtualization_types {
        let mut list_531 = scope_528.start_list(true, Some("item"));
        for item_530 in var_529 {
            #[allow(unused_mut)]
            let mut entry_532 = list_531.entry();
            entry_532.string(item_530.as_str());
        }
        list_531.finish();
    }
    #[allow(unused_mut)]
    let mut scope_533 = writer.prefix("InstanceRequirements");
    if let Some(var_534) = &input.instance_requirements {
        crate::query_ser::serialize_structure_crate_model_instance_requirements_request(
            scope_533, var_534,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_client_data(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ClientData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_535 = writer.prefix("Comment");
    if let Some(var_536) = &input.comment {
        scope_535.string(var_536);
    }
    #[allow(unused_mut)]
    let mut scope_537 = writer.prefix("UploadEnd");
    if let Some(var_538) = &input.upload_end {
        scope_537.date_time(var_538, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_539 = writer.prefix("UploadSize");
    if let Some(var_540) = &input.upload_size {
        scope_539.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_540).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_541 = writer.prefix("UploadStart");
    if let Some(var_542) = &input.upload_start {
        scope_541.date_time(var_542, aws_smithy_types::date_time::Format::DateTime)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_image_disk_container(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ImageDiskContainer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_543 = writer.prefix("Description");
    if let Some(var_544) = &input.description {
        scope_543.string(var_544);
    }
    #[allow(unused_mut)]
    let mut scope_545 = writer.prefix("DeviceName");
    if let Some(var_546) = &input.device_name {
        scope_545.string(var_546);
    }
    #[allow(unused_mut)]
    let mut scope_547 = writer.prefix("Format");
    if let Some(var_548) = &input.format {
        scope_547.string(var_548);
    }
    #[allow(unused_mut)]
    let mut scope_549 = writer.prefix("SnapshotId");
    if let Some(var_550) = &input.snapshot_id {
        scope_549.string(var_550);
    }
    #[allow(unused_mut)]
    let mut scope_551 = writer.prefix("Url");
    if let Some(var_552) = &input.url {
        scope_551.string(var_552);
    }
    #[allow(unused_mut)]
    let mut scope_553 = writer.prefix("UserBucket");
    if let Some(var_554) = &input.user_bucket {
        crate::query_ser::serialize_structure_crate_model_user_bucket(scope_553, var_554)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_import_image_license_configuration_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ImportImageLicenseConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_555 = writer.prefix("LicenseConfigurationArn");
    if let Some(var_556) = &input.license_configuration_arn {
        scope_555.string(var_556);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_disk_image(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::DiskImage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_557 = writer.prefix("Description");
    if let Some(var_558) = &input.description {
        scope_557.string(var_558);
    }
    #[allow(unused_mut)]
    let mut scope_559 = writer.prefix("Image");
    if let Some(var_560) = &input.image {
        crate::query_ser::serialize_structure_crate_model_disk_image_detail(scope_559, var_560)?;
    }
    #[allow(unused_mut)]
    let mut scope_561 = writer.prefix("Volume");
    if let Some(var_562) = &input.volume {
        crate::query_ser::serialize_structure_crate_model_volume_detail(scope_561, var_562)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_import_instance_launch_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ImportInstanceLaunchSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_563 = writer.prefix("AdditionalInfo");
    if let Some(var_564) = &input.additional_info {
        scope_563.string(var_564);
    }
    #[allow(unused_mut)]
    let mut scope_565 = writer.prefix("Architecture");
    if let Some(var_566) = &input.architecture {
        scope_565.string(var_566.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_567 = writer.prefix("GroupId");
    if let Some(var_568) = &input.group_ids {
        let mut list_570 = scope_567.start_list(true, Some("SecurityGroupId"));
        for item_569 in var_568 {
            #[allow(unused_mut)]
            let mut entry_571 = list_570.entry();
            entry_571.string(item_569);
        }
        list_570.finish();
    }
    #[allow(unused_mut)]
    let mut scope_572 = writer.prefix("GroupName");
    if let Some(var_573) = &input.group_names {
        let mut list_575 = scope_572.start_list(true, Some("SecurityGroup"));
        for item_574 in var_573 {
            #[allow(unused_mut)]
            let mut entry_576 = list_575.entry();
            entry_576.string(item_574);
        }
        list_575.finish();
    }
    #[allow(unused_mut)]
    let mut scope_577 = writer.prefix("InstanceInitiatedShutdownBehavior");
    if let Some(var_578) = &input.instance_initiated_shutdown_behavior {
        scope_577.string(var_578.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_579 = writer.prefix("InstanceType");
    if let Some(var_580) = &input.instance_type {
        scope_579.string(var_580.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_581 = writer.prefix("Monitoring");
    if let Some(var_582) = &input.monitoring {
        scope_581.boolean(*var_582);
    }
    #[allow(unused_mut)]
    let mut scope_583 = writer.prefix("Placement");
    if let Some(var_584) = &input.placement {
        crate::query_ser::serialize_structure_crate_model_placement(scope_583, var_584)?;
    }
    #[allow(unused_mut)]
    let mut scope_585 = writer.prefix("PrivateIpAddress");
    if let Some(var_586) = &input.private_ip_address {
        scope_585.string(var_586);
    }
    #[allow(unused_mut)]
    let mut scope_587 = writer.prefix("SubnetId");
    if let Some(var_588) = &input.subnet_id {
        scope_587.string(var_588);
    }
    #[allow(unused_mut)]
    let mut scope_589 = writer.prefix("UserData");
    if let Some(var_590) = &input.user_data {
        crate::query_ser::serialize_structure_crate_model_user_data(scope_589, var_590)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_snapshot_disk_container(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SnapshotDiskContainer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_591 = writer.prefix("Description");
    if let Some(var_592) = &input.description {
        scope_591.string(var_592);
    }
    #[allow(unused_mut)]
    let mut scope_593 = writer.prefix("Format");
    if let Some(var_594) = &input.format {
        scope_593.string(var_594);
    }
    #[allow(unused_mut)]
    let mut scope_595 = writer.prefix("Url");
    if let Some(var_596) = &input.url {
        scope_595.string(var_596);
    }
    #[allow(unused_mut)]
    let mut scope_597 = writer.prefix("UserBucket");
    if let Some(var_598) = &input.user_bucket {
        crate::query_ser::serialize_structure_crate_model_user_bucket(scope_597, var_598)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_disk_image_detail(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::DiskImageDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_599 = writer.prefix("Bytes");
    if let Some(var_600) = &input.bytes {
        scope_599.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_600).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_601 = writer.prefix("Format");
    if let Some(var_602) = &input.format {
        scope_601.string(var_602.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_603 = writer.prefix("ImportManifestUrl");
    if let Some(var_604) = &input.import_manifest_url {
        scope_603.string(var_604);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_volume_detail(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::VolumeDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_605 = writer.prefix("Size");
    if let Some(var_606) = &input.size {
        scope_605.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_606).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_dns_servers_options_modify_structure(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::DnsServersOptionsModifyStructure,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_607 = writer.prefix("CustomDnsServers");
    if let Some(var_608) = &input.custom_dns_servers {
        let mut list_610 = scope_607.start_list(true, Some("item"));
        for item_609 in var_608 {
            #[allow(unused_mut)]
            let mut entry_611 = list_610.entry();
            entry_611.string(item_609);
        }
        list_610.finish();
    }
    #[allow(unused_mut)]
    let mut scope_612 = writer.prefix("Enabled");
    if let Some(var_613) = &input.enabled {
        scope_612.boolean(*var_613);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_load_permission_modifications(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LoadPermissionModifications,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_614 = writer.prefix("Add");
    if let Some(var_615) = &input.add {
        let mut list_617 = scope_614.start_list(true, Some("item"));
        for item_616 in var_615 {
            #[allow(unused_mut)]
            let mut entry_618 = list_617.entry();
            crate::query_ser::serialize_structure_crate_model_load_permission_request(
                entry_618, item_616,
            )?;
        }
        list_617.finish();
    }
    #[allow(unused_mut)]
    let mut scope_619 = writer.prefix("Remove");
    if let Some(var_620) = &input.remove {
        let mut list_622 = scope_619.start_list(true, Some("item"));
        for item_621 in var_620 {
            #[allow(unused_mut)]
            let mut entry_623 = list_622.entry();
            crate::query_ser::serialize_structure_crate_model_load_permission_request(
                entry_623, item_621,
            )?;
        }
        list_622.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_attribute_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AttributeValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_624 = writer.prefix("Value");
    if let Some(var_625) = &input.value {
        scope_624.string(var_625);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_permission_modifications(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchPermissionModifications,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_626 = writer.prefix("Add");
    if let Some(var_627) = &input.add {
        let mut list_629 = scope_626.start_list(true, Some("item"));
        for item_628 in var_627 {
            #[allow(unused_mut)]
            let mut entry_630 = list_629.entry();
            crate::query_ser::serialize_structure_crate_model_launch_permission(
                entry_630, item_628,
            )?;
        }
        list_629.finish();
    }
    #[allow(unused_mut)]
    let mut scope_631 = writer.prefix("Remove");
    if let Some(var_632) = &input.remove {
        let mut list_634 = scope_631.start_list(true, Some("item"));
        for item_633 in var_632 {
            #[allow(unused_mut)]
            let mut entry_635 = list_634.entry();
            crate::query_ser::serialize_structure_crate_model_launch_permission(
                entry_635, item_633,
            )?;
        }
        list_634.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_attribute_boolean_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AttributeBooleanValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_636 = writer.prefix("Value");
    if let Some(var_637) = &input.value {
        scope_636.boolean(*var_637);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_block_device_mapping_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceBlockDeviceMappingSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_638 = writer.prefix("DeviceName");
    if let Some(var_639) = &input.device_name {
        scope_638.string(var_639);
    }
    #[allow(unused_mut)]
    let mut scope_640 = writer.prefix("Ebs");
    if let Some(var_641) = &input.ebs {
        crate::query_ser::serialize_structure_crate_model_ebs_instance_block_device_specification(
            scope_640, var_641,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_642 = writer.prefix("NoDevice");
    if let Some(var_643) = &input.no_device {
        scope_642.string(var_643);
    }
    #[allow(unused_mut)]
    let mut scope_644 = writer.prefix("VirtualName");
    if let Some(var_645) = &input.virtual_name {
        scope_644.string(var_645);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_blob_attribute_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::BlobAttributeValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_646 = writer.prefix("Value");
    if let Some(var_647) = &input.value {
        scope_646.string(&aws_smithy_types::base64::encode(var_647));
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_capacity_reservation_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CapacityReservationSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_648 = writer.prefix("CapacityReservationPreference");
    if let Some(var_649) = &input.capacity_reservation_preference {
        scope_648.string(var_649.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_650 = writer.prefix("CapacityReservationTarget");
    if let Some(var_651) = &input.capacity_reservation_target {
        crate::query_ser::serialize_structure_crate_model_capacity_reservation_target(
            scope_650, var_651,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_credit_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceCreditSpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_652 = writer.prefix("InstanceId");
    if let Some(var_653) = &input.instance_id {
        scope_652.string(var_653);
    }
    #[allow(unused_mut)]
    let mut scope_654 = writer.prefix("CpuCredits");
    if let Some(var_655) = &input.cpu_credits {
        scope_654.string(var_655);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_remove_ipam_operating_region(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::RemoveIpamOperatingRegion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_656 = writer.prefix("RegionName");
    if let Some(var_657) = &input.region_name {
        scope_656.string(var_657);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_remove_prefix_list_entry(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::RemovePrefixListEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_658 = writer.prefix("Cidr");
    if let Some(var_659) = &input.cidr {
        scope_658.string(var_659);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_network_interface_attachment_changes(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::NetworkInterfaceAttachmentChanges,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_660 = writer.prefix("AttachmentId");
    if let Some(var_661) = &input.attachment_id {
        scope_660.string(var_661);
    }
    #[allow(unused_mut)]
    let mut scope_662 = writer.prefix("DeleteOnTermination");
    if let Some(var_663) = &input.delete_on_termination {
        scope_662.boolean(*var_663);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_reserved_instances_configuration(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ReservedInstancesConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_664 = writer.prefix("AvailabilityZone");
    if let Some(var_665) = &input.availability_zone {
        scope_664.string(var_665);
    }
    #[allow(unused_mut)]
    let mut scope_666 = writer.prefix("InstanceCount");
    if let Some(var_667) = &input.instance_count {
        scope_666.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_667).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_668 = writer.prefix("InstanceType");
    if let Some(var_669) = &input.instance_type {
        scope_668.string(var_669.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_670 = writer.prefix("Platform");
    if let Some(var_671) = &input.platform {
        scope_670.string(var_671);
    }
    #[allow(unused_mut)]
    let mut scope_672 = writer.prefix("Scope");
    if let Some(var_673) = &input.scope {
        scope_672.string(var_673.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_security_group_rule_update(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SecurityGroupRuleUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_674 = writer.prefix("SecurityGroupRuleId");
    if let Some(var_675) = &input.security_group_rule_id {
        scope_674.string(var_675);
    }
    #[allow(unused_mut)]
    let mut scope_676 = writer.prefix("SecurityGroupRule");
    if let Some(var_677) = &input.security_group_rule {
        crate::query_ser::serialize_structure_crate_model_security_group_rule_request(
            scope_676, var_677,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_volume_permission_modifications(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CreateVolumePermissionModifications,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_678 = writer.prefix("Add");
    if let Some(var_679) = &input.add {
        let mut list_681 = scope_678.start_list(true, Some("item"));
        for item_680 in var_679 {
            #[allow(unused_mut)]
            let mut entry_682 = list_681.entry();
            crate::query_ser::serialize_structure_crate_model_create_volume_permission(
                entry_682, item_680,
            )?;
        }
        list_681.finish();
    }
    #[allow(unused_mut)]
    let mut scope_683 = writer.prefix("Remove");
    if let Some(var_684) = &input.remove {
        let mut list_686 = scope_683.start_list(true, Some("item"));
        for item_685 in var_684 {
            #[allow(unused_mut)]
            let mut entry_687 = list_686.entry();
            crate::query_ser::serialize_structure_crate_model_create_volume_permission(
                entry_687, item_685,
            )?;
        }
        list_686.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_config(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_688 = writer.prefix("LaunchTemplateSpecification");
    if let Some(var_689) = &input.launch_template_specification {
        crate::query_ser::serialize_structure_crate_model_fleet_launch_template_specification(
            scope_688, var_689,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_690 = writer.prefix("Overrides");
    if let Some(var_691) = &input.overrides {
        let mut list_693 = scope_690.start_list(true, Some("item"));
        for item_692 in var_691 {
            #[allow(unused_mut)]
            let mut entry_694 = list_693.entry();
            crate::query_ser::serialize_structure_crate_model_launch_template_overrides(
                entry_694, item_692,
            )?;
        }
        list_693.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_modify_transit_gateway_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ModifyTransitGatewayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_695 = writer.prefix("AddTransitGatewayCidrBlocks");
    if let Some(var_696) = &input.add_transit_gateway_cidr_blocks {
        let mut list_698 = scope_695.start_list(true, Some("item"));
        for item_697 in var_696 {
            #[allow(unused_mut)]
            let mut entry_699 = list_698.entry();
            entry_699.string(item_697);
        }
        list_698.finish();
    }
    #[allow(unused_mut)]
    let mut scope_700 = writer.prefix("RemoveTransitGatewayCidrBlocks");
    if let Some(var_701) = &input.remove_transit_gateway_cidr_blocks {
        let mut list_703 = scope_700.start_list(true, Some("item"));
        for item_702 in var_701 {
            #[allow(unused_mut)]
            let mut entry_704 = list_703.entry();
            entry_704.string(item_702);
        }
        list_703.finish();
    }
    #[allow(unused_mut)]
    let mut scope_705 = writer.prefix("VpnEcmpSupport");
    if let Some(var_706) = &input.vpn_ecmp_support {
        scope_705.string(var_706.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_707 = writer.prefix("DnsSupport");
    if let Some(var_708) = &input.dns_support {
        scope_707.string(var_708.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_709 = writer.prefix("AutoAcceptSharedAttachments");
    if let Some(var_710) = &input.auto_accept_shared_attachments {
        scope_709.string(var_710.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_711 = writer.prefix("DefaultRouteTableAssociation");
    if let Some(var_712) = &input.default_route_table_association {
        scope_711.string(var_712.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_713 = writer.prefix("AssociationDefaultRouteTableId");
    if let Some(var_714) = &input.association_default_route_table_id {
        scope_713.string(var_714);
    }
    #[allow(unused_mut)]
    let mut scope_715 = writer.prefix("DefaultRouteTablePropagation");
    if let Some(var_716) = &input.default_route_table_propagation {
        scope_715.string(var_716.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_717 = writer.prefix("PropagationDefaultRouteTableId");
    if let Some(var_718) = &input.propagation_default_route_table_id {
        scope_717.string(var_718);
    }
    #[allow(unused_mut)]
    let mut scope_719 = writer.prefix("AmazonSideAsn");
    if let Some(var_720) = &input.amazon_side_asn {
        scope_719.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_720).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_modify_transit_gateway_vpc_attachment_request_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ModifyTransitGatewayVpcAttachmentRequestOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_721 = writer.prefix("DnsSupport");
    if let Some(var_722) = &input.dns_support {
        scope_721.string(var_722.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_723 = writer.prefix("Ipv6Support");
    if let Some(var_724) = &input.ipv6_support {
        scope_723.string(var_724.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_725 = writer.prefix("ApplianceModeSupport");
    if let Some(var_726) = &input.appliance_mode_support {
        scope_725.string(var_726.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_peering_connection_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PeeringConnectionOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_727 = writer.prefix("AllowDnsResolutionFromRemoteVpc");
    if let Some(var_728) = &input.allow_dns_resolution_from_remote_vpc {
        scope_727.boolean(*var_728);
    }
    #[allow(unused_mut)]
    let mut scope_729 = writer.prefix("AllowEgressFromLocalClassicLinkToRemoteVpc");
    if let Some(var_730) = &input.allow_egress_from_local_classic_link_to_remote_vpc {
        scope_729.boolean(*var_730);
    }
    #[allow(unused_mut)]
    let mut scope_731 = writer.prefix("AllowEgressFromLocalVpcToRemoteClassicLink");
    if let Some(var_732) = &input.allow_egress_from_local_vpc_to_remote_classic_link {
        scope_731.boolean(*var_732);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_modify_vpn_tunnel_options_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ModifyVpnTunnelOptionsSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_733 = writer.prefix("TunnelInsideCidr");
    if let Some(var_734) = &input.tunnel_inside_cidr {
        scope_733.string(var_734);
    }
    #[allow(unused_mut)]
    let mut scope_735 = writer.prefix("TunnelInsideIpv6Cidr");
    if let Some(var_736) = &input.tunnel_inside_ipv6_cidr {
        scope_735.string(var_736);
    }
    #[allow(unused_mut)]
    let mut scope_737 = writer.prefix("PreSharedKey");
    if let Some(var_738) = &input.pre_shared_key {
        scope_737.string(var_738);
    }
    #[allow(unused_mut)]
    let mut scope_739 = writer.prefix("Phase1LifetimeSeconds");
    if let Some(var_740) = &input.phase1_lifetime_seconds {
        scope_739.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_740).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_741 = writer.prefix("Phase2LifetimeSeconds");
    if let Some(var_742) = &input.phase2_lifetime_seconds {
        scope_741.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_742).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_743 = writer.prefix("RekeyMarginTimeSeconds");
    if let Some(var_744) = &input.rekey_margin_time_seconds {
        scope_743.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_744).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_745 = writer.prefix("RekeyFuzzPercentage");
    if let Some(var_746) = &input.rekey_fuzz_percentage {
        scope_745.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_746).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_747 = writer.prefix("ReplayWindowSize");
    if let Some(var_748) = &input.replay_window_size {
        scope_747.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_748).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_749 = writer.prefix("DPDTimeoutSeconds");
    if let Some(var_750) = &input.dpd_timeout_seconds {
        scope_749.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_750).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_751 = writer.prefix("DPDTimeoutAction");
    if let Some(var_752) = &input.dpd_timeout_action {
        scope_751.string(var_752);
    }
    #[allow(unused_mut)]
    let mut scope_753 = writer.prefix("Phase1EncryptionAlgorithm");
    if let Some(var_754) = &input.phase1_encryption_algorithms {
        let mut list_756 = scope_753.start_list(true, Some("item"));
        for item_755 in var_754 {
            #[allow(unused_mut)]
            let mut entry_757 = list_756.entry();
            crate::query_ser::serialize_structure_crate_model_phase1_encryption_algorithms_request_list_value(entry_757, item_755)?;
        }
        list_756.finish();
    }
    #[allow(unused_mut)]
    let mut scope_758 = writer.prefix("Phase2EncryptionAlgorithm");
    if let Some(var_759) = &input.phase2_encryption_algorithms {
        let mut list_761 = scope_758.start_list(true, Some("item"));
        for item_760 in var_759 {
            #[allow(unused_mut)]
            let mut entry_762 = list_761.entry();
            crate::query_ser::serialize_structure_crate_model_phase2_encryption_algorithms_request_list_value(entry_762, item_760)?;
        }
        list_761.finish();
    }
    #[allow(unused_mut)]
    let mut scope_763 = writer.prefix("Phase1IntegrityAlgorithm");
    if let Some(var_764) = &input.phase1_integrity_algorithms {
        let mut list_766 = scope_763.start_list(true, Some("item"));
        for item_765 in var_764 {
            #[allow(unused_mut)]
            let mut entry_767 = list_766.entry();
            crate::query_ser::serialize_structure_crate_model_phase1_integrity_algorithms_request_list_value(entry_767, item_765)?;
        }
        list_766.finish();
    }
    #[allow(unused_mut)]
    let mut scope_768 = writer.prefix("Phase2IntegrityAlgorithm");
    if let Some(var_769) = &input.phase2_integrity_algorithms {
        let mut list_771 = scope_768.start_list(true, Some("item"));
        for item_770 in var_769 {
            #[allow(unused_mut)]
            let mut entry_772 = list_771.entry();
            crate::query_ser::serialize_structure_crate_model_phase2_integrity_algorithms_request_list_value(entry_772, item_770)?;
        }
        list_771.finish();
    }
    #[allow(unused_mut)]
    let mut scope_773 = writer.prefix("Phase1DHGroupNumber");
    if let Some(var_774) = &input.phase1_dh_group_numbers {
        let mut list_776 = scope_773.start_list(true, Some("item"));
        for item_775 in var_774 {
            #[allow(unused_mut)]
            let mut entry_777 = list_776.entry();
            crate::query_ser::serialize_structure_crate_model_phase1_dh_group_numbers_request_list_value(entry_777, item_775)?;
        }
        list_776.finish();
    }
    #[allow(unused_mut)]
    let mut scope_778 = writer.prefix("Phase2DHGroupNumber");
    if let Some(var_779) = &input.phase2_dh_group_numbers {
        let mut list_781 = scope_778.start_list(true, Some("item"));
        for item_780 in var_779 {
            #[allow(unused_mut)]
            let mut entry_782 = list_781.entry();
            crate::query_ser::serialize_structure_crate_model_phase2_dh_group_numbers_request_list_value(entry_782, item_780)?;
        }
        list_781.finish();
    }
    #[allow(unused_mut)]
    let mut scope_783 = writer.prefix("IKEVersion");
    if let Some(var_784) = &input.ike_versions {
        let mut list_786 = scope_783.start_list(true, Some("item"));
        for item_785 in var_784 {
            #[allow(unused_mut)]
            let mut entry_787 = list_786.entry();
            crate::query_ser::serialize_structure_crate_model_ike_versions_request_list_value(
                entry_787, item_785,
            )?;
        }
        list_786.finish();
    }
    #[allow(unused_mut)]
    let mut scope_788 = writer.prefix("StartupAction");
    if let Some(var_789) = &input.startup_action {
        scope_788.string(var_789);
    }
    #[allow(unused_mut)]
    let mut scope_790 = writer.prefix("LogOptions");
    if let Some(var_791) = &input.log_options {
        crate::query_ser::serialize_structure_crate_model_vpn_tunnel_log_options_specification(
            scope_790, var_791,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_cidr_authorization_context(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CidrAuthorizationContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_792 = writer.prefix("Message");
    if let Some(var_793) = &input.message {
        scope_792.string(var_793);
    }
    #[allow(unused_mut)]
    let mut scope_794 = writer.prefix("Signature");
    if let Some(var_795) = &input.signature {
        scope_794.string(var_795);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ipam_cidr_authorization_context(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::IpamCidrAuthorizationContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_796 = writer.prefix("Message");
    if let Some(var_797) = &input.message {
        scope_796.string(var_797);
    }
    #[allow(unused_mut)]
    let mut scope_798 = writer.prefix("Signature");
    if let Some(var_799) = &input.signature {
        scope_798.string(var_799);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_reserved_instance_limit_price(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ReservedInstanceLimitPrice,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_800 = writer.prefix("Amount");
    if let Some(var_801) = &input.amount {
        scope_800.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_801).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_802 = writer.prefix("CurrencyCode");
    if let Some(var_803) = &input.currency_code {
        scope_802.string(var_803.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_purchase_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PurchaseRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_804 = writer.prefix("InstanceCount");
    if let Some(var_805) = &input.instance_count {
        scope_804.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_805).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_806 = writer.prefix("PurchaseToken");
    if let Some(var_807) = &input.purchase_token {
        scope_806.string(var_807);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_register_instance_tag_attribute_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::RegisterInstanceTagAttributeRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_808 = writer.prefix("IncludeAllTagsOfInstance");
    if let Some(var_809) = &input.include_all_tags_of_instance {
        scope_808.boolean(*var_809);
    }
    #[allow(unused_mut)]
    let mut scope_810 = writer.prefix("InstanceTagKey");
    if let Some(var_811) = &input.instance_tag_keys {
        let mut list_813 = scope_810.start_list(true, Some("item"));
        for item_812 in var_811 {
            #[allow(unused_mut)]
            let mut entry_814 = list_813.entry();
            entry_814.string(item_812);
        }
        list_813.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_fleet_request_config_data(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SpotFleetRequestConfigData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_815 = writer.prefix("AllocationStrategy");
    if let Some(var_816) = &input.allocation_strategy {
        scope_815.string(var_816.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_817 = writer.prefix("OnDemandAllocationStrategy");
    if let Some(var_818) = &input.on_demand_allocation_strategy {
        scope_817.string(var_818.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_819 = writer.prefix("SpotMaintenanceStrategies");
    if let Some(var_820) = &input.spot_maintenance_strategies {
        crate::query_ser::serialize_structure_crate_model_spot_maintenance_strategies(
            scope_819, var_820,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_821 = writer.prefix("ClientToken");
    if let Some(var_822) = &input.client_token {
        scope_821.string(var_822);
    }
    #[allow(unused_mut)]
    let mut scope_823 = writer.prefix("ExcessCapacityTerminationPolicy");
    if let Some(var_824) = &input.excess_capacity_termination_policy {
        scope_823.string(var_824.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_825 = writer.prefix("FulfilledCapacity");
    if let Some(var_826) = &input.fulfilled_capacity {
        scope_825.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_826).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_827 = writer.prefix("OnDemandFulfilledCapacity");
    if let Some(var_828) = &input.on_demand_fulfilled_capacity {
        scope_827.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_828).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_829 = writer.prefix("IamFleetRole");
    if let Some(var_830) = &input.iam_fleet_role {
        scope_829.string(var_830);
    }
    #[allow(unused_mut)]
    let mut scope_831 = writer.prefix("LaunchSpecifications");
    if let Some(var_832) = &input.launch_specifications {
        let mut list_834 = scope_831.start_list(true, Some("item"));
        for item_833 in var_832 {
            #[allow(unused_mut)]
            let mut entry_835 = list_834.entry();
            crate::query_ser::serialize_structure_crate_model_spot_fleet_launch_specification(
                entry_835, item_833,
            )?;
        }
        list_834.finish();
    }
    #[allow(unused_mut)]
    let mut scope_836 = writer.prefix("LaunchTemplateConfigs");
    if let Some(var_837) = &input.launch_template_configs {
        let mut list_839 = scope_836.start_list(true, Some("item"));
        for item_838 in var_837 {
            #[allow(unused_mut)]
            let mut entry_840 = list_839.entry();
            crate::query_ser::serialize_structure_crate_model_launch_template_config(
                entry_840, item_838,
            )?;
        }
        list_839.finish();
    }
    #[allow(unused_mut)]
    let mut scope_841 = writer.prefix("SpotPrice");
    if let Some(var_842) = &input.spot_price {
        scope_841.string(var_842);
    }
    #[allow(unused_mut)]
    let mut scope_843 = writer.prefix("TargetCapacity");
    if let Some(var_844) = &input.target_capacity {
        scope_843.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_844).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_845 = writer.prefix("OnDemandTargetCapacity");
    if let Some(var_846) = &input.on_demand_target_capacity {
        scope_845.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_846).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_847 = writer.prefix("OnDemandMaxTotalPrice");
    if let Some(var_848) = &input.on_demand_max_total_price {
        scope_847.string(var_848);
    }
    #[allow(unused_mut)]
    let mut scope_849 = writer.prefix("SpotMaxTotalPrice");
    if let Some(var_850) = &input.spot_max_total_price {
        scope_849.string(var_850);
    }
    #[allow(unused_mut)]
    let mut scope_851 = writer.prefix("TerminateInstancesWithExpiration");
    if let Some(var_852) = &input.terminate_instances_with_expiration {
        scope_851.boolean(*var_852);
    }
    #[allow(unused_mut)]
    let mut scope_853 = writer.prefix("Type");
    if let Some(var_854) = &input.r#type {
        scope_853.string(var_854.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_855 = writer.prefix("ValidFrom");
    if let Some(var_856) = &input.valid_from {
        scope_855.date_time(var_856, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_857 = writer.prefix("ValidUntil");
    if let Some(var_858) = &input.valid_until {
        scope_857.date_time(var_858, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_859 = writer.prefix("ReplaceUnhealthyInstances");
    if let Some(var_860) = &input.replace_unhealthy_instances {
        scope_859.boolean(*var_860);
    }
    #[allow(unused_mut)]
    let mut scope_861 = writer.prefix("InstanceInterruptionBehavior");
    if let Some(var_862) = &input.instance_interruption_behavior {
        scope_861.string(var_862.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_863 = writer.prefix("LoadBalancersConfig");
    if let Some(var_864) = &input.load_balancers_config {
        crate::query_ser::serialize_structure_crate_model_load_balancers_config(
            scope_863, var_864,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_865 = writer.prefix("InstancePoolsToUseCount");
    if let Some(var_866) = &input.instance_pools_to_use_count {
        scope_865.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_866).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_867 = writer.prefix("Context");
    if let Some(var_868) = &input.context {
        scope_867.string(var_868);
    }
    #[allow(unused_mut)]
    let mut scope_869 = writer.prefix("TargetCapacityUnitType");
    if let Some(var_870) = &input.target_capacity_unit_type {
        scope_869.string(var_870.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_871 = writer.prefix("TagSpecification");
    if let Some(var_872) = &input.tag_specifications {
        let mut list_874 = scope_871.start_list(true, Some("item"));
        for item_873 in var_872 {
            #[allow(unused_mut)]
            let mut entry_875 = list_874.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_875, item_873,
            )?;
        }
        list_874.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_request_spot_launch_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::RequestSpotLaunchSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_876 = writer.prefix("SecurityGroupId");
    if let Some(var_877) = &input.security_group_ids {
        let mut list_879 = scope_876.start_list(true, Some("item"));
        for item_878 in var_877 {
            #[allow(unused_mut)]
            let mut entry_880 = list_879.entry();
            entry_880.string(item_878);
        }
        list_879.finish();
    }
    #[allow(unused_mut)]
    let mut scope_881 = writer.prefix("SecurityGroup");
    if let Some(var_882) = &input.security_groups {
        let mut list_884 = scope_881.start_list(true, Some("item"));
        for item_883 in var_882 {
            #[allow(unused_mut)]
            let mut entry_885 = list_884.entry();
            entry_885.string(item_883);
        }
        list_884.finish();
    }
    #[allow(unused_mut)]
    let mut scope_886 = writer.prefix("AddressingType");
    if let Some(var_887) = &input.addressing_type {
        scope_886.string(var_887);
    }
    #[allow(unused_mut)]
    let mut scope_888 = writer.prefix("BlockDeviceMapping");
    if let Some(var_889) = &input.block_device_mappings {
        let mut list_891 = scope_888.start_list(true, Some("item"));
        for item_890 in var_889 {
            #[allow(unused_mut)]
            let mut entry_892 = list_891.entry();
            crate::query_ser::serialize_structure_crate_model_block_device_mapping(
                entry_892, item_890,
            )?;
        }
        list_891.finish();
    }
    #[allow(unused_mut)]
    let mut scope_893 = writer.prefix("EbsOptimized");
    if let Some(var_894) = &input.ebs_optimized {
        scope_893.boolean(*var_894);
    }
    #[allow(unused_mut)]
    let mut scope_895 = writer.prefix("IamInstanceProfile");
    if let Some(var_896) = &input.iam_instance_profile {
        crate::query_ser::serialize_structure_crate_model_iam_instance_profile_specification(
            scope_895, var_896,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_897 = writer.prefix("ImageId");
    if let Some(var_898) = &input.image_id {
        scope_897.string(var_898);
    }
    #[allow(unused_mut)]
    let mut scope_899 = writer.prefix("InstanceType");
    if let Some(var_900) = &input.instance_type {
        scope_899.string(var_900.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_901 = writer.prefix("KernelId");
    if let Some(var_902) = &input.kernel_id {
        scope_901.string(var_902);
    }
    #[allow(unused_mut)]
    let mut scope_903 = writer.prefix("KeyName");
    if let Some(var_904) = &input.key_name {
        scope_903.string(var_904);
    }
    #[allow(unused_mut)]
    let mut scope_905 = writer.prefix("Monitoring");
    if let Some(var_906) = &input.monitoring {
        crate::query_ser::serialize_structure_crate_model_run_instances_monitoring_enabled(
            scope_905, var_906,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_907 = writer.prefix("NetworkInterface");
    if let Some(var_908) = &input.network_interfaces {
        let mut list_910 = scope_907.start_list(true, Some("item"));
        for item_909 in var_908 {
            #[allow(unused_mut)]
            let mut entry_911 = list_910.entry();
            crate::query_ser::serialize_structure_crate_model_instance_network_interface_specification(entry_911, item_909)?;
        }
        list_910.finish();
    }
    #[allow(unused_mut)]
    let mut scope_912 = writer.prefix("Placement");
    if let Some(var_913) = &input.placement {
        crate::query_ser::serialize_structure_crate_model_spot_placement(scope_912, var_913)?;
    }
    #[allow(unused_mut)]
    let mut scope_914 = writer.prefix("RamdiskId");
    if let Some(var_915) = &input.ramdisk_id {
        scope_914.string(var_915);
    }
    #[allow(unused_mut)]
    let mut scope_916 = writer.prefix("SubnetId");
    if let Some(var_917) = &input.subnet_id {
        scope_916.string(var_917);
    }
    #[allow(unused_mut)]
    let mut scope_918 = writer.prefix("UserData");
    if let Some(var_919) = &input.user_data {
        scope_918.string(var_919);
    }
    Ok(())
}

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

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_placement(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Placement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_922 = writer.prefix("AvailabilityZone");
    if let Some(var_923) = &input.availability_zone {
        scope_922.string(var_923);
    }
    #[allow(unused_mut)]
    let mut scope_924 = writer.prefix("Affinity");
    if let Some(var_925) = &input.affinity {
        scope_924.string(var_925);
    }
    #[allow(unused_mut)]
    let mut scope_926 = writer.prefix("GroupName");
    if let Some(var_927) = &input.group_name {
        scope_926.string(var_927);
    }
    #[allow(unused_mut)]
    let mut scope_928 = writer.prefix("PartitionNumber");
    if let Some(var_929) = &input.partition_number {
        scope_928.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_929).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_930 = writer.prefix("HostId");
    if let Some(var_931) = &input.host_id {
        scope_930.string(var_931);
    }
    #[allow(unused_mut)]
    let mut scope_932 = writer.prefix("Tenancy");
    if let Some(var_933) = &input.tenancy {
        scope_932.string(var_933.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_934 = writer.prefix("SpreadDomain");
    if let Some(var_935) = &input.spread_domain {
        scope_934.string(var_935);
    }
    #[allow(unused_mut)]
    let mut scope_936 = writer.prefix("HostResourceGroupArn");
    if let Some(var_937) = &input.host_resource_group_arn {
        scope_936.string(var_937);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_network_interface_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceNetworkInterfaceSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_938 = writer.prefix("AssociatePublicIpAddress");
    if let Some(var_939) = &input.associate_public_ip_address {
        scope_938.boolean(*var_939);
    }
    #[allow(unused_mut)]
    let mut scope_940 = writer.prefix("DeleteOnTermination");
    if let Some(var_941) = &input.delete_on_termination {
        scope_940.boolean(*var_941);
    }
    #[allow(unused_mut)]
    let mut scope_942 = writer.prefix("Description");
    if let Some(var_943) = &input.description {
        scope_942.string(var_943);
    }
    #[allow(unused_mut)]
    let mut scope_944 = writer.prefix("DeviceIndex");
    if let Some(var_945) = &input.device_index {
        scope_944.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_945).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_946 = writer.prefix("SecurityGroupId");
    if let Some(var_947) = &input.groups {
        let mut list_949 = scope_946.start_list(true, Some("SecurityGroupId"));
        for item_948 in var_947 {
            #[allow(unused_mut)]
            let mut entry_950 = list_949.entry();
            entry_950.string(item_948);
        }
        list_949.finish();
    }
    #[allow(unused_mut)]
    let mut scope_951 = writer.prefix("Ipv6AddressCount");
    if let Some(var_952) = &input.ipv6_address_count {
        scope_951.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_952).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_953 = writer.prefix("Ipv6Addresses");
    if let Some(var_954) = &input.ipv6_addresses {
        let mut list_956 = scope_953.start_list(true, Some("item"));
        for item_955 in var_954 {
            #[allow(unused_mut)]
            let mut entry_957 = list_956.entry();
            crate::query_ser::serialize_structure_crate_model_instance_ipv6_address(
                entry_957, item_955,
            )?;
        }
        list_956.finish();
    }
    #[allow(unused_mut)]
    let mut scope_958 = writer.prefix("NetworkInterfaceId");
    if let Some(var_959) = &input.network_interface_id {
        scope_958.string(var_959);
    }
    #[allow(unused_mut)]
    let mut scope_960 = writer.prefix("PrivateIpAddress");
    if let Some(var_961) = &input.private_ip_address {
        scope_960.string(var_961);
    }
    #[allow(unused_mut)]
    let mut scope_962 = writer.prefix("PrivateIpAddresses");
    if let Some(var_963) = &input.private_ip_addresses {
        let mut list_965 = scope_962.start_list(true, Some("item"));
        for item_964 in var_963 {
            #[allow(unused_mut)]
            let mut entry_966 = list_965.entry();
            crate::query_ser::serialize_structure_crate_model_private_ip_address_specification(
                entry_966, item_964,
            )?;
        }
        list_965.finish();
    }
    #[allow(unused_mut)]
    let mut scope_967 = writer.prefix("SecondaryPrivateIpAddressCount");
    if let Some(var_968) = &input.secondary_private_ip_address_count {
        scope_967.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_968).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_969 = writer.prefix("SubnetId");
    if let Some(var_970) = &input.subnet_id {
        scope_969.string(var_970);
    }
    #[allow(unused_mut)]
    let mut scope_971 = writer.prefix("AssociateCarrierIpAddress");
    if let Some(var_972) = &input.associate_carrier_ip_address {
        scope_971.boolean(*var_972);
    }
    #[allow(unused_mut)]
    let mut scope_973 = writer.prefix("InterfaceType");
    if let Some(var_974) = &input.interface_type {
        scope_973.string(var_974);
    }
    #[allow(unused_mut)]
    let mut scope_975 = writer.prefix("NetworkCardIndex");
    if let Some(var_976) = &input.network_card_index {
        scope_975.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_976).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_977 = writer.prefix("Ipv4Prefix");
    if let Some(var_978) = &input.ipv4_prefixes {
        let mut list_980 = scope_977.start_list(true, Some("item"));
        for item_979 in var_978 {
            #[allow(unused_mut)]
            let mut entry_981 = list_980.entry();
            crate::query_ser::serialize_structure_crate_model_ipv4_prefix_specification_request(
                entry_981, item_979,
            )?;
        }
        list_980.finish();
    }
    #[allow(unused_mut)]
    let mut scope_982 = writer.prefix("Ipv4PrefixCount");
    if let Some(var_983) = &input.ipv4_prefix_count {
        scope_982.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_983).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_984 = writer.prefix("Ipv6Prefix");
    if let Some(var_985) = &input.ipv6_prefixes {
        let mut list_987 = scope_984.start_list(true, Some("item"));
        for item_986 in var_985 {
            #[allow(unused_mut)]
            let mut entry_988 = list_987.entry();
            crate::query_ser::serialize_structure_crate_model_ipv6_prefix_specification_request(
                entry_988, item_986,
            )?;
        }
        list_987.finish();
    }
    #[allow(unused_mut)]
    let mut scope_989 = writer.prefix("Ipv6PrefixCount");
    if let Some(var_990) = &input.ipv6_prefix_count {
        scope_989.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_990).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_elastic_gpu_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ElasticGpuSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_991 = writer.prefix("Type");
    if let Some(var_992) = &input.r#type {
        scope_991.string(var_992);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_elastic_inference_accelerator(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ElasticInferenceAccelerator,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_993 = writer.prefix("Type");
    if let Some(var_994) = &input.r#type {
        scope_993.string(var_994);
    }
    #[allow(unused_mut)]
    let mut scope_995 = writer.prefix("Count");
    if let Some(var_996) = &input.count {
        scope_995.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_996).into()),
        );
    }
    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_997 = writer.prefix("LaunchTemplateId");
    if let Some(var_998) = &input.launch_template_id {
        scope_997.string(var_998);
    }
    #[allow(unused_mut)]
    let mut scope_999 = writer.prefix("LaunchTemplateName");
    if let Some(var_1000) = &input.launch_template_name {
        scope_999.string(var_1000);
    }
    #[allow(unused_mut)]
    let mut scope_1001 = writer.prefix("Version");
    if let Some(var_1002) = &input.version {
        scope_1001.string(var_1002);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_market_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceMarketOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1003 = writer.prefix("MarketType");
    if let Some(var_1004) = &input.market_type {
        scope_1003.string(var_1004.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1005 = writer.prefix("SpotOptions");
    if let Some(var_1006) = &input.spot_options {
        crate::query_ser::serialize_structure_crate_model_spot_market_options(
            scope_1005, var_1006,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_credit_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CreditSpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1007 = writer.prefix("CpuCredits");
    if let Some(var_1008) = &input.cpu_credits {
        scope_1007.string(var_1008);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_cpu_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CpuOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1009 = writer.prefix("CoreCount");
    if let Some(var_1010) = &input.core_count {
        scope_1009.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1010).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1011 = writer.prefix("ThreadsPerCore");
    if let Some(var_1012) = &input.threads_per_core {
        scope_1011.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1012).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_hibernation_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::HibernationOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1013 = writer.prefix("Configured");
    if let Some(var_1014) = &input.configured {
        scope_1013.boolean(*var_1014);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_license_configuration_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LicenseConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1015 = writer.prefix("LicenseConfigurationArn");
    if let Some(var_1016) = &input.license_configuration_arn {
        scope_1015.string(var_1016);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_metadata_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceMetadataOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1017 = writer.prefix("HttpTokens");
    if let Some(var_1018) = &input.http_tokens {
        scope_1017.string(var_1018.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1019 = writer.prefix("HttpPutResponseHopLimit");
    if let Some(var_1020) = &input.http_put_response_hop_limit {
        scope_1019.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1020).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1021 = writer.prefix("HttpEndpoint");
    if let Some(var_1022) = &input.http_endpoint {
        scope_1021.string(var_1022.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1023 = writer.prefix("HttpProtocolIpv6");
    if let Some(var_1024) = &input.http_protocol_ipv6 {
        scope_1023.string(var_1024.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1025 = writer.prefix("InstanceMetadataTags");
    if let Some(var_1026) = &input.instance_metadata_tags {
        scope_1025.string(var_1026.as_str());
    }
    Ok(())
}

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

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_private_dns_name_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PrivateDnsNameOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1029 = writer.prefix("HostnameType");
    if let Some(var_1030) = &input.hostname_type {
        scope_1029.string(var_1030.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1031 = writer.prefix("EnableResourceNameDnsARecord");
    if let Some(var_1032) = &input.enable_resource_name_dns_a_record {
        scope_1031.boolean(*var_1032);
    }
    #[allow(unused_mut)]
    let mut scope_1033 = writer.prefix("EnableResourceNameDnsAAAARecord");
    if let Some(var_1034) = &input.enable_resource_name_dns_aaaa_record {
        scope_1033.boolean(*var_1034);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_maintenance_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceMaintenanceOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1035 = writer.prefix("AutoRecovery");
    if let Some(var_1036) = &input.auto_recovery {
        scope_1035.string(var_1036.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_launch_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ScheduledInstancesLaunchSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1037 = writer.prefix("BlockDeviceMapping");
    if let Some(var_1038) = &input.block_device_mappings {
        let mut list_1040 = scope_1037.start_list(true, Some("BlockDeviceMapping"));
        for item_1039 in var_1038 {
            #[allow(unused_mut)]
            let mut entry_1041 = list_1040.entry();
            crate::query_ser::serialize_structure_crate_model_scheduled_instances_block_device_mapping(entry_1041, item_1039)?;
        }
        list_1040.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1042 = writer.prefix("EbsOptimized");
    if let Some(var_1043) = &input.ebs_optimized {
        scope_1042.boolean(*var_1043);
    }
    #[allow(unused_mut)]
    let mut scope_1044 = writer.prefix("IamInstanceProfile");
    if let Some(var_1045) = &input.iam_instance_profile {
        crate::query_ser::serialize_structure_crate_model_scheduled_instances_iam_instance_profile(
            scope_1044, var_1045,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1046 = writer.prefix("ImageId");
    if let Some(var_1047) = &input.image_id {
        scope_1046.string(var_1047);
    }
    #[allow(unused_mut)]
    let mut scope_1048 = writer.prefix("InstanceType");
    if let Some(var_1049) = &input.instance_type {
        scope_1048.string(var_1049);
    }
    #[allow(unused_mut)]
    let mut scope_1050 = writer.prefix("KernelId");
    if let Some(var_1051) = &input.kernel_id {
        scope_1050.string(var_1051);
    }
    #[allow(unused_mut)]
    let mut scope_1052 = writer.prefix("KeyName");
    if let Some(var_1053) = &input.key_name {
        scope_1052.string(var_1053);
    }
    #[allow(unused_mut)]
    let mut scope_1054 = writer.prefix("Monitoring");
    if let Some(var_1055) = &input.monitoring {
        crate::query_ser::serialize_structure_crate_model_scheduled_instances_monitoring(
            scope_1054, var_1055,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1056 = writer.prefix("NetworkInterface");
    if let Some(var_1057) = &input.network_interfaces {
        let mut list_1059 = scope_1056.start_list(true, Some("NetworkInterface"));
        for item_1058 in var_1057 {
            #[allow(unused_mut)]
            let mut entry_1060 = list_1059.entry();
            crate::query_ser::serialize_structure_crate_model_scheduled_instances_network_interface(entry_1060, item_1058)?;
        }
        list_1059.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1061 = writer.prefix("Placement");
    if let Some(var_1062) = &input.placement {
        crate::query_ser::serialize_structure_crate_model_scheduled_instances_placement(
            scope_1061, var_1062,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1063 = writer.prefix("RamdiskId");
    if let Some(var_1064) = &input.ramdisk_id {
        scope_1063.string(var_1064);
    }
    #[allow(unused_mut)]
    let mut scope_1065 = writer.prefix("SecurityGroupId");
    if let Some(var_1066) = &input.security_group_ids {
        let mut list_1068 = scope_1065.start_list(true, Some("SecurityGroupId"));
        for item_1067 in var_1066 {
            #[allow(unused_mut)]
            let mut entry_1069 = list_1068.entry();
            entry_1069.string(item_1067);
        }
        list_1068.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1070 = writer.prefix("SubnetId");
    if let Some(var_1071) = &input.subnet_id {
        scope_1070.string(var_1071);
    }
    #[allow(unused_mut)]
    let mut scope_1072 = writer.prefix("UserData");
    if let Some(var_1073) = &input.user_data {
        scope_1072.string(var_1073);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_security_group_rule_description(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SecurityGroupRuleDescription,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1074 = writer.prefix("SecurityGroupRuleId");
    if let Some(var_1075) = &input.security_group_rule_id {
        scope_1074.string(var_1075);
    }
    #[allow(unused_mut)]
    let mut scope_1076 = writer.prefix("Description");
    if let Some(var_1077) = &input.description {
        scope_1076.string(var_1077);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ip_range(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::IpRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1078 = writer.prefix("CidrIp");
    if let Some(var_1079) = &input.cidr_ip {
        scope_1078.string(var_1079);
    }
    #[allow(unused_mut)]
    let mut scope_1080 = writer.prefix("Description");
    if let Some(var_1081) = &input.description {
        scope_1080.string(var_1081);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ipv6_range(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Ipv6Range,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1082 = writer.prefix("CidrIpv6");
    if let Some(var_1083) = &input.cidr_ipv6 {
        scope_1082.string(var_1083);
    }
    #[allow(unused_mut)]
    let mut scope_1084 = writer.prefix("Description");
    if let Some(var_1085) = &input.description {
        scope_1084.string(var_1085);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_prefix_list_id(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PrefixListId,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1086 = writer.prefix("Description");
    if let Some(var_1087) = &input.description {
        scope_1086.string(var_1087);
    }
    #[allow(unused_mut)]
    let mut scope_1088 = writer.prefix("PrefixListId");
    if let Some(var_1089) = &input.prefix_list_id {
        scope_1088.string(var_1089);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_user_id_group_pair(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::UserIdGroupPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1090 = writer.prefix("Description");
    if let Some(var_1091) = &input.description {
        scope_1090.string(var_1091);
    }
    #[allow(unused_mut)]
    let mut scope_1092 = writer.prefix("GroupId");
    if let Some(var_1093) = &input.group_id {
        scope_1092.string(var_1093);
    }
    #[allow(unused_mut)]
    let mut scope_1094 = writer.prefix("GroupName");
    if let Some(var_1095) = &input.group_name {
        scope_1094.string(var_1095);
    }
    #[allow(unused_mut)]
    let mut scope_1096 = writer.prefix("PeeringStatus");
    if let Some(var_1097) = &input.peering_status {
        scope_1096.string(var_1097);
    }
    #[allow(unused_mut)]
    let mut scope_1098 = writer.prefix("UserId");
    if let Some(var_1099) = &input.user_id {
        scope_1098.string(var_1099);
    }
    #[allow(unused_mut)]
    let mut scope_1100 = writer.prefix("VpcId");
    if let Some(var_1101) = &input.vpc_id {
        scope_1100.string(var_1101);
    }
    #[allow(unused_mut)]
    let mut scope_1102 = writer.prefix("VpcPeeringConnectionId");
    if let Some(var_1103) = &input.vpc_peering_connection_id {
        scope_1102.string(var_1103);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_s3_storage(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::S3Storage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1104 = writer.prefix("AWSAccessKeyId");
    if let Some(var_1105) = &input.aws_access_key_id {
        scope_1104.string(var_1105);
    }
    #[allow(unused_mut)]
    let mut scope_1106 = writer.prefix("Bucket");
    if let Some(var_1107) = &input.bucket {
        scope_1106.string(var_1107);
    }
    #[allow(unused_mut)]
    let mut scope_1108 = writer.prefix("Prefix");
    if let Some(var_1109) = &input.prefix {
        scope_1108.string(var_1109);
    }
    #[allow(unused_mut)]
    let mut scope_1110 = writer.prefix("UploadPolicy");
    if let Some(var_1111) = &input.upload_policy {
        scope_1110.string(&aws_smithy_types::base64::encode(var_1111));
    }
    #[allow(unused_mut)]
    let mut scope_1112 = writer.prefix("UploadPolicySignature");
    if let Some(var_1113) = &input.upload_policy_signature {
        scope_1112.string(var_1113);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_directory_service_authentication_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::DirectoryServiceAuthenticationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1114 = writer.prefix("DirectoryId");
    if let Some(var_1115) = &input.directory_id {
        scope_1114.string(var_1115);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_certificate_authentication_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CertificateAuthenticationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1116 = writer.prefix("ClientRootCertificateChainArn");
    if let Some(var_1117) = &input.client_root_certificate_chain_arn {
        scope_1116.string(var_1117);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_federated_authentication_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::FederatedAuthenticationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1118 = writer.prefix("SAMLProviderArn");
    if let Some(var_1119) = &input.saml_provider_arn {
        scope_1118.string(var_1119);
    }
    #[allow(unused_mut)]
    let mut scope_1120 = writer.prefix("SelfServiceSAMLProviderArn");
    if let Some(var_1121) = &input.self_service_saml_provider_arn {
        scope_1120.string(var_1121);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_spot_maintenance_strategies_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::FleetSpotMaintenanceStrategiesRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1122 = writer.prefix("CapacityRebalance");
    if let Some(var_1123) = &input.capacity_rebalance {
        crate::query_ser::serialize_structure_crate_model_fleet_spot_capacity_rebalance_request(
            scope_1122, var_1123,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_capacity_reservation_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CapacityReservationOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1124 = writer.prefix("UsageStrategy");
    if let Some(var_1125) = &input.usage_strategy {
        scope_1124.string(var_1125.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_launch_template_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::FleetLaunchTemplateSpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1126 = writer.prefix("LaunchTemplateId");
    if let Some(var_1127) = &input.launch_template_id {
        scope_1126.string(var_1127);
    }
    #[allow(unused_mut)]
    let mut scope_1128 = writer.prefix("LaunchTemplateName");
    if let Some(var_1129) = &input.launch_template_name {
        scope_1128.string(var_1129);
    }
    #[allow(unused_mut)]
    let mut scope_1130 = writer.prefix("Version");
    if let Some(var_1131) = &input.version {
        scope_1130.string(var_1131);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_launch_template_overrides_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::FleetLaunchTemplateOverridesRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1132 = writer.prefix("InstanceType");
    if let Some(var_1133) = &input.instance_type {
        scope_1132.string(var_1133.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1134 = writer.prefix("MaxPrice");
    if let Some(var_1135) = &input.max_price {
        scope_1134.string(var_1135);
    }
    #[allow(unused_mut)]
    let mut scope_1136 = writer.prefix("SubnetId");
    if let Some(var_1137) = &input.subnet_id {
        scope_1136.string(var_1137);
    }
    #[allow(unused_mut)]
    let mut scope_1138 = writer.prefix("AvailabilityZone");
    if let Some(var_1139) = &input.availability_zone {
        scope_1138.string(var_1139);
    }
    #[allow(unused_mut)]
    let mut scope_1140 = writer.prefix("WeightedCapacity");
    if let Some(var_1141) = &input.weighted_capacity {
        scope_1140.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1141).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1142 = writer.prefix("Priority");
    if let Some(var_1143) = &input.priority {
        scope_1142.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1143).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1144 = writer.prefix("Placement");
    if let Some(var_1145) = &input.placement {
        crate::query_ser::serialize_structure_crate_model_placement(scope_1144, var_1145)?;
    }
    #[allow(unused_mut)]
    let mut scope_1146 = writer.prefix("InstanceRequirements");
    if let Some(var_1147) = &input.instance_requirements {
        crate::query_ser::serialize_structure_crate_model_instance_requirements_request(
            scope_1146, var_1147,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1148 = writer.prefix("ImageId");
    if let Some(var_1149) = &input.image_id {
        scope_1148.string(var_1149);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ebs_block_device(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::EbsBlockDevice,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1150 = writer.prefix("DeleteOnTermination");
    if let Some(var_1151) = &input.delete_on_termination {
        scope_1150.boolean(*var_1151);
    }
    #[allow(unused_mut)]
    let mut scope_1152 = writer.prefix("Iops");
    if let Some(var_1153) = &input.iops {
        scope_1152.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1153).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1154 = writer.prefix("SnapshotId");
    if let Some(var_1155) = &input.snapshot_id {
        scope_1154.string(var_1155);
    }
    #[allow(unused_mut)]
    let mut scope_1156 = writer.prefix("VolumeSize");
    if let Some(var_1157) = &input.volume_size {
        scope_1156.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1157).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1158 = writer.prefix("VolumeType");
    if let Some(var_1159) = &input.volume_type {
        scope_1158.string(var_1159.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1160 = writer.prefix("KmsKeyId");
    if let Some(var_1161) = &input.kms_key_id {
        scope_1160.string(var_1161);
    }
    #[allow(unused_mut)]
    let mut scope_1162 = writer.prefix("Throughput");
    if let Some(var_1163) = &input.throughput {
        scope_1162.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1163).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1164 = writer.prefix("OutpostArn");
    if let Some(var_1165) = &input.outpost_arn {
        scope_1164.string(var_1165);
    }
    #[allow(unused_mut)]
    let mut scope_1166 = writer.prefix("Encrypted");
    if let Some(var_1167) = &input.encrypted {
        scope_1166.boolean(*var_1167);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_iam_instance_profile_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateIamInstanceProfileSpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1168 = writer.prefix("Arn");
    if let Some(var_1169) = &input.arn {
        scope_1168.string(var_1169);
    }
    #[allow(unused_mut)]
    let mut scope_1170 = writer.prefix("Name");
    if let Some(var_1171) = &input.name {
        scope_1170.string(var_1171);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_block_device_mapping_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateBlockDeviceMappingRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1172 = writer.prefix("DeviceName");
    if let Some(var_1173) = &input.device_name {
        scope_1172.string(var_1173);
    }
    #[allow(unused_mut)]
    let mut scope_1174 = writer.prefix("VirtualName");
    if let Some(var_1175) = &input.virtual_name {
        scope_1174.string(var_1175);
    }
    #[allow(unused_mut)]
    let mut scope_1176 = writer.prefix("Ebs");
    if let Some(var_1177) = &input.ebs {
        crate::query_ser::serialize_structure_crate_model_launch_template_ebs_block_device_request(
            scope_1176, var_1177,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1178 = writer.prefix("NoDevice");
    if let Some(var_1179) = &input.no_device {
        scope_1178.string(var_1179);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_instance_network_interface_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateInstanceNetworkInterfaceSpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1180 = writer.prefix("AssociateCarrierIpAddress");
    if let Some(var_1181) = &input.associate_carrier_ip_address {
        scope_1180.boolean(*var_1181);
    }
    #[allow(unused_mut)]
    let mut scope_1182 = writer.prefix("AssociatePublicIpAddress");
    if let Some(var_1183) = &input.associate_public_ip_address {
        scope_1182.boolean(*var_1183);
    }
    #[allow(unused_mut)]
    let mut scope_1184 = writer.prefix("DeleteOnTermination");
    if let Some(var_1185) = &input.delete_on_termination {
        scope_1184.boolean(*var_1185);
    }
    #[allow(unused_mut)]
    let mut scope_1186 = writer.prefix("Description");
    if let Some(var_1187) = &input.description {
        scope_1186.string(var_1187);
    }
    #[allow(unused_mut)]
    let mut scope_1188 = writer.prefix("DeviceIndex");
    if let Some(var_1189) = &input.device_index {
        scope_1188.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1189).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1190 = writer.prefix("SecurityGroupId");
    if let Some(var_1191) = &input.groups {
        let mut list_1193 = scope_1190.start_list(true, Some("SecurityGroupId"));
        for item_1192 in var_1191 {
            #[allow(unused_mut)]
            let mut entry_1194 = list_1193.entry();
            entry_1194.string(item_1192);
        }
        list_1193.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1195 = writer.prefix("InterfaceType");
    if let Some(var_1196) = &input.interface_type {
        scope_1195.string(var_1196);
    }
    #[allow(unused_mut)]
    let mut scope_1197 = writer.prefix("Ipv6AddressCount");
    if let Some(var_1198) = &input.ipv6_address_count {
        scope_1197.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1198).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1199 = writer.prefix("Ipv6Addresses");
    if let Some(var_1200) = &input.ipv6_addresses {
        let mut list_1202 = scope_1199.start_list(true, Some("InstanceIpv6Address"));
        for item_1201 in var_1200 {
            #[allow(unused_mut)]
            let mut entry_1203 = list_1202.entry();
            crate::query_ser::serialize_structure_crate_model_instance_ipv6_address_request(
                entry_1203, item_1201,
            )?;
        }
        list_1202.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1204 = writer.prefix("NetworkInterfaceId");
    if let Some(var_1205) = &input.network_interface_id {
        scope_1204.string(var_1205);
    }
    #[allow(unused_mut)]
    let mut scope_1206 = writer.prefix("PrivateIpAddress");
    if let Some(var_1207) = &input.private_ip_address {
        scope_1206.string(var_1207);
    }
    #[allow(unused_mut)]
    let mut scope_1208 = writer.prefix("PrivateIpAddresses");
    if let Some(var_1209) = &input.private_ip_addresses {
        let mut list_1211 = scope_1208.start_list(true, Some("item"));
        for item_1210 in var_1209 {
            #[allow(unused_mut)]
            let mut entry_1212 = list_1211.entry();
            crate::query_ser::serialize_structure_crate_model_private_ip_address_specification(
                entry_1212, item_1210,
            )?;
        }
        list_1211.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1213 = writer.prefix("SecondaryPrivateIpAddressCount");
    if let Some(var_1214) = &input.secondary_private_ip_address_count {
        scope_1213.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1214).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1215 = writer.prefix("SubnetId");
    if let Some(var_1216) = &input.subnet_id {
        scope_1215.string(var_1216);
    }
    #[allow(unused_mut)]
    let mut scope_1217 = writer.prefix("NetworkCardIndex");
    if let Some(var_1218) = &input.network_card_index {
        scope_1217.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1218).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1219 = writer.prefix("Ipv4Prefix");
    if let Some(var_1220) = &input.ipv4_prefixes {
        let mut list_1222 = scope_1219.start_list(true, Some("item"));
        for item_1221 in var_1220 {
            #[allow(unused_mut)]
            let mut entry_1223 = list_1222.entry();
            crate::query_ser::serialize_structure_crate_model_ipv4_prefix_specification_request(
                entry_1223, item_1221,
            )?;
        }
        list_1222.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1224 = writer.prefix("Ipv4PrefixCount");
    if let Some(var_1225) = &input.ipv4_prefix_count {
        scope_1224.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1225).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1226 = writer.prefix("Ipv6Prefix");
    if let Some(var_1227) = &input.ipv6_prefixes {
        let mut list_1229 = scope_1226.start_list(true, Some("item"));
        for item_1228 in var_1227 {
            #[allow(unused_mut)]
            let mut entry_1230 = list_1229.entry();
            crate::query_ser::serialize_structure_crate_model_ipv6_prefix_specification_request(
                entry_1230, item_1228,
            )?;
        }
        list_1229.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1231 = writer.prefix("Ipv6PrefixCount");
    if let Some(var_1232) = &input.ipv6_prefix_count {
        scope_1231.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1232).into()),
        );
    }
    Ok(())
}

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

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_placement_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplatePlacementRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1235 = writer.prefix("AvailabilityZone");
    if let Some(var_1236) = &input.availability_zone {
        scope_1235.string(var_1236);
    }
    #[allow(unused_mut)]
    let mut scope_1237 = writer.prefix("Affinity");
    if let Some(var_1238) = &input.affinity {
        scope_1237.string(var_1238);
    }
    #[allow(unused_mut)]
    let mut scope_1239 = writer.prefix("GroupName");
    if let Some(var_1240) = &input.group_name {
        scope_1239.string(var_1240);
    }
    #[allow(unused_mut)]
    let mut scope_1241 = writer.prefix("HostId");
    if let Some(var_1242) = &input.host_id {
        scope_1241.string(var_1242);
    }
    #[allow(unused_mut)]
    let mut scope_1243 = writer.prefix("Tenancy");
    if let Some(var_1244) = &input.tenancy {
        scope_1243.string(var_1244.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1245 = writer.prefix("SpreadDomain");
    if let Some(var_1246) = &input.spread_domain {
        scope_1245.string(var_1246);
    }
    #[allow(unused_mut)]
    let mut scope_1247 = writer.prefix("HostResourceGroupArn");
    if let Some(var_1248) = &input.host_resource_group_arn {
        scope_1247.string(var_1248);
    }
    #[allow(unused_mut)]
    let mut scope_1249 = writer.prefix("PartitionNumber");
    if let Some(var_1250) = &input.partition_number {
        scope_1249.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1250).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_tag_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateTagSpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1251 = writer.prefix("ResourceType");
    if let Some(var_1252) = &input.resource_type {
        scope_1251.string(var_1252.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1253 = writer.prefix("Tag");
    if let Some(var_1254) = &input.tags {
        let mut list_1256 = scope_1253.start_list(true, Some("item"));
        for item_1255 in var_1254 {
            #[allow(unused_mut)]
            let mut entry_1257 = list_1256.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_1257, item_1255)?;
        }
        list_1256.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_elastic_inference_accelerator(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateElasticInferenceAccelerator,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1258 = writer.prefix("Type");
    if let Some(var_1259) = &input.r#type {
        scope_1258.string(var_1259);
    }
    #[allow(unused_mut)]
    let mut scope_1260 = writer.prefix("Count");
    if let Some(var_1261) = &input.count {
        scope_1260.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1261).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_instance_market_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateInstanceMarketOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1262 = writer.prefix("MarketType");
    if let Some(var_1263) = &input.market_type {
        scope_1262.string(var_1263.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1264 = writer.prefix("SpotOptions");
    if let Some(var_1265) = &input.spot_options {
        crate::query_ser::serialize_structure_crate_model_launch_template_spot_market_options_request(scope_1264, var_1265)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_cpu_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateCpuOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1266 = writer.prefix("CoreCount");
    if let Some(var_1267) = &input.core_count {
        scope_1266.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1267).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1268 = writer.prefix("ThreadsPerCore");
    if let Some(var_1269) = &input.threads_per_core {
        scope_1268.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1269).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_capacity_reservation_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateCapacityReservationSpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1270 = writer.prefix("CapacityReservationPreference");
    if let Some(var_1271) = &input.capacity_reservation_preference {
        scope_1270.string(var_1271.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1272 = writer.prefix("CapacityReservationTarget");
    if let Some(var_1273) = &input.capacity_reservation_target {
        crate::query_ser::serialize_structure_crate_model_capacity_reservation_target(
            scope_1272, var_1273,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_license_configuration_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateLicenseConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1274 = writer.prefix("LicenseConfigurationArn");
    if let Some(var_1275) = &input.license_configuration_arn {
        scope_1274.string(var_1275);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_hibernation_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateHibernationOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1276 = writer.prefix("Configured");
    if let Some(var_1277) = &input.configured {
        scope_1276.boolean(*var_1277);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_instance_metadata_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateInstanceMetadataOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1278 = writer.prefix("HttpTokens");
    if let Some(var_1279) = &input.http_tokens {
        scope_1278.string(var_1279.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1280 = writer.prefix("HttpPutResponseHopLimit");
    if let Some(var_1281) = &input.http_put_response_hop_limit {
        scope_1280.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1281).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1282 = writer.prefix("HttpEndpoint");
    if let Some(var_1283) = &input.http_endpoint {
        scope_1282.string(var_1283.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1284 = writer.prefix("HttpProtocolIpv6");
    if let Some(var_1285) = &input.http_protocol_ipv6 {
        scope_1284.string(var_1285.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1286 = writer.prefix("InstanceMetadataTags");
    if let Some(var_1287) = &input.instance_metadata_tags {
        scope_1286.string(var_1287.as_str());
    }
    Ok(())
}

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

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_private_dns_name_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplatePrivateDnsNameOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1290 = writer.prefix("HostnameType");
    if let Some(var_1291) = &input.hostname_type {
        scope_1290.string(var_1291.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1292 = writer.prefix("EnableResourceNameDnsARecord");
    if let Some(var_1293) = &input.enable_resource_name_dns_a_record {
        scope_1292.boolean(*var_1293);
    }
    #[allow(unused_mut)]
    let mut scope_1294 = writer.prefix("EnableResourceNameDnsAAAARecord");
    if let Some(var_1295) = &input.enable_resource_name_dns_aaaa_record {
        scope_1294.boolean(*var_1295);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_instance_maintenance_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateInstanceMaintenanceOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1296 = writer.prefix("AutoRecovery");
    if let Some(var_1297) = &input.auto_recovery {
        scope_1296.string(var_1297.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_path_statement_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PathStatementRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1298 = writer.prefix("PacketHeaderStatement");
    if let Some(var_1299) = &input.packet_header_statement {
        crate::query_ser::serialize_structure_crate_model_packet_header_statement_request(
            scope_1298, var_1299,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1300 = writer.prefix("ResourceStatement");
    if let Some(var_1301) = &input.resource_statement {
        crate::query_ser::serialize_structure_crate_model_resource_statement_request(
            scope_1300, var_1301,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_through_resources_statement_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ThroughResourcesStatementRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1302 = writer.prefix("ResourceStatement");
    if let Some(var_1303) = &input.resource_statement {
        crate::query_ser::serialize_structure_crate_model_resource_statement_request(
            scope_1302, var_1303,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_vpn_tunnel_options_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::VpnTunnelOptionsSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1304 = writer.prefix("TunnelInsideCidr");
    if let Some(var_1305) = &input.tunnel_inside_cidr {
        scope_1304.string(var_1305);
    }
    #[allow(unused_mut)]
    let mut scope_1306 = writer.prefix("TunnelInsideIpv6Cidr");
    if let Some(var_1307) = &input.tunnel_inside_ipv6_cidr {
        scope_1306.string(var_1307);
    }
    #[allow(unused_mut)]
    let mut scope_1308 = writer.prefix("PreSharedKey");
    if let Some(var_1309) = &input.pre_shared_key {
        scope_1308.string(var_1309);
    }
    #[allow(unused_mut)]
    let mut scope_1310 = writer.prefix("Phase1LifetimeSeconds");
    if let Some(var_1311) = &input.phase1_lifetime_seconds {
        scope_1310.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1311).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1312 = writer.prefix("Phase2LifetimeSeconds");
    if let Some(var_1313) = &input.phase2_lifetime_seconds {
        scope_1312.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1313).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1314 = writer.prefix("RekeyMarginTimeSeconds");
    if let Some(var_1315) = &input.rekey_margin_time_seconds {
        scope_1314.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1315).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1316 = writer.prefix("RekeyFuzzPercentage");
    if let Some(var_1317) = &input.rekey_fuzz_percentage {
        scope_1316.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1317).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1318 = writer.prefix("ReplayWindowSize");
    if let Some(var_1319) = &input.replay_window_size {
        scope_1318.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1319).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1320 = writer.prefix("DPDTimeoutSeconds");
    if let Some(var_1321) = &input.dpd_timeout_seconds {
        scope_1320.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1321).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1322 = writer.prefix("DPDTimeoutAction");
    if let Some(var_1323) = &input.dpd_timeout_action {
        scope_1322.string(var_1323);
    }
    #[allow(unused_mut)]
    let mut scope_1324 = writer.prefix("Phase1EncryptionAlgorithm");
    if let Some(var_1325) = &input.phase1_encryption_algorithms {
        let mut list_1327 = scope_1324.start_list(true, Some("item"));
        for item_1326 in var_1325 {
            #[allow(unused_mut)]
            let mut entry_1328 = list_1327.entry();
            crate::query_ser::serialize_structure_crate_model_phase1_encryption_algorithms_request_list_value(entry_1328, item_1326)?;
        }
        list_1327.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1329 = writer.prefix("Phase2EncryptionAlgorithm");
    if let Some(var_1330) = &input.phase2_encryption_algorithms {
        let mut list_1332 = scope_1329.start_list(true, Some("item"));
        for item_1331 in var_1330 {
            #[allow(unused_mut)]
            let mut entry_1333 = list_1332.entry();
            crate::query_ser::serialize_structure_crate_model_phase2_encryption_algorithms_request_list_value(entry_1333, item_1331)?;
        }
        list_1332.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1334 = writer.prefix("Phase1IntegrityAlgorithm");
    if let Some(var_1335) = &input.phase1_integrity_algorithms {
        let mut list_1337 = scope_1334.start_list(true, Some("item"));
        for item_1336 in var_1335 {
            #[allow(unused_mut)]
            let mut entry_1338 = list_1337.entry();
            crate::query_ser::serialize_structure_crate_model_phase1_integrity_algorithms_request_list_value(entry_1338, item_1336)?;
        }
        list_1337.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1339 = writer.prefix("Phase2IntegrityAlgorithm");
    if let Some(var_1340) = &input.phase2_integrity_algorithms {
        let mut list_1342 = scope_1339.start_list(true, Some("item"));
        for item_1341 in var_1340 {
            #[allow(unused_mut)]
            let mut entry_1343 = list_1342.entry();
            crate::query_ser::serialize_structure_crate_model_phase2_integrity_algorithms_request_list_value(entry_1343, item_1341)?;
        }
        list_1342.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1344 = writer.prefix("Phase1DHGroupNumber");
    if let Some(var_1345) = &input.phase1_dh_group_numbers {
        let mut list_1347 = scope_1344.start_list(true, Some("item"));
        for item_1346 in var_1345 {
            #[allow(unused_mut)]
            let mut entry_1348 = list_1347.entry();
            crate::query_ser::serialize_structure_crate_model_phase1_dh_group_numbers_request_list_value(entry_1348, item_1346)?;
        }
        list_1347.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1349 = writer.prefix("Phase2DHGroupNumber");
    if let Some(var_1350) = &input.phase2_dh_group_numbers {
        let mut list_1352 = scope_1349.start_list(true, Some("item"));
        for item_1351 in var_1350 {
            #[allow(unused_mut)]
            let mut entry_1353 = list_1352.entry();
            crate::query_ser::serialize_structure_crate_model_phase2_dh_group_numbers_request_list_value(entry_1353, item_1351)?;
        }
        list_1352.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1354 = writer.prefix("IKEVersion");
    if let Some(var_1355) = &input.ike_versions {
        let mut list_1357 = scope_1354.start_list(true, Some("item"));
        for item_1356 in var_1355 {
            #[allow(unused_mut)]
            let mut entry_1358 = list_1357.entry();
            crate::query_ser::serialize_structure_crate_model_ike_versions_request_list_value(
                entry_1358, item_1356,
            )?;
        }
        list_1357.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1359 = writer.prefix("StartupAction");
    if let Some(var_1360) = &input.startup_action {
        scope_1359.string(var_1360);
    }
    #[allow(unused_mut)]
    let mut scope_1361 = writer.prefix("LogOptions");
    if let Some(var_1362) = &input.log_options {
        crate::query_ser::serialize_structure_crate_model_vpn_tunnel_log_options_specification(
            scope_1361, var_1362,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_athena_integration(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AthenaIntegration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1363 = writer.prefix("IntegrationResultS3DestinationArn");
    if let Some(var_1364) = &input.integration_result_s3_destination_arn {
        scope_1363.string(var_1364);
    }
    #[allow(unused_mut)]
    let mut scope_1365 = writer.prefix("PartitionLoadFrequency");
    if let Some(var_1366) = &input.partition_load_frequency {
        scope_1365.string(var_1366.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1367 = writer.prefix("PartitionStartDate");
    if let Some(var_1368) = &input.partition_start_date {
        scope_1367.date_time(var_1368, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_1369 = writer.prefix("PartitionEndDate");
    if let Some(var_1370) = &input.partition_end_date {
        scope_1369.date_time(var_1370, aws_smithy_types::date_time::Format::DateTime)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_v_cpu_count_range_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::VCpuCountRangeRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1371 = writer.prefix("Min");
    if let Some(var_1372) = &input.min {
        scope_1371.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1372).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1373 = writer.prefix("Max");
    if let Some(var_1374) = &input.max {
        scope_1373.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1374).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_1375 = writer.prefix("Min");
    if let Some(var_1376) = &input.min {
        scope_1375.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1376).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1377 = writer.prefix("Max");
    if let Some(var_1378) = &input.max {
        scope_1377.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1378).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_1379 = writer.prefix("Min");
    if let Some(var_1380) = &input.min {
        scope_1379.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1380).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1381 = writer.prefix("Max");
    if let Some(var_1382) = &input.max {
        scope_1381.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1382).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_1383 = writer.prefix("Min");
    if let Some(var_1384) = &input.min {
        scope_1383.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1384).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1385 = writer.prefix("Max");
    if let Some(var_1386) = &input.max {
        scope_1385.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1386).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_1387 = writer.prefix("Min");
    if let Some(var_1388) = &input.min {
        scope_1387.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1388).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1389 = writer.prefix("Max");
    if let Some(var_1390) = &input.max {
        scope_1389.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1390).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_1391 = writer.prefix("Min");
    if let Some(var_1392) = &input.min {
        scope_1391.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1392).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1393 = writer.prefix("Max");
    if let Some(var_1394) = &input.max {
        scope_1393.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1394).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_1395 = writer.prefix("Min");
    if let Some(var_1396) = &input.min {
        scope_1395.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1396).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1397 = writer.prefix("Max");
    if let Some(var_1398) = &input.max {
        scope_1397.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1398).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_1399 = writer.prefix("Min");
    if let Some(var_1400) = &input.min {
        scope_1399.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1400).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1401 = writer.prefix("Max");
    if let Some(var_1402) = &input.max {
        scope_1401.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1402).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_user_bucket(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::UserBucket,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1403 = writer.prefix("S3Bucket");
    if let Some(var_1404) = &input.s3_bucket {
        scope_1403.string(var_1404);
    }
    #[allow(unused_mut)]
    let mut scope_1405 = writer.prefix("S3Key");
    if let Some(var_1406) = &input.s3_key {
        scope_1405.string(var_1406);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_user_data(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::UserData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1407 = writer.prefix("Data");
    if let Some(var_1408) = &input.data {
        scope_1407.string(var_1408);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_load_permission_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LoadPermissionRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1409 = writer.prefix("Group");
    if let Some(var_1410) = &input.group {
        scope_1409.string(var_1410.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1411 = writer.prefix("UserId");
    if let Some(var_1412) = &input.user_id {
        scope_1411.string(var_1412);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_permission(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchPermission,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1413 = writer.prefix("Group");
    if let Some(var_1414) = &input.group {
        scope_1413.string(var_1414.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1415 = writer.prefix("UserId");
    if let Some(var_1416) = &input.user_id {
        scope_1415.string(var_1416);
    }
    #[allow(unused_mut)]
    let mut scope_1417 = writer.prefix("OrganizationArn");
    if let Some(var_1418) = &input.organization_arn {
        scope_1417.string(var_1418);
    }
    #[allow(unused_mut)]
    let mut scope_1419 = writer.prefix("OrganizationalUnitArn");
    if let Some(var_1420) = &input.organizational_unit_arn {
        scope_1419.string(var_1420);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ebs_instance_block_device_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::EbsInstanceBlockDeviceSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1421 = writer.prefix("DeleteOnTermination");
    if let Some(var_1422) = &input.delete_on_termination {
        scope_1421.boolean(*var_1422);
    }
    #[allow(unused_mut)]
    let mut scope_1423 = writer.prefix("VolumeId");
    if let Some(var_1424) = &input.volume_id {
        scope_1423.string(var_1424);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_capacity_reservation_target(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CapacityReservationTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1425 = writer.prefix("CapacityReservationId");
    if let Some(var_1426) = &input.capacity_reservation_id {
        scope_1425.string(var_1426);
    }
    #[allow(unused_mut)]
    let mut scope_1427 = writer.prefix("CapacityReservationResourceGroupArn");
    if let Some(var_1428) = &input.capacity_reservation_resource_group_arn {
        scope_1427.string(var_1428);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_security_group_rule_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SecurityGroupRuleRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1429 = writer.prefix("IpProtocol");
    if let Some(var_1430) = &input.ip_protocol {
        scope_1429.string(var_1430);
    }
    #[allow(unused_mut)]
    let mut scope_1431 = writer.prefix("FromPort");
    if let Some(var_1432) = &input.from_port {
        scope_1431.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1432).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1433 = writer.prefix("ToPort");
    if let Some(var_1434) = &input.to_port {
        scope_1433.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1434).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1435 = writer.prefix("CidrIpv4");
    if let Some(var_1436) = &input.cidr_ipv4 {
        scope_1435.string(var_1436);
    }
    #[allow(unused_mut)]
    let mut scope_1437 = writer.prefix("CidrIpv6");
    if let Some(var_1438) = &input.cidr_ipv6 {
        scope_1437.string(var_1438);
    }
    #[allow(unused_mut)]
    let mut scope_1439 = writer.prefix("PrefixListId");
    if let Some(var_1440) = &input.prefix_list_id {
        scope_1439.string(var_1440);
    }
    #[allow(unused_mut)]
    let mut scope_1441 = writer.prefix("ReferencedGroupId");
    if let Some(var_1442) = &input.referenced_group_id {
        scope_1441.string(var_1442);
    }
    #[allow(unused_mut)]
    let mut scope_1443 = writer.prefix("Description");
    if let Some(var_1444) = &input.description {
        scope_1443.string(var_1444);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_volume_permission(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CreateVolumePermission,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1445 = writer.prefix("Group");
    if let Some(var_1446) = &input.group {
        scope_1445.string(var_1446.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1447 = writer.prefix("UserId");
    if let Some(var_1448) = &input.user_id {
        scope_1447.string(var_1448);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_launch_template_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::FleetLaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1449 = writer.prefix("LaunchTemplateId");
    if let Some(var_1450) = &input.launch_template_id {
        scope_1449.string(var_1450);
    }
    #[allow(unused_mut)]
    let mut scope_1451 = writer.prefix("LaunchTemplateName");
    if let Some(var_1452) = &input.launch_template_name {
        scope_1451.string(var_1452);
    }
    #[allow(unused_mut)]
    let mut scope_1453 = writer.prefix("Version");
    if let Some(var_1454) = &input.version {
        scope_1453.string(var_1454);
    }
    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_1455 = writer.prefix("InstanceType");
    if let Some(var_1456) = &input.instance_type {
        scope_1455.string(var_1456.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1457 = writer.prefix("SpotPrice");
    if let Some(var_1458) = &input.spot_price {
        scope_1457.string(var_1458);
    }
    #[allow(unused_mut)]
    let mut scope_1459 = writer.prefix("SubnetId");
    if let Some(var_1460) = &input.subnet_id {
        scope_1459.string(var_1460);
    }
    #[allow(unused_mut)]
    let mut scope_1461 = writer.prefix("AvailabilityZone");
    if let Some(var_1462) = &input.availability_zone {
        scope_1461.string(var_1462);
    }
    #[allow(unused_mut)]
    let mut scope_1463 = writer.prefix("WeightedCapacity");
    if let Some(var_1464) = &input.weighted_capacity {
        scope_1463.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1464).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1465 = writer.prefix("Priority");
    if let Some(var_1466) = &input.priority {
        scope_1465.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1466).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1467 = writer.prefix("InstanceRequirements");
    if let Some(var_1468) = &input.instance_requirements {
        crate::query_ser::serialize_structure_crate_model_instance_requirements(
            scope_1467, var_1468,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase1_encryption_algorithms_request_list_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Phase1EncryptionAlgorithmsRequestListValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1469 = writer.prefix("Value");
    if let Some(var_1470) = &input.value {
        scope_1469.string(var_1470);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase2_encryption_algorithms_request_list_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Phase2EncryptionAlgorithmsRequestListValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1471 = writer.prefix("Value");
    if let Some(var_1472) = &input.value {
        scope_1471.string(var_1472);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase1_integrity_algorithms_request_list_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Phase1IntegrityAlgorithmsRequestListValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1473 = writer.prefix("Value");
    if let Some(var_1474) = &input.value {
        scope_1473.string(var_1474);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase2_integrity_algorithms_request_list_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Phase2IntegrityAlgorithmsRequestListValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1475 = writer.prefix("Value");
    if let Some(var_1476) = &input.value {
        scope_1475.string(var_1476);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase1_dh_group_numbers_request_list_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Phase1DhGroupNumbersRequestListValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1477 = writer.prefix("Value");
    if let Some(var_1478) = &input.value {
        scope_1477.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1478).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase2_dh_group_numbers_request_list_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Phase2DhGroupNumbersRequestListValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1479 = writer.prefix("Value");
    if let Some(var_1480) = &input.value {
        scope_1479.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1480).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ike_versions_request_list_value(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::IkeVersionsRequestListValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1481 = writer.prefix("Value");
    if let Some(var_1482) = &input.value {
        scope_1481.string(var_1482);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_vpn_tunnel_log_options_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::VpnTunnelLogOptionsSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1483 = writer.prefix("CloudWatchLogOptions");
    if let Some(var_1484) = &input.cloud_watch_log_options {
        crate::query_ser::serialize_structure_crate_model_cloud_watch_log_options_specification(
            scope_1483, var_1484,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_maintenance_strategies(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SpotMaintenanceStrategies,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1485 = writer.prefix("CapacityRebalance");
    if let Some(var_1486) = &input.capacity_rebalance {
        crate::query_ser::serialize_structure_crate_model_spot_capacity_rebalance(
            scope_1485, var_1486,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_fleet_launch_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SpotFleetLaunchSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1487 = writer.prefix("GroupSet");
    if let Some(var_1488) = &input.security_groups {
        let mut list_1490 = scope_1487.start_list(true, Some("item"));
        for item_1489 in var_1488 {
            #[allow(unused_mut)]
            let mut entry_1491 = list_1490.entry();
            crate::query_ser::serialize_structure_crate_model_group_identifier(
                entry_1491, item_1489,
            )?;
        }
        list_1490.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1492 = writer.prefix("AddressingType");
    if let Some(var_1493) = &input.addressing_type {
        scope_1492.string(var_1493);
    }
    #[allow(unused_mut)]
    let mut scope_1494 = writer.prefix("BlockDeviceMapping");
    if let Some(var_1495) = &input.block_device_mappings {
        let mut list_1497 = scope_1494.start_list(true, Some("item"));
        for item_1496 in var_1495 {
            #[allow(unused_mut)]
            let mut entry_1498 = list_1497.entry();
            crate::query_ser::serialize_structure_crate_model_block_device_mapping(
                entry_1498, item_1496,
            )?;
        }
        list_1497.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1499 = writer.prefix("EbsOptimized");
    if let Some(var_1500) = &input.ebs_optimized {
        scope_1499.boolean(*var_1500);
    }
    #[allow(unused_mut)]
    let mut scope_1501 = writer.prefix("IamInstanceProfile");
    if let Some(var_1502) = &input.iam_instance_profile {
        crate::query_ser::serialize_structure_crate_model_iam_instance_profile_specification(
            scope_1501, var_1502,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1503 = writer.prefix("ImageId");
    if let Some(var_1504) = &input.image_id {
        scope_1503.string(var_1504);
    }
    #[allow(unused_mut)]
    let mut scope_1505 = writer.prefix("InstanceType");
    if let Some(var_1506) = &input.instance_type {
        scope_1505.string(var_1506.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1507 = writer.prefix("KernelId");
    if let Some(var_1508) = &input.kernel_id {
        scope_1507.string(var_1508);
    }
    #[allow(unused_mut)]
    let mut scope_1509 = writer.prefix("KeyName");
    if let Some(var_1510) = &input.key_name {
        scope_1509.string(var_1510);
    }
    #[allow(unused_mut)]
    let mut scope_1511 = writer.prefix("Monitoring");
    if let Some(var_1512) = &input.monitoring {
        crate::query_ser::serialize_structure_crate_model_spot_fleet_monitoring(
            scope_1511, var_1512,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1513 = writer.prefix("NetworkInterfaceSet");
    if let Some(var_1514) = &input.network_interfaces {
        let mut list_1516 = scope_1513.start_list(true, Some("item"));
        for item_1515 in var_1514 {
            #[allow(unused_mut)]
            let mut entry_1517 = list_1516.entry();
            crate::query_ser::serialize_structure_crate_model_instance_network_interface_specification(entry_1517, item_1515)?;
        }
        list_1516.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1518 = writer.prefix("Placement");
    if let Some(var_1519) = &input.placement {
        crate::query_ser::serialize_structure_crate_model_spot_placement(scope_1518, var_1519)?;
    }
    #[allow(unused_mut)]
    let mut scope_1520 = writer.prefix("RamdiskId");
    if let Some(var_1521) = &input.ramdisk_id {
        scope_1520.string(var_1521);
    }
    #[allow(unused_mut)]
    let mut scope_1522 = writer.prefix("SpotPrice");
    if let Some(var_1523) = &input.spot_price {
        scope_1522.string(var_1523);
    }
    #[allow(unused_mut)]
    let mut scope_1524 = writer.prefix("SubnetId");
    if let Some(var_1525) = &input.subnet_id {
        scope_1524.string(var_1525);
    }
    #[allow(unused_mut)]
    let mut scope_1526 = writer.prefix("UserData");
    if let Some(var_1527) = &input.user_data {
        scope_1526.string(var_1527);
    }
    #[allow(unused_mut)]
    let mut scope_1528 = writer.prefix("WeightedCapacity");
    if let Some(var_1529) = &input.weighted_capacity {
        scope_1528.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1529).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1530 = writer.prefix("TagSpecificationSet");
    if let Some(var_1531) = &input.tag_specifications {
        let mut list_1533 = scope_1530.start_list(true, Some("item"));
        for item_1532 in var_1531 {
            #[allow(unused_mut)]
            let mut entry_1534 = list_1533.entry();
            crate::query_ser::serialize_structure_crate_model_spot_fleet_tag_specification(
                entry_1534, item_1532,
            )?;
        }
        list_1533.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1535 = writer.prefix("InstanceRequirements");
    if let Some(var_1536) = &input.instance_requirements {
        crate::query_ser::serialize_structure_crate_model_instance_requirements(
            scope_1535, var_1536,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_load_balancers_config(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LoadBalancersConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1537 = writer.prefix("ClassicLoadBalancersConfig");
    if let Some(var_1538) = &input.classic_load_balancers_config {
        crate::query_ser::serialize_structure_crate_model_classic_load_balancers_config(
            scope_1537, var_1538,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1539 = writer.prefix("TargetGroupsConfig");
    if let Some(var_1540) = &input.target_groups_config {
        crate::query_ser::serialize_structure_crate_model_target_groups_config(
            scope_1539, var_1540,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_placement(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SpotPlacement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1541 = writer.prefix("AvailabilityZone");
    if let Some(var_1542) = &input.availability_zone {
        scope_1541.string(var_1542);
    }
    #[allow(unused_mut)]
    let mut scope_1543 = writer.prefix("GroupName");
    if let Some(var_1544) = &input.group_name {
        scope_1543.string(var_1544);
    }
    #[allow(unused_mut)]
    let mut scope_1545 = writer.prefix("Tenancy");
    if let Some(var_1546) = &input.tenancy {
        scope_1545.string(var_1546.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_market_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SpotMarketOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1547 = writer.prefix("MaxPrice");
    if let Some(var_1548) = &input.max_price {
        scope_1547.string(var_1548);
    }
    #[allow(unused_mut)]
    let mut scope_1549 = writer.prefix("SpotInstanceType");
    if let Some(var_1550) = &input.spot_instance_type {
        scope_1549.string(var_1550.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1551 = writer.prefix("BlockDurationMinutes");
    if let Some(var_1552) = &input.block_duration_minutes {
        scope_1551.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1552).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1553 = writer.prefix("ValidUntil");
    if let Some(var_1554) = &input.valid_until {
        scope_1553.date_time(var_1554, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_1555 = writer.prefix("InstanceInterruptionBehavior");
    if let Some(var_1556) = &input.instance_interruption_behavior {
        scope_1555.string(var_1556.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_block_device_mapping(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ScheduledInstancesBlockDeviceMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1557 = writer.prefix("DeviceName");
    if let Some(var_1558) = &input.device_name {
        scope_1557.string(var_1558);
    }
    #[allow(unused_mut)]
    let mut scope_1559 = writer.prefix("Ebs");
    if let Some(var_1560) = &input.ebs {
        crate::query_ser::serialize_structure_crate_model_scheduled_instances_ebs(
            scope_1559, var_1560,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1561 = writer.prefix("NoDevice");
    if let Some(var_1562) = &input.no_device {
        scope_1561.string(var_1562);
    }
    #[allow(unused_mut)]
    let mut scope_1563 = writer.prefix("VirtualName");
    if let Some(var_1564) = &input.virtual_name {
        scope_1563.string(var_1564);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_iam_instance_profile(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ScheduledInstancesIamInstanceProfile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1565 = writer.prefix("Arn");
    if let Some(var_1566) = &input.arn {
        scope_1565.string(var_1566);
    }
    #[allow(unused_mut)]
    let mut scope_1567 = writer.prefix("Name");
    if let Some(var_1568) = &input.name {
        scope_1567.string(var_1568);
    }
    Ok(())
}

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

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_network_interface(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ScheduledInstancesNetworkInterface,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1571 = writer.prefix("AssociatePublicIpAddress");
    if let Some(var_1572) = &input.associate_public_ip_address {
        scope_1571.boolean(*var_1572);
    }
    #[allow(unused_mut)]
    let mut scope_1573 = writer.prefix("DeleteOnTermination");
    if let Some(var_1574) = &input.delete_on_termination {
        scope_1573.boolean(*var_1574);
    }
    #[allow(unused_mut)]
    let mut scope_1575 = writer.prefix("Description");
    if let Some(var_1576) = &input.description {
        scope_1575.string(var_1576);
    }
    #[allow(unused_mut)]
    let mut scope_1577 = writer.prefix("DeviceIndex");
    if let Some(var_1578) = &input.device_index {
        scope_1577.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1578).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1579 = writer.prefix("Group");
    if let Some(var_1580) = &input.groups {
        let mut list_1582 = scope_1579.start_list(true, Some("SecurityGroupId"));
        for item_1581 in var_1580 {
            #[allow(unused_mut)]
            let mut entry_1583 = list_1582.entry();
            entry_1583.string(item_1581);
        }
        list_1582.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1584 = writer.prefix("Ipv6AddressCount");
    if let Some(var_1585) = &input.ipv6_address_count {
        scope_1584.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1585).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1586 = writer.prefix("Ipv6Address");
    if let Some(var_1587) = &input.ipv6_addresses {
        let mut list_1589 = scope_1586.start_list(true, Some("Ipv6Address"));
        for item_1588 in var_1587 {
            #[allow(unused_mut)]
            let mut entry_1590 = list_1589.entry();
            crate::query_ser::serialize_structure_crate_model_scheduled_instances_ipv6_address(
                entry_1590, item_1588,
            )?;
        }
        list_1589.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1591 = writer.prefix("NetworkInterfaceId");
    if let Some(var_1592) = &input.network_interface_id {
        scope_1591.string(var_1592);
    }
    #[allow(unused_mut)]
    let mut scope_1593 = writer.prefix("PrivateIpAddress");
    if let Some(var_1594) = &input.private_ip_address {
        scope_1593.string(var_1594);
    }
    #[allow(unused_mut)]
    let mut scope_1595 = writer.prefix("PrivateIpAddressConfig");
    if let Some(var_1596) = &input.private_ip_address_configs {
        let mut list_1598 = scope_1595.start_list(true, Some("PrivateIpAddressConfigSet"));
        for item_1597 in var_1596 {
            #[allow(unused_mut)]
            let mut entry_1599 = list_1598.entry();
            crate::query_ser::serialize_structure_crate_model_scheduled_instances_private_ip_address_config(entry_1599, item_1597)?;
        }
        list_1598.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1600 = writer.prefix("SecondaryPrivateIpAddressCount");
    if let Some(var_1601) = &input.secondary_private_ip_address_count {
        scope_1600.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1601).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1602 = writer.prefix("SubnetId");
    if let Some(var_1603) = &input.subnet_id {
        scope_1602.string(var_1603);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_placement(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ScheduledInstancesPlacement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1604 = writer.prefix("AvailabilityZone");
    if let Some(var_1605) = &input.availability_zone {
        scope_1604.string(var_1605);
    }
    #[allow(unused_mut)]
    let mut scope_1606 = writer.prefix("GroupName");
    if let Some(var_1607) = &input.group_name {
        scope_1606.string(var_1607);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_spot_capacity_rebalance_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::FleetSpotCapacityRebalanceRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1608 = writer.prefix("ReplacementStrategy");
    if let Some(var_1609) = &input.replacement_strategy {
        scope_1608.string(var_1609.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1610 = writer.prefix("TerminationDelay");
    if let Some(var_1611) = &input.termination_delay {
        scope_1610.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1611).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_ebs_block_device_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateEbsBlockDeviceRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1612 = writer.prefix("Encrypted");
    if let Some(var_1613) = &input.encrypted {
        scope_1612.boolean(*var_1613);
    }
    #[allow(unused_mut)]
    let mut scope_1614 = writer.prefix("DeleteOnTermination");
    if let Some(var_1615) = &input.delete_on_termination {
        scope_1614.boolean(*var_1615);
    }
    #[allow(unused_mut)]
    let mut scope_1616 = writer.prefix("Iops");
    if let Some(var_1617) = &input.iops {
        scope_1616.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1617).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1618 = writer.prefix("KmsKeyId");
    if let Some(var_1619) = &input.kms_key_id {
        scope_1618.string(var_1619);
    }
    #[allow(unused_mut)]
    let mut scope_1620 = writer.prefix("SnapshotId");
    if let Some(var_1621) = &input.snapshot_id {
        scope_1620.string(var_1621);
    }
    #[allow(unused_mut)]
    let mut scope_1622 = writer.prefix("VolumeSize");
    if let Some(var_1623) = &input.volume_size {
        scope_1622.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1623).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1624 = writer.prefix("VolumeType");
    if let Some(var_1625) = &input.volume_type {
        scope_1624.string(var_1625.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1626 = writer.prefix("Throughput");
    if let Some(var_1627) = &input.throughput {
        scope_1626.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1627).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_ipv6_address_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceIpv6AddressRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1628 = writer.prefix("Ipv6Address");
    if let Some(var_1629) = &input.ipv6_address {
        scope_1628.string(var_1629);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_spot_market_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateSpotMarketOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1630 = writer.prefix("MaxPrice");
    if let Some(var_1631) = &input.max_price {
        scope_1630.string(var_1631);
    }
    #[allow(unused_mut)]
    let mut scope_1632 = writer.prefix("SpotInstanceType");
    if let Some(var_1633) = &input.spot_instance_type {
        scope_1632.string(var_1633.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1634 = writer.prefix("BlockDurationMinutes");
    if let Some(var_1635) = &input.block_duration_minutes {
        scope_1634.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1635).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1636 = writer.prefix("ValidUntil");
    if let Some(var_1637) = &input.valid_until {
        scope_1636.date_time(var_1637, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_1638 = writer.prefix("InstanceInterruptionBehavior");
    if let Some(var_1639) = &input.instance_interruption_behavior {
        scope_1638.string(var_1639.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_packet_header_statement_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PacketHeaderStatementRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1640 = writer.prefix("SourceAddress");
    if let Some(var_1641) = &input.source_addresses {
        let mut list_1643 = scope_1640.start_list(true, Some("item"));
        for item_1642 in var_1641 {
            #[allow(unused_mut)]
            let mut entry_1644 = list_1643.entry();
            entry_1644.string(item_1642);
        }
        list_1643.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1645 = writer.prefix("DestinationAddress");
    if let Some(var_1646) = &input.destination_addresses {
        let mut list_1648 = scope_1645.start_list(true, Some("item"));
        for item_1647 in var_1646 {
            #[allow(unused_mut)]
            let mut entry_1649 = list_1648.entry();
            entry_1649.string(item_1647);
        }
        list_1648.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1650 = writer.prefix("SourcePort");
    if let Some(var_1651) = &input.source_ports {
        let mut list_1653 = scope_1650.start_list(true, Some("item"));
        for item_1652 in var_1651 {
            #[allow(unused_mut)]
            let mut entry_1654 = list_1653.entry();
            entry_1654.string(item_1652);
        }
        list_1653.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1655 = writer.prefix("DestinationPort");
    if let Some(var_1656) = &input.destination_ports {
        let mut list_1658 = scope_1655.start_list(true, Some("item"));
        for item_1657 in var_1656 {
            #[allow(unused_mut)]
            let mut entry_1659 = list_1658.entry();
            entry_1659.string(item_1657);
        }
        list_1658.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1660 = writer.prefix("SourcePrefixList");
    if let Some(var_1661) = &input.source_prefix_lists {
        let mut list_1663 = scope_1660.start_list(true, Some("item"));
        for item_1662 in var_1661 {
            #[allow(unused_mut)]
            let mut entry_1664 = list_1663.entry();
            entry_1664.string(item_1662);
        }
        list_1663.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1665 = writer.prefix("DestinationPrefixList");
    if let Some(var_1666) = &input.destination_prefix_lists {
        let mut list_1668 = scope_1665.start_list(true, Some("item"));
        for item_1667 in var_1666 {
            #[allow(unused_mut)]
            let mut entry_1669 = list_1668.entry();
            entry_1669.string(item_1667);
        }
        list_1668.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1670 = writer.prefix("Protocol");
    if let Some(var_1671) = &input.protocols {
        let mut list_1673 = scope_1670.start_list(true, Some("item"));
        for item_1672 in var_1671 {
            #[allow(unused_mut)]
            let mut entry_1674 = list_1673.entry();
            entry_1674.string(item_1672.as_str());
        }
        list_1673.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_resource_statement_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ResourceStatementRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1675 = writer.prefix("Resource");
    if let Some(var_1676) = &input.resources {
        let mut list_1678 = scope_1675.start_list(true, Some("item"));
        for item_1677 in var_1676 {
            #[allow(unused_mut)]
            let mut entry_1679 = list_1678.entry();
            entry_1679.string(item_1677);
        }
        list_1678.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1680 = writer.prefix("ResourceType");
    if let Some(var_1681) = &input.resource_types {
        let mut list_1683 = scope_1680.start_list(true, Some("item"));
        for item_1682 in var_1681 {
            #[allow(unused_mut)]
            let mut entry_1684 = list_1683.entry();
            entry_1684.string(item_1682);
        }
        list_1683.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_1685 = writer.prefix("VCpuCount");
    if let Some(var_1686) = &input.v_cpu_count {
        crate::query_ser::serialize_structure_crate_model_v_cpu_count_range(scope_1685, var_1686)?;
    }
    #[allow(unused_mut)]
    let mut scope_1687 = writer.prefix("MemoryMiB");
    if let Some(var_1688) = &input.memory_mi_b {
        crate::query_ser::serialize_structure_crate_model_memory_mi_b(scope_1687, var_1688)?;
    }
    #[allow(unused_mut)]
    let mut scope_1689 = writer.prefix("CpuManufacturerSet");
    if let Some(var_1690) = &input.cpu_manufacturers {
        let mut list_1692 = scope_1689.start_list(true, Some("item"));
        for item_1691 in var_1690 {
            #[allow(unused_mut)]
            let mut entry_1693 = list_1692.entry();
            entry_1693.string(item_1691.as_str());
        }
        list_1692.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1694 = writer.prefix("MemoryGiBPerVCpu");
    if let Some(var_1695) = &input.memory_gi_b_per_v_cpu {
        crate::query_ser::serialize_structure_crate_model_memory_gi_b_per_v_cpu(
            scope_1694, var_1695,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1696 = writer.prefix("ExcludedInstanceTypeSet");
    if let Some(var_1697) = &input.excluded_instance_types {
        let mut list_1699 = scope_1696.start_list(true, Some("item"));
        for item_1698 in var_1697 {
            #[allow(unused_mut)]
            let mut entry_1700 = list_1699.entry();
            entry_1700.string(item_1698);
        }
        list_1699.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1701 = writer.prefix("InstanceGenerationSet");
    if let Some(var_1702) = &input.instance_generations {
        let mut list_1704 = scope_1701.start_list(true, Some("item"));
        for item_1703 in var_1702 {
            #[allow(unused_mut)]
            let mut entry_1705 = list_1704.entry();
            entry_1705.string(item_1703.as_str());
        }
        list_1704.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1706 = writer.prefix("SpotMaxPricePercentageOverLowestPrice");
    if let Some(var_1707) = &input.spot_max_price_percentage_over_lowest_price {
        scope_1706.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1707).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1708 = writer.prefix("OnDemandMaxPricePercentageOverLowestPrice");
    if let Some(var_1709) = &input.on_demand_max_price_percentage_over_lowest_price {
        scope_1708.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1709).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1710 = writer.prefix("BareMetal");
    if let Some(var_1711) = &input.bare_metal {
        scope_1710.string(var_1711.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1712 = writer.prefix("BurstablePerformance");
    if let Some(var_1713) = &input.burstable_performance {
        scope_1712.string(var_1713.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1714 = writer.prefix("RequireHibernateSupport");
    if let Some(var_1715) = &input.require_hibernate_support {
        scope_1714.boolean(*var_1715);
    }
    #[allow(unused_mut)]
    let mut scope_1716 = writer.prefix("NetworkInterfaceCount");
    if let Some(var_1717) = &input.network_interface_count {
        crate::query_ser::serialize_structure_crate_model_network_interface_count(
            scope_1716, var_1717,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1718 = writer.prefix("LocalStorage");
    if let Some(var_1719) = &input.local_storage {
        scope_1718.string(var_1719.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1720 = writer.prefix("LocalStorageTypeSet");
    if let Some(var_1721) = &input.local_storage_types {
        let mut list_1723 = scope_1720.start_list(true, Some("item"));
        for item_1722 in var_1721 {
            #[allow(unused_mut)]
            let mut entry_1724 = list_1723.entry();
            entry_1724.string(item_1722.as_str());
        }
        list_1723.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1725 = writer.prefix("TotalLocalStorageGB");
    if let Some(var_1726) = &input.total_local_storage_gb {
        crate::query_ser::serialize_structure_crate_model_total_local_storage_gb(
            scope_1725, var_1726,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1727 = writer.prefix("BaselineEbsBandwidthMbps");
    if let Some(var_1728) = &input.baseline_ebs_bandwidth_mbps {
        crate::query_ser::serialize_structure_crate_model_baseline_ebs_bandwidth_mbps(
            scope_1727, var_1728,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1729 = writer.prefix("AcceleratorTypeSet");
    if let Some(var_1730) = &input.accelerator_types {
        let mut list_1732 = scope_1729.start_list(true, Some("item"));
        for item_1731 in var_1730 {
            #[allow(unused_mut)]
            let mut entry_1733 = list_1732.entry();
            entry_1733.string(item_1731.as_str());
        }
        list_1732.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1734 = writer.prefix("AcceleratorCount");
    if let Some(var_1735) = &input.accelerator_count {
        crate::query_ser::serialize_structure_crate_model_accelerator_count(scope_1734, var_1735)?;
    }
    #[allow(unused_mut)]
    let mut scope_1736 = writer.prefix("AcceleratorManufacturerSet");
    if let Some(var_1737) = &input.accelerator_manufacturers {
        let mut list_1739 = scope_1736.start_list(true, Some("item"));
        for item_1738 in var_1737 {
            #[allow(unused_mut)]
            let mut entry_1740 = list_1739.entry();
            entry_1740.string(item_1738.as_str());
        }
        list_1739.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1741 = writer.prefix("AcceleratorNameSet");
    if let Some(var_1742) = &input.accelerator_names {
        let mut list_1744 = scope_1741.start_list(true, Some("item"));
        for item_1743 in var_1742 {
            #[allow(unused_mut)]
            let mut entry_1745 = list_1744.entry();
            entry_1745.string(item_1743.as_str());
        }
        list_1744.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1746 = writer.prefix("AcceleratorTotalMemoryMiB");
    if let Some(var_1747) = &input.accelerator_total_memory_mi_b {
        crate::query_ser::serialize_structure_crate_model_accelerator_total_memory_mi_b(
            scope_1746, var_1747,
        )?;
    }
    Ok(())
}

pub const fn values() -> &'static [&'static str]

Returns all the &str values of the enum members.

Trait Implementations

impl AsRef<str> for LocalStorageType

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for LocalStorageType

fn clone(&self) -> LocalStorageType

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LocalStorageType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&str> for LocalStorageType

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for LocalStorageType

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for LocalStorageType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for LocalStorageType

fn cmp(&self, other: &LocalStorageType) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<LocalStorageType> for LocalStorageType

fn eq(&self, other: &LocalStorageType) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<LocalStorageType> for LocalStorageType

fn partial_cmp(&self, other: &LocalStorageType) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for LocalStorageType

impl StructuralEq for LocalStorageType

impl StructuralPartialEq for LocalStorageType