Enum aws_sdk_ec2::model::GatewayType

#[non_exhaustive]
pub enum GatewayType {
    Ipsec1,
    Unknown(UnknownVariantValue),
}

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

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

Ipsec1

Unknown(UnknownVariantValue)

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

Implementations

impl GatewayType

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 36927)

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

src/operation_ser.rs (line 2269)

pub fn serialize_operation_crate_operation_create_customer_gateway(
    input: &crate::input::CreateCustomerGatewayInput,
) -> 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, "CreateCustomerGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_628 = writer.prefix("BgpAsn");
    if let Some(var_629) = &input.bgp_asn {
        scope_628.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_629).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_630 = writer.prefix("PublicIp");
    if let Some(var_631) = &input.public_ip {
        scope_630.string(var_631);
    }
    #[allow(unused_mut)]
    let mut scope_632 = writer.prefix("CertificateArn");
    if let Some(var_633) = &input.certificate_arn {
        scope_632.string(var_633);
    }
    #[allow(unused_mut)]
    let mut scope_634 = writer.prefix("Type");
    if let Some(var_635) = &input.r#type {
        scope_634.string(var_635.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_636 = writer.prefix("TagSpecification");
    if let Some(var_637) = &input.tag_specifications {
        let mut list_639 = scope_636.start_list(true, Some("item"));
        for item_638 in var_637 {
            #[allow(unused_mut)]
            let mut entry_640 = list_639.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_640, item_638,
            )?;
        }
        list_639.finish();
    }
    #[allow(unused_mut)]
    let mut scope_641 = writer.prefix("DeviceName");
    if let Some(var_642) = &input.device_name {
        scope_641.string(var_642);
    }
    #[allow(unused_mut)]
    let mut scope_643 = writer.prefix("IpAddress");
    if let Some(var_644) = &input.ip_address {
        scope_643.string(var_644);
    }
    #[allow(unused_mut)]
    let mut scope_645 = writer.prefix("DryRun");
    if let Some(var_646) = &input.dry_run {
        scope_645.boolean(*var_646);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_default_subnet(
    input: &crate::input::CreateDefaultSubnetInput,
) -> 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, "CreateDefaultSubnet", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_647 = writer.prefix("AvailabilityZone");
    if let Some(var_648) = &input.availability_zone {
        scope_647.string(var_648);
    }
    #[allow(unused_mut)]
    let mut scope_649 = writer.prefix("DryRun");
    if let Some(var_650) = &input.dry_run {
        scope_649.boolean(*var_650);
    }
    #[allow(unused_mut)]
    let mut scope_651 = writer.prefix("Ipv6Native");
    if let Some(var_652) = &input.ipv6_native {
        scope_651.boolean(*var_652);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_default_vpc(
    input: &crate::input::CreateDefaultVpcInput,
) -> 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, "CreateDefaultVpc", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_653 = writer.prefix("DryRun");
    if let Some(var_654) = &input.dry_run {
        scope_653.boolean(*var_654);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_dhcp_options(
    input: &crate::input::CreateDhcpOptionsInput,
) -> 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, "CreateDhcpOptions", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_655 = writer.prefix("DhcpConfiguration");
    if let Some(var_656) = &input.dhcp_configurations {
        let mut list_658 = scope_655.start_list(true, Some("item"));
        for item_657 in var_656 {
            #[allow(unused_mut)]
            let mut entry_659 = list_658.entry();
            crate::query_ser::serialize_structure_crate_model_new_dhcp_configuration(
                entry_659, item_657,
            )?;
        }
        list_658.finish();
    }
    #[allow(unused_mut)]
    let mut scope_660 = writer.prefix("TagSpecification");
    if let Some(var_661) = &input.tag_specifications {
        let mut list_663 = scope_660.start_list(true, Some("item"));
        for item_662 in var_661 {
            #[allow(unused_mut)]
            let mut entry_664 = list_663.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_664, item_662,
            )?;
        }
        list_663.finish();
    }
    #[allow(unused_mut)]
    let mut scope_665 = writer.prefix("DryRun");
    if let Some(var_666) = &input.dry_run {
        scope_665.boolean(*var_666);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_egress_only_internet_gateway(
    input: &crate::input::CreateEgressOnlyInternetGatewayInput,
) -> 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,
        "CreateEgressOnlyInternetGateway",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_667 = writer.prefix("ClientToken");
    if let Some(var_668) = &input.client_token {
        scope_667.string(var_668);
    }
    #[allow(unused_mut)]
    let mut scope_669 = writer.prefix("DryRun");
    if let Some(var_670) = &input.dry_run {
        scope_669.boolean(*var_670);
    }
    #[allow(unused_mut)]
    let mut scope_671 = writer.prefix("VpcId");
    if let Some(var_672) = &input.vpc_id {
        scope_671.string(var_672);
    }
    #[allow(unused_mut)]
    let mut scope_673 = writer.prefix("TagSpecification");
    if let Some(var_674) = &input.tag_specifications {
        let mut list_676 = scope_673.start_list(true, Some("item"));
        for item_675 in var_674 {
            #[allow(unused_mut)]
            let mut entry_677 = list_676.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_677, item_675,
            )?;
        }
        list_676.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_fleet(
    input: &crate::input::CreateFleetInput,
) -> 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, "CreateFleet", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_678 = writer.prefix("DryRun");
    if let Some(var_679) = &input.dry_run {
        scope_678.boolean(*var_679);
    }
    #[allow(unused_mut)]
    let mut scope_680 = writer.prefix("ClientToken");
    if let Some(var_681) = &input.client_token {
        scope_680.string(var_681);
    }
    #[allow(unused_mut)]
    let mut scope_682 = writer.prefix("SpotOptions");
    if let Some(var_683) = &input.spot_options {
        crate::query_ser::serialize_structure_crate_model_spot_options_request(scope_682, var_683)?;
    }
    #[allow(unused_mut)]
    let mut scope_684 = writer.prefix("OnDemandOptions");
    if let Some(var_685) = &input.on_demand_options {
        crate::query_ser::serialize_structure_crate_model_on_demand_options_request(
            scope_684, var_685,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_686 = writer.prefix("ExcessCapacityTerminationPolicy");
    if let Some(var_687) = &input.excess_capacity_termination_policy {
        scope_686.string(var_687.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_688 = writer.prefix("LaunchTemplateConfigs");
    if let Some(var_689) = &input.launch_template_configs {
        let mut list_691 = scope_688.start_list(true, Some("item"));
        for item_690 in var_689 {
            #[allow(unused_mut)]
            let mut entry_692 = list_691.entry();
            crate::query_ser::serialize_structure_crate_model_fleet_launch_template_config_request(
                entry_692, item_690,
            )?;
        }
        list_691.finish();
    }
    #[allow(unused_mut)]
    let mut scope_693 = writer.prefix("TargetCapacitySpecification");
    if let Some(var_694) = &input.target_capacity_specification {
        crate::query_ser::serialize_structure_crate_model_target_capacity_specification_request(
            scope_693, var_694,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_695 = writer.prefix("TerminateInstancesWithExpiration");
    if let Some(var_696) = &input.terminate_instances_with_expiration {
        scope_695.boolean(*var_696);
    }
    #[allow(unused_mut)]
    let mut scope_697 = writer.prefix("Type");
    if let Some(var_698) = &input.r#type {
        scope_697.string(var_698.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_699 = writer.prefix("ValidFrom");
    if let Some(var_700) = &input.valid_from {
        scope_699.date_time(var_700, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_701 = writer.prefix("ValidUntil");
    if let Some(var_702) = &input.valid_until {
        scope_701.date_time(var_702, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_703 = writer.prefix("ReplaceUnhealthyInstances");
    if let Some(var_704) = &input.replace_unhealthy_instances {
        scope_703.boolean(*var_704);
    }
    #[allow(unused_mut)]
    let mut scope_705 = writer.prefix("TagSpecification");
    if let Some(var_706) = &input.tag_specifications {
        let mut list_708 = scope_705.start_list(true, Some("item"));
        for item_707 in var_706 {
            #[allow(unused_mut)]
            let mut entry_709 = list_708.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_709, item_707,
            )?;
        }
        list_708.finish();
    }
    #[allow(unused_mut)]
    let mut scope_710 = writer.prefix("Context");
    if let Some(var_711) = &input.context {
        scope_710.string(var_711);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_flow_logs(
    input: &crate::input::CreateFlowLogsInput,
) -> 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, "CreateFlowLogs", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_712 = writer.prefix("DryRun");
    if let Some(var_713) = &input.dry_run {
        scope_712.boolean(*var_713);
    }
    #[allow(unused_mut)]
    let mut scope_714 = writer.prefix("ClientToken");
    if let Some(var_715) = &input.client_token {
        scope_714.string(var_715);
    }
    #[allow(unused_mut)]
    let mut scope_716 = writer.prefix("DeliverLogsPermissionArn");
    if let Some(var_717) = &input.deliver_logs_permission_arn {
        scope_716.string(var_717);
    }
    #[allow(unused_mut)]
    let mut scope_718 = writer.prefix("DeliverCrossAccountRole");
    if let Some(var_719) = &input.deliver_cross_account_role {
        scope_718.string(var_719);
    }
    #[allow(unused_mut)]
    let mut scope_720 = writer.prefix("LogGroupName");
    if let Some(var_721) = &input.log_group_name {
        scope_720.string(var_721);
    }
    #[allow(unused_mut)]
    let mut scope_722 = writer.prefix("ResourceId");
    if let Some(var_723) = &input.resource_ids {
        let mut list_725 = scope_722.start_list(true, Some("item"));
        for item_724 in var_723 {
            #[allow(unused_mut)]
            let mut entry_726 = list_725.entry();
            entry_726.string(item_724);
        }
        list_725.finish();
    }
    #[allow(unused_mut)]
    let mut scope_727 = writer.prefix("ResourceType");
    if let Some(var_728) = &input.resource_type {
        scope_727.string(var_728.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_729 = writer.prefix("TrafficType");
    if let Some(var_730) = &input.traffic_type {
        scope_729.string(var_730.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_731 = writer.prefix("LogDestinationType");
    if let Some(var_732) = &input.log_destination_type {
        scope_731.string(var_732.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_733 = writer.prefix("LogDestination");
    if let Some(var_734) = &input.log_destination {
        scope_733.string(var_734);
    }
    #[allow(unused_mut)]
    let mut scope_735 = writer.prefix("LogFormat");
    if let Some(var_736) = &input.log_format {
        scope_735.string(var_736);
    }
    #[allow(unused_mut)]
    let mut scope_737 = writer.prefix("TagSpecification");
    if let Some(var_738) = &input.tag_specifications {
        let mut list_740 = scope_737.start_list(true, Some("item"));
        for item_739 in var_738 {
            #[allow(unused_mut)]
            let mut entry_741 = list_740.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_741, item_739,
            )?;
        }
        list_740.finish();
    }
    #[allow(unused_mut)]
    let mut scope_742 = writer.prefix("MaxAggregationInterval");
    if let Some(var_743) = &input.max_aggregation_interval {
        scope_742.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_743).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_744 = writer.prefix("DestinationOptions");
    if let Some(var_745) = &input.destination_options {
        crate::query_ser::serialize_structure_crate_model_destination_options_request(
            scope_744, var_745,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_fpga_image(
    input: &crate::input::CreateFpgaImageInput,
) -> 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, "CreateFpgaImage", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_746 = writer.prefix("DryRun");
    if let Some(var_747) = &input.dry_run {
        scope_746.boolean(*var_747);
    }
    #[allow(unused_mut)]
    let mut scope_748 = writer.prefix("InputStorageLocation");
    if let Some(var_749) = &input.input_storage_location {
        crate::query_ser::serialize_structure_crate_model_storage_location(scope_748, var_749)?;
    }
    #[allow(unused_mut)]
    let mut scope_750 = writer.prefix("LogsStorageLocation");
    if let Some(var_751) = &input.logs_storage_location {
        crate::query_ser::serialize_structure_crate_model_storage_location(scope_750, var_751)?;
    }
    #[allow(unused_mut)]
    let mut scope_752 = writer.prefix("Description");
    if let Some(var_753) = &input.description {
        scope_752.string(var_753);
    }
    #[allow(unused_mut)]
    let mut scope_754 = writer.prefix("Name");
    if let Some(var_755) = &input.name {
        scope_754.string(var_755);
    }
    #[allow(unused_mut)]
    let mut scope_756 = writer.prefix("ClientToken");
    if let Some(var_757) = &input.client_token {
        scope_756.string(var_757);
    }
    #[allow(unused_mut)]
    let mut scope_758 = writer.prefix("TagSpecification");
    if let Some(var_759) = &input.tag_specifications {
        let mut list_761 = scope_758.start_list(true, Some("item"));
        for item_760 in var_759 {
            #[allow(unused_mut)]
            let mut entry_762 = list_761.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_762, item_760,
            )?;
        }
        list_761.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_image(
    input: &crate::input::CreateImageInput,
) -> 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, "CreateImage", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_763 = writer.prefix("BlockDeviceMapping");
    if let Some(var_764) = &input.block_device_mappings {
        let mut list_766 = scope_763.start_list(true, Some("BlockDeviceMapping"));
        for item_765 in var_764 {
            #[allow(unused_mut)]
            let mut entry_767 = list_766.entry();
            crate::query_ser::serialize_structure_crate_model_block_device_mapping(
                entry_767, item_765,
            )?;
        }
        list_766.finish();
    }
    #[allow(unused_mut)]
    let mut scope_768 = writer.prefix("Description");
    if let Some(var_769) = &input.description {
        scope_768.string(var_769);
    }
    #[allow(unused_mut)]
    let mut scope_770 = writer.prefix("DryRun");
    if let Some(var_771) = &input.dry_run {
        scope_770.boolean(*var_771);
    }
    #[allow(unused_mut)]
    let mut scope_772 = writer.prefix("InstanceId");
    if let Some(var_773) = &input.instance_id {
        scope_772.string(var_773);
    }
    #[allow(unused_mut)]
    let mut scope_774 = writer.prefix("Name");
    if let Some(var_775) = &input.name {
        scope_774.string(var_775);
    }
    #[allow(unused_mut)]
    let mut scope_776 = writer.prefix("NoReboot");
    if let Some(var_777) = &input.no_reboot {
        scope_776.boolean(*var_777);
    }
    #[allow(unused_mut)]
    let mut scope_778 = writer.prefix("TagSpecification");
    if let Some(var_779) = &input.tag_specifications {
        let mut list_781 = scope_778.start_list(true, Some("item"));
        for item_780 in var_779 {
            #[allow(unused_mut)]
            let mut entry_782 = list_781.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_782, item_780,
            )?;
        }
        list_781.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_instance_event_window(
    input: &crate::input::CreateInstanceEventWindowInput,
) -> 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, "CreateInstanceEventWindow", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_783 = writer.prefix("DryRun");
    if let Some(var_784) = &input.dry_run {
        scope_783.boolean(*var_784);
    }
    #[allow(unused_mut)]
    let mut scope_785 = writer.prefix("Name");
    if let Some(var_786) = &input.name {
        scope_785.string(var_786);
    }
    #[allow(unused_mut)]
    let mut scope_787 = writer.prefix("TimeRange");
    if let Some(var_788) = &input.time_ranges {
        let mut list_790 = scope_787.start_list(true, None);
        for item_789 in var_788 {
            #[allow(unused_mut)]
            let mut entry_791 = list_790.entry();
            crate::query_ser::serialize_structure_crate_model_instance_event_window_time_range_request(entry_791, item_789)?;
        }
        list_790.finish();
    }
    #[allow(unused_mut)]
    let mut scope_792 = writer.prefix("CronExpression");
    if let Some(var_793) = &input.cron_expression {
        scope_792.string(var_793);
    }
    #[allow(unused_mut)]
    let mut scope_794 = writer.prefix("TagSpecification");
    if let Some(var_795) = &input.tag_specifications {
        let mut list_797 = scope_794.start_list(true, Some("item"));
        for item_796 in var_795 {
            #[allow(unused_mut)]
            let mut entry_798 = list_797.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_798, item_796,
            )?;
        }
        list_797.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_instance_export_task(
    input: &crate::input::CreateInstanceExportTaskInput,
) -> 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, "CreateInstanceExportTask", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_799 = writer.prefix("Description");
    if let Some(var_800) = &input.description {
        scope_799.string(var_800);
    }
    #[allow(unused_mut)]
    let mut scope_801 = writer.prefix("ExportToS3");
    if let Some(var_802) = &input.export_to_s3_task {
        crate::query_ser::serialize_structure_crate_model_export_to_s3_task_specification(
            scope_801, var_802,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_803 = writer.prefix("InstanceId");
    if let Some(var_804) = &input.instance_id {
        scope_803.string(var_804);
    }
    #[allow(unused_mut)]
    let mut scope_805 = writer.prefix("TargetEnvironment");
    if let Some(var_806) = &input.target_environment {
        scope_805.string(var_806.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_807 = writer.prefix("TagSpecification");
    if let Some(var_808) = &input.tag_specifications {
        let mut list_810 = scope_807.start_list(true, Some("item"));
        for item_809 in var_808 {
            #[allow(unused_mut)]
            let mut entry_811 = list_810.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_811, item_809,
            )?;
        }
        list_810.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_internet_gateway(
    input: &crate::input::CreateInternetGatewayInput,
) -> 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, "CreateInternetGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_812 = writer.prefix("TagSpecification");
    if let Some(var_813) = &input.tag_specifications {
        let mut list_815 = scope_812.start_list(true, Some("item"));
        for item_814 in var_813 {
            #[allow(unused_mut)]
            let mut entry_816 = list_815.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_816, item_814,
            )?;
        }
        list_815.finish();
    }
    #[allow(unused_mut)]
    let mut scope_817 = writer.prefix("DryRun");
    if let Some(var_818) = &input.dry_run {
        scope_817.boolean(*var_818);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_ipam(
    input: &crate::input::CreateIpamInput,
) -> 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, "CreateIpam", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_819 = writer.prefix("DryRun");
    if let Some(var_820) = &input.dry_run {
        scope_819.boolean(*var_820);
    }
    #[allow(unused_mut)]
    let mut scope_821 = writer.prefix("Description");
    if let Some(var_822) = &input.description {
        scope_821.string(var_822);
    }
    #[allow(unused_mut)]
    let mut scope_823 = writer.prefix("OperatingRegion");
    if let Some(var_824) = &input.operating_regions {
        let mut list_826 = scope_823.start_list(true, None);
        for item_825 in var_824 {
            #[allow(unused_mut)]
            let mut entry_827 = list_826.entry();
            crate::query_ser::serialize_structure_crate_model_add_ipam_operating_region(
                entry_827, item_825,
            )?;
        }
        list_826.finish();
    }
    #[allow(unused_mut)]
    let mut scope_828 = writer.prefix("TagSpecification");
    if let Some(var_829) = &input.tag_specifications {
        let mut list_831 = scope_828.start_list(true, Some("item"));
        for item_830 in var_829 {
            #[allow(unused_mut)]
            let mut entry_832 = list_831.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_832, item_830,
            )?;
        }
        list_831.finish();
    }
    #[allow(unused_mut)]
    let mut scope_833 = writer.prefix("ClientToken");
    if let Some(var_834) = &input.client_token {
        scope_833.string(var_834);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_ipam_pool(
    input: &crate::input::CreateIpamPoolInput,
) -> 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, "CreateIpamPool", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_835 = writer.prefix("DryRun");
    if let Some(var_836) = &input.dry_run {
        scope_835.boolean(*var_836);
    }
    #[allow(unused_mut)]
    let mut scope_837 = writer.prefix("IpamScopeId");
    if let Some(var_838) = &input.ipam_scope_id {
        scope_837.string(var_838);
    }
    #[allow(unused_mut)]
    let mut scope_839 = writer.prefix("Locale");
    if let Some(var_840) = &input.locale {
        scope_839.string(var_840);
    }
    #[allow(unused_mut)]
    let mut scope_841 = writer.prefix("SourceIpamPoolId");
    if let Some(var_842) = &input.source_ipam_pool_id {
        scope_841.string(var_842);
    }
    #[allow(unused_mut)]
    let mut scope_843 = writer.prefix("Description");
    if let Some(var_844) = &input.description {
        scope_843.string(var_844);
    }
    #[allow(unused_mut)]
    let mut scope_845 = writer.prefix("AddressFamily");
    if let Some(var_846) = &input.address_family {
        scope_845.string(var_846.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_847 = writer.prefix("AutoImport");
    if let Some(var_848) = &input.auto_import {
        scope_847.boolean(*var_848);
    }
    #[allow(unused_mut)]
    let mut scope_849 = writer.prefix("PubliclyAdvertisable");
    if let Some(var_850) = &input.publicly_advertisable {
        scope_849.boolean(*var_850);
    }
    #[allow(unused_mut)]
    let mut scope_851 = writer.prefix("AllocationMinNetmaskLength");
    if let Some(var_852) = &input.allocation_min_netmask_length {
        scope_851.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_852).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_853 = writer.prefix("AllocationMaxNetmaskLength");
    if let Some(var_854) = &input.allocation_max_netmask_length {
        scope_853.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_854).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_855 = writer.prefix("AllocationDefaultNetmaskLength");
    if let Some(var_856) = &input.allocation_default_netmask_length {
        scope_855.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_856).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_857 = writer.prefix("AllocationResourceTag");
    if let Some(var_858) = &input.allocation_resource_tags {
        let mut list_860 = scope_857.start_list(true, Some("item"));
        for item_859 in var_858 {
            #[allow(unused_mut)]
            let mut entry_861 = list_860.entry();
            crate::query_ser::serialize_structure_crate_model_request_ipam_resource_tag(
                entry_861, item_859,
            )?;
        }
        list_860.finish();
    }
    #[allow(unused_mut)]
    let mut scope_862 = writer.prefix("TagSpecification");
    if let Some(var_863) = &input.tag_specifications {
        let mut list_865 = scope_862.start_list(true, Some("item"));
        for item_864 in var_863 {
            #[allow(unused_mut)]
            let mut entry_866 = list_865.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_866, item_864,
            )?;
        }
        list_865.finish();
    }
    #[allow(unused_mut)]
    let mut scope_867 = writer.prefix("ClientToken");
    if let Some(var_868) = &input.client_token {
        scope_867.string(var_868);
    }
    #[allow(unused_mut)]
    let mut scope_869 = writer.prefix("AwsService");
    if let Some(var_870) = &input.aws_service {
        scope_869.string(var_870.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_ipam_scope(
    input: &crate::input::CreateIpamScopeInput,
) -> 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, "CreateIpamScope", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_871 = writer.prefix("DryRun");
    if let Some(var_872) = &input.dry_run {
        scope_871.boolean(*var_872);
    }
    #[allow(unused_mut)]
    let mut scope_873 = writer.prefix("IpamId");
    if let Some(var_874) = &input.ipam_id {
        scope_873.string(var_874);
    }
    #[allow(unused_mut)]
    let mut scope_875 = writer.prefix("Description");
    if let Some(var_876) = &input.description {
        scope_875.string(var_876);
    }
    #[allow(unused_mut)]
    let mut scope_877 = writer.prefix("TagSpecification");
    if let Some(var_878) = &input.tag_specifications {
        let mut list_880 = scope_877.start_list(true, Some("item"));
        for item_879 in var_878 {
            #[allow(unused_mut)]
            let mut entry_881 = list_880.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_881, item_879,
            )?;
        }
        list_880.finish();
    }
    #[allow(unused_mut)]
    let mut scope_882 = writer.prefix("ClientToken");
    if let Some(var_883) = &input.client_token {
        scope_882.string(var_883);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_key_pair(
    input: &crate::input::CreateKeyPairInput,
) -> 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, "CreateKeyPair", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_884 = writer.prefix("KeyName");
    if let Some(var_885) = &input.key_name {
        scope_884.string(var_885);
    }
    #[allow(unused_mut)]
    let mut scope_886 = writer.prefix("DryRun");
    if let Some(var_887) = &input.dry_run {
        scope_886.boolean(*var_887);
    }
    #[allow(unused_mut)]
    let mut scope_888 = writer.prefix("KeyType");
    if let Some(var_889) = &input.key_type {
        scope_888.string(var_889.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_890 = writer.prefix("TagSpecification");
    if let Some(var_891) = &input.tag_specifications {
        let mut list_893 = scope_890.start_list(true, Some("item"));
        for item_892 in var_891 {
            #[allow(unused_mut)]
            let mut entry_894 = list_893.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_894, item_892,
            )?;
        }
        list_893.finish();
    }
    #[allow(unused_mut)]
    let mut scope_895 = writer.prefix("KeyFormat");
    if let Some(var_896) = &input.key_format {
        scope_895.string(var_896.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_launch_template(
    input: &crate::input::CreateLaunchTemplateInput,
) -> 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, "CreateLaunchTemplate", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_897 = writer.prefix("DryRun");
    if let Some(var_898) = &input.dry_run {
        scope_897.boolean(*var_898);
    }
    #[allow(unused_mut)]
    let mut scope_899 = writer.prefix("ClientToken");
    if let Some(var_900) = &input.client_token {
        scope_899.string(var_900);
    }
    #[allow(unused_mut)]
    let mut scope_901 = writer.prefix("LaunchTemplateName");
    if let Some(var_902) = &input.launch_template_name {
        scope_901.string(var_902);
    }
    #[allow(unused_mut)]
    let mut scope_903 = writer.prefix("VersionDescription");
    if let Some(var_904) = &input.version_description {
        scope_903.string(var_904);
    }
    #[allow(unused_mut)]
    let mut scope_905 = writer.prefix("LaunchTemplateData");
    if let Some(var_906) = &input.launch_template_data {
        crate::query_ser::serialize_structure_crate_model_request_launch_template_data(
            scope_905, var_906,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_907 = writer.prefix("TagSpecification");
    if let Some(var_908) = &input.tag_specifications {
        let mut list_910 = scope_907.start_list(true, Some("item"));
        for item_909 in var_908 {
            #[allow(unused_mut)]
            let mut entry_911 = list_910.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_911, item_909,
            )?;
        }
        list_910.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_launch_template_version(
    input: &crate::input::CreateLaunchTemplateVersionInput,
) -> 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, "CreateLaunchTemplateVersion", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_912 = writer.prefix("DryRun");
    if let Some(var_913) = &input.dry_run {
        scope_912.boolean(*var_913);
    }
    #[allow(unused_mut)]
    let mut scope_914 = writer.prefix("ClientToken");
    if let Some(var_915) = &input.client_token {
        scope_914.string(var_915);
    }
    #[allow(unused_mut)]
    let mut scope_916 = writer.prefix("LaunchTemplateId");
    if let Some(var_917) = &input.launch_template_id {
        scope_916.string(var_917);
    }
    #[allow(unused_mut)]
    let mut scope_918 = writer.prefix("LaunchTemplateName");
    if let Some(var_919) = &input.launch_template_name {
        scope_918.string(var_919);
    }
    #[allow(unused_mut)]
    let mut scope_920 = writer.prefix("SourceVersion");
    if let Some(var_921) = &input.source_version {
        scope_920.string(var_921);
    }
    #[allow(unused_mut)]
    let mut scope_922 = writer.prefix("VersionDescription");
    if let Some(var_923) = &input.version_description {
        scope_922.string(var_923);
    }
    #[allow(unused_mut)]
    let mut scope_924 = writer.prefix("LaunchTemplateData");
    if let Some(var_925) = &input.launch_template_data {
        crate::query_ser::serialize_structure_crate_model_request_launch_template_data(
            scope_924, var_925,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_local_gateway_route(
    input: &crate::input::CreateLocalGatewayRouteInput,
) -> 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, "CreateLocalGatewayRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_926 = writer.prefix("DestinationCidrBlock");
    if let Some(var_927) = &input.destination_cidr_block {
        scope_926.string(var_927);
    }
    #[allow(unused_mut)]
    let mut scope_928 = writer.prefix("LocalGatewayRouteTableId");
    if let Some(var_929) = &input.local_gateway_route_table_id {
        scope_928.string(var_929);
    }
    #[allow(unused_mut)]
    let mut scope_930 = writer.prefix("LocalGatewayVirtualInterfaceGroupId");
    if let Some(var_931) = &input.local_gateway_virtual_interface_group_id {
        scope_930.string(var_931);
    }
    #[allow(unused_mut)]
    let mut scope_932 = writer.prefix("DryRun");
    if let Some(var_933) = &input.dry_run {
        scope_932.boolean(*var_933);
    }
    #[allow(unused_mut)]
    let mut scope_934 = writer.prefix("NetworkInterfaceId");
    if let Some(var_935) = &input.network_interface_id {
        scope_934.string(var_935);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_local_gateway_route_table(
    input: &crate::input::CreateLocalGatewayRouteTableInput,
) -> 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, "CreateLocalGatewayRouteTable", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_936 = writer.prefix("LocalGatewayId");
    if let Some(var_937) = &input.local_gateway_id {
        scope_936.string(var_937);
    }
    #[allow(unused_mut)]
    let mut scope_938 = writer.prefix("Mode");
    if let Some(var_939) = &input.mode {
        scope_938.string(var_939.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_940 = writer.prefix("TagSpecification");
    if let Some(var_941) = &input.tag_specifications {
        let mut list_943 = scope_940.start_list(true, Some("item"));
        for item_942 in var_941 {
            #[allow(unused_mut)]
            let mut entry_944 = list_943.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_944, item_942,
            )?;
        }
        list_943.finish();
    }
    #[allow(unused_mut)]
    let mut scope_945 = writer.prefix("DryRun");
    if let Some(var_946) = &input.dry_run {
        scope_945.boolean(*var_946);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_local_gateway_route_table_virtual_interface_group_association(
    input: &crate::input::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput,
) -> 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,
        "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_947 = writer.prefix("LocalGatewayRouteTableId");
    if let Some(var_948) = &input.local_gateway_route_table_id {
        scope_947.string(var_948);
    }
    #[allow(unused_mut)]
    let mut scope_949 = writer.prefix("LocalGatewayVirtualInterfaceGroupId");
    if let Some(var_950) = &input.local_gateway_virtual_interface_group_id {
        scope_949.string(var_950);
    }
    #[allow(unused_mut)]
    let mut scope_951 = writer.prefix("TagSpecification");
    if let Some(var_952) = &input.tag_specifications {
        let mut list_954 = scope_951.start_list(true, Some("item"));
        for item_953 in var_952 {
            #[allow(unused_mut)]
            let mut entry_955 = list_954.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_955, item_953,
            )?;
        }
        list_954.finish();
    }
    #[allow(unused_mut)]
    let mut scope_956 = writer.prefix("DryRun");
    if let Some(var_957) = &input.dry_run {
        scope_956.boolean(*var_957);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_local_gateway_route_table_vpc_association(
    input: &crate::input::CreateLocalGatewayRouteTableVpcAssociationInput,
) -> 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,
        "CreateLocalGatewayRouteTableVpcAssociation",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_958 = writer.prefix("LocalGatewayRouteTableId");
    if let Some(var_959) = &input.local_gateway_route_table_id {
        scope_958.string(var_959);
    }
    #[allow(unused_mut)]
    let mut scope_960 = writer.prefix("VpcId");
    if let Some(var_961) = &input.vpc_id {
        scope_960.string(var_961);
    }
    #[allow(unused_mut)]
    let mut scope_962 = writer.prefix("TagSpecification");
    if let Some(var_963) = &input.tag_specifications {
        let mut list_965 = scope_962.start_list(true, Some("item"));
        for item_964 in var_963 {
            #[allow(unused_mut)]
            let mut entry_966 = list_965.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_966, item_964,
            )?;
        }
        list_965.finish();
    }
    #[allow(unused_mut)]
    let mut scope_967 = writer.prefix("DryRun");
    if let Some(var_968) = &input.dry_run {
        scope_967.boolean(*var_968);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_managed_prefix_list(
    input: &crate::input::CreateManagedPrefixListInput,
) -> 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, "CreateManagedPrefixList", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_969 = writer.prefix("DryRun");
    if let Some(var_970) = &input.dry_run {
        scope_969.boolean(*var_970);
    }
    #[allow(unused_mut)]
    let mut scope_971 = writer.prefix("PrefixListName");
    if let Some(var_972) = &input.prefix_list_name {
        scope_971.string(var_972);
    }
    #[allow(unused_mut)]
    let mut scope_973 = writer.prefix("Entry");
    if let Some(var_974) = &input.entries {
        let mut list_976 = scope_973.start_list(true, None);
        for item_975 in var_974 {
            #[allow(unused_mut)]
            let mut entry_977 = list_976.entry();
            crate::query_ser::serialize_structure_crate_model_add_prefix_list_entry(
                entry_977, item_975,
            )?;
        }
        list_976.finish();
    }
    #[allow(unused_mut)]
    let mut scope_978 = writer.prefix("MaxEntries");
    if let Some(var_979) = &input.max_entries {
        scope_978.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_979).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_980 = writer.prefix("TagSpecification");
    if let Some(var_981) = &input.tag_specifications {
        let mut list_983 = scope_980.start_list(true, Some("item"));
        for item_982 in var_981 {
            #[allow(unused_mut)]
            let mut entry_984 = list_983.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_984, item_982,
            )?;
        }
        list_983.finish();
    }
    #[allow(unused_mut)]
    let mut scope_985 = writer.prefix("AddressFamily");
    if let Some(var_986) = &input.address_family {
        scope_985.string(var_986);
    }
    #[allow(unused_mut)]
    let mut scope_987 = writer.prefix("ClientToken");
    if let Some(var_988) = &input.client_token {
        scope_987.string(var_988);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_nat_gateway(
    input: &crate::input::CreateNatGatewayInput,
) -> 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, "CreateNatGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_989 = writer.prefix("AllocationId");
    if let Some(var_990) = &input.allocation_id {
        scope_989.string(var_990);
    }
    #[allow(unused_mut)]
    let mut scope_991 = writer.prefix("ClientToken");
    if let Some(var_992) = &input.client_token {
        scope_991.string(var_992);
    }
    #[allow(unused_mut)]
    let mut scope_993 = writer.prefix("DryRun");
    if let Some(var_994) = &input.dry_run {
        scope_993.boolean(*var_994);
    }
    #[allow(unused_mut)]
    let mut scope_995 = writer.prefix("SubnetId");
    if let Some(var_996) = &input.subnet_id {
        scope_995.string(var_996);
    }
    #[allow(unused_mut)]
    let mut scope_997 = writer.prefix("TagSpecification");
    if let Some(var_998) = &input.tag_specifications {
        let mut list_1000 = scope_997.start_list(true, Some("item"));
        for item_999 in var_998 {
            #[allow(unused_mut)]
            let mut entry_1001 = list_1000.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1001, item_999,
            )?;
        }
        list_1000.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1002 = writer.prefix("ConnectivityType");
    if let Some(var_1003) = &input.connectivity_type {
        scope_1002.string(var_1003.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_network_acl(
    input: &crate::input::CreateNetworkAclInput,
) -> 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, "CreateNetworkAcl", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1004 = writer.prefix("DryRun");
    if let Some(var_1005) = &input.dry_run {
        scope_1004.boolean(*var_1005);
    }
    #[allow(unused_mut)]
    let mut scope_1006 = writer.prefix("VpcId");
    if let Some(var_1007) = &input.vpc_id {
        scope_1006.string(var_1007);
    }
    #[allow(unused_mut)]
    let mut scope_1008 = writer.prefix("TagSpecification");
    if let Some(var_1009) = &input.tag_specifications {
        let mut list_1011 = scope_1008.start_list(true, Some("item"));
        for item_1010 in var_1009 {
            #[allow(unused_mut)]
            let mut entry_1012 = list_1011.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1012, item_1010,
            )?;
        }
        list_1011.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_network_acl_entry(
    input: &crate::input::CreateNetworkAclEntryInput,
) -> 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, "CreateNetworkAclEntry", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1013 = writer.prefix("CidrBlock");
    if let Some(var_1014) = &input.cidr_block {
        scope_1013.string(var_1014);
    }
    #[allow(unused_mut)]
    let mut scope_1015 = writer.prefix("DryRun");
    if let Some(var_1016) = &input.dry_run {
        scope_1015.boolean(*var_1016);
    }
    #[allow(unused_mut)]
    let mut scope_1017 = writer.prefix("Egress");
    if let Some(var_1018) = &input.egress {
        scope_1017.boolean(*var_1018);
    }
    #[allow(unused_mut)]
    let mut scope_1019 = writer.prefix("Icmp");
    if let Some(var_1020) = &input.icmp_type_code {
        crate::query_ser::serialize_structure_crate_model_icmp_type_code(scope_1019, var_1020)?;
    }
    #[allow(unused_mut)]
    let mut scope_1021 = writer.prefix("Ipv6CidrBlock");
    if let Some(var_1022) = &input.ipv6_cidr_block {
        scope_1021.string(var_1022);
    }
    #[allow(unused_mut)]
    let mut scope_1023 = writer.prefix("NetworkAclId");
    if let Some(var_1024) = &input.network_acl_id {
        scope_1023.string(var_1024);
    }
    #[allow(unused_mut)]
    let mut scope_1025 = writer.prefix("PortRange");
    if let Some(var_1026) = &input.port_range {
        crate::query_ser::serialize_structure_crate_model_port_range(scope_1025, var_1026)?;
    }
    #[allow(unused_mut)]
    let mut scope_1027 = writer.prefix("Protocol");
    if let Some(var_1028) = &input.protocol {
        scope_1027.string(var_1028);
    }
    #[allow(unused_mut)]
    let mut scope_1029 = writer.prefix("RuleAction");
    if let Some(var_1030) = &input.rule_action {
        scope_1029.string(var_1030.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1031 = writer.prefix("RuleNumber");
    if let Some(var_1032) = &input.rule_number {
        scope_1031.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1032).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_network_insights_access_scope(
    input: &crate::input::CreateNetworkInsightsAccessScopeInput,
) -> 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,
        "CreateNetworkInsightsAccessScope",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1033 = writer.prefix("MatchPath");
    if let Some(var_1034) = &input.match_paths {
        let mut list_1036 = scope_1033.start_list(true, Some("item"));
        for item_1035 in var_1034 {
            #[allow(unused_mut)]
            let mut entry_1037 = list_1036.entry();
            crate::query_ser::serialize_structure_crate_model_access_scope_path_request(
                entry_1037, item_1035,
            )?;
        }
        list_1036.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1038 = writer.prefix("ExcludePath");
    if let Some(var_1039) = &input.exclude_paths {
        let mut list_1041 = scope_1038.start_list(true, Some("item"));
        for item_1040 in var_1039 {
            #[allow(unused_mut)]
            let mut entry_1042 = list_1041.entry();
            crate::query_ser::serialize_structure_crate_model_access_scope_path_request(
                entry_1042, item_1040,
            )?;
        }
        list_1041.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1043 = writer.prefix("ClientToken");
    if let Some(var_1044) = &input.client_token {
        scope_1043.string(var_1044);
    }
    #[allow(unused_mut)]
    let mut scope_1045 = writer.prefix("TagSpecification");
    if let Some(var_1046) = &input.tag_specifications {
        let mut list_1048 = scope_1045.start_list(true, Some("item"));
        for item_1047 in var_1046 {
            #[allow(unused_mut)]
            let mut entry_1049 = list_1048.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1049, item_1047,
            )?;
        }
        list_1048.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1050 = writer.prefix("DryRun");
    if let Some(var_1051) = &input.dry_run {
        scope_1050.boolean(*var_1051);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_network_insights_path(
    input: &crate::input::CreateNetworkInsightsPathInput,
) -> 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, "CreateNetworkInsightsPath", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1052 = writer.prefix("SourceIp");
    if let Some(var_1053) = &input.source_ip {
        scope_1052.string(var_1053);
    }
    #[allow(unused_mut)]
    let mut scope_1054 = writer.prefix("DestinationIp");
    if let Some(var_1055) = &input.destination_ip {
        scope_1054.string(var_1055);
    }
    #[allow(unused_mut)]
    let mut scope_1056 = writer.prefix("Source");
    if let Some(var_1057) = &input.source {
        scope_1056.string(var_1057);
    }
    #[allow(unused_mut)]
    let mut scope_1058 = writer.prefix("Destination");
    if let Some(var_1059) = &input.destination {
        scope_1058.string(var_1059);
    }
    #[allow(unused_mut)]
    let mut scope_1060 = writer.prefix("Protocol");
    if let Some(var_1061) = &input.protocol {
        scope_1060.string(var_1061.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1062 = writer.prefix("DestinationPort");
    if let Some(var_1063) = &input.destination_port {
        scope_1062.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1063).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1064 = writer.prefix("TagSpecification");
    if let Some(var_1065) = &input.tag_specifications {
        let mut list_1067 = scope_1064.start_list(true, Some("item"));
        for item_1066 in var_1065 {
            #[allow(unused_mut)]
            let mut entry_1068 = list_1067.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1068, item_1066,
            )?;
        }
        list_1067.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1069 = writer.prefix("DryRun");
    if let Some(var_1070) = &input.dry_run {
        scope_1069.boolean(*var_1070);
    }
    #[allow(unused_mut)]
    let mut scope_1071 = writer.prefix("ClientToken");
    if let Some(var_1072) = &input.client_token {
        scope_1071.string(var_1072);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_network_interface(
    input: &crate::input::CreateNetworkInterfaceInput,
) -> 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, "CreateNetworkInterface", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1073 = writer.prefix("Description");
    if let Some(var_1074) = &input.description {
        scope_1073.string(var_1074);
    }
    #[allow(unused_mut)]
    let mut scope_1075 = writer.prefix("DryRun");
    if let Some(var_1076) = &input.dry_run {
        scope_1075.boolean(*var_1076);
    }
    #[allow(unused_mut)]
    let mut scope_1077 = writer.prefix("SecurityGroupId");
    if let Some(var_1078) = &input.groups {
        let mut list_1080 = scope_1077.start_list(true, Some("SecurityGroupId"));
        for item_1079 in var_1078 {
            #[allow(unused_mut)]
            let mut entry_1081 = list_1080.entry();
            entry_1081.string(item_1079);
        }
        list_1080.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1082 = writer.prefix("Ipv6AddressCount");
    if let Some(var_1083) = &input.ipv6_address_count {
        scope_1082.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1083).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1084 = writer.prefix("Ipv6Addresses");
    if let Some(var_1085) = &input.ipv6_addresses {
        let mut list_1087 = scope_1084.start_list(true, Some("item"));
        for item_1086 in var_1085 {
            #[allow(unused_mut)]
            let mut entry_1088 = list_1087.entry();
            crate::query_ser::serialize_structure_crate_model_instance_ipv6_address(
                entry_1088, item_1086,
            )?;
        }
        list_1087.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1089 = writer.prefix("PrivateIpAddress");
    if let Some(var_1090) = &input.private_ip_address {
        scope_1089.string(var_1090);
    }
    #[allow(unused_mut)]
    let mut scope_1091 = writer.prefix("PrivateIpAddresses");
    if let Some(var_1092) = &input.private_ip_addresses {
        let mut list_1094 = scope_1091.start_list(true, Some("item"));
        for item_1093 in var_1092 {
            #[allow(unused_mut)]
            let mut entry_1095 = list_1094.entry();
            crate::query_ser::serialize_structure_crate_model_private_ip_address_specification(
                entry_1095, item_1093,
            )?;
        }
        list_1094.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1096 = writer.prefix("SecondaryPrivateIpAddressCount");
    if let Some(var_1097) = &input.secondary_private_ip_address_count {
        scope_1096.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1097).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1098 = writer.prefix("Ipv4Prefix");
    if let Some(var_1099) = &input.ipv4_prefixes {
        let mut list_1101 = scope_1098.start_list(true, Some("item"));
        for item_1100 in var_1099 {
            #[allow(unused_mut)]
            let mut entry_1102 = list_1101.entry();
            crate::query_ser::serialize_structure_crate_model_ipv4_prefix_specification_request(
                entry_1102, item_1100,
            )?;
        }
        list_1101.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1103 = writer.prefix("Ipv4PrefixCount");
    if let Some(var_1104) = &input.ipv4_prefix_count {
        scope_1103.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1104).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1105 = writer.prefix("Ipv6Prefix");
    if let Some(var_1106) = &input.ipv6_prefixes {
        let mut list_1108 = scope_1105.start_list(true, Some("item"));
        for item_1107 in var_1106 {
            #[allow(unused_mut)]
            let mut entry_1109 = list_1108.entry();
            crate::query_ser::serialize_structure_crate_model_ipv6_prefix_specification_request(
                entry_1109, item_1107,
            )?;
        }
        list_1108.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1110 = writer.prefix("Ipv6PrefixCount");
    if let Some(var_1111) = &input.ipv6_prefix_count {
        scope_1110.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1111).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1112 = writer.prefix("InterfaceType");
    if let Some(var_1113) = &input.interface_type {
        scope_1112.string(var_1113.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1114 = writer.prefix("SubnetId");
    if let Some(var_1115) = &input.subnet_id {
        scope_1114.string(var_1115);
    }
    #[allow(unused_mut)]
    let mut scope_1116 = writer.prefix("TagSpecification");
    if let Some(var_1117) = &input.tag_specifications {
        let mut list_1119 = scope_1116.start_list(true, Some("item"));
        for item_1118 in var_1117 {
            #[allow(unused_mut)]
            let mut entry_1120 = list_1119.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1120, item_1118,
            )?;
        }
        list_1119.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1121 = writer.prefix("ClientToken");
    if let Some(var_1122) = &input.client_token {
        scope_1121.string(var_1122);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_network_interface_permission(
    input: &crate::input::CreateNetworkInterfacePermissionInput,
) -> 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,
        "CreateNetworkInterfacePermission",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1123 = writer.prefix("NetworkInterfaceId");
    if let Some(var_1124) = &input.network_interface_id {
        scope_1123.string(var_1124);
    }
    #[allow(unused_mut)]
    let mut scope_1125 = writer.prefix("AwsAccountId");
    if let Some(var_1126) = &input.aws_account_id {
        scope_1125.string(var_1126);
    }
    #[allow(unused_mut)]
    let mut scope_1127 = writer.prefix("AwsService");
    if let Some(var_1128) = &input.aws_service {
        scope_1127.string(var_1128);
    }
    #[allow(unused_mut)]
    let mut scope_1129 = writer.prefix("Permission");
    if let Some(var_1130) = &input.permission {
        scope_1129.string(var_1130.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1131 = writer.prefix("DryRun");
    if let Some(var_1132) = &input.dry_run {
        scope_1131.boolean(*var_1132);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_placement_group(
    input: &crate::input::CreatePlacementGroupInput,
) -> 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, "CreatePlacementGroup", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1133 = writer.prefix("DryRun");
    if let Some(var_1134) = &input.dry_run {
        scope_1133.boolean(*var_1134);
    }
    #[allow(unused_mut)]
    let mut scope_1135 = writer.prefix("GroupName");
    if let Some(var_1136) = &input.group_name {
        scope_1135.string(var_1136);
    }
    #[allow(unused_mut)]
    let mut scope_1137 = writer.prefix("Strategy");
    if let Some(var_1138) = &input.strategy {
        scope_1137.string(var_1138.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1139 = writer.prefix("PartitionCount");
    if let Some(var_1140) = &input.partition_count {
        scope_1139.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1140).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1141 = writer.prefix("TagSpecification");
    if let Some(var_1142) = &input.tag_specifications {
        let mut list_1144 = scope_1141.start_list(true, Some("item"));
        for item_1143 in var_1142 {
            #[allow(unused_mut)]
            let mut entry_1145 = list_1144.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1145, item_1143,
            )?;
        }
        list_1144.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1146 = writer.prefix("SpreadLevel");
    if let Some(var_1147) = &input.spread_level {
        scope_1146.string(var_1147.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_public_ipv4_pool(
    input: &crate::input::CreatePublicIpv4PoolInput,
) -> 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, "CreatePublicIpv4Pool", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1148 = writer.prefix("DryRun");
    if let Some(var_1149) = &input.dry_run {
        scope_1148.boolean(*var_1149);
    }
    #[allow(unused_mut)]
    let mut scope_1150 = writer.prefix("TagSpecification");
    if let Some(var_1151) = &input.tag_specifications {
        let mut list_1153 = scope_1150.start_list(true, Some("item"));
        for item_1152 in var_1151 {
            #[allow(unused_mut)]
            let mut entry_1154 = list_1153.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1154, item_1152,
            )?;
        }
        list_1153.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_replace_root_volume_task(
    input: &crate::input::CreateReplaceRootVolumeTaskInput,
) -> 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, "CreateReplaceRootVolumeTask", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1155 = writer.prefix("InstanceId");
    if let Some(var_1156) = &input.instance_id {
        scope_1155.string(var_1156);
    }
    #[allow(unused_mut)]
    let mut scope_1157 = writer.prefix("SnapshotId");
    if let Some(var_1158) = &input.snapshot_id {
        scope_1157.string(var_1158);
    }
    #[allow(unused_mut)]
    let mut scope_1159 = writer.prefix("ClientToken");
    if let Some(var_1160) = &input.client_token {
        scope_1159.string(var_1160);
    }
    #[allow(unused_mut)]
    let mut scope_1161 = writer.prefix("DryRun");
    if let Some(var_1162) = &input.dry_run {
        scope_1161.boolean(*var_1162);
    }
    #[allow(unused_mut)]
    let mut scope_1163 = writer.prefix("TagSpecification");
    if let Some(var_1164) = &input.tag_specifications {
        let mut list_1166 = scope_1163.start_list(true, Some("item"));
        for item_1165 in var_1164 {
            #[allow(unused_mut)]
            let mut entry_1167 = list_1166.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1167, item_1165,
            )?;
        }
        list_1166.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_reserved_instances_listing(
    input: &crate::input::CreateReservedInstancesListingInput,
) -> 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,
        "CreateReservedInstancesListing",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1168 = writer.prefix("ClientToken");
    if let Some(var_1169) = &input.client_token {
        scope_1168.string(var_1169);
    }
    #[allow(unused_mut)]
    let mut scope_1170 = writer.prefix("InstanceCount");
    if let Some(var_1171) = &input.instance_count {
        scope_1170.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1171).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1172 = writer.prefix("PriceSchedules");
    if let Some(var_1173) = &input.price_schedules {
        let mut list_1175 = scope_1172.start_list(true, Some("item"));
        for item_1174 in var_1173 {
            #[allow(unused_mut)]
            let mut entry_1176 = list_1175.entry();
            crate::query_ser::serialize_structure_crate_model_price_schedule_specification(
                entry_1176, item_1174,
            )?;
        }
        list_1175.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1177 = writer.prefix("ReservedInstancesId");
    if let Some(var_1178) = &input.reserved_instances_id {
        scope_1177.string(var_1178);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_restore_image_task(
    input: &crate::input::CreateRestoreImageTaskInput,
) -> 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, "CreateRestoreImageTask", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1179 = writer.prefix("Bucket");
    if let Some(var_1180) = &input.bucket {
        scope_1179.string(var_1180);
    }
    #[allow(unused_mut)]
    let mut scope_1181 = writer.prefix("ObjectKey");
    if let Some(var_1182) = &input.object_key {
        scope_1181.string(var_1182);
    }
    #[allow(unused_mut)]
    let mut scope_1183 = writer.prefix("Name");
    if let Some(var_1184) = &input.name {
        scope_1183.string(var_1184);
    }
    #[allow(unused_mut)]
    let mut scope_1185 = writer.prefix("TagSpecification");
    if let Some(var_1186) = &input.tag_specifications {
        let mut list_1188 = scope_1185.start_list(true, Some("item"));
        for item_1187 in var_1186 {
            #[allow(unused_mut)]
            let mut entry_1189 = list_1188.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1189, item_1187,
            )?;
        }
        list_1188.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1190 = writer.prefix("DryRun");
    if let Some(var_1191) = &input.dry_run {
        scope_1190.boolean(*var_1191);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_route(
    input: &crate::input::CreateRouteInput,
) -> 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, "CreateRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1192 = writer.prefix("DestinationCidrBlock");
    if let Some(var_1193) = &input.destination_cidr_block {
        scope_1192.string(var_1193);
    }
    #[allow(unused_mut)]
    let mut scope_1194 = writer.prefix("DestinationIpv6CidrBlock");
    if let Some(var_1195) = &input.destination_ipv6_cidr_block {
        scope_1194.string(var_1195);
    }
    #[allow(unused_mut)]
    let mut scope_1196 = writer.prefix("DestinationPrefixListId");
    if let Some(var_1197) = &input.destination_prefix_list_id {
        scope_1196.string(var_1197);
    }
    #[allow(unused_mut)]
    let mut scope_1198 = writer.prefix("DryRun");
    if let Some(var_1199) = &input.dry_run {
        scope_1198.boolean(*var_1199);
    }
    #[allow(unused_mut)]
    let mut scope_1200 = writer.prefix("VpcEndpointId");
    if let Some(var_1201) = &input.vpc_endpoint_id {
        scope_1200.string(var_1201);
    }
    #[allow(unused_mut)]
    let mut scope_1202 = writer.prefix("EgressOnlyInternetGatewayId");
    if let Some(var_1203) = &input.egress_only_internet_gateway_id {
        scope_1202.string(var_1203);
    }
    #[allow(unused_mut)]
    let mut scope_1204 = writer.prefix("GatewayId");
    if let Some(var_1205) = &input.gateway_id {
        scope_1204.string(var_1205);
    }
    #[allow(unused_mut)]
    let mut scope_1206 = writer.prefix("InstanceId");
    if let Some(var_1207) = &input.instance_id {
        scope_1206.string(var_1207);
    }
    #[allow(unused_mut)]
    let mut scope_1208 = writer.prefix("NatGatewayId");
    if let Some(var_1209) = &input.nat_gateway_id {
        scope_1208.string(var_1209);
    }
    #[allow(unused_mut)]
    let mut scope_1210 = writer.prefix("TransitGatewayId");
    if let Some(var_1211) = &input.transit_gateway_id {
        scope_1210.string(var_1211);
    }
    #[allow(unused_mut)]
    let mut scope_1212 = writer.prefix("LocalGatewayId");
    if let Some(var_1213) = &input.local_gateway_id {
        scope_1212.string(var_1213);
    }
    #[allow(unused_mut)]
    let mut scope_1214 = writer.prefix("CarrierGatewayId");
    if let Some(var_1215) = &input.carrier_gateway_id {
        scope_1214.string(var_1215);
    }
    #[allow(unused_mut)]
    let mut scope_1216 = writer.prefix("NetworkInterfaceId");
    if let Some(var_1217) = &input.network_interface_id {
        scope_1216.string(var_1217);
    }
    #[allow(unused_mut)]
    let mut scope_1218 = writer.prefix("RouteTableId");
    if let Some(var_1219) = &input.route_table_id {
        scope_1218.string(var_1219);
    }
    #[allow(unused_mut)]
    let mut scope_1220 = writer.prefix("VpcPeeringConnectionId");
    if let Some(var_1221) = &input.vpc_peering_connection_id {
        scope_1220.string(var_1221);
    }
    #[allow(unused_mut)]
    let mut scope_1222 = writer.prefix("CoreNetworkArn");
    if let Some(var_1223) = &input.core_network_arn {
        scope_1222.string(var_1223);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_route_table(
    input: &crate::input::CreateRouteTableInput,
) -> 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, "CreateRouteTable", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1224 = writer.prefix("DryRun");
    if let Some(var_1225) = &input.dry_run {
        scope_1224.boolean(*var_1225);
    }
    #[allow(unused_mut)]
    let mut scope_1226 = writer.prefix("VpcId");
    if let Some(var_1227) = &input.vpc_id {
        scope_1226.string(var_1227);
    }
    #[allow(unused_mut)]
    let mut scope_1228 = writer.prefix("TagSpecification");
    if let Some(var_1229) = &input.tag_specifications {
        let mut list_1231 = scope_1228.start_list(true, Some("item"));
        for item_1230 in var_1229 {
            #[allow(unused_mut)]
            let mut entry_1232 = list_1231.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1232, item_1230,
            )?;
        }
        list_1231.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_security_group(
    input: &crate::input::CreateSecurityGroupInput,
) -> 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, "CreateSecurityGroup", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1233 = writer.prefix("GroupDescription");
    if let Some(var_1234) = &input.description {
        scope_1233.string(var_1234);
    }
    #[allow(unused_mut)]
    let mut scope_1235 = writer.prefix("GroupName");
    if let Some(var_1236) = &input.group_name {
        scope_1235.string(var_1236);
    }
    #[allow(unused_mut)]
    let mut scope_1237 = writer.prefix("VpcId");
    if let Some(var_1238) = &input.vpc_id {
        scope_1237.string(var_1238);
    }
    #[allow(unused_mut)]
    let mut scope_1239 = writer.prefix("TagSpecification");
    if let Some(var_1240) = &input.tag_specifications {
        let mut list_1242 = scope_1239.start_list(true, Some("item"));
        for item_1241 in var_1240 {
            #[allow(unused_mut)]
            let mut entry_1243 = list_1242.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1243, item_1241,
            )?;
        }
        list_1242.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1244 = writer.prefix("DryRun");
    if let Some(var_1245) = &input.dry_run {
        scope_1244.boolean(*var_1245);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_snapshot(
    input: &crate::input::CreateSnapshotInput,
) -> 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, "CreateSnapshot", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1246 = writer.prefix("Description");
    if let Some(var_1247) = &input.description {
        scope_1246.string(var_1247);
    }
    #[allow(unused_mut)]
    let mut scope_1248 = writer.prefix("OutpostArn");
    if let Some(var_1249) = &input.outpost_arn {
        scope_1248.string(var_1249);
    }
    #[allow(unused_mut)]
    let mut scope_1250 = writer.prefix("VolumeId");
    if let Some(var_1251) = &input.volume_id {
        scope_1250.string(var_1251);
    }
    #[allow(unused_mut)]
    let mut scope_1252 = writer.prefix("TagSpecification");
    if let Some(var_1253) = &input.tag_specifications {
        let mut list_1255 = scope_1252.start_list(true, Some("item"));
        for item_1254 in var_1253 {
            #[allow(unused_mut)]
            let mut entry_1256 = list_1255.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1256, item_1254,
            )?;
        }
        list_1255.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1257 = writer.prefix("DryRun");
    if let Some(var_1258) = &input.dry_run {
        scope_1257.boolean(*var_1258);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_snapshots(
    input: &crate::input::CreateSnapshotsInput,
) -> 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, "CreateSnapshots", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1259 = writer.prefix("Description");
    if let Some(var_1260) = &input.description {
        scope_1259.string(var_1260);
    }
    #[allow(unused_mut)]
    let mut scope_1261 = writer.prefix("InstanceSpecification");
    if let Some(var_1262) = &input.instance_specification {
        crate::query_ser::serialize_structure_crate_model_instance_specification(
            scope_1261, var_1262,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1263 = writer.prefix("OutpostArn");
    if let Some(var_1264) = &input.outpost_arn {
        scope_1263.string(var_1264);
    }
    #[allow(unused_mut)]
    let mut scope_1265 = writer.prefix("TagSpecification");
    if let Some(var_1266) = &input.tag_specifications {
        let mut list_1268 = scope_1265.start_list(true, Some("item"));
        for item_1267 in var_1266 {
            #[allow(unused_mut)]
            let mut entry_1269 = list_1268.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1269, item_1267,
            )?;
        }
        list_1268.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1270 = writer.prefix("DryRun");
    if let Some(var_1271) = &input.dry_run {
        scope_1270.boolean(*var_1271);
    }
    #[allow(unused_mut)]
    let mut scope_1272 = writer.prefix("CopyTagsFromSource");
    if let Some(var_1273) = &input.copy_tags_from_source {
        scope_1272.string(var_1273.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_spot_datafeed_subscription(
    input: &crate::input::CreateSpotDatafeedSubscriptionInput,
) -> 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,
        "CreateSpotDatafeedSubscription",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1274 = writer.prefix("Bucket");
    if let Some(var_1275) = &input.bucket {
        scope_1274.string(var_1275);
    }
    #[allow(unused_mut)]
    let mut scope_1276 = writer.prefix("DryRun");
    if let Some(var_1277) = &input.dry_run {
        scope_1276.boolean(*var_1277);
    }
    #[allow(unused_mut)]
    let mut scope_1278 = writer.prefix("Prefix");
    if let Some(var_1279) = &input.prefix {
        scope_1278.string(var_1279);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_store_image_task(
    input: &crate::input::CreateStoreImageTaskInput,
) -> 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, "CreateStoreImageTask", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1280 = writer.prefix("ImageId");
    if let Some(var_1281) = &input.image_id {
        scope_1280.string(var_1281);
    }
    #[allow(unused_mut)]
    let mut scope_1282 = writer.prefix("Bucket");
    if let Some(var_1283) = &input.bucket {
        scope_1282.string(var_1283);
    }
    #[allow(unused_mut)]
    let mut scope_1284 = writer.prefix("S3ObjectTag");
    if let Some(var_1285) = &input.s3_object_tags {
        let mut list_1287 = scope_1284.start_list(true, Some("item"));
        for item_1286 in var_1285 {
            #[allow(unused_mut)]
            let mut entry_1288 = list_1287.entry();
            crate::query_ser::serialize_structure_crate_model_s3_object_tag(entry_1288, item_1286)?;
        }
        list_1287.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1289 = writer.prefix("DryRun");
    if let Some(var_1290) = &input.dry_run {
        scope_1289.boolean(*var_1290);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_subnet(
    input: &crate::input::CreateSubnetInput,
) -> 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, "CreateSubnet", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1291 = writer.prefix("TagSpecification");
    if let Some(var_1292) = &input.tag_specifications {
        let mut list_1294 = scope_1291.start_list(true, Some("item"));
        for item_1293 in var_1292 {
            #[allow(unused_mut)]
            let mut entry_1295 = list_1294.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1295, item_1293,
            )?;
        }
        list_1294.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1296 = writer.prefix("AvailabilityZone");
    if let Some(var_1297) = &input.availability_zone {
        scope_1296.string(var_1297);
    }
    #[allow(unused_mut)]
    let mut scope_1298 = writer.prefix("AvailabilityZoneId");
    if let Some(var_1299) = &input.availability_zone_id {
        scope_1298.string(var_1299);
    }
    #[allow(unused_mut)]
    let mut scope_1300 = writer.prefix("CidrBlock");
    if let Some(var_1301) = &input.cidr_block {
        scope_1300.string(var_1301);
    }
    #[allow(unused_mut)]
    let mut scope_1302 = writer.prefix("Ipv6CidrBlock");
    if let Some(var_1303) = &input.ipv6_cidr_block {
        scope_1302.string(var_1303);
    }
    #[allow(unused_mut)]
    let mut scope_1304 = writer.prefix("OutpostArn");
    if let Some(var_1305) = &input.outpost_arn {
        scope_1304.string(var_1305);
    }
    #[allow(unused_mut)]
    let mut scope_1306 = writer.prefix("VpcId");
    if let Some(var_1307) = &input.vpc_id {
        scope_1306.string(var_1307);
    }
    #[allow(unused_mut)]
    let mut scope_1308 = writer.prefix("DryRun");
    if let Some(var_1309) = &input.dry_run {
        scope_1308.boolean(*var_1309);
    }
    #[allow(unused_mut)]
    let mut scope_1310 = writer.prefix("Ipv6Native");
    if let Some(var_1311) = &input.ipv6_native {
        scope_1310.boolean(*var_1311);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_subnet_cidr_reservation(
    input: &crate::input::CreateSubnetCidrReservationInput,
) -> 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, "CreateSubnetCidrReservation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1312 = writer.prefix("SubnetId");
    if let Some(var_1313) = &input.subnet_id {
        scope_1312.string(var_1313);
    }
    #[allow(unused_mut)]
    let mut scope_1314 = writer.prefix("Cidr");
    if let Some(var_1315) = &input.cidr {
        scope_1314.string(var_1315);
    }
    #[allow(unused_mut)]
    let mut scope_1316 = writer.prefix("ReservationType");
    if let Some(var_1317) = &input.reservation_type {
        scope_1316.string(var_1317.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1318 = writer.prefix("Description");
    if let Some(var_1319) = &input.description {
        scope_1318.string(var_1319);
    }
    #[allow(unused_mut)]
    let mut scope_1320 = writer.prefix("DryRun");
    if let Some(var_1321) = &input.dry_run {
        scope_1320.boolean(*var_1321);
    }
    #[allow(unused_mut)]
    let mut scope_1322 = writer.prefix("TagSpecification");
    if let Some(var_1323) = &input.tag_specifications {
        let mut list_1325 = scope_1322.start_list(true, Some("item"));
        for item_1324 in var_1323 {
            #[allow(unused_mut)]
            let mut entry_1326 = list_1325.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1326, item_1324,
            )?;
        }
        list_1325.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_tags(
    input: &crate::input::CreateTagsInput,
) -> 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, "CreateTags", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1327 = writer.prefix("DryRun");
    if let Some(var_1328) = &input.dry_run {
        scope_1327.boolean(*var_1328);
    }
    #[allow(unused_mut)]
    let mut scope_1329 = writer.prefix("ResourceId");
    if let Some(var_1330) = &input.resources {
        let mut list_1332 = scope_1329.start_list(true, None);
        for item_1331 in var_1330 {
            #[allow(unused_mut)]
            let mut entry_1333 = list_1332.entry();
            entry_1333.string(item_1331);
        }
        list_1332.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1334 = writer.prefix("Tag");
    if let Some(var_1335) = &input.tags {
        let mut list_1337 = scope_1334.start_list(true, Some("item"));
        for item_1336 in var_1335 {
            #[allow(unused_mut)]
            let mut entry_1338 = list_1337.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_1338, item_1336)?;
        }
        list_1337.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_traffic_mirror_filter(
    input: &crate::input::CreateTrafficMirrorFilterInput,
) -> 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, "CreateTrafficMirrorFilter", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1339 = writer.prefix("Description");
    if let Some(var_1340) = &input.description {
        scope_1339.string(var_1340);
    }
    #[allow(unused_mut)]
    let mut scope_1341 = writer.prefix("TagSpecification");
    if let Some(var_1342) = &input.tag_specifications {
        let mut list_1344 = scope_1341.start_list(true, Some("item"));
        for item_1343 in var_1342 {
            #[allow(unused_mut)]
            let mut entry_1345 = list_1344.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1345, item_1343,
            )?;
        }
        list_1344.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1346 = writer.prefix("DryRun");
    if let Some(var_1347) = &input.dry_run {
        scope_1346.boolean(*var_1347);
    }
    #[allow(unused_mut)]
    let mut scope_1348 = writer.prefix("ClientToken");
    if let Some(var_1349) = &input.client_token {
        scope_1348.string(var_1349);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_traffic_mirror_filter_rule(
    input: &crate::input::CreateTrafficMirrorFilterRuleInput,
) -> 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, "CreateTrafficMirrorFilterRule", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1350 = writer.prefix("TrafficMirrorFilterId");
    if let Some(var_1351) = &input.traffic_mirror_filter_id {
        scope_1350.string(var_1351);
    }
    #[allow(unused_mut)]
    let mut scope_1352 = writer.prefix("TrafficDirection");
    if let Some(var_1353) = &input.traffic_direction {
        scope_1352.string(var_1353.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1354 = writer.prefix("RuleNumber");
    if let Some(var_1355) = &input.rule_number {
        scope_1354.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1355).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1356 = writer.prefix("RuleAction");
    if let Some(var_1357) = &input.rule_action {
        scope_1356.string(var_1357.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1358 = writer.prefix("DestinationPortRange");
    if let Some(var_1359) = &input.destination_port_range {
        crate::query_ser::serialize_structure_crate_model_traffic_mirror_port_range_request(
            scope_1358, var_1359,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1360 = writer.prefix("SourcePortRange");
    if let Some(var_1361) = &input.source_port_range {
        crate::query_ser::serialize_structure_crate_model_traffic_mirror_port_range_request(
            scope_1360, var_1361,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1362 = writer.prefix("Protocol");
    if let Some(var_1363) = &input.protocol {
        scope_1362.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1363).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1364 = writer.prefix("DestinationCidrBlock");
    if let Some(var_1365) = &input.destination_cidr_block {
        scope_1364.string(var_1365);
    }
    #[allow(unused_mut)]
    let mut scope_1366 = writer.prefix("SourceCidrBlock");
    if let Some(var_1367) = &input.source_cidr_block {
        scope_1366.string(var_1367);
    }
    #[allow(unused_mut)]
    let mut scope_1368 = writer.prefix("Description");
    if let Some(var_1369) = &input.description {
        scope_1368.string(var_1369);
    }
    #[allow(unused_mut)]
    let mut scope_1370 = writer.prefix("DryRun");
    if let Some(var_1371) = &input.dry_run {
        scope_1370.boolean(*var_1371);
    }
    #[allow(unused_mut)]
    let mut scope_1372 = writer.prefix("ClientToken");
    if let Some(var_1373) = &input.client_token {
        scope_1372.string(var_1373);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_traffic_mirror_session(
    input: &crate::input::CreateTrafficMirrorSessionInput,
) -> 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, "CreateTrafficMirrorSession", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1374 = writer.prefix("NetworkInterfaceId");
    if let Some(var_1375) = &input.network_interface_id {
        scope_1374.string(var_1375);
    }
    #[allow(unused_mut)]
    let mut scope_1376 = writer.prefix("TrafficMirrorTargetId");
    if let Some(var_1377) = &input.traffic_mirror_target_id {
        scope_1376.string(var_1377);
    }
    #[allow(unused_mut)]
    let mut scope_1378 = writer.prefix("TrafficMirrorFilterId");
    if let Some(var_1379) = &input.traffic_mirror_filter_id {
        scope_1378.string(var_1379);
    }
    #[allow(unused_mut)]
    let mut scope_1380 = writer.prefix("PacketLength");
    if let Some(var_1381) = &input.packet_length {
        scope_1380.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1381).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1382 = writer.prefix("SessionNumber");
    if let Some(var_1383) = &input.session_number {
        scope_1382.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1383).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1384 = writer.prefix("VirtualNetworkId");
    if let Some(var_1385) = &input.virtual_network_id {
        scope_1384.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1385).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1386 = writer.prefix("Description");
    if let Some(var_1387) = &input.description {
        scope_1386.string(var_1387);
    }
    #[allow(unused_mut)]
    let mut scope_1388 = writer.prefix("TagSpecification");
    if let Some(var_1389) = &input.tag_specifications {
        let mut list_1391 = scope_1388.start_list(true, Some("item"));
        for item_1390 in var_1389 {
            #[allow(unused_mut)]
            let mut entry_1392 = list_1391.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1392, item_1390,
            )?;
        }
        list_1391.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1393 = writer.prefix("DryRun");
    if let Some(var_1394) = &input.dry_run {
        scope_1393.boolean(*var_1394);
    }
    #[allow(unused_mut)]
    let mut scope_1395 = writer.prefix("ClientToken");
    if let Some(var_1396) = &input.client_token {
        scope_1395.string(var_1396);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_traffic_mirror_target(
    input: &crate::input::CreateTrafficMirrorTargetInput,
) -> 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, "CreateTrafficMirrorTarget", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1397 = writer.prefix("NetworkInterfaceId");
    if let Some(var_1398) = &input.network_interface_id {
        scope_1397.string(var_1398);
    }
    #[allow(unused_mut)]
    let mut scope_1399 = writer.prefix("NetworkLoadBalancerArn");
    if let Some(var_1400) = &input.network_load_balancer_arn {
        scope_1399.string(var_1400);
    }
    #[allow(unused_mut)]
    let mut scope_1401 = writer.prefix("Description");
    if let Some(var_1402) = &input.description {
        scope_1401.string(var_1402);
    }
    #[allow(unused_mut)]
    let mut scope_1403 = writer.prefix("TagSpecification");
    if let Some(var_1404) = &input.tag_specifications {
        let mut list_1406 = scope_1403.start_list(true, Some("item"));
        for item_1405 in var_1404 {
            #[allow(unused_mut)]
            let mut entry_1407 = list_1406.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1407, item_1405,
            )?;
        }
        list_1406.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1408 = writer.prefix("DryRun");
    if let Some(var_1409) = &input.dry_run {
        scope_1408.boolean(*var_1409);
    }
    #[allow(unused_mut)]
    let mut scope_1410 = writer.prefix("ClientToken");
    if let Some(var_1411) = &input.client_token {
        scope_1410.string(var_1411);
    }
    #[allow(unused_mut)]
    let mut scope_1412 = writer.prefix("GatewayLoadBalancerEndpointId");
    if let Some(var_1413) = &input.gateway_load_balancer_endpoint_id {
        scope_1412.string(var_1413);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway(
    input: &crate::input::CreateTransitGatewayInput,
) -> 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, "CreateTransitGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1414 = writer.prefix("Description");
    if let Some(var_1415) = &input.description {
        scope_1414.string(var_1415);
    }
    #[allow(unused_mut)]
    let mut scope_1416 = writer.prefix("Options");
    if let Some(var_1417) = &input.options {
        crate::query_ser::serialize_structure_crate_model_transit_gateway_request_options(
            scope_1416, var_1417,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1418 = writer.prefix("TagSpecification");
    if let Some(var_1419) = &input.tag_specifications {
        let mut list_1421 = scope_1418.start_list(true, Some("item"));
        for item_1420 in var_1419 {
            #[allow(unused_mut)]
            let mut entry_1422 = list_1421.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1422, item_1420,
            )?;
        }
        list_1421.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1423 = writer.prefix("DryRun");
    if let Some(var_1424) = &input.dry_run {
        scope_1423.boolean(*var_1424);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway_connect(
    input: &crate::input::CreateTransitGatewayConnectInput,
) -> 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, "CreateTransitGatewayConnect", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1425 = writer.prefix("TransportTransitGatewayAttachmentId");
    if let Some(var_1426) = &input.transport_transit_gateway_attachment_id {
        scope_1425.string(var_1426);
    }
    #[allow(unused_mut)]
    let mut scope_1427 = writer.prefix("Options");
    if let Some(var_1428) = &input.options {
        crate::query_ser::serialize_structure_crate_model_create_transit_gateway_connect_request_options(scope_1427, var_1428)?;
    }
    #[allow(unused_mut)]
    let mut scope_1429 = writer.prefix("TagSpecification");
    if let Some(var_1430) = &input.tag_specifications {
        let mut list_1432 = scope_1429.start_list(true, Some("item"));
        for item_1431 in var_1430 {
            #[allow(unused_mut)]
            let mut entry_1433 = list_1432.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1433, item_1431,
            )?;
        }
        list_1432.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1434 = writer.prefix("DryRun");
    if let Some(var_1435) = &input.dry_run {
        scope_1434.boolean(*var_1435);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway_connect_peer(
    input: &crate::input::CreateTransitGatewayConnectPeerInput,
) -> 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,
        "CreateTransitGatewayConnectPeer",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1436 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_1437) = &input.transit_gateway_attachment_id {
        scope_1436.string(var_1437);
    }
    #[allow(unused_mut)]
    let mut scope_1438 = writer.prefix("TransitGatewayAddress");
    if let Some(var_1439) = &input.transit_gateway_address {
        scope_1438.string(var_1439);
    }
    #[allow(unused_mut)]
    let mut scope_1440 = writer.prefix("PeerAddress");
    if let Some(var_1441) = &input.peer_address {
        scope_1440.string(var_1441);
    }
    #[allow(unused_mut)]
    let mut scope_1442 = writer.prefix("BgpOptions");
    if let Some(var_1443) = &input.bgp_options {
        crate::query_ser::serialize_structure_crate_model_transit_gateway_connect_request_bgp_options(scope_1442, var_1443)?;
    }
    #[allow(unused_mut)]
    let mut scope_1444 = writer.prefix("InsideCidrBlocks");
    if let Some(var_1445) = &input.inside_cidr_blocks {
        let mut list_1447 = scope_1444.start_list(true, Some("item"));
        for item_1446 in var_1445 {
            #[allow(unused_mut)]
            let mut entry_1448 = list_1447.entry();
            entry_1448.string(item_1446);
        }
        list_1447.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1449 = writer.prefix("TagSpecification");
    if let Some(var_1450) = &input.tag_specifications {
        let mut list_1452 = scope_1449.start_list(true, Some("item"));
        for item_1451 in var_1450 {
            #[allow(unused_mut)]
            let mut entry_1453 = list_1452.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1453, item_1451,
            )?;
        }
        list_1452.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1454 = writer.prefix("DryRun");
    if let Some(var_1455) = &input.dry_run {
        scope_1454.boolean(*var_1455);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway_multicast_domain(
    input: &crate::input::CreateTransitGatewayMulticastDomainInput,
) -> 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,
        "CreateTransitGatewayMulticastDomain",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1456 = writer.prefix("TransitGatewayId");
    if let Some(var_1457) = &input.transit_gateway_id {
        scope_1456.string(var_1457);
    }
    #[allow(unused_mut)]
    let mut scope_1458 = writer.prefix("Options");
    if let Some(var_1459) = &input.options {
        crate::query_ser::serialize_structure_crate_model_create_transit_gateway_multicast_domain_request_options(scope_1458, var_1459)?;
    }
    #[allow(unused_mut)]
    let mut scope_1460 = writer.prefix("TagSpecification");
    if let Some(var_1461) = &input.tag_specifications {
        let mut list_1463 = scope_1460.start_list(true, Some("item"));
        for item_1462 in var_1461 {
            #[allow(unused_mut)]
            let mut entry_1464 = list_1463.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1464, item_1462,
            )?;
        }
        list_1463.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1465 = writer.prefix("DryRun");
    if let Some(var_1466) = &input.dry_run {
        scope_1465.boolean(*var_1466);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway_peering_attachment(
    input: &crate::input::CreateTransitGatewayPeeringAttachmentInput,
) -> 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,
        "CreateTransitGatewayPeeringAttachment",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1467 = writer.prefix("TransitGatewayId");
    if let Some(var_1468) = &input.transit_gateway_id {
        scope_1467.string(var_1468);
    }
    #[allow(unused_mut)]
    let mut scope_1469 = writer.prefix("PeerTransitGatewayId");
    if let Some(var_1470) = &input.peer_transit_gateway_id {
        scope_1469.string(var_1470);
    }
    #[allow(unused_mut)]
    let mut scope_1471 = writer.prefix("PeerAccountId");
    if let Some(var_1472) = &input.peer_account_id {
        scope_1471.string(var_1472);
    }
    #[allow(unused_mut)]
    let mut scope_1473 = writer.prefix("PeerRegion");
    if let Some(var_1474) = &input.peer_region {
        scope_1473.string(var_1474);
    }
    #[allow(unused_mut)]
    let mut scope_1475 = writer.prefix("Options");
    if let Some(var_1476) = &input.options {
        crate::query_ser::serialize_structure_crate_model_create_transit_gateway_peering_attachment_request_options(scope_1475, var_1476)?;
    }
    #[allow(unused_mut)]
    let mut scope_1477 = writer.prefix("TagSpecification");
    if let Some(var_1478) = &input.tag_specifications {
        let mut list_1480 = scope_1477.start_list(true, Some("item"));
        for item_1479 in var_1478 {
            #[allow(unused_mut)]
            let mut entry_1481 = list_1480.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1481, item_1479,
            )?;
        }
        list_1480.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1482 = writer.prefix("DryRun");
    if let Some(var_1483) = &input.dry_run {
        scope_1482.boolean(*var_1483);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway_policy_table(
    input: &crate::input::CreateTransitGatewayPolicyTableInput,
) -> 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,
        "CreateTransitGatewayPolicyTable",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1484 = writer.prefix("TransitGatewayId");
    if let Some(var_1485) = &input.transit_gateway_id {
        scope_1484.string(var_1485);
    }
    #[allow(unused_mut)]
    let mut scope_1486 = writer.prefix("TagSpecifications");
    if let Some(var_1487) = &input.tag_specifications {
        let mut list_1489 = scope_1486.start_list(true, Some("item"));
        for item_1488 in var_1487 {
            #[allow(unused_mut)]
            let mut entry_1490 = list_1489.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1490, item_1488,
            )?;
        }
        list_1489.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1491 = writer.prefix("DryRun");
    if let Some(var_1492) = &input.dry_run {
        scope_1491.boolean(*var_1492);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway_prefix_list_reference(
    input: &crate::input::CreateTransitGatewayPrefixListReferenceInput,
) -> 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,
        "CreateTransitGatewayPrefixListReference",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1493 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_1494) = &input.transit_gateway_route_table_id {
        scope_1493.string(var_1494);
    }
    #[allow(unused_mut)]
    let mut scope_1495 = writer.prefix("PrefixListId");
    if let Some(var_1496) = &input.prefix_list_id {
        scope_1495.string(var_1496);
    }
    #[allow(unused_mut)]
    let mut scope_1497 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_1498) = &input.transit_gateway_attachment_id {
        scope_1497.string(var_1498);
    }
    #[allow(unused_mut)]
    let mut scope_1499 = writer.prefix("Blackhole");
    if let Some(var_1500) = &input.blackhole {
        scope_1499.boolean(*var_1500);
    }
    #[allow(unused_mut)]
    let mut scope_1501 = writer.prefix("DryRun");
    if let Some(var_1502) = &input.dry_run {
        scope_1501.boolean(*var_1502);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway_route(
    input: &crate::input::CreateTransitGatewayRouteInput,
) -> 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, "CreateTransitGatewayRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1503 = writer.prefix("DestinationCidrBlock");
    if let Some(var_1504) = &input.destination_cidr_block {
        scope_1503.string(var_1504);
    }
    #[allow(unused_mut)]
    let mut scope_1505 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_1506) = &input.transit_gateway_route_table_id {
        scope_1505.string(var_1506);
    }
    #[allow(unused_mut)]
    let mut scope_1507 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_1508) = &input.transit_gateway_attachment_id {
        scope_1507.string(var_1508);
    }
    #[allow(unused_mut)]
    let mut scope_1509 = writer.prefix("Blackhole");
    if let Some(var_1510) = &input.blackhole {
        scope_1509.boolean(*var_1510);
    }
    #[allow(unused_mut)]
    let mut scope_1511 = writer.prefix("DryRun");
    if let Some(var_1512) = &input.dry_run {
        scope_1511.boolean(*var_1512);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway_route_table(
    input: &crate::input::CreateTransitGatewayRouteTableInput,
) -> 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,
        "CreateTransitGatewayRouteTable",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1513 = writer.prefix("TransitGatewayId");
    if let Some(var_1514) = &input.transit_gateway_id {
        scope_1513.string(var_1514);
    }
    #[allow(unused_mut)]
    let mut scope_1515 = writer.prefix("TagSpecifications");
    if let Some(var_1516) = &input.tag_specifications {
        let mut list_1518 = scope_1515.start_list(true, Some("item"));
        for item_1517 in var_1516 {
            #[allow(unused_mut)]
            let mut entry_1519 = list_1518.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1519, item_1517,
            )?;
        }
        list_1518.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1520 = writer.prefix("DryRun");
    if let Some(var_1521) = &input.dry_run {
        scope_1520.boolean(*var_1521);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway_route_table_announcement(
    input: &crate::input::CreateTransitGatewayRouteTableAnnouncementInput,
) -> 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,
        "CreateTransitGatewayRouteTableAnnouncement",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1522 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_1523) = &input.transit_gateway_route_table_id {
        scope_1522.string(var_1523);
    }
    #[allow(unused_mut)]
    let mut scope_1524 = writer.prefix("PeeringAttachmentId");
    if let Some(var_1525) = &input.peering_attachment_id {
        scope_1524.string(var_1525);
    }
    #[allow(unused_mut)]
    let mut scope_1526 = writer.prefix("TagSpecification");
    if let Some(var_1527) = &input.tag_specifications {
        let mut list_1529 = scope_1526.start_list(true, Some("item"));
        for item_1528 in var_1527 {
            #[allow(unused_mut)]
            let mut entry_1530 = list_1529.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1530, item_1528,
            )?;
        }
        list_1529.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1531 = writer.prefix("DryRun");
    if let Some(var_1532) = &input.dry_run {
        scope_1531.boolean(*var_1532);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_transit_gateway_vpc_attachment(
    input: &crate::input::CreateTransitGatewayVpcAttachmentInput,
) -> 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,
        "CreateTransitGatewayVpcAttachment",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1533 = writer.prefix("TransitGatewayId");
    if let Some(var_1534) = &input.transit_gateway_id {
        scope_1533.string(var_1534);
    }
    #[allow(unused_mut)]
    let mut scope_1535 = writer.prefix("VpcId");
    if let Some(var_1536) = &input.vpc_id {
        scope_1535.string(var_1536);
    }
    #[allow(unused_mut)]
    let mut scope_1537 = writer.prefix("SubnetIds");
    if let Some(var_1538) = &input.subnet_ids {
        let mut list_1540 = scope_1537.start_list(true, Some("item"));
        for item_1539 in var_1538 {
            #[allow(unused_mut)]
            let mut entry_1541 = list_1540.entry();
            entry_1541.string(item_1539);
        }
        list_1540.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1542 = writer.prefix("Options");
    if let Some(var_1543) = &input.options {
        crate::query_ser::serialize_structure_crate_model_create_transit_gateway_vpc_attachment_request_options(scope_1542, var_1543)?;
    }
    #[allow(unused_mut)]
    let mut scope_1544 = writer.prefix("TagSpecifications");
    if let Some(var_1545) = &input.tag_specifications {
        let mut list_1547 = scope_1544.start_list(true, Some("item"));
        for item_1546 in var_1545 {
            #[allow(unused_mut)]
            let mut entry_1548 = list_1547.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1548, item_1546,
            )?;
        }
        list_1547.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1549 = writer.prefix("DryRun");
    if let Some(var_1550) = &input.dry_run {
        scope_1549.boolean(*var_1550);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_volume(
    input: &crate::input::CreateVolumeInput,
) -> 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, "CreateVolume", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1551 = writer.prefix("AvailabilityZone");
    if let Some(var_1552) = &input.availability_zone {
        scope_1551.string(var_1552);
    }
    #[allow(unused_mut)]
    let mut scope_1553 = writer.prefix("Encrypted");
    if let Some(var_1554) = &input.encrypted {
        scope_1553.boolean(*var_1554);
    }
    #[allow(unused_mut)]
    let mut scope_1555 = writer.prefix("Iops");
    if let Some(var_1556) = &input.iops {
        scope_1555.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1556).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1557 = writer.prefix("KmsKeyId");
    if let Some(var_1558) = &input.kms_key_id {
        scope_1557.string(var_1558);
    }
    #[allow(unused_mut)]
    let mut scope_1559 = writer.prefix("OutpostArn");
    if let Some(var_1560) = &input.outpost_arn {
        scope_1559.string(var_1560);
    }
    #[allow(unused_mut)]
    let mut scope_1561 = writer.prefix("Size");
    if let Some(var_1562) = &input.size {
        scope_1561.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1562).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1563 = writer.prefix("SnapshotId");
    if let Some(var_1564) = &input.snapshot_id {
        scope_1563.string(var_1564);
    }
    #[allow(unused_mut)]
    let mut scope_1565 = writer.prefix("VolumeType");
    if let Some(var_1566) = &input.volume_type {
        scope_1565.string(var_1566.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1567 = writer.prefix("DryRun");
    if let Some(var_1568) = &input.dry_run {
        scope_1567.boolean(*var_1568);
    }
    #[allow(unused_mut)]
    let mut scope_1569 = writer.prefix("TagSpecification");
    if let Some(var_1570) = &input.tag_specifications {
        let mut list_1572 = scope_1569.start_list(true, Some("item"));
        for item_1571 in var_1570 {
            #[allow(unused_mut)]
            let mut entry_1573 = list_1572.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1573, item_1571,
            )?;
        }
        list_1572.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1574 = writer.prefix("MultiAttachEnabled");
    if let Some(var_1575) = &input.multi_attach_enabled {
        scope_1574.boolean(*var_1575);
    }
    #[allow(unused_mut)]
    let mut scope_1576 = writer.prefix("Throughput");
    if let Some(var_1577) = &input.throughput {
        scope_1576.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1577).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1578 = writer.prefix("ClientToken");
    if let Some(var_1579) = &input.client_token {
        scope_1578.string(var_1579);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_vpc(
    input: &crate::input::CreateVpcInput,
) -> 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, "CreateVpc", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1580 = writer.prefix("CidrBlock");
    if let Some(var_1581) = &input.cidr_block {
        scope_1580.string(var_1581);
    }
    #[allow(unused_mut)]
    let mut scope_1582 = writer.prefix("AmazonProvidedIpv6CidrBlock");
    if let Some(var_1583) = &input.amazon_provided_ipv6_cidr_block {
        scope_1582.boolean(*var_1583);
    }
    #[allow(unused_mut)]
    let mut scope_1584 = writer.prefix("Ipv6Pool");
    if let Some(var_1585) = &input.ipv6_pool {
        scope_1584.string(var_1585);
    }
    #[allow(unused_mut)]
    let mut scope_1586 = writer.prefix("Ipv6CidrBlock");
    if let Some(var_1587) = &input.ipv6_cidr_block {
        scope_1586.string(var_1587);
    }
    #[allow(unused_mut)]
    let mut scope_1588 = writer.prefix("Ipv4IpamPoolId");
    if let Some(var_1589) = &input.ipv4_ipam_pool_id {
        scope_1588.string(var_1589);
    }
    #[allow(unused_mut)]
    let mut scope_1590 = writer.prefix("Ipv4NetmaskLength");
    if let Some(var_1591) = &input.ipv4_netmask_length {
        scope_1590.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1591).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1592 = writer.prefix("Ipv6IpamPoolId");
    if let Some(var_1593) = &input.ipv6_ipam_pool_id {
        scope_1592.string(var_1593);
    }
    #[allow(unused_mut)]
    let mut scope_1594 = writer.prefix("Ipv6NetmaskLength");
    if let Some(var_1595) = &input.ipv6_netmask_length {
        scope_1594.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1595).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1596 = writer.prefix("DryRun");
    if let Some(var_1597) = &input.dry_run {
        scope_1596.boolean(*var_1597);
    }
    #[allow(unused_mut)]
    let mut scope_1598 = writer.prefix("InstanceTenancy");
    if let Some(var_1599) = &input.instance_tenancy {
        scope_1598.string(var_1599.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1600 = writer.prefix("Ipv6CidrBlockNetworkBorderGroup");
    if let Some(var_1601) = &input.ipv6_cidr_block_network_border_group {
        scope_1600.string(var_1601);
    }
    #[allow(unused_mut)]
    let mut scope_1602 = writer.prefix("TagSpecification");
    if let Some(var_1603) = &input.tag_specifications {
        let mut list_1605 = scope_1602.start_list(true, Some("item"));
        for item_1604 in var_1603 {
            #[allow(unused_mut)]
            let mut entry_1606 = list_1605.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1606, item_1604,
            )?;
        }
        list_1605.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_vpc_endpoint(
    input: &crate::input::CreateVpcEndpointInput,
) -> 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, "CreateVpcEndpoint", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1607 = writer.prefix("DryRun");
    if let Some(var_1608) = &input.dry_run {
        scope_1607.boolean(*var_1608);
    }
    #[allow(unused_mut)]
    let mut scope_1609 = writer.prefix("VpcEndpointType");
    if let Some(var_1610) = &input.vpc_endpoint_type {
        scope_1609.string(var_1610.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1611 = writer.prefix("VpcId");
    if let Some(var_1612) = &input.vpc_id {
        scope_1611.string(var_1612);
    }
    #[allow(unused_mut)]
    let mut scope_1613 = writer.prefix("ServiceName");
    if let Some(var_1614) = &input.service_name {
        scope_1613.string(var_1614);
    }
    #[allow(unused_mut)]
    let mut scope_1615 = writer.prefix("PolicyDocument");
    if let Some(var_1616) = &input.policy_document {
        scope_1615.string(var_1616);
    }
    #[allow(unused_mut)]
    let mut scope_1617 = writer.prefix("RouteTableId");
    if let Some(var_1618) = &input.route_table_ids {
        let mut list_1620 = scope_1617.start_list(true, Some("item"));
        for item_1619 in var_1618 {
            #[allow(unused_mut)]
            let mut entry_1621 = list_1620.entry();
            entry_1621.string(item_1619);
        }
        list_1620.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1622 = writer.prefix("SubnetId");
    if let Some(var_1623) = &input.subnet_ids {
        let mut list_1625 = scope_1622.start_list(true, Some("item"));
        for item_1624 in var_1623 {
            #[allow(unused_mut)]
            let mut entry_1626 = list_1625.entry();
            entry_1626.string(item_1624);
        }
        list_1625.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1627 = writer.prefix("SecurityGroupId");
    if let Some(var_1628) = &input.security_group_ids {
        let mut list_1630 = scope_1627.start_list(true, Some("item"));
        for item_1629 in var_1628 {
            #[allow(unused_mut)]
            let mut entry_1631 = list_1630.entry();
            entry_1631.string(item_1629);
        }
        list_1630.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1632 = writer.prefix("IpAddressType");
    if let Some(var_1633) = &input.ip_address_type {
        scope_1632.string(var_1633.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1634 = writer.prefix("DnsOptions");
    if let Some(var_1635) = &input.dns_options {
        crate::query_ser::serialize_structure_crate_model_dns_options_specification(
            scope_1634, var_1635,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1636 = writer.prefix("ClientToken");
    if let Some(var_1637) = &input.client_token {
        scope_1636.string(var_1637);
    }
    #[allow(unused_mut)]
    let mut scope_1638 = writer.prefix("PrivateDnsEnabled");
    if let Some(var_1639) = &input.private_dns_enabled {
        scope_1638.boolean(*var_1639);
    }
    #[allow(unused_mut)]
    let mut scope_1640 = writer.prefix("TagSpecification");
    if let Some(var_1641) = &input.tag_specifications {
        let mut list_1643 = scope_1640.start_list(true, Some("item"));
        for item_1642 in var_1641 {
            #[allow(unused_mut)]
            let mut entry_1644 = list_1643.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1644, item_1642,
            )?;
        }
        list_1643.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_vpc_endpoint_connection_notification(
    input: &crate::input::CreateVpcEndpointConnectionNotificationInput,
) -> 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,
        "CreateVpcEndpointConnectionNotification",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1645 = writer.prefix("DryRun");
    if let Some(var_1646) = &input.dry_run {
        scope_1645.boolean(*var_1646);
    }
    #[allow(unused_mut)]
    let mut scope_1647 = writer.prefix("ServiceId");
    if let Some(var_1648) = &input.service_id {
        scope_1647.string(var_1648);
    }
    #[allow(unused_mut)]
    let mut scope_1649 = writer.prefix("VpcEndpointId");
    if let Some(var_1650) = &input.vpc_endpoint_id {
        scope_1649.string(var_1650);
    }
    #[allow(unused_mut)]
    let mut scope_1651 = writer.prefix("ConnectionNotificationArn");
    if let Some(var_1652) = &input.connection_notification_arn {
        scope_1651.string(var_1652);
    }
    #[allow(unused_mut)]
    let mut scope_1653 = writer.prefix("ConnectionEvents");
    if let Some(var_1654) = &input.connection_events {
        let mut list_1656 = scope_1653.start_list(true, Some("item"));
        for item_1655 in var_1654 {
            #[allow(unused_mut)]
            let mut entry_1657 = list_1656.entry();
            entry_1657.string(item_1655);
        }
        list_1656.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1658 = writer.prefix("ClientToken");
    if let Some(var_1659) = &input.client_token {
        scope_1658.string(var_1659);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_vpc_endpoint_service_configuration(
    input: &crate::input::CreateVpcEndpointServiceConfigurationInput,
) -> 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,
        "CreateVpcEndpointServiceConfiguration",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1660 = writer.prefix("DryRun");
    if let Some(var_1661) = &input.dry_run {
        scope_1660.boolean(*var_1661);
    }
    #[allow(unused_mut)]
    let mut scope_1662 = writer.prefix("AcceptanceRequired");
    if let Some(var_1663) = &input.acceptance_required {
        scope_1662.boolean(*var_1663);
    }
    #[allow(unused_mut)]
    let mut scope_1664 = writer.prefix("PrivateDnsName");
    if let Some(var_1665) = &input.private_dns_name {
        scope_1664.string(var_1665);
    }
    #[allow(unused_mut)]
    let mut scope_1666 = writer.prefix("NetworkLoadBalancerArn");
    if let Some(var_1667) = &input.network_load_balancer_arns {
        let mut list_1669 = scope_1666.start_list(true, Some("item"));
        for item_1668 in var_1667 {
            #[allow(unused_mut)]
            let mut entry_1670 = list_1669.entry();
            entry_1670.string(item_1668);
        }
        list_1669.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1671 = writer.prefix("GatewayLoadBalancerArn");
    if let Some(var_1672) = &input.gateway_load_balancer_arns {
        let mut list_1674 = scope_1671.start_list(true, Some("item"));
        for item_1673 in var_1672 {
            #[allow(unused_mut)]
            let mut entry_1675 = list_1674.entry();
            entry_1675.string(item_1673);
        }
        list_1674.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1676 = writer.prefix("SupportedIpAddressType");
    if let Some(var_1677) = &input.supported_ip_address_types {
        let mut list_1679 = scope_1676.start_list(true, Some("item"));
        for item_1678 in var_1677 {
            #[allow(unused_mut)]
            let mut entry_1680 = list_1679.entry();
            entry_1680.string(item_1678);
        }
        list_1679.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1681 = writer.prefix("ClientToken");
    if let Some(var_1682) = &input.client_token {
        scope_1681.string(var_1682);
    }
    #[allow(unused_mut)]
    let mut scope_1683 = writer.prefix("TagSpecification");
    if let Some(var_1684) = &input.tag_specifications {
        let mut list_1686 = scope_1683.start_list(true, Some("item"));
        for item_1685 in var_1684 {
            #[allow(unused_mut)]
            let mut entry_1687 = list_1686.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1687, item_1685,
            )?;
        }
        list_1686.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_vpc_peering_connection(
    input: &crate::input::CreateVpcPeeringConnectionInput,
) -> 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, "CreateVpcPeeringConnection", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1688 = writer.prefix("DryRun");
    if let Some(var_1689) = &input.dry_run {
        scope_1688.boolean(*var_1689);
    }
    #[allow(unused_mut)]
    let mut scope_1690 = writer.prefix("PeerOwnerId");
    if let Some(var_1691) = &input.peer_owner_id {
        scope_1690.string(var_1691);
    }
    #[allow(unused_mut)]
    let mut scope_1692 = writer.prefix("PeerVpcId");
    if let Some(var_1693) = &input.peer_vpc_id {
        scope_1692.string(var_1693);
    }
    #[allow(unused_mut)]
    let mut scope_1694 = writer.prefix("VpcId");
    if let Some(var_1695) = &input.vpc_id {
        scope_1694.string(var_1695);
    }
    #[allow(unused_mut)]
    let mut scope_1696 = writer.prefix("PeerRegion");
    if let Some(var_1697) = &input.peer_region {
        scope_1696.string(var_1697);
    }
    #[allow(unused_mut)]
    let mut scope_1698 = writer.prefix("TagSpecification");
    if let Some(var_1699) = &input.tag_specifications {
        let mut list_1701 = scope_1698.start_list(true, Some("item"));
        for item_1700 in var_1699 {
            #[allow(unused_mut)]
            let mut entry_1702 = list_1701.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1702, item_1700,
            )?;
        }
        list_1701.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_vpn_connection(
    input: &crate::input::CreateVpnConnectionInput,
) -> 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, "CreateVpnConnection", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1703 = writer.prefix("CustomerGatewayId");
    if let Some(var_1704) = &input.customer_gateway_id {
        scope_1703.string(var_1704);
    }
    #[allow(unused_mut)]
    let mut scope_1705 = writer.prefix("Type");
    if let Some(var_1706) = &input.r#type {
        scope_1705.string(var_1706);
    }
    #[allow(unused_mut)]
    let mut scope_1707 = writer.prefix("VpnGatewayId");
    if let Some(var_1708) = &input.vpn_gateway_id {
        scope_1707.string(var_1708);
    }
    #[allow(unused_mut)]
    let mut scope_1709 = writer.prefix("TransitGatewayId");
    if let Some(var_1710) = &input.transit_gateway_id {
        scope_1709.string(var_1710);
    }
    #[allow(unused_mut)]
    let mut scope_1711 = writer.prefix("DryRun");
    if let Some(var_1712) = &input.dry_run {
        scope_1711.boolean(*var_1712);
    }
    #[allow(unused_mut)]
    let mut scope_1713 = writer.prefix("Options");
    if let Some(var_1714) = &input.options {
        crate::query_ser::serialize_structure_crate_model_vpn_connection_options_specification(
            scope_1713, var_1714,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_1715 = writer.prefix("TagSpecification");
    if let Some(var_1716) = &input.tag_specifications {
        let mut list_1718 = scope_1715.start_list(true, Some("item"));
        for item_1717 in var_1716 {
            #[allow(unused_mut)]
            let mut entry_1719 = list_1718.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1719, item_1717,
            )?;
        }
        list_1718.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_vpn_connection_route(
    input: &crate::input::CreateVpnConnectionRouteInput,
) -> 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, "CreateVpnConnectionRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1720 = writer.prefix("DestinationCidrBlock");
    if let Some(var_1721) = &input.destination_cidr_block {
        scope_1720.string(var_1721);
    }
    #[allow(unused_mut)]
    let mut scope_1722 = writer.prefix("VpnConnectionId");
    if let Some(var_1723) = &input.vpn_connection_id {
        scope_1722.string(var_1723);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_vpn_gateway(
    input: &crate::input::CreateVpnGatewayInput,
) -> 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, "CreateVpnGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1724 = writer.prefix("AvailabilityZone");
    if let Some(var_1725) = &input.availability_zone {
        scope_1724.string(var_1725);
    }
    #[allow(unused_mut)]
    let mut scope_1726 = writer.prefix("Type");
    if let Some(var_1727) = &input.r#type {
        scope_1726.string(var_1727.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1728 = writer.prefix("TagSpecification");
    if let Some(var_1729) = &input.tag_specifications {
        let mut list_1731 = scope_1728.start_list(true, Some("item"));
        for item_1730 in var_1729 {
            #[allow(unused_mut)]
            let mut entry_1732 = list_1731.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_1732, item_1730,
            )?;
        }
        list_1731.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1733 = writer.prefix("AmazonSideAsn");
    if let Some(var_1734) = &input.amazon_side_asn {
        scope_1733.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1734).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1735 = writer.prefix("DryRun");
    if let Some(var_1736) = &input.dry_run {
        scope_1735.boolean(*var_1736);
    }
    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 GatewayType

fn as_ref(&self) -> &str

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

impl Clone for GatewayType

fn clone(&self) -> GatewayType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GatewayType

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

Formats the value using the given formatter.

impl From<&str> for GatewayType

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for GatewayType

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 GatewayType

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 GatewayType

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

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

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

impl StructuralEq for GatewayType

impl StructuralPartialEq for GatewayType