Enum aws_sdk_ec2::model::BootModeValues

#[non_exhaustive]
pub enum BootModeValues {
    LegacyBios,
    Uefi,
    Unknown(UnknownVariantValue),
}

When writing a match expression against BootModeValues, 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 bootmodevalues = unimplemented!();
match bootmodevalues {
    BootModeValues::LegacyBios => { /* ... */ },
    BootModeValues::Uefi => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

The above code demonstrates that when bootmodevalues represents NewFeature, the execution path will lead to the second last match arm, even though the enum does not contain a variant BootModeValues::NewFeature in the current version of SDK. The reason is that the variable other, created by the @ operator, is bound to BootModeValues::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 BootModeValues::NewFeature is defined. Specifically, when bootmodevalues represents NewFeature, the execution path will hit the second last match arm as before by virtue of calling as_str on BootModeValues::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.

LegacyBios

Uefi

Unknown(UnknownVariantValue)

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

Implementations

impl BootModeValues

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 10896)

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

src/operation_ser.rs (line 16859)

pub fn serialize_operation_crate_operation_import_image(
    input: &crate::input::ImportImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ImportImage", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4685 = writer.prefix("Architecture");
    if let Some(var_4686) = &input.architecture {
        scope_4685.string(var_4686);
    }
    #[allow(unused_mut)]
    let mut scope_4687 = writer.prefix("ClientData");
    if let Some(var_4688) = &input.client_data {
        crate::query_ser::serialize_structure_crate_model_client_data(scope_4687, var_4688)?;
    }
    #[allow(unused_mut)]
    let mut scope_4689 = writer.prefix("ClientToken");
    if let Some(var_4690) = &input.client_token {
        scope_4689.string(var_4690);
    }
    #[allow(unused_mut)]
    let mut scope_4691 = writer.prefix("Description");
    if let Some(var_4692) = &input.description {
        scope_4691.string(var_4692);
    }
    #[allow(unused_mut)]
    let mut scope_4693 = writer.prefix("DiskContainer");
    if let Some(var_4694) = &input.disk_containers {
        let mut list_4696 = scope_4693.start_list(true, Some("item"));
        for item_4695 in var_4694 {
            #[allow(unused_mut)]
            let mut entry_4697 = list_4696.entry();
            crate::query_ser::serialize_structure_crate_model_image_disk_container(
                entry_4697, item_4695,
            )?;
        }
        list_4696.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4698 = writer.prefix("DryRun");
    if let Some(var_4699) = &input.dry_run {
        scope_4698.boolean(*var_4699);
    }
    #[allow(unused_mut)]
    let mut scope_4700 = writer.prefix("Encrypted");
    if let Some(var_4701) = &input.encrypted {
        scope_4700.boolean(*var_4701);
    }
    #[allow(unused_mut)]
    let mut scope_4702 = writer.prefix("Hypervisor");
    if let Some(var_4703) = &input.hypervisor {
        scope_4702.string(var_4703);
    }
    #[allow(unused_mut)]
    let mut scope_4704 = writer.prefix("KmsKeyId");
    if let Some(var_4705) = &input.kms_key_id {
        scope_4704.string(var_4705);
    }
    #[allow(unused_mut)]
    let mut scope_4706 = writer.prefix("LicenseType");
    if let Some(var_4707) = &input.license_type {
        scope_4706.string(var_4707);
    }
    #[allow(unused_mut)]
    let mut scope_4708 = writer.prefix("Platform");
    if let Some(var_4709) = &input.platform {
        scope_4708.string(var_4709);
    }
    #[allow(unused_mut)]
    let mut scope_4710 = writer.prefix("RoleName");
    if let Some(var_4711) = &input.role_name {
        scope_4710.string(var_4711);
    }
    #[allow(unused_mut)]
    let mut scope_4712 = writer.prefix("LicenseSpecifications");
    if let Some(var_4713) = &input.license_specifications {
        let mut list_4715 = scope_4712.start_list(true, Some("item"));
        for item_4714 in var_4713 {
            #[allow(unused_mut)]
            let mut entry_4716 = list_4715.entry();
            crate::query_ser::serialize_structure_crate_model_import_image_license_configuration_request(entry_4716, item_4714)?;
        }
        list_4715.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4717 = writer.prefix("TagSpecification");
    if let Some(var_4718) = &input.tag_specifications {
        let mut list_4720 = scope_4717.start_list(true, Some("item"));
        for item_4719 in var_4718 {
            #[allow(unused_mut)]
            let mut entry_4721 = list_4720.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_4721, item_4719,
            )?;
        }
        list_4720.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4722 = writer.prefix("UsageOperation");
    if let Some(var_4723) = &input.usage_operation {
        scope_4722.string(var_4723);
    }
    #[allow(unused_mut)]
    let mut scope_4724 = writer.prefix("BootMode");
    if let Some(var_4725) = &input.boot_mode {
        scope_4724.string(var_4725.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_import_instance(
    input: &crate::input::ImportInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ImportInstance", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4726 = writer.prefix("Description");
    if let Some(var_4727) = &input.description {
        scope_4726.string(var_4727);
    }
    #[allow(unused_mut)]
    let mut scope_4728 = writer.prefix("DiskImage");
    if let Some(var_4729) = &input.disk_images {
        let mut list_4731 = scope_4728.start_list(true, None);
        for item_4730 in var_4729 {
            #[allow(unused_mut)]
            let mut entry_4732 = list_4731.entry();
            crate::query_ser::serialize_structure_crate_model_disk_image(entry_4732, item_4730)?;
        }
        list_4731.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4733 = writer.prefix("DryRun");
    if let Some(var_4734) = &input.dry_run {
        scope_4733.boolean(*var_4734);
    }
    #[allow(unused_mut)]
    let mut scope_4735 = writer.prefix("LaunchSpecification");
    if let Some(var_4736) = &input.launch_specification {
        crate::query_ser::serialize_structure_crate_model_import_instance_launch_specification(
            scope_4735, var_4736,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4737 = writer.prefix("Platform");
    if let Some(var_4738) = &input.platform {
        scope_4737.string(var_4738.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_import_key_pair(
    input: &crate::input::ImportKeyPairInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ImportKeyPair", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4739 = writer.prefix("DryRun");
    if let Some(var_4740) = &input.dry_run {
        scope_4739.boolean(*var_4740);
    }
    #[allow(unused_mut)]
    let mut scope_4741 = writer.prefix("KeyName");
    if let Some(var_4742) = &input.key_name {
        scope_4741.string(var_4742);
    }
    #[allow(unused_mut)]
    let mut scope_4743 = writer.prefix("PublicKeyMaterial");
    if let Some(var_4744) = &input.public_key_material {
        scope_4743.string(&aws_smithy_types::base64::encode(var_4744));
    }
    #[allow(unused_mut)]
    let mut scope_4745 = writer.prefix("TagSpecification");
    if let Some(var_4746) = &input.tag_specifications {
        let mut list_4748 = scope_4745.start_list(true, Some("item"));
        for item_4747 in var_4746 {
            #[allow(unused_mut)]
            let mut entry_4749 = list_4748.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_4749, item_4747,
            )?;
        }
        list_4748.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_import_snapshot(
    input: &crate::input::ImportSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ImportSnapshot", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4750 = writer.prefix("ClientData");
    if let Some(var_4751) = &input.client_data {
        crate::query_ser::serialize_structure_crate_model_client_data(scope_4750, var_4751)?;
    }
    #[allow(unused_mut)]
    let mut scope_4752 = writer.prefix("ClientToken");
    if let Some(var_4753) = &input.client_token {
        scope_4752.string(var_4753);
    }
    #[allow(unused_mut)]
    let mut scope_4754 = writer.prefix("Description");
    if let Some(var_4755) = &input.description {
        scope_4754.string(var_4755);
    }
    #[allow(unused_mut)]
    let mut scope_4756 = writer.prefix("DiskContainer");
    if let Some(var_4757) = &input.disk_container {
        crate::query_ser::serialize_structure_crate_model_snapshot_disk_container(
            scope_4756, var_4757,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4758 = writer.prefix("DryRun");
    if let Some(var_4759) = &input.dry_run {
        scope_4758.boolean(*var_4759);
    }
    #[allow(unused_mut)]
    let mut scope_4760 = writer.prefix("Encrypted");
    if let Some(var_4761) = &input.encrypted {
        scope_4760.boolean(*var_4761);
    }
    #[allow(unused_mut)]
    let mut scope_4762 = writer.prefix("KmsKeyId");
    if let Some(var_4763) = &input.kms_key_id {
        scope_4762.string(var_4763);
    }
    #[allow(unused_mut)]
    let mut scope_4764 = writer.prefix("RoleName");
    if let Some(var_4765) = &input.role_name {
        scope_4764.string(var_4765);
    }
    #[allow(unused_mut)]
    let mut scope_4766 = writer.prefix("TagSpecification");
    if let Some(var_4767) = &input.tag_specifications {
        let mut list_4769 = scope_4766.start_list(true, Some("item"));
        for item_4768 in var_4767 {
            #[allow(unused_mut)]
            let mut entry_4770 = list_4769.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_4770, item_4768,
            )?;
        }
        list_4769.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_import_volume(
    input: &crate::input::ImportVolumeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ImportVolume", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4771 = writer.prefix("AvailabilityZone");
    if let Some(var_4772) = &input.availability_zone {
        scope_4771.string(var_4772);
    }
    #[allow(unused_mut)]
    let mut scope_4773 = writer.prefix("Description");
    if let Some(var_4774) = &input.description {
        scope_4773.string(var_4774);
    }
    #[allow(unused_mut)]
    let mut scope_4775 = writer.prefix("DryRun");
    if let Some(var_4776) = &input.dry_run {
        scope_4775.boolean(*var_4776);
    }
    #[allow(unused_mut)]
    let mut scope_4777 = writer.prefix("Image");
    if let Some(var_4778) = &input.image {
        crate::query_ser::serialize_structure_crate_model_disk_image_detail(scope_4777, var_4778)?;
    }
    #[allow(unused_mut)]
    let mut scope_4779 = writer.prefix("Volume");
    if let Some(var_4780) = &input.volume {
        crate::query_ser::serialize_structure_crate_model_volume_detail(scope_4779, var_4780)?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_images_in_recycle_bin(
    input: &crate::input::ListImagesInRecycleBinInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListImagesInRecycleBin", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4781 = writer.prefix("ImageId");
    if let Some(var_4782) = &input.image_ids {
        let mut list_4784 = scope_4781.start_list(true, Some("ImageId"));
        for item_4783 in var_4782 {
            #[allow(unused_mut)]
            let mut entry_4785 = list_4784.entry();
            entry_4785.string(item_4783);
        }
        list_4784.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4786 = writer.prefix("NextToken");
    if let Some(var_4787) = &input.next_token {
        scope_4786.string(var_4787);
    }
    #[allow(unused_mut)]
    let mut scope_4788 = writer.prefix("MaxResults");
    if let Some(var_4789) = &input.max_results {
        scope_4788.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4789).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4790 = writer.prefix("DryRun");
    if let Some(var_4791) = &input.dry_run {
        scope_4790.boolean(*var_4791);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_snapshots_in_recycle_bin(
    input: &crate::input::ListSnapshotsInRecycleBinInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListSnapshotsInRecycleBin", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4792 = writer.prefix("MaxResults");
    if let Some(var_4793) = &input.max_results {
        scope_4792.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4793).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4794 = writer.prefix("NextToken");
    if let Some(var_4795) = &input.next_token {
        scope_4794.string(var_4795);
    }
    #[allow(unused_mut)]
    let mut scope_4796 = writer.prefix("SnapshotId");
    if let Some(var_4797) = &input.snapshot_ids {
        let mut list_4799 = scope_4796.start_list(true, Some("SnapshotId"));
        for item_4798 in var_4797 {
            #[allow(unused_mut)]
            let mut entry_4800 = list_4799.entry();
            entry_4800.string(item_4798);
        }
        list_4799.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4801 = writer.prefix("DryRun");
    if let Some(var_4802) = &input.dry_run {
        scope_4801.boolean(*var_4802);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_address_attribute(
    input: &crate::input::ModifyAddressAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyAddressAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4803 = writer.prefix("AllocationId");
    if let Some(var_4804) = &input.allocation_id {
        scope_4803.string(var_4804);
    }
    #[allow(unused_mut)]
    let mut scope_4805 = writer.prefix("DomainName");
    if let Some(var_4806) = &input.domain_name {
        scope_4805.string(var_4806);
    }
    #[allow(unused_mut)]
    let mut scope_4807 = writer.prefix("DryRun");
    if let Some(var_4808) = &input.dry_run {
        scope_4807.boolean(*var_4808);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_availability_zone_group(
    input: &crate::input::ModifyAvailabilityZoneGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyAvailabilityZoneGroup", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4809 = writer.prefix("GroupName");
    if let Some(var_4810) = &input.group_name {
        scope_4809.string(var_4810);
    }
    #[allow(unused_mut)]
    let mut scope_4811 = writer.prefix("OptInStatus");
    if let Some(var_4812) = &input.opt_in_status {
        scope_4811.string(var_4812.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4813 = writer.prefix("DryRun");
    if let Some(var_4814) = &input.dry_run {
        scope_4813.boolean(*var_4814);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_capacity_reservation(
    input: &crate::input::ModifyCapacityReservationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyCapacityReservation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4815 = writer.prefix("CapacityReservationId");
    if let Some(var_4816) = &input.capacity_reservation_id {
        scope_4815.string(var_4816);
    }
    #[allow(unused_mut)]
    let mut scope_4817 = writer.prefix("InstanceCount");
    if let Some(var_4818) = &input.instance_count {
        scope_4817.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4818).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4819 = writer.prefix("EndDate");
    if let Some(var_4820) = &input.end_date {
        scope_4819.date_time(var_4820, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_4821 = writer.prefix("EndDateType");
    if let Some(var_4822) = &input.end_date_type {
        scope_4821.string(var_4822.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4823 = writer.prefix("Accept");
    if let Some(var_4824) = &input.accept {
        scope_4823.boolean(*var_4824);
    }
    #[allow(unused_mut)]
    let mut scope_4825 = writer.prefix("DryRun");
    if let Some(var_4826) = &input.dry_run {
        scope_4825.boolean(*var_4826);
    }
    #[allow(unused_mut)]
    let mut scope_4827 = writer.prefix("AdditionalInfo");
    if let Some(var_4828) = &input.additional_info {
        scope_4827.string(var_4828);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_capacity_reservation_fleet(
    input: &crate::input::ModifyCapacityReservationFleetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyCapacityReservationFleet",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4829 = writer.prefix("CapacityReservationFleetId");
    if let Some(var_4830) = &input.capacity_reservation_fleet_id {
        scope_4829.string(var_4830);
    }
    #[allow(unused_mut)]
    let mut scope_4831 = writer.prefix("TotalTargetCapacity");
    if let Some(var_4832) = &input.total_target_capacity {
        scope_4831.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4832).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4833 = writer.prefix("EndDate");
    if let Some(var_4834) = &input.end_date {
        scope_4833.date_time(var_4834, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_4835 = writer.prefix("DryRun");
    if let Some(var_4836) = &input.dry_run {
        scope_4835.boolean(*var_4836);
    }
    #[allow(unused_mut)]
    let mut scope_4837 = writer.prefix("RemoveEndDate");
    if let Some(var_4838) = &input.remove_end_date {
        scope_4837.boolean(*var_4838);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_client_vpn_endpoint(
    input: &crate::input::ModifyClientVpnEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyClientVpnEndpoint", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4839 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_4840) = &input.client_vpn_endpoint_id {
        scope_4839.string(var_4840);
    }
    #[allow(unused_mut)]
    let mut scope_4841 = writer.prefix("ServerCertificateArn");
    if let Some(var_4842) = &input.server_certificate_arn {
        scope_4841.string(var_4842);
    }
    #[allow(unused_mut)]
    let mut scope_4843 = writer.prefix("ConnectionLogOptions");
    if let Some(var_4844) = &input.connection_log_options {
        crate::query_ser::serialize_structure_crate_model_connection_log_options(
            scope_4843, var_4844,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4845 = writer.prefix("DnsServers");
    if let Some(var_4846) = &input.dns_servers {
        crate::query_ser::serialize_structure_crate_model_dns_servers_options_modify_structure(
            scope_4845, var_4846,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4847 = writer.prefix("VpnPort");
    if let Some(var_4848) = &input.vpn_port {
        scope_4847.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4848).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4849 = writer.prefix("Description");
    if let Some(var_4850) = &input.description {
        scope_4849.string(var_4850);
    }
    #[allow(unused_mut)]
    let mut scope_4851 = writer.prefix("SplitTunnel");
    if let Some(var_4852) = &input.split_tunnel {
        scope_4851.boolean(*var_4852);
    }
    #[allow(unused_mut)]
    let mut scope_4853 = writer.prefix("DryRun");
    if let Some(var_4854) = &input.dry_run {
        scope_4853.boolean(*var_4854);
    }
    #[allow(unused_mut)]
    let mut scope_4855 = writer.prefix("SecurityGroupId");
    if let Some(var_4856) = &input.security_group_ids {
        let mut list_4858 = scope_4855.start_list(true, Some("item"));
        for item_4857 in var_4856 {
            #[allow(unused_mut)]
            let mut entry_4859 = list_4858.entry();
            entry_4859.string(item_4857);
        }
        list_4858.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4860 = writer.prefix("VpcId");
    if let Some(var_4861) = &input.vpc_id {
        scope_4860.string(var_4861);
    }
    #[allow(unused_mut)]
    let mut scope_4862 = writer.prefix("SelfServicePortal");
    if let Some(var_4863) = &input.self_service_portal {
        scope_4862.string(var_4863.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4864 = writer.prefix("ClientConnectOptions");
    if let Some(var_4865) = &input.client_connect_options {
        crate::query_ser::serialize_structure_crate_model_client_connect_options(
            scope_4864, var_4865,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4866 = writer.prefix("SessionTimeoutHours");
    if let Some(var_4867) = &input.session_timeout_hours {
        scope_4866.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4867).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4868 = writer.prefix("ClientLoginBannerOptions");
    if let Some(var_4869) = &input.client_login_banner_options {
        crate::query_ser::serialize_structure_crate_model_client_login_banner_options(
            scope_4868, var_4869,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_default_credit_specification(
    input: &crate::input::ModifyDefaultCreditSpecificationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyDefaultCreditSpecification",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4870 = writer.prefix("DryRun");
    if let Some(var_4871) = &input.dry_run {
        scope_4870.boolean(*var_4871);
    }
    #[allow(unused_mut)]
    let mut scope_4872 = writer.prefix("InstanceFamily");
    if let Some(var_4873) = &input.instance_family {
        scope_4872.string(var_4873.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4874 = writer.prefix("CpuCredits");
    if let Some(var_4875) = &input.cpu_credits {
        scope_4874.string(var_4875);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_ebs_default_kms_key_id(
    input: &crate::input::ModifyEbsDefaultKmsKeyIdInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyEbsDefaultKmsKeyId", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4876 = writer.prefix("KmsKeyId");
    if let Some(var_4877) = &input.kms_key_id {
        scope_4876.string(var_4877);
    }
    #[allow(unused_mut)]
    let mut scope_4878 = writer.prefix("DryRun");
    if let Some(var_4879) = &input.dry_run {
        scope_4878.boolean(*var_4879);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_fleet(
    input: &crate::input::ModifyFleetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyFleet", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4880 = writer.prefix("DryRun");
    if let Some(var_4881) = &input.dry_run {
        scope_4880.boolean(*var_4881);
    }
    #[allow(unused_mut)]
    let mut scope_4882 = writer.prefix("ExcessCapacityTerminationPolicy");
    if let Some(var_4883) = &input.excess_capacity_termination_policy {
        scope_4882.string(var_4883.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4884 = writer.prefix("LaunchTemplateConfig");
    if let Some(var_4885) = &input.launch_template_configs {
        let mut list_4887 = scope_4884.start_list(true, Some("item"));
        for item_4886 in var_4885 {
            #[allow(unused_mut)]
            let mut entry_4888 = list_4887.entry();
            crate::query_ser::serialize_structure_crate_model_fleet_launch_template_config_request(
                entry_4888, item_4886,
            )?;
        }
        list_4887.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4889 = writer.prefix("FleetId");
    if let Some(var_4890) = &input.fleet_id {
        scope_4889.string(var_4890);
    }
    #[allow(unused_mut)]
    let mut scope_4891 = writer.prefix("TargetCapacitySpecification");
    if let Some(var_4892) = &input.target_capacity_specification {
        crate::query_ser::serialize_structure_crate_model_target_capacity_specification_request(
            scope_4891, var_4892,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4893 = writer.prefix("Context");
    if let Some(var_4894) = &input.context {
        scope_4893.string(var_4894);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_fpga_image_attribute(
    input: &crate::input::ModifyFpgaImageAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyFpgaImageAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4895 = writer.prefix("DryRun");
    if let Some(var_4896) = &input.dry_run {
        scope_4895.boolean(*var_4896);
    }
    #[allow(unused_mut)]
    let mut scope_4897 = writer.prefix("FpgaImageId");
    if let Some(var_4898) = &input.fpga_image_id {
        scope_4897.string(var_4898);
    }
    #[allow(unused_mut)]
    let mut scope_4899 = writer.prefix("Attribute");
    if let Some(var_4900) = &input.attribute {
        scope_4899.string(var_4900.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4901 = writer.prefix("OperationType");
    if let Some(var_4902) = &input.operation_type {
        scope_4901.string(var_4902.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4903 = writer.prefix("UserId");
    if let Some(var_4904) = &input.user_ids {
        let mut list_4906 = scope_4903.start_list(true, Some("UserId"));
        for item_4905 in var_4904 {
            #[allow(unused_mut)]
            let mut entry_4907 = list_4906.entry();
            entry_4907.string(item_4905);
        }
        list_4906.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4908 = writer.prefix("UserGroup");
    if let Some(var_4909) = &input.user_groups {
        let mut list_4911 = scope_4908.start_list(true, Some("UserGroup"));
        for item_4910 in var_4909 {
            #[allow(unused_mut)]
            let mut entry_4912 = list_4911.entry();
            entry_4912.string(item_4910);
        }
        list_4911.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4913 = writer.prefix("ProductCode");
    if let Some(var_4914) = &input.product_codes {
        let mut list_4916 = scope_4913.start_list(true, Some("ProductCode"));
        for item_4915 in var_4914 {
            #[allow(unused_mut)]
            let mut entry_4917 = list_4916.entry();
            entry_4917.string(item_4915);
        }
        list_4916.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4918 = writer.prefix("LoadPermission");
    if let Some(var_4919) = &input.load_permission {
        crate::query_ser::serialize_structure_crate_model_load_permission_modifications(
            scope_4918, var_4919,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4920 = writer.prefix("Description");
    if let Some(var_4921) = &input.description {
        scope_4920.string(var_4921);
    }
    #[allow(unused_mut)]
    let mut scope_4922 = writer.prefix("Name");
    if let Some(var_4923) = &input.name {
        scope_4922.string(var_4923);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_hosts(
    input: &crate::input::ModifyHostsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyHosts", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4924 = writer.prefix("AutoPlacement");
    if let Some(var_4925) = &input.auto_placement {
        scope_4924.string(var_4925.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4926 = writer.prefix("HostId");
    if let Some(var_4927) = &input.host_ids {
        let mut list_4929 = scope_4926.start_list(true, Some("item"));
        for item_4928 in var_4927 {
            #[allow(unused_mut)]
            let mut entry_4930 = list_4929.entry();
            entry_4930.string(item_4928);
        }
        list_4929.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4931 = writer.prefix("HostRecovery");
    if let Some(var_4932) = &input.host_recovery {
        scope_4931.string(var_4932.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4933 = writer.prefix("InstanceType");
    if let Some(var_4934) = &input.instance_type {
        scope_4933.string(var_4934);
    }
    #[allow(unused_mut)]
    let mut scope_4935 = writer.prefix("InstanceFamily");
    if let Some(var_4936) = &input.instance_family {
        scope_4935.string(var_4936);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_identity_id_format(
    input: &crate::input::ModifyIdentityIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyIdentityIdFormat", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4937 = writer.prefix("PrincipalArn");
    if let Some(var_4938) = &input.principal_arn {
        scope_4937.string(var_4938);
    }
    #[allow(unused_mut)]
    let mut scope_4939 = writer.prefix("Resource");
    if let Some(var_4940) = &input.resource {
        scope_4939.string(var_4940);
    }
    #[allow(unused_mut)]
    let mut scope_4941 = writer.prefix("UseLongIds");
    if let Some(var_4942) = &input.use_long_ids {
        scope_4941.boolean(*var_4942);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_id_format(
    input: &crate::input::ModifyIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyIdFormat", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4943 = writer.prefix("Resource");
    if let Some(var_4944) = &input.resource {
        scope_4943.string(var_4944);
    }
    #[allow(unused_mut)]
    let mut scope_4945 = writer.prefix("UseLongIds");
    if let Some(var_4946) = &input.use_long_ids {
        scope_4945.boolean(*var_4946);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_image_attribute(
    input: &crate::input::ModifyImageAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyImageAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4947 = writer.prefix("Attribute");
    if let Some(var_4948) = &input.attribute {
        scope_4947.string(var_4948);
    }
    #[allow(unused_mut)]
    let mut scope_4949 = writer.prefix("Description");
    if let Some(var_4950) = &input.description {
        crate::query_ser::serialize_structure_crate_model_attribute_value(scope_4949, var_4950)?;
    }
    #[allow(unused_mut)]
    let mut scope_4951 = writer.prefix("ImageId");
    if let Some(var_4952) = &input.image_id {
        scope_4951.string(var_4952);
    }
    #[allow(unused_mut)]
    let mut scope_4953 = writer.prefix("LaunchPermission");
    if let Some(var_4954) = &input.launch_permission {
        crate::query_ser::serialize_structure_crate_model_launch_permission_modifications(
            scope_4953, var_4954,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4955 = writer.prefix("OperationType");
    if let Some(var_4956) = &input.operation_type {
        scope_4955.string(var_4956.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4957 = writer.prefix("ProductCode");
    if let Some(var_4958) = &input.product_codes {
        let mut list_4960 = scope_4957.start_list(true, Some("ProductCode"));
        for item_4959 in var_4958 {
            #[allow(unused_mut)]
            let mut entry_4961 = list_4960.entry();
            entry_4961.string(item_4959);
        }
        list_4960.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4962 = writer.prefix("UserGroup");
    if let Some(var_4963) = &input.user_groups {
        let mut list_4965 = scope_4962.start_list(true, Some("UserGroup"));
        for item_4964 in var_4963 {
            #[allow(unused_mut)]
            let mut entry_4966 = list_4965.entry();
            entry_4966.string(item_4964);
        }
        list_4965.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4967 = writer.prefix("UserId");
    if let Some(var_4968) = &input.user_ids {
        let mut list_4970 = scope_4967.start_list(true, Some("UserId"));
        for item_4969 in var_4968 {
            #[allow(unused_mut)]
            let mut entry_4971 = list_4970.entry();
            entry_4971.string(item_4969);
        }
        list_4970.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4972 = writer.prefix("Value");
    if let Some(var_4973) = &input.value {
        scope_4972.string(var_4973);
    }
    #[allow(unused_mut)]
    let mut scope_4974 = writer.prefix("DryRun");
    if let Some(var_4975) = &input.dry_run {
        scope_4974.boolean(*var_4975);
    }
    #[allow(unused_mut)]
    let mut scope_4976 = writer.prefix("OrganizationArn");
    if let Some(var_4977) = &input.organization_arns {
        let mut list_4979 = scope_4976.start_list(true, Some("OrganizationArn"));
        for item_4978 in var_4977 {
            #[allow(unused_mut)]
            let mut entry_4980 = list_4979.entry();
            entry_4980.string(item_4978);
        }
        list_4979.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4981 = writer.prefix("OrganizationalUnitArn");
    if let Some(var_4982) = &input.organizational_unit_arns {
        let mut list_4984 = scope_4981.start_list(true, Some("OrganizationalUnitArn"));
        for item_4983 in var_4982 {
            #[allow(unused_mut)]
            let mut entry_4985 = list_4984.entry();
            entry_4985.string(item_4983);
        }
        list_4984.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_instance_attribute(
    input: &crate::input::ModifyInstanceAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyInstanceAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4986 = writer.prefix("SourceDestCheck");
    if let Some(var_4987) = &input.source_dest_check {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_4986, var_4987,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4988 = writer.prefix("Attribute");
    if let Some(var_4989) = &input.attribute {
        scope_4988.string(var_4989.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4990 = writer.prefix("BlockDeviceMapping");
    if let Some(var_4991) = &input.block_device_mappings {
        let mut list_4993 = scope_4990.start_list(true, Some("item"));
        for item_4992 in var_4991 {
            #[allow(unused_mut)]
            let mut entry_4994 = list_4993.entry();
            crate::query_ser::serialize_structure_crate_model_instance_block_device_mapping_specification(entry_4994, item_4992)?;
        }
        list_4993.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4995 = writer.prefix("DisableApiTermination");
    if let Some(var_4996) = &input.disable_api_termination {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_4995, var_4996,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4997 = writer.prefix("DryRun");
    if let Some(var_4998) = &input.dry_run {
        scope_4997.boolean(*var_4998);
    }
    #[allow(unused_mut)]
    let mut scope_4999 = writer.prefix("EbsOptimized");
    if let Some(var_5000) = &input.ebs_optimized {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_4999, var_5000,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5001 = writer.prefix("EnaSupport");
    if let Some(var_5002) = &input.ena_support {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5001, var_5002,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5003 = writer.prefix("GroupId");
    if let Some(var_5004) = &input.groups {
        let mut list_5006 = scope_5003.start_list(true, Some("groupId"));
        for item_5005 in var_5004 {
            #[allow(unused_mut)]
            let mut entry_5007 = list_5006.entry();
            entry_5007.string(item_5005);
        }
        list_5006.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5008 = writer.prefix("InstanceId");
    if let Some(var_5009) = &input.instance_id {
        scope_5008.string(var_5009);
    }
    #[allow(unused_mut)]
    let mut scope_5010 = writer.prefix("InstanceInitiatedShutdownBehavior");
    if let Some(var_5011) = &input.instance_initiated_shutdown_behavior {
        crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5010, var_5011)?;
    }
    #[allow(unused_mut)]
    let mut scope_5012 = writer.prefix("InstanceType");
    if let Some(var_5013) = &input.instance_type {
        crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5012, var_5013)?;
    }
    #[allow(unused_mut)]
    let mut scope_5014 = writer.prefix("Kernel");
    if let Some(var_5015) = &input.kernel {
        crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5014, var_5015)?;
    }
    #[allow(unused_mut)]
    let mut scope_5016 = writer.prefix("Ramdisk");
    if let Some(var_5017) = &input.ramdisk {
        crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5016, var_5017)?;
    }
    #[allow(unused_mut)]
    let mut scope_5018 = writer.prefix("SriovNetSupport");
    if let Some(var_5019) = &input.sriov_net_support {
        crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5018, var_5019)?;
    }
    #[allow(unused_mut)]
    let mut scope_5020 = writer.prefix("UserData");
    if let Some(var_5021) = &input.user_data {
        crate::query_ser::serialize_structure_crate_model_blob_attribute_value(
            scope_5020, var_5021,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5022 = writer.prefix("Value");
    if let Some(var_5023) = &input.value {
        scope_5022.string(var_5023);
    }
    #[allow(unused_mut)]
    let mut scope_5024 = writer.prefix("DisableApiStop");
    if let Some(var_5025) = &input.disable_api_stop {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5024, var_5025,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_instance_capacity_reservation_attributes(
    input: &crate::input::ModifyInstanceCapacityReservationAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyInstanceCapacityReservationAttributes",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5026 = writer.prefix("InstanceId");
    if let Some(var_5027) = &input.instance_id {
        scope_5026.string(var_5027);
    }
    #[allow(unused_mut)]
    let mut scope_5028 = writer.prefix("CapacityReservationSpecification");
    if let Some(var_5029) = &input.capacity_reservation_specification {
        crate::query_ser::serialize_structure_crate_model_capacity_reservation_specification(
            scope_5028, var_5029,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5030 = writer.prefix("DryRun");
    if let Some(var_5031) = &input.dry_run {
        scope_5030.boolean(*var_5031);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_instance_credit_specification(
    input: &crate::input::ModifyInstanceCreditSpecificationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyInstanceCreditSpecification",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5032 = writer.prefix("DryRun");
    if let Some(var_5033) = &input.dry_run {
        scope_5032.boolean(*var_5033);
    }
    #[allow(unused_mut)]
    let mut scope_5034 = writer.prefix("ClientToken");
    if let Some(var_5035) = &input.client_token {
        scope_5034.string(var_5035);
    }
    #[allow(unused_mut)]
    let mut scope_5036 = writer.prefix("InstanceCreditSpecification");
    if let Some(var_5037) = &input.instance_credit_specifications {
        let mut list_5039 = scope_5036.start_list(true, Some("item"));
        for item_5038 in var_5037 {
            #[allow(unused_mut)]
            let mut entry_5040 = list_5039.entry();
            crate::query_ser::serialize_structure_crate_model_instance_credit_specification_request(entry_5040, item_5038)?;
        }
        list_5039.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_instance_event_start_time(
    input: &crate::input::ModifyInstanceEventStartTimeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyInstanceEventStartTime", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5041 = writer.prefix("DryRun");
    if let Some(var_5042) = &input.dry_run {
        scope_5041.boolean(*var_5042);
    }
    #[allow(unused_mut)]
    let mut scope_5043 = writer.prefix("InstanceId");
    if let Some(var_5044) = &input.instance_id {
        scope_5043.string(var_5044);
    }
    #[allow(unused_mut)]
    let mut scope_5045 = writer.prefix("InstanceEventId");
    if let Some(var_5046) = &input.instance_event_id {
        scope_5045.string(var_5046);
    }
    #[allow(unused_mut)]
    let mut scope_5047 = writer.prefix("NotBefore");
    if let Some(var_5048) = &input.not_before {
        scope_5047.date_time(var_5048, aws_smithy_types::date_time::Format::DateTime)?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_instance_event_window(
    input: &crate::input::ModifyInstanceEventWindowInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyInstanceEventWindow", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5049 = writer.prefix("DryRun");
    if let Some(var_5050) = &input.dry_run {
        scope_5049.boolean(*var_5050);
    }
    #[allow(unused_mut)]
    let mut scope_5051 = writer.prefix("Name");
    if let Some(var_5052) = &input.name {
        scope_5051.string(var_5052);
    }
    #[allow(unused_mut)]
    let mut scope_5053 = writer.prefix("InstanceEventWindowId");
    if let Some(var_5054) = &input.instance_event_window_id {
        scope_5053.string(var_5054);
    }
    #[allow(unused_mut)]
    let mut scope_5055 = writer.prefix("TimeRange");
    if let Some(var_5056) = &input.time_ranges {
        let mut list_5058 = scope_5055.start_list(true, None);
        for item_5057 in var_5056 {
            #[allow(unused_mut)]
            let mut entry_5059 = list_5058.entry();
            crate::query_ser::serialize_structure_crate_model_instance_event_window_time_range_request(entry_5059, item_5057)?;
        }
        list_5058.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5060 = writer.prefix("CronExpression");
    if let Some(var_5061) = &input.cron_expression {
        scope_5060.string(var_5061);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_instance_maintenance_options(
    input: &crate::input::ModifyInstanceMaintenanceOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyInstanceMaintenanceOptions",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5062 = writer.prefix("InstanceId");
    if let Some(var_5063) = &input.instance_id {
        scope_5062.string(var_5063);
    }
    #[allow(unused_mut)]
    let mut scope_5064 = writer.prefix("AutoRecovery");
    if let Some(var_5065) = &input.auto_recovery {
        scope_5064.string(var_5065.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5066 = writer.prefix("DryRun");
    if let Some(var_5067) = &input.dry_run {
        scope_5066.boolean(*var_5067);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_instance_metadata_options(
    input: &crate::input::ModifyInstanceMetadataOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyInstanceMetadataOptions", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5068 = writer.prefix("InstanceId");
    if let Some(var_5069) = &input.instance_id {
        scope_5068.string(var_5069);
    }
    #[allow(unused_mut)]
    let mut scope_5070 = writer.prefix("HttpTokens");
    if let Some(var_5071) = &input.http_tokens {
        scope_5070.string(var_5071.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5072 = writer.prefix("HttpPutResponseHopLimit");
    if let Some(var_5073) = &input.http_put_response_hop_limit {
        scope_5072.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5073).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5074 = writer.prefix("HttpEndpoint");
    if let Some(var_5075) = &input.http_endpoint {
        scope_5074.string(var_5075.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5076 = writer.prefix("DryRun");
    if let Some(var_5077) = &input.dry_run {
        scope_5076.boolean(*var_5077);
    }
    #[allow(unused_mut)]
    let mut scope_5078 = writer.prefix("HttpProtocolIpv6");
    if let Some(var_5079) = &input.http_protocol_ipv6 {
        scope_5078.string(var_5079.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5080 = writer.prefix("InstanceMetadataTags");
    if let Some(var_5081) = &input.instance_metadata_tags {
        scope_5080.string(var_5081.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_instance_placement(
    input: &crate::input::ModifyInstancePlacementInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyInstancePlacement", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5082 = writer.prefix("Affinity");
    if let Some(var_5083) = &input.affinity {
        scope_5082.string(var_5083.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5084 = writer.prefix("GroupName");
    if let Some(var_5085) = &input.group_name {
        scope_5084.string(var_5085);
    }
    #[allow(unused_mut)]
    let mut scope_5086 = writer.prefix("HostId");
    if let Some(var_5087) = &input.host_id {
        scope_5086.string(var_5087);
    }
    #[allow(unused_mut)]
    let mut scope_5088 = writer.prefix("InstanceId");
    if let Some(var_5089) = &input.instance_id {
        scope_5088.string(var_5089);
    }
    #[allow(unused_mut)]
    let mut scope_5090 = writer.prefix("Tenancy");
    if let Some(var_5091) = &input.tenancy {
        scope_5090.string(var_5091.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5092 = writer.prefix("PartitionNumber");
    if let Some(var_5093) = &input.partition_number {
        scope_5092.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5093).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5094 = writer.prefix("HostResourceGroupArn");
    if let Some(var_5095) = &input.host_resource_group_arn {
        scope_5094.string(var_5095);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_ipam(
    input: &crate::input::ModifyIpamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyIpam", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5096 = writer.prefix("DryRun");
    if let Some(var_5097) = &input.dry_run {
        scope_5096.boolean(*var_5097);
    }
    #[allow(unused_mut)]
    let mut scope_5098 = writer.prefix("IpamId");
    if let Some(var_5099) = &input.ipam_id {
        scope_5098.string(var_5099);
    }
    #[allow(unused_mut)]
    let mut scope_5100 = writer.prefix("Description");
    if let Some(var_5101) = &input.description {
        scope_5100.string(var_5101);
    }
    #[allow(unused_mut)]
    let mut scope_5102 = writer.prefix("AddOperatingRegion");
    if let Some(var_5103) = &input.add_operating_regions {
        let mut list_5105 = scope_5102.start_list(true, None);
        for item_5104 in var_5103 {
            #[allow(unused_mut)]
            let mut entry_5106 = list_5105.entry();
            crate::query_ser::serialize_structure_crate_model_add_ipam_operating_region(
                entry_5106, item_5104,
            )?;
        }
        list_5105.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5107 = writer.prefix("RemoveOperatingRegion");
    if let Some(var_5108) = &input.remove_operating_regions {
        let mut list_5110 = scope_5107.start_list(true, None);
        for item_5109 in var_5108 {
            #[allow(unused_mut)]
            let mut entry_5111 = list_5110.entry();
            crate::query_ser::serialize_structure_crate_model_remove_ipam_operating_region(
                entry_5111, item_5109,
            )?;
        }
        list_5110.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_ipam_pool(
    input: &crate::input::ModifyIpamPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyIpamPool", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5112 = writer.prefix("DryRun");
    if let Some(var_5113) = &input.dry_run {
        scope_5112.boolean(*var_5113);
    }
    #[allow(unused_mut)]
    let mut scope_5114 = writer.prefix("IpamPoolId");
    if let Some(var_5115) = &input.ipam_pool_id {
        scope_5114.string(var_5115);
    }
    #[allow(unused_mut)]
    let mut scope_5116 = writer.prefix("Description");
    if let Some(var_5117) = &input.description {
        scope_5116.string(var_5117);
    }
    #[allow(unused_mut)]
    let mut scope_5118 = writer.prefix("AutoImport");
    if let Some(var_5119) = &input.auto_import {
        scope_5118.boolean(*var_5119);
    }
    #[allow(unused_mut)]
    let mut scope_5120 = writer.prefix("AllocationMinNetmaskLength");
    if let Some(var_5121) = &input.allocation_min_netmask_length {
        scope_5120.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5121).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5122 = writer.prefix("AllocationMaxNetmaskLength");
    if let Some(var_5123) = &input.allocation_max_netmask_length {
        scope_5122.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5123).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5124 = writer.prefix("AllocationDefaultNetmaskLength");
    if let Some(var_5125) = &input.allocation_default_netmask_length {
        scope_5124.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5125).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5126 = writer.prefix("ClearAllocationDefaultNetmaskLength");
    if let Some(var_5127) = &input.clear_allocation_default_netmask_length {
        scope_5126.boolean(*var_5127);
    }
    #[allow(unused_mut)]
    let mut scope_5128 = writer.prefix("AddAllocationResourceTag");
    if let Some(var_5129) = &input.add_allocation_resource_tags {
        let mut list_5131 = scope_5128.start_list(true, Some("item"));
        for item_5130 in var_5129 {
            #[allow(unused_mut)]
            let mut entry_5132 = list_5131.entry();
            crate::query_ser::serialize_structure_crate_model_request_ipam_resource_tag(
                entry_5132, item_5130,
            )?;
        }
        list_5131.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5133 = writer.prefix("RemoveAllocationResourceTag");
    if let Some(var_5134) = &input.remove_allocation_resource_tags {
        let mut list_5136 = scope_5133.start_list(true, Some("item"));
        for item_5135 in var_5134 {
            #[allow(unused_mut)]
            let mut entry_5137 = list_5136.entry();
            crate::query_ser::serialize_structure_crate_model_request_ipam_resource_tag(
                entry_5137, item_5135,
            )?;
        }
        list_5136.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_ipam_resource_cidr(
    input: &crate::input::ModifyIpamResourceCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyIpamResourceCidr", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5138 = writer.prefix("DryRun");
    if let Some(var_5139) = &input.dry_run {
        scope_5138.boolean(*var_5139);
    }
    #[allow(unused_mut)]
    let mut scope_5140 = writer.prefix("ResourceId");
    if let Some(var_5141) = &input.resource_id {
        scope_5140.string(var_5141);
    }
    #[allow(unused_mut)]
    let mut scope_5142 = writer.prefix("ResourceCidr");
    if let Some(var_5143) = &input.resource_cidr {
        scope_5142.string(var_5143);
    }
    #[allow(unused_mut)]
    let mut scope_5144 = writer.prefix("ResourceRegion");
    if let Some(var_5145) = &input.resource_region {
        scope_5144.string(var_5145);
    }
    #[allow(unused_mut)]
    let mut scope_5146 = writer.prefix("CurrentIpamScopeId");
    if let Some(var_5147) = &input.current_ipam_scope_id {
        scope_5146.string(var_5147);
    }
    #[allow(unused_mut)]
    let mut scope_5148 = writer.prefix("DestinationIpamScopeId");
    if let Some(var_5149) = &input.destination_ipam_scope_id {
        scope_5148.string(var_5149);
    }
    #[allow(unused_mut)]
    let mut scope_5150 = writer.prefix("Monitored");
    if let Some(var_5151) = &input.monitored {
        scope_5150.boolean(*var_5151);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_ipam_scope(
    input: &crate::input::ModifyIpamScopeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyIpamScope", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5152 = writer.prefix("DryRun");
    if let Some(var_5153) = &input.dry_run {
        scope_5152.boolean(*var_5153);
    }
    #[allow(unused_mut)]
    let mut scope_5154 = writer.prefix("IpamScopeId");
    if let Some(var_5155) = &input.ipam_scope_id {
        scope_5154.string(var_5155);
    }
    #[allow(unused_mut)]
    let mut scope_5156 = writer.prefix("Description");
    if let Some(var_5157) = &input.description {
        scope_5156.string(var_5157);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_launch_template(
    input: &crate::input::ModifyLaunchTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyLaunchTemplate", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5158 = writer.prefix("DryRun");
    if let Some(var_5159) = &input.dry_run {
        scope_5158.boolean(*var_5159);
    }
    #[allow(unused_mut)]
    let mut scope_5160 = writer.prefix("ClientToken");
    if let Some(var_5161) = &input.client_token {
        scope_5160.string(var_5161);
    }
    #[allow(unused_mut)]
    let mut scope_5162 = writer.prefix("LaunchTemplateId");
    if let Some(var_5163) = &input.launch_template_id {
        scope_5162.string(var_5163);
    }
    #[allow(unused_mut)]
    let mut scope_5164 = writer.prefix("LaunchTemplateName");
    if let Some(var_5165) = &input.launch_template_name {
        scope_5164.string(var_5165);
    }
    #[allow(unused_mut)]
    let mut scope_5166 = writer.prefix("SetDefaultVersion");
    if let Some(var_5167) = &input.default_version {
        scope_5166.string(var_5167);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_local_gateway_route(
    input: &crate::input::ModifyLocalGatewayRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyLocalGatewayRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5168 = writer.prefix("DestinationCidrBlock");
    if let Some(var_5169) = &input.destination_cidr_block {
        scope_5168.string(var_5169);
    }
    #[allow(unused_mut)]
    let mut scope_5170 = writer.prefix("LocalGatewayRouteTableId");
    if let Some(var_5171) = &input.local_gateway_route_table_id {
        scope_5170.string(var_5171);
    }
    #[allow(unused_mut)]
    let mut scope_5172 = writer.prefix("LocalGatewayVirtualInterfaceGroupId");
    if let Some(var_5173) = &input.local_gateway_virtual_interface_group_id {
        scope_5172.string(var_5173);
    }
    #[allow(unused_mut)]
    let mut scope_5174 = writer.prefix("NetworkInterfaceId");
    if let Some(var_5175) = &input.network_interface_id {
        scope_5174.string(var_5175);
    }
    #[allow(unused_mut)]
    let mut scope_5176 = writer.prefix("DryRun");
    if let Some(var_5177) = &input.dry_run {
        scope_5176.boolean(*var_5177);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_managed_prefix_list(
    input: &crate::input::ModifyManagedPrefixListInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyManagedPrefixList", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5178 = writer.prefix("DryRun");
    if let Some(var_5179) = &input.dry_run {
        scope_5178.boolean(*var_5179);
    }
    #[allow(unused_mut)]
    let mut scope_5180 = writer.prefix("PrefixListId");
    if let Some(var_5181) = &input.prefix_list_id {
        scope_5180.string(var_5181);
    }
    #[allow(unused_mut)]
    let mut scope_5182 = writer.prefix("CurrentVersion");
    if let Some(var_5183) = &input.current_version {
        scope_5182.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5183).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5184 = writer.prefix("PrefixListName");
    if let Some(var_5185) = &input.prefix_list_name {
        scope_5184.string(var_5185);
    }
    #[allow(unused_mut)]
    let mut scope_5186 = writer.prefix("AddEntry");
    if let Some(var_5187) = &input.add_entries {
        let mut list_5189 = scope_5186.start_list(true, None);
        for item_5188 in var_5187 {
            #[allow(unused_mut)]
            let mut entry_5190 = list_5189.entry();
            crate::query_ser::serialize_structure_crate_model_add_prefix_list_entry(
                entry_5190, item_5188,
            )?;
        }
        list_5189.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5191 = writer.prefix("RemoveEntry");
    if let Some(var_5192) = &input.remove_entries {
        let mut list_5194 = scope_5191.start_list(true, None);
        for item_5193 in var_5192 {
            #[allow(unused_mut)]
            let mut entry_5195 = list_5194.entry();
            crate::query_ser::serialize_structure_crate_model_remove_prefix_list_entry(
                entry_5195, item_5193,
            )?;
        }
        list_5194.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5196 = writer.prefix("MaxEntries");
    if let Some(var_5197) = &input.max_entries {
        scope_5196.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5197).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_network_interface_attribute(
    input: &crate::input::ModifyNetworkInterfaceAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyNetworkInterfaceAttribute",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5198 = writer.prefix("Attachment");
    if let Some(var_5199) = &input.attachment {
        crate::query_ser::serialize_structure_crate_model_network_interface_attachment_changes(
            scope_5198, var_5199,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5200 = writer.prefix("Description");
    if let Some(var_5201) = &input.description {
        crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5200, var_5201)?;
    }
    #[allow(unused_mut)]
    let mut scope_5202 = writer.prefix("DryRun");
    if let Some(var_5203) = &input.dry_run {
        scope_5202.boolean(*var_5203);
    }
    #[allow(unused_mut)]
    let mut scope_5204 = writer.prefix("SecurityGroupId");
    if let Some(var_5205) = &input.groups {
        let mut list_5207 = scope_5204.start_list(true, Some("SecurityGroupId"));
        for item_5206 in var_5205 {
            #[allow(unused_mut)]
            let mut entry_5208 = list_5207.entry();
            entry_5208.string(item_5206);
        }
        list_5207.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5209 = writer.prefix("NetworkInterfaceId");
    if let Some(var_5210) = &input.network_interface_id {
        scope_5209.string(var_5210);
    }
    #[allow(unused_mut)]
    let mut scope_5211 = writer.prefix("SourceDestCheck");
    if let Some(var_5212) = &input.source_dest_check {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5211, var_5212,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_private_dns_name_options(
    input: &crate::input::ModifyPrivateDnsNameOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyPrivateDnsNameOptions", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5213 = writer.prefix("DryRun");
    if let Some(var_5214) = &input.dry_run {
        scope_5213.boolean(*var_5214);
    }
    #[allow(unused_mut)]
    let mut scope_5215 = writer.prefix("InstanceId");
    if let Some(var_5216) = &input.instance_id {
        scope_5215.string(var_5216);
    }
    #[allow(unused_mut)]
    let mut scope_5217 = writer.prefix("PrivateDnsHostnameType");
    if let Some(var_5218) = &input.private_dns_hostname_type {
        scope_5217.string(var_5218.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5219 = writer.prefix("EnableResourceNameDnsARecord");
    if let Some(var_5220) = &input.enable_resource_name_dns_a_record {
        scope_5219.boolean(*var_5220);
    }
    #[allow(unused_mut)]
    let mut scope_5221 = writer.prefix("EnableResourceNameDnsAAAARecord");
    if let Some(var_5222) = &input.enable_resource_name_dns_aaaa_record {
        scope_5221.boolean(*var_5222);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_reserved_instances(
    input: &crate::input::ModifyReservedInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyReservedInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5223 = writer.prefix("ReservedInstancesId");
    if let Some(var_5224) = &input.reserved_instances_ids {
        let mut list_5226 = scope_5223.start_list(true, Some("ReservedInstancesId"));
        for item_5225 in var_5224 {
            #[allow(unused_mut)]
            let mut entry_5227 = list_5226.entry();
            entry_5227.string(item_5225);
        }
        list_5226.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5228 = writer.prefix("ClientToken");
    if let Some(var_5229) = &input.client_token {
        scope_5228.string(var_5229);
    }
    #[allow(unused_mut)]
    let mut scope_5230 = writer.prefix("ReservedInstancesConfigurationSetItemType");
    if let Some(var_5231) = &input.target_configurations {
        let mut list_5233 = scope_5230.start_list(true, Some("item"));
        for item_5232 in var_5231 {
            #[allow(unused_mut)]
            let mut entry_5234 = list_5233.entry();
            crate::query_ser::serialize_structure_crate_model_reserved_instances_configuration(
                entry_5234, item_5232,
            )?;
        }
        list_5233.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_security_group_rules(
    input: &crate::input::ModifySecurityGroupRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifySecurityGroupRules", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5235 = writer.prefix("GroupId");
    if let Some(var_5236) = &input.group_id {
        scope_5235.string(var_5236);
    }
    #[allow(unused_mut)]
    let mut scope_5237 = writer.prefix("SecurityGroupRule");
    if let Some(var_5238) = &input.security_group_rules {
        let mut list_5240 = scope_5237.start_list(true, Some("item"));
        for item_5239 in var_5238 {
            #[allow(unused_mut)]
            let mut entry_5241 = list_5240.entry();
            crate::query_ser::serialize_structure_crate_model_security_group_rule_update(
                entry_5241, item_5239,
            )?;
        }
        list_5240.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5242 = writer.prefix("DryRun");
    if let Some(var_5243) = &input.dry_run {
        scope_5242.boolean(*var_5243);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_snapshot_attribute(
    input: &crate::input::ModifySnapshotAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifySnapshotAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5244 = writer.prefix("Attribute");
    if let Some(var_5245) = &input.attribute {
        scope_5244.string(var_5245.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5246 = writer.prefix("CreateVolumePermission");
    if let Some(var_5247) = &input.create_volume_permission {
        crate::query_ser::serialize_structure_crate_model_create_volume_permission_modifications(
            scope_5246, var_5247,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5248 = writer.prefix("UserGroup");
    if let Some(var_5249) = &input.group_names {
        let mut list_5251 = scope_5248.start_list(true, Some("GroupName"));
        for item_5250 in var_5249 {
            #[allow(unused_mut)]
            let mut entry_5252 = list_5251.entry();
            entry_5252.string(item_5250);
        }
        list_5251.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5253 = writer.prefix("OperationType");
    if let Some(var_5254) = &input.operation_type {
        scope_5253.string(var_5254.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5255 = writer.prefix("SnapshotId");
    if let Some(var_5256) = &input.snapshot_id {
        scope_5255.string(var_5256);
    }
    #[allow(unused_mut)]
    let mut scope_5257 = writer.prefix("UserId");
    if let Some(var_5258) = &input.user_ids {
        let mut list_5260 = scope_5257.start_list(true, Some("UserId"));
        for item_5259 in var_5258 {
            #[allow(unused_mut)]
            let mut entry_5261 = list_5260.entry();
            entry_5261.string(item_5259);
        }
        list_5260.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5262 = writer.prefix("DryRun");
    if let Some(var_5263) = &input.dry_run {
        scope_5262.boolean(*var_5263);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_snapshot_tier(
    input: &crate::input::ModifySnapshotTierInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifySnapshotTier", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5264 = writer.prefix("SnapshotId");
    if let Some(var_5265) = &input.snapshot_id {
        scope_5264.string(var_5265);
    }
    #[allow(unused_mut)]
    let mut scope_5266 = writer.prefix("StorageTier");
    if let Some(var_5267) = &input.storage_tier {
        scope_5266.string(var_5267.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5268 = writer.prefix("DryRun");
    if let Some(var_5269) = &input.dry_run {
        scope_5268.boolean(*var_5269);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_spot_fleet_request(
    input: &crate::input::ModifySpotFleetRequestInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifySpotFleetRequest", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5270 = writer.prefix("ExcessCapacityTerminationPolicy");
    if let Some(var_5271) = &input.excess_capacity_termination_policy {
        scope_5270.string(var_5271.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5272 = writer.prefix("LaunchTemplateConfig");
    if let Some(var_5273) = &input.launch_template_configs {
        let mut list_5275 = scope_5272.start_list(true, Some("item"));
        for item_5274 in var_5273 {
            #[allow(unused_mut)]
            let mut entry_5276 = list_5275.entry();
            crate::query_ser::serialize_structure_crate_model_launch_template_config(
                entry_5276, item_5274,
            )?;
        }
        list_5275.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5277 = writer.prefix("SpotFleetRequestId");
    if let Some(var_5278) = &input.spot_fleet_request_id {
        scope_5277.string(var_5278);
    }
    #[allow(unused_mut)]
    let mut scope_5279 = writer.prefix("TargetCapacity");
    if let Some(var_5280) = &input.target_capacity {
        scope_5279.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5280).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5281 = writer.prefix("OnDemandTargetCapacity");
    if let Some(var_5282) = &input.on_demand_target_capacity {
        scope_5281.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5282).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5283 = writer.prefix("Context");
    if let Some(var_5284) = &input.context {
        scope_5283.string(var_5284);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_subnet_attribute(
    input: &crate::input::ModifySubnetAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifySubnetAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5285 = writer.prefix("AssignIpv6AddressOnCreation");
    if let Some(var_5286) = &input.assign_ipv6_address_on_creation {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5285, var_5286,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5287 = writer.prefix("MapPublicIpOnLaunch");
    if let Some(var_5288) = &input.map_public_ip_on_launch {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5287, var_5288,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5289 = writer.prefix("SubnetId");
    if let Some(var_5290) = &input.subnet_id {
        scope_5289.string(var_5290);
    }
    #[allow(unused_mut)]
    let mut scope_5291 = writer.prefix("MapCustomerOwnedIpOnLaunch");
    if let Some(var_5292) = &input.map_customer_owned_ip_on_launch {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5291, var_5292,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5293 = writer.prefix("CustomerOwnedIpv4Pool");
    if let Some(var_5294) = &input.customer_owned_ipv4_pool {
        scope_5293.string(var_5294);
    }
    #[allow(unused_mut)]
    let mut scope_5295 = writer.prefix("EnableDns64");
    if let Some(var_5296) = &input.enable_dns64 {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5295, var_5296,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5297 = writer.prefix("PrivateDnsHostnameTypeOnLaunch");
    if let Some(var_5298) = &input.private_dns_hostname_type_on_launch {
        scope_5297.string(var_5298.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5299 = writer.prefix("EnableResourceNameDnsARecordOnLaunch");
    if let Some(var_5300) = &input.enable_resource_name_dns_a_record_on_launch {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5299, var_5300,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5301 = writer.prefix("EnableResourceNameDnsAAAARecordOnLaunch");
    if let Some(var_5302) = &input.enable_resource_name_dns_aaaa_record_on_launch {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5301, var_5302,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5303 = writer.prefix("EnableLniAtDeviceIndex");
    if let Some(var_5304) = &input.enable_lni_at_device_index {
        scope_5303.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5304).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5305 = writer.prefix("DisableLniAtDeviceIndex");
    if let Some(var_5306) = &input.disable_lni_at_device_index {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5305, var_5306,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_traffic_mirror_filter_network_services(
    input: &crate::input::ModifyTrafficMirrorFilterNetworkServicesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyTrafficMirrorFilterNetworkServices",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5307 = writer.prefix("TrafficMirrorFilterId");
    if let Some(var_5308) = &input.traffic_mirror_filter_id {
        scope_5307.string(var_5308);
    }
    #[allow(unused_mut)]
    let mut scope_5309 = writer.prefix("AddNetworkService");
    if let Some(var_5310) = &input.add_network_services {
        let mut list_5312 = scope_5309.start_list(true, Some("item"));
        for item_5311 in var_5310 {
            #[allow(unused_mut)]
            let mut entry_5313 = list_5312.entry();
            entry_5313.string(item_5311.as_str());
        }
        list_5312.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5314 = writer.prefix("RemoveNetworkService");
    if let Some(var_5315) = &input.remove_network_services {
        let mut list_5317 = scope_5314.start_list(true, Some("item"));
        for item_5316 in var_5315 {
            #[allow(unused_mut)]
            let mut entry_5318 = list_5317.entry();
            entry_5318.string(item_5316.as_str());
        }
        list_5317.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5319 = writer.prefix("DryRun");
    if let Some(var_5320) = &input.dry_run {
        scope_5319.boolean(*var_5320);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_traffic_mirror_filter_rule(
    input: &crate::input::ModifyTrafficMirrorFilterRuleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyTrafficMirrorFilterRule", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5321 = writer.prefix("TrafficMirrorFilterRuleId");
    if let Some(var_5322) = &input.traffic_mirror_filter_rule_id {
        scope_5321.string(var_5322);
    }
    #[allow(unused_mut)]
    let mut scope_5323 = writer.prefix("TrafficDirection");
    if let Some(var_5324) = &input.traffic_direction {
        scope_5323.string(var_5324.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5325 = writer.prefix("RuleNumber");
    if let Some(var_5326) = &input.rule_number {
        scope_5325.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5326).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5327 = writer.prefix("RuleAction");
    if let Some(var_5328) = &input.rule_action {
        scope_5327.string(var_5328.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5329 = writer.prefix("DestinationPortRange");
    if let Some(var_5330) = &input.destination_port_range {
        crate::query_ser::serialize_structure_crate_model_traffic_mirror_port_range_request(
            scope_5329, var_5330,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5331 = writer.prefix("SourcePortRange");
    if let Some(var_5332) = &input.source_port_range {
        crate::query_ser::serialize_structure_crate_model_traffic_mirror_port_range_request(
            scope_5331, var_5332,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5333 = writer.prefix("Protocol");
    if let Some(var_5334) = &input.protocol {
        scope_5333.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5334).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5335 = writer.prefix("DestinationCidrBlock");
    if let Some(var_5336) = &input.destination_cidr_block {
        scope_5335.string(var_5336);
    }
    #[allow(unused_mut)]
    let mut scope_5337 = writer.prefix("SourceCidrBlock");
    if let Some(var_5338) = &input.source_cidr_block {
        scope_5337.string(var_5338);
    }
    #[allow(unused_mut)]
    let mut scope_5339 = writer.prefix("Description");
    if let Some(var_5340) = &input.description {
        scope_5339.string(var_5340);
    }
    #[allow(unused_mut)]
    let mut scope_5341 = writer.prefix("RemoveField");
    if let Some(var_5342) = &input.remove_fields {
        let mut list_5344 = scope_5341.start_list(true, None);
        for item_5343 in var_5342 {
            #[allow(unused_mut)]
            let mut entry_5345 = list_5344.entry();
            entry_5345.string(item_5343.as_str());
        }
        list_5344.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5346 = writer.prefix("DryRun");
    if let Some(var_5347) = &input.dry_run {
        scope_5346.boolean(*var_5347);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_traffic_mirror_session(
    input: &crate::input::ModifyTrafficMirrorSessionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyTrafficMirrorSession", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5348 = writer.prefix("TrafficMirrorSessionId");
    if let Some(var_5349) = &input.traffic_mirror_session_id {
        scope_5348.string(var_5349);
    }
    #[allow(unused_mut)]
    let mut scope_5350 = writer.prefix("TrafficMirrorTargetId");
    if let Some(var_5351) = &input.traffic_mirror_target_id {
        scope_5350.string(var_5351);
    }
    #[allow(unused_mut)]
    let mut scope_5352 = writer.prefix("TrafficMirrorFilterId");
    if let Some(var_5353) = &input.traffic_mirror_filter_id {
        scope_5352.string(var_5353);
    }
    #[allow(unused_mut)]
    let mut scope_5354 = writer.prefix("PacketLength");
    if let Some(var_5355) = &input.packet_length {
        scope_5354.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5355).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5356 = writer.prefix("SessionNumber");
    if let Some(var_5357) = &input.session_number {
        scope_5356.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5357).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5358 = writer.prefix("VirtualNetworkId");
    if let Some(var_5359) = &input.virtual_network_id {
        scope_5358.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5359).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5360 = writer.prefix("Description");
    if let Some(var_5361) = &input.description {
        scope_5360.string(var_5361);
    }
    #[allow(unused_mut)]
    let mut scope_5362 = writer.prefix("RemoveField");
    if let Some(var_5363) = &input.remove_fields {
        let mut list_5365 = scope_5362.start_list(true, None);
        for item_5364 in var_5363 {
            #[allow(unused_mut)]
            let mut entry_5366 = list_5365.entry();
            entry_5366.string(item_5364.as_str());
        }
        list_5365.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5367 = writer.prefix("DryRun");
    if let Some(var_5368) = &input.dry_run {
        scope_5367.boolean(*var_5368);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_transit_gateway(
    input: &crate::input::ModifyTransitGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyTransitGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5369 = writer.prefix("TransitGatewayId");
    if let Some(var_5370) = &input.transit_gateway_id {
        scope_5369.string(var_5370);
    }
    #[allow(unused_mut)]
    let mut scope_5371 = writer.prefix("Description");
    if let Some(var_5372) = &input.description {
        scope_5371.string(var_5372);
    }
    #[allow(unused_mut)]
    let mut scope_5373 = writer.prefix("Options");
    if let Some(var_5374) = &input.options {
        crate::query_ser::serialize_structure_crate_model_modify_transit_gateway_options(
            scope_5373, var_5374,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5375 = writer.prefix("DryRun");
    if let Some(var_5376) = &input.dry_run {
        scope_5375.boolean(*var_5376);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_transit_gateway_prefix_list_reference(
    input: &crate::input::ModifyTransitGatewayPrefixListReferenceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyTransitGatewayPrefixListReference",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5377 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_5378) = &input.transit_gateway_route_table_id {
        scope_5377.string(var_5378);
    }
    #[allow(unused_mut)]
    let mut scope_5379 = writer.prefix("PrefixListId");
    if let Some(var_5380) = &input.prefix_list_id {
        scope_5379.string(var_5380);
    }
    #[allow(unused_mut)]
    let mut scope_5381 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_5382) = &input.transit_gateway_attachment_id {
        scope_5381.string(var_5382);
    }
    #[allow(unused_mut)]
    let mut scope_5383 = writer.prefix("Blackhole");
    if let Some(var_5384) = &input.blackhole {
        scope_5383.boolean(*var_5384);
    }
    #[allow(unused_mut)]
    let mut scope_5385 = writer.prefix("DryRun");
    if let Some(var_5386) = &input.dry_run {
        scope_5385.boolean(*var_5386);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_transit_gateway_vpc_attachment(
    input: &crate::input::ModifyTransitGatewayVpcAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyTransitGatewayVpcAttachment",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5387 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_5388) = &input.transit_gateway_attachment_id {
        scope_5387.string(var_5388);
    }
    #[allow(unused_mut)]
    let mut scope_5389 = writer.prefix("AddSubnetIds");
    if let Some(var_5390) = &input.add_subnet_ids {
        let mut list_5392 = scope_5389.start_list(true, Some("item"));
        for item_5391 in var_5390 {
            #[allow(unused_mut)]
            let mut entry_5393 = list_5392.entry();
            entry_5393.string(item_5391);
        }
        list_5392.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5394 = writer.prefix("RemoveSubnetIds");
    if let Some(var_5395) = &input.remove_subnet_ids {
        let mut list_5397 = scope_5394.start_list(true, Some("item"));
        for item_5396 in var_5395 {
            #[allow(unused_mut)]
            let mut entry_5398 = list_5397.entry();
            entry_5398.string(item_5396);
        }
        list_5397.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5399 = writer.prefix("Options");
    if let Some(var_5400) = &input.options {
        crate::query_ser::serialize_structure_crate_model_modify_transit_gateway_vpc_attachment_request_options(scope_5399, var_5400)?;
    }
    #[allow(unused_mut)]
    let mut scope_5401 = writer.prefix("DryRun");
    if let Some(var_5402) = &input.dry_run {
        scope_5401.boolean(*var_5402);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_volume(
    input: &crate::input::ModifyVolumeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyVolume", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5403 = writer.prefix("DryRun");
    if let Some(var_5404) = &input.dry_run {
        scope_5403.boolean(*var_5404);
    }
    #[allow(unused_mut)]
    let mut scope_5405 = writer.prefix("VolumeId");
    if let Some(var_5406) = &input.volume_id {
        scope_5405.string(var_5406);
    }
    #[allow(unused_mut)]
    let mut scope_5407 = writer.prefix("Size");
    if let Some(var_5408) = &input.size {
        scope_5407.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5408).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5409 = writer.prefix("VolumeType");
    if let Some(var_5410) = &input.volume_type {
        scope_5409.string(var_5410.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5411 = writer.prefix("Iops");
    if let Some(var_5412) = &input.iops {
        scope_5411.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5412).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5413 = writer.prefix("Throughput");
    if let Some(var_5414) = &input.throughput {
        scope_5413.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5414).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5415 = writer.prefix("MultiAttachEnabled");
    if let Some(var_5416) = &input.multi_attach_enabled {
        scope_5415.boolean(*var_5416);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_volume_attribute(
    input: &crate::input::ModifyVolumeAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyVolumeAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5417 = writer.prefix("AutoEnableIO");
    if let Some(var_5418) = &input.auto_enable_io {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5417, var_5418,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5419 = writer.prefix("VolumeId");
    if let Some(var_5420) = &input.volume_id {
        scope_5419.string(var_5420);
    }
    #[allow(unused_mut)]
    let mut scope_5421 = writer.prefix("DryRun");
    if let Some(var_5422) = &input.dry_run {
        scope_5421.boolean(*var_5422);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpc_attribute(
    input: &crate::input::ModifyVpcAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpcAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5423 = writer.prefix("EnableDnsHostnames");
    if let Some(var_5424) = &input.enable_dns_hostnames {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5423, var_5424,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5425 = writer.prefix("EnableDnsSupport");
    if let Some(var_5426) = &input.enable_dns_support {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5425, var_5426,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5427 = writer.prefix("VpcId");
    if let Some(var_5428) = &input.vpc_id {
        scope_5427.string(var_5428);
    }
    #[allow(unused_mut)]
    let mut scope_5429 = writer.prefix("EnableNetworkAddressUsageMetrics");
    if let Some(var_5430) = &input.enable_network_address_usage_metrics {
        crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
            scope_5429, var_5430,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpc_endpoint(
    input: &crate::input::ModifyVpcEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpcEndpoint", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5431 = writer.prefix("DryRun");
    if let Some(var_5432) = &input.dry_run {
        scope_5431.boolean(*var_5432);
    }
    #[allow(unused_mut)]
    let mut scope_5433 = writer.prefix("VpcEndpointId");
    if let Some(var_5434) = &input.vpc_endpoint_id {
        scope_5433.string(var_5434);
    }
    #[allow(unused_mut)]
    let mut scope_5435 = writer.prefix("ResetPolicy");
    if let Some(var_5436) = &input.reset_policy {
        scope_5435.boolean(*var_5436);
    }
    #[allow(unused_mut)]
    let mut scope_5437 = writer.prefix("PolicyDocument");
    if let Some(var_5438) = &input.policy_document {
        scope_5437.string(var_5438);
    }
    #[allow(unused_mut)]
    let mut scope_5439 = writer.prefix("AddRouteTableId");
    if let Some(var_5440) = &input.add_route_table_ids {
        let mut list_5442 = scope_5439.start_list(true, Some("item"));
        for item_5441 in var_5440 {
            #[allow(unused_mut)]
            let mut entry_5443 = list_5442.entry();
            entry_5443.string(item_5441);
        }
        list_5442.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5444 = writer.prefix("RemoveRouteTableId");
    if let Some(var_5445) = &input.remove_route_table_ids {
        let mut list_5447 = scope_5444.start_list(true, Some("item"));
        for item_5446 in var_5445 {
            #[allow(unused_mut)]
            let mut entry_5448 = list_5447.entry();
            entry_5448.string(item_5446);
        }
        list_5447.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5449 = writer.prefix("AddSubnetId");
    if let Some(var_5450) = &input.add_subnet_ids {
        let mut list_5452 = scope_5449.start_list(true, Some("item"));
        for item_5451 in var_5450 {
            #[allow(unused_mut)]
            let mut entry_5453 = list_5452.entry();
            entry_5453.string(item_5451);
        }
        list_5452.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5454 = writer.prefix("RemoveSubnetId");
    if let Some(var_5455) = &input.remove_subnet_ids {
        let mut list_5457 = scope_5454.start_list(true, Some("item"));
        for item_5456 in var_5455 {
            #[allow(unused_mut)]
            let mut entry_5458 = list_5457.entry();
            entry_5458.string(item_5456);
        }
        list_5457.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5459 = writer.prefix("AddSecurityGroupId");
    if let Some(var_5460) = &input.add_security_group_ids {
        let mut list_5462 = scope_5459.start_list(true, Some("item"));
        for item_5461 in var_5460 {
            #[allow(unused_mut)]
            let mut entry_5463 = list_5462.entry();
            entry_5463.string(item_5461);
        }
        list_5462.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5464 = writer.prefix("RemoveSecurityGroupId");
    if let Some(var_5465) = &input.remove_security_group_ids {
        let mut list_5467 = scope_5464.start_list(true, Some("item"));
        for item_5466 in var_5465 {
            #[allow(unused_mut)]
            let mut entry_5468 = list_5467.entry();
            entry_5468.string(item_5466);
        }
        list_5467.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5469 = writer.prefix("IpAddressType");
    if let Some(var_5470) = &input.ip_address_type {
        scope_5469.string(var_5470.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5471 = writer.prefix("DnsOptions");
    if let Some(var_5472) = &input.dns_options {
        crate::query_ser::serialize_structure_crate_model_dns_options_specification(
            scope_5471, var_5472,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5473 = writer.prefix("PrivateDnsEnabled");
    if let Some(var_5474) = &input.private_dns_enabled {
        scope_5473.boolean(*var_5474);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpc_endpoint_connection_notification(
    input: &crate::input::ModifyVpcEndpointConnectionNotificationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyVpcEndpointConnectionNotification",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5475 = writer.prefix("DryRun");
    if let Some(var_5476) = &input.dry_run {
        scope_5475.boolean(*var_5476);
    }
    #[allow(unused_mut)]
    let mut scope_5477 = writer.prefix("ConnectionNotificationId");
    if let Some(var_5478) = &input.connection_notification_id {
        scope_5477.string(var_5478);
    }
    #[allow(unused_mut)]
    let mut scope_5479 = writer.prefix("ConnectionNotificationArn");
    if let Some(var_5480) = &input.connection_notification_arn {
        scope_5479.string(var_5480);
    }
    #[allow(unused_mut)]
    let mut scope_5481 = writer.prefix("ConnectionEvents");
    if let Some(var_5482) = &input.connection_events {
        let mut list_5484 = scope_5481.start_list(true, Some("item"));
        for item_5483 in var_5482 {
            #[allow(unused_mut)]
            let mut entry_5485 = list_5484.entry();
            entry_5485.string(item_5483);
        }
        list_5484.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpc_endpoint_service_configuration(
    input: &crate::input::ModifyVpcEndpointServiceConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyVpcEndpointServiceConfiguration",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5486 = writer.prefix("DryRun");
    if let Some(var_5487) = &input.dry_run {
        scope_5486.boolean(*var_5487);
    }
    #[allow(unused_mut)]
    let mut scope_5488 = writer.prefix("ServiceId");
    if let Some(var_5489) = &input.service_id {
        scope_5488.string(var_5489);
    }
    #[allow(unused_mut)]
    let mut scope_5490 = writer.prefix("PrivateDnsName");
    if let Some(var_5491) = &input.private_dns_name {
        scope_5490.string(var_5491);
    }
    #[allow(unused_mut)]
    let mut scope_5492 = writer.prefix("RemovePrivateDnsName");
    if let Some(var_5493) = &input.remove_private_dns_name {
        scope_5492.boolean(*var_5493);
    }
    #[allow(unused_mut)]
    let mut scope_5494 = writer.prefix("AcceptanceRequired");
    if let Some(var_5495) = &input.acceptance_required {
        scope_5494.boolean(*var_5495);
    }
    #[allow(unused_mut)]
    let mut scope_5496 = writer.prefix("AddNetworkLoadBalancerArn");
    if let Some(var_5497) = &input.add_network_load_balancer_arns {
        let mut list_5499 = scope_5496.start_list(true, Some("item"));
        for item_5498 in var_5497 {
            #[allow(unused_mut)]
            let mut entry_5500 = list_5499.entry();
            entry_5500.string(item_5498);
        }
        list_5499.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5501 = writer.prefix("RemoveNetworkLoadBalancerArn");
    if let Some(var_5502) = &input.remove_network_load_balancer_arns {
        let mut list_5504 = scope_5501.start_list(true, Some("item"));
        for item_5503 in var_5502 {
            #[allow(unused_mut)]
            let mut entry_5505 = list_5504.entry();
            entry_5505.string(item_5503);
        }
        list_5504.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5506 = writer.prefix("AddGatewayLoadBalancerArn");
    if let Some(var_5507) = &input.add_gateway_load_balancer_arns {
        let mut list_5509 = scope_5506.start_list(true, Some("item"));
        for item_5508 in var_5507 {
            #[allow(unused_mut)]
            let mut entry_5510 = list_5509.entry();
            entry_5510.string(item_5508);
        }
        list_5509.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5511 = writer.prefix("RemoveGatewayLoadBalancerArn");
    if let Some(var_5512) = &input.remove_gateway_load_balancer_arns {
        let mut list_5514 = scope_5511.start_list(true, Some("item"));
        for item_5513 in var_5512 {
            #[allow(unused_mut)]
            let mut entry_5515 = list_5514.entry();
            entry_5515.string(item_5513);
        }
        list_5514.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5516 = writer.prefix("AddSupportedIpAddressType");
    if let Some(var_5517) = &input.add_supported_ip_address_types {
        let mut list_5519 = scope_5516.start_list(true, Some("item"));
        for item_5518 in var_5517 {
            #[allow(unused_mut)]
            let mut entry_5520 = list_5519.entry();
            entry_5520.string(item_5518);
        }
        list_5519.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5521 = writer.prefix("RemoveSupportedIpAddressType");
    if let Some(var_5522) = &input.remove_supported_ip_address_types {
        let mut list_5524 = scope_5521.start_list(true, Some("item"));
        for item_5523 in var_5522 {
            #[allow(unused_mut)]
            let mut entry_5525 = list_5524.entry();
            entry_5525.string(item_5523);
        }
        list_5524.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpc_endpoint_service_payer_responsibility(
    input: &crate::input::ModifyVpcEndpointServicePayerResponsibilityInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyVpcEndpointServicePayerResponsibility",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5526 = writer.prefix("DryRun");
    if let Some(var_5527) = &input.dry_run {
        scope_5526.boolean(*var_5527);
    }
    #[allow(unused_mut)]
    let mut scope_5528 = writer.prefix("ServiceId");
    if let Some(var_5529) = &input.service_id {
        scope_5528.string(var_5529);
    }
    #[allow(unused_mut)]
    let mut scope_5530 = writer.prefix("PayerResponsibility");
    if let Some(var_5531) = &input.payer_responsibility {
        scope_5530.string(var_5531.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpc_endpoint_service_permissions(
    input: &crate::input::ModifyVpcEndpointServicePermissionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyVpcEndpointServicePermissions",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5532 = writer.prefix("DryRun");
    if let Some(var_5533) = &input.dry_run {
        scope_5532.boolean(*var_5533);
    }
    #[allow(unused_mut)]
    let mut scope_5534 = writer.prefix("ServiceId");
    if let Some(var_5535) = &input.service_id {
        scope_5534.string(var_5535);
    }
    #[allow(unused_mut)]
    let mut scope_5536 = writer.prefix("AddAllowedPrincipals");
    if let Some(var_5537) = &input.add_allowed_principals {
        let mut list_5539 = scope_5536.start_list(true, Some("item"));
        for item_5538 in var_5537 {
            #[allow(unused_mut)]
            let mut entry_5540 = list_5539.entry();
            entry_5540.string(item_5538);
        }
        list_5539.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5541 = writer.prefix("RemoveAllowedPrincipals");
    if let Some(var_5542) = &input.remove_allowed_principals {
        let mut list_5544 = scope_5541.start_list(true, Some("item"));
        for item_5543 in var_5542 {
            #[allow(unused_mut)]
            let mut entry_5545 = list_5544.entry();
            entry_5545.string(item_5543);
        }
        list_5544.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpc_peering_connection_options(
    input: &crate::input::ModifyVpcPeeringConnectionOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ModifyVpcPeeringConnectionOptions",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5546 = writer.prefix("AccepterPeeringConnectionOptions");
    if let Some(var_5547) = &input.accepter_peering_connection_options {
        crate::query_ser::serialize_structure_crate_model_peering_connection_options_request(
            scope_5546, var_5547,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5548 = writer.prefix("DryRun");
    if let Some(var_5549) = &input.dry_run {
        scope_5548.boolean(*var_5549);
    }
    #[allow(unused_mut)]
    let mut scope_5550 = writer.prefix("RequesterPeeringConnectionOptions");
    if let Some(var_5551) = &input.requester_peering_connection_options {
        crate::query_ser::serialize_structure_crate_model_peering_connection_options_request(
            scope_5550, var_5551,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5552 = writer.prefix("VpcPeeringConnectionId");
    if let Some(var_5553) = &input.vpc_peering_connection_id {
        scope_5552.string(var_5553);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpc_tenancy(
    input: &crate::input::ModifyVpcTenancyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpcTenancy", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5554 = writer.prefix("VpcId");
    if let Some(var_5555) = &input.vpc_id {
        scope_5554.string(var_5555);
    }
    #[allow(unused_mut)]
    let mut scope_5556 = writer.prefix("InstanceTenancy");
    if let Some(var_5557) = &input.instance_tenancy {
        scope_5556.string(var_5557.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5558 = writer.prefix("DryRun");
    if let Some(var_5559) = &input.dry_run {
        scope_5558.boolean(*var_5559);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpn_connection(
    input: &crate::input::ModifyVpnConnectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpnConnection", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5560 = writer.prefix("VpnConnectionId");
    if let Some(var_5561) = &input.vpn_connection_id {
        scope_5560.string(var_5561);
    }
    #[allow(unused_mut)]
    let mut scope_5562 = writer.prefix("TransitGatewayId");
    if let Some(var_5563) = &input.transit_gateway_id {
        scope_5562.string(var_5563);
    }
    #[allow(unused_mut)]
    let mut scope_5564 = writer.prefix("CustomerGatewayId");
    if let Some(var_5565) = &input.customer_gateway_id {
        scope_5564.string(var_5565);
    }
    #[allow(unused_mut)]
    let mut scope_5566 = writer.prefix("VpnGatewayId");
    if let Some(var_5567) = &input.vpn_gateway_id {
        scope_5566.string(var_5567);
    }
    #[allow(unused_mut)]
    let mut scope_5568 = writer.prefix("DryRun");
    if let Some(var_5569) = &input.dry_run {
        scope_5568.boolean(*var_5569);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpn_connection_options(
    input: &crate::input::ModifyVpnConnectionOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpnConnectionOptions", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5570 = writer.prefix("VpnConnectionId");
    if let Some(var_5571) = &input.vpn_connection_id {
        scope_5570.string(var_5571);
    }
    #[allow(unused_mut)]
    let mut scope_5572 = writer.prefix("LocalIpv4NetworkCidr");
    if let Some(var_5573) = &input.local_ipv4_network_cidr {
        scope_5572.string(var_5573);
    }
    #[allow(unused_mut)]
    let mut scope_5574 = writer.prefix("RemoteIpv4NetworkCidr");
    if let Some(var_5575) = &input.remote_ipv4_network_cidr {
        scope_5574.string(var_5575);
    }
    #[allow(unused_mut)]
    let mut scope_5576 = writer.prefix("LocalIpv6NetworkCidr");
    if let Some(var_5577) = &input.local_ipv6_network_cidr {
        scope_5576.string(var_5577);
    }
    #[allow(unused_mut)]
    let mut scope_5578 = writer.prefix("RemoteIpv6NetworkCidr");
    if let Some(var_5579) = &input.remote_ipv6_network_cidr {
        scope_5578.string(var_5579);
    }
    #[allow(unused_mut)]
    let mut scope_5580 = writer.prefix("DryRun");
    if let Some(var_5581) = &input.dry_run {
        scope_5580.boolean(*var_5581);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpn_tunnel_certificate(
    input: &crate::input::ModifyVpnTunnelCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpnTunnelCertificate", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5582 = writer.prefix("VpnConnectionId");
    if let Some(var_5583) = &input.vpn_connection_id {
        scope_5582.string(var_5583);
    }
    #[allow(unused_mut)]
    let mut scope_5584 = writer.prefix("VpnTunnelOutsideIpAddress");
    if let Some(var_5585) = &input.vpn_tunnel_outside_ip_address {
        scope_5584.string(var_5585);
    }
    #[allow(unused_mut)]
    let mut scope_5586 = writer.prefix("DryRun");
    if let Some(var_5587) = &input.dry_run {
        scope_5586.boolean(*var_5587);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_modify_vpn_tunnel_options(
    input: &crate::input::ModifyVpnTunnelOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpnTunnelOptions", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5588 = writer.prefix("VpnConnectionId");
    if let Some(var_5589) = &input.vpn_connection_id {
        scope_5588.string(var_5589);
    }
    #[allow(unused_mut)]
    let mut scope_5590 = writer.prefix("VpnTunnelOutsideIpAddress");
    if let Some(var_5591) = &input.vpn_tunnel_outside_ip_address {
        scope_5590.string(var_5591);
    }
    #[allow(unused_mut)]
    let mut scope_5592 = writer.prefix("TunnelOptions");
    if let Some(var_5593) = &input.tunnel_options {
        crate::query_ser::serialize_structure_crate_model_modify_vpn_tunnel_options_specification(
            scope_5592, var_5593,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5594 = writer.prefix("DryRun");
    if let Some(var_5595) = &input.dry_run {
        scope_5594.boolean(*var_5595);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_monitor_instances(
    input: &crate::input::MonitorInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "MonitorInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5596 = writer.prefix("InstanceId");
    if let Some(var_5597) = &input.instance_ids {
        let mut list_5599 = scope_5596.start_list(true, Some("InstanceId"));
        for item_5598 in var_5597 {
            #[allow(unused_mut)]
            let mut entry_5600 = list_5599.entry();
            entry_5600.string(item_5598);
        }
        list_5599.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5601 = writer.prefix("DryRun");
    if let Some(var_5602) = &input.dry_run {
        scope_5601.boolean(*var_5602);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_move_address_to_vpc(
    input: &crate::input::MoveAddressToVpcInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "MoveAddressToVpc", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5603 = writer.prefix("DryRun");
    if let Some(var_5604) = &input.dry_run {
        scope_5603.boolean(*var_5604);
    }
    #[allow(unused_mut)]
    let mut scope_5605 = writer.prefix("PublicIp");
    if let Some(var_5606) = &input.public_ip {
        scope_5605.string(var_5606);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_move_byoip_cidr_to_ipam(
    input: &crate::input::MoveByoipCidrToIpamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "MoveByoipCidrToIpam", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5607 = writer.prefix("DryRun");
    if let Some(var_5608) = &input.dry_run {
        scope_5607.boolean(*var_5608);
    }
    #[allow(unused_mut)]
    let mut scope_5609 = writer.prefix("Cidr");
    if let Some(var_5610) = &input.cidr {
        scope_5609.string(var_5610);
    }
    #[allow(unused_mut)]
    let mut scope_5611 = writer.prefix("IpamPoolId");
    if let Some(var_5612) = &input.ipam_pool_id {
        scope_5611.string(var_5612);
    }
    #[allow(unused_mut)]
    let mut scope_5613 = writer.prefix("IpamPoolOwner");
    if let Some(var_5614) = &input.ipam_pool_owner {
        scope_5613.string(var_5614);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_provision_byoip_cidr(
    input: &crate::input::ProvisionByoipCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ProvisionByoipCidr", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5615 = writer.prefix("Cidr");
    if let Some(var_5616) = &input.cidr {
        scope_5615.string(var_5616);
    }
    #[allow(unused_mut)]
    let mut scope_5617 = writer.prefix("CidrAuthorizationContext");
    if let Some(var_5618) = &input.cidr_authorization_context {
        crate::query_ser::serialize_structure_crate_model_cidr_authorization_context(
            scope_5617, var_5618,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5619 = writer.prefix("PubliclyAdvertisable");
    if let Some(var_5620) = &input.publicly_advertisable {
        scope_5619.boolean(*var_5620);
    }
    #[allow(unused_mut)]
    let mut scope_5621 = writer.prefix("Description");
    if let Some(var_5622) = &input.description {
        scope_5621.string(var_5622);
    }
    #[allow(unused_mut)]
    let mut scope_5623 = writer.prefix("DryRun");
    if let Some(var_5624) = &input.dry_run {
        scope_5623.boolean(*var_5624);
    }
    #[allow(unused_mut)]
    let mut scope_5625 = writer.prefix("PoolTagSpecification");
    if let Some(var_5626) = &input.pool_tag_specifications {
        let mut list_5628 = scope_5625.start_list(true, Some("item"));
        for item_5627 in var_5626 {
            #[allow(unused_mut)]
            let mut entry_5629 = list_5628.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_5629, item_5627,
            )?;
        }
        list_5628.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5630 = writer.prefix("MultiRegion");
    if let Some(var_5631) = &input.multi_region {
        scope_5630.boolean(*var_5631);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_provision_ipam_pool_cidr(
    input: &crate::input::ProvisionIpamPoolCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ProvisionIpamPoolCidr", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5632 = writer.prefix("DryRun");
    if let Some(var_5633) = &input.dry_run {
        scope_5632.boolean(*var_5633);
    }
    #[allow(unused_mut)]
    let mut scope_5634 = writer.prefix("IpamPoolId");
    if let Some(var_5635) = &input.ipam_pool_id {
        scope_5634.string(var_5635);
    }
    #[allow(unused_mut)]
    let mut scope_5636 = writer.prefix("Cidr");
    if let Some(var_5637) = &input.cidr {
        scope_5636.string(var_5637);
    }
    #[allow(unused_mut)]
    let mut scope_5638 = writer.prefix("CidrAuthorizationContext");
    if let Some(var_5639) = &input.cidr_authorization_context {
        crate::query_ser::serialize_structure_crate_model_ipam_cidr_authorization_context(
            scope_5638, var_5639,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_provision_public_ipv4_pool_cidr(
    input: &crate::input::ProvisionPublicIpv4PoolCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ProvisionPublicIpv4PoolCidr", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5640 = writer.prefix("DryRun");
    if let Some(var_5641) = &input.dry_run {
        scope_5640.boolean(*var_5641);
    }
    #[allow(unused_mut)]
    let mut scope_5642 = writer.prefix("IpamPoolId");
    if let Some(var_5643) = &input.ipam_pool_id {
        scope_5642.string(var_5643);
    }
    #[allow(unused_mut)]
    let mut scope_5644 = writer.prefix("PoolId");
    if let Some(var_5645) = &input.pool_id {
        scope_5644.string(var_5645);
    }
    #[allow(unused_mut)]
    let mut scope_5646 = writer.prefix("NetmaskLength");
    if let Some(var_5647) = &input.netmask_length {
        scope_5646.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5647).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_purchase_host_reservation(
    input: &crate::input::PurchaseHostReservationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "PurchaseHostReservation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5648 = writer.prefix("ClientToken");
    if let Some(var_5649) = &input.client_token {
        scope_5648.string(var_5649);
    }
    #[allow(unused_mut)]
    let mut scope_5650 = writer.prefix("CurrencyCode");
    if let Some(var_5651) = &input.currency_code {
        scope_5650.string(var_5651.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5652 = writer.prefix("HostIdSet");
    if let Some(var_5653) = &input.host_id_set {
        let mut list_5655 = scope_5652.start_list(true, Some("item"));
        for item_5654 in var_5653 {
            #[allow(unused_mut)]
            let mut entry_5656 = list_5655.entry();
            entry_5656.string(item_5654);
        }
        list_5655.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5657 = writer.prefix("LimitPrice");
    if let Some(var_5658) = &input.limit_price {
        scope_5657.string(var_5658);
    }
    #[allow(unused_mut)]
    let mut scope_5659 = writer.prefix("OfferingId");
    if let Some(var_5660) = &input.offering_id {
        scope_5659.string(var_5660);
    }
    #[allow(unused_mut)]
    let mut scope_5661 = writer.prefix("TagSpecification");
    if let Some(var_5662) = &input.tag_specifications {
        let mut list_5664 = scope_5661.start_list(true, Some("item"));
        for item_5663 in var_5662 {
            #[allow(unused_mut)]
            let mut entry_5665 = list_5664.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_5665, item_5663,
            )?;
        }
        list_5664.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_purchase_reserved_instances_offering(
    input: &crate::input::PurchaseReservedInstancesOfferingInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "PurchaseReservedInstancesOffering",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5666 = writer.prefix("InstanceCount");
    if let Some(var_5667) = &input.instance_count {
        scope_5666.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5667).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5668 = writer.prefix("ReservedInstancesOfferingId");
    if let Some(var_5669) = &input.reserved_instances_offering_id {
        scope_5668.string(var_5669);
    }
    #[allow(unused_mut)]
    let mut scope_5670 = writer.prefix("DryRun");
    if let Some(var_5671) = &input.dry_run {
        scope_5670.boolean(*var_5671);
    }
    #[allow(unused_mut)]
    let mut scope_5672 = writer.prefix("LimitPrice");
    if let Some(var_5673) = &input.limit_price {
        crate::query_ser::serialize_structure_crate_model_reserved_instance_limit_price(
            scope_5672, var_5673,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5674 = writer.prefix("PurchaseTime");
    if let Some(var_5675) = &input.purchase_time {
        scope_5674.date_time(var_5675, aws_smithy_types::date_time::Format::DateTime)?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_purchase_scheduled_instances(
    input: &crate::input::PurchaseScheduledInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "PurchaseScheduledInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5676 = writer.prefix("ClientToken");
    if let Some(var_5677) = &input.client_token {
        scope_5676.string(var_5677);
    }
    #[allow(unused_mut)]
    let mut scope_5678 = writer.prefix("DryRun");
    if let Some(var_5679) = &input.dry_run {
        scope_5678.boolean(*var_5679);
    }
    #[allow(unused_mut)]
    let mut scope_5680 = writer.prefix("PurchaseRequest");
    if let Some(var_5681) = &input.purchase_requests {
        let mut list_5683 = scope_5680.start_list(true, Some("PurchaseRequest"));
        for item_5682 in var_5681 {
            #[allow(unused_mut)]
            let mut entry_5684 = list_5683.entry();
            crate::query_ser::serialize_structure_crate_model_purchase_request(
                entry_5684, item_5682,
            )?;
        }
        list_5683.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reboot_instances(
    input: &crate::input::RebootInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RebootInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5685 = writer.prefix("InstanceId");
    if let Some(var_5686) = &input.instance_ids {
        let mut list_5688 = scope_5685.start_list(true, Some("InstanceId"));
        for item_5687 in var_5686 {
            #[allow(unused_mut)]
            let mut entry_5689 = list_5688.entry();
            entry_5689.string(item_5687);
        }
        list_5688.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5690 = writer.prefix("DryRun");
    if let Some(var_5691) = &input.dry_run {
        scope_5690.boolean(*var_5691);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_register_image(
    input: &crate::input::RegisterImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RegisterImage", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5692 = writer.prefix("ImageLocation");
    if let Some(var_5693) = &input.image_location {
        scope_5692.string(var_5693);
    }
    #[allow(unused_mut)]
    let mut scope_5694 = writer.prefix("Architecture");
    if let Some(var_5695) = &input.architecture {
        scope_5694.string(var_5695.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5696 = writer.prefix("BlockDeviceMapping");
    if let Some(var_5697) = &input.block_device_mappings {
        let mut list_5699 = scope_5696.start_list(true, Some("BlockDeviceMapping"));
        for item_5698 in var_5697 {
            #[allow(unused_mut)]
            let mut entry_5700 = list_5699.entry();
            crate::query_ser::serialize_structure_crate_model_block_device_mapping(
                entry_5700, item_5698,
            )?;
        }
        list_5699.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5701 = writer.prefix("Description");
    if let Some(var_5702) = &input.description {
        scope_5701.string(var_5702);
    }
    #[allow(unused_mut)]
    let mut scope_5703 = writer.prefix("DryRun");
    if let Some(var_5704) = &input.dry_run {
        scope_5703.boolean(*var_5704);
    }
    #[allow(unused_mut)]
    let mut scope_5705 = writer.prefix("EnaSupport");
    if let Some(var_5706) = &input.ena_support {
        scope_5705.boolean(*var_5706);
    }
    #[allow(unused_mut)]
    let mut scope_5707 = writer.prefix("KernelId");
    if let Some(var_5708) = &input.kernel_id {
        scope_5707.string(var_5708);
    }
    #[allow(unused_mut)]
    let mut scope_5709 = writer.prefix("Name");
    if let Some(var_5710) = &input.name {
        scope_5709.string(var_5710);
    }
    #[allow(unused_mut)]
    let mut scope_5711 = writer.prefix("BillingProduct");
    if let Some(var_5712) = &input.billing_products {
        let mut list_5714 = scope_5711.start_list(true, Some("item"));
        for item_5713 in var_5712 {
            #[allow(unused_mut)]
            let mut entry_5715 = list_5714.entry();
            entry_5715.string(item_5713);
        }
        list_5714.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5716 = writer.prefix("RamdiskId");
    if let Some(var_5717) = &input.ramdisk_id {
        scope_5716.string(var_5717);
    }
    #[allow(unused_mut)]
    let mut scope_5718 = writer.prefix("RootDeviceName");
    if let Some(var_5719) = &input.root_device_name {
        scope_5718.string(var_5719);
    }
    #[allow(unused_mut)]
    let mut scope_5720 = writer.prefix("SriovNetSupport");
    if let Some(var_5721) = &input.sriov_net_support {
        scope_5720.string(var_5721);
    }
    #[allow(unused_mut)]
    let mut scope_5722 = writer.prefix("VirtualizationType");
    if let Some(var_5723) = &input.virtualization_type {
        scope_5722.string(var_5723);
    }
    #[allow(unused_mut)]
    let mut scope_5724 = writer.prefix("BootMode");
    if let Some(var_5725) = &input.boot_mode {
        scope_5724.string(var_5725.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5726 = writer.prefix("TpmSupport");
    if let Some(var_5727) = &input.tpm_support {
        scope_5726.string(var_5727.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5728 = writer.prefix("UefiData");
    if let Some(var_5729) = &input.uefi_data {
        scope_5728.string(var_5729);
    }
    #[allow(unused_mut)]
    let mut scope_5730 = writer.prefix("ImdsSupport");
    if let Some(var_5731) = &input.imds_support {
        scope_5730.string(var_5731.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

Returns all the &str values of the enum members.

Trait Implementations

impl AsRef<str> for BootModeValues

fn as_ref(&self) -> &str

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

impl Clone for BootModeValues

fn clone(&self) -> BootModeValues

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BootModeValues

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

Formats the value using the given formatter.

impl From<&str> for BootModeValues

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for BootModeValues

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 BootModeValues

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 BootModeValues

fn cmp(&self, other: &BootModeValues) -> 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<BootModeValues> for BootModeValues

fn eq(&self, other: &BootModeValues) -> 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<BootModeValues> for BootModeValues

fn partial_cmp(&self, other: &BootModeValues) -> 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 BootModeValues

impl StructuralEq for BootModeValues

impl StructuralPartialEq for BootModeValues