Enum aws_sdk_ec2::model::InstanceAttributeName

#[non_exhaustive]
pub enum InstanceAttributeName {
    BlockDeviceMapping,
    DisableApiStop,
    DisableApiTermination,
    EbsOptimized,
    EnaSupport,
    EnclaveOptions,
    GroupSet,
    InstanceInitiatedShutdownBehavior,
    InstanceType,
    Kernel,
    ProductCodes,
    Ramdisk,
    RootDeviceName,
    SourceDestCheck,
    SriovNetSupport,
    UserData,
    Unknown(UnknownVariantValue),
}

When writing a match expression against InstanceAttributeName, 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 instanceattributename = unimplemented!();
match instanceattributename {
    InstanceAttributeName::BlockDeviceMapping => { /* ... */ },
    InstanceAttributeName::DisableApiStop => { /* ... */ },
    InstanceAttributeName::DisableApiTermination => { /* ... */ },
    InstanceAttributeName::EbsOptimized => { /* ... */ },
    InstanceAttributeName::EnaSupport => { /* ... */ },
    InstanceAttributeName::EnclaveOptions => { /* ... */ },
    InstanceAttributeName::GroupSet => { /* ... */ },
    InstanceAttributeName::InstanceInitiatedShutdownBehavior => { /* ... */ },
    InstanceAttributeName::InstanceType => { /* ... */ },
    InstanceAttributeName::Kernel => { /* ... */ },
    InstanceAttributeName::ProductCodes => { /* ... */ },
    InstanceAttributeName::Ramdisk => { /* ... */ },
    InstanceAttributeName::RootDeviceName => { /* ... */ },
    InstanceAttributeName::SourceDestCheck => { /* ... */ },
    InstanceAttributeName::SriovNetSupport => { /* ... */ },
    InstanceAttributeName::UserData => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

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

BlockDeviceMapping

DisableApiStop

DisableApiTermination

EbsOptimized

EnaSupport

EnclaveOptions

GroupSet

InstanceInitiatedShutdownBehavior

InstanceType

Kernel

ProductCodes

Ramdisk

RootDeviceName

SourceDestCheck

SriovNetSupport

UserData

Unknown(UnknownVariantValue)

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

Implementations

impl InstanceAttributeName

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 22446)

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

src/operation_ser.rs (line 9602)

pub fn serialize_operation_crate_operation_describe_instance_attribute(
    input: &crate::input::DescribeInstanceAttributeInput,
) -> 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, "DescribeInstanceAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2680 = writer.prefix("Attribute");
    if let Some(var_2681) = &input.attribute {
        scope_2680.string(var_2681.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_2682 = writer.prefix("DryRun");
    if let Some(var_2683) = &input.dry_run {
        scope_2682.boolean(*var_2683);
    }
    #[allow(unused_mut)]
    let mut scope_2684 = writer.prefix("InstanceId");
    if let Some(var_2685) = &input.instance_id {
        scope_2684.string(var_2685);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_instance_credit_specifications(
    input: &crate::input::DescribeInstanceCreditSpecificationsInput,
) -> 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,
        "DescribeInstanceCreditSpecifications",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2686 = writer.prefix("DryRun");
    if let Some(var_2687) = &input.dry_run {
        scope_2686.boolean(*var_2687);
    }
    #[allow(unused_mut)]
    let mut scope_2688 = writer.prefix("Filter");
    if let Some(var_2689) = &input.filters {
        let mut list_2691 = scope_2688.start_list(true, Some("Filter"));
        for item_2690 in var_2689 {
            #[allow(unused_mut)]
            let mut entry_2692 = list_2691.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2692, item_2690)?;
        }
        list_2691.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2693 = writer.prefix("InstanceId");
    if let Some(var_2694) = &input.instance_ids {
        let mut list_2696 = scope_2693.start_list(true, Some("InstanceId"));
        for item_2695 in var_2694 {
            #[allow(unused_mut)]
            let mut entry_2697 = list_2696.entry();
            entry_2697.string(item_2695);
        }
        list_2696.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2698 = writer.prefix("MaxResults");
    if let Some(var_2699) = &input.max_results {
        scope_2698.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2699).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2700 = writer.prefix("NextToken");
    if let Some(var_2701) = &input.next_token {
        scope_2700.string(var_2701);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

pub fn serialize_operation_crate_operation_describe_instance_event_windows(
    input: &crate::input::DescribeInstanceEventWindowsInput,
) -> 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, "DescribeInstanceEventWindows", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2704 = writer.prefix("DryRun");
    if let Some(var_2705) = &input.dry_run {
        scope_2704.boolean(*var_2705);
    }
    #[allow(unused_mut)]
    let mut scope_2706 = writer.prefix("InstanceEventWindowId");
    if let Some(var_2707) = &input.instance_event_window_ids {
        let mut list_2709 = scope_2706.start_list(true, Some("InstanceEventWindowId"));
        for item_2708 in var_2707 {
            #[allow(unused_mut)]
            let mut entry_2710 = list_2709.entry();
            entry_2710.string(item_2708);
        }
        list_2709.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2711 = writer.prefix("Filter");
    if let Some(var_2712) = &input.filters {
        let mut list_2714 = scope_2711.start_list(true, Some("Filter"));
        for item_2713 in var_2712 {
            #[allow(unused_mut)]
            let mut entry_2715 = list_2714.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2715, item_2713)?;
        }
        list_2714.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2716 = writer.prefix("MaxResults");
    if let Some(var_2717) = &input.max_results {
        scope_2716.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2717).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2718 = writer.prefix("NextToken");
    if let Some(var_2719) = &input.next_token {
        scope_2718.string(var_2719);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_instances(
    input: &crate::input::DescribeInstancesInput,
) -> 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, "DescribeInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2720 = writer.prefix("Filter");
    if let Some(var_2721) = &input.filters {
        let mut list_2723 = scope_2720.start_list(true, Some("Filter"));
        for item_2722 in var_2721 {
            #[allow(unused_mut)]
            let mut entry_2724 = list_2723.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2724, item_2722)?;
        }
        list_2723.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2725 = writer.prefix("InstanceId");
    if let Some(var_2726) = &input.instance_ids {
        let mut list_2728 = scope_2725.start_list(true, Some("InstanceId"));
        for item_2727 in var_2726 {
            #[allow(unused_mut)]
            let mut entry_2729 = list_2728.entry();
            entry_2729.string(item_2727);
        }
        list_2728.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2730 = writer.prefix("DryRun");
    if let Some(var_2731) = &input.dry_run {
        scope_2730.boolean(*var_2731);
    }
    #[allow(unused_mut)]
    let mut scope_2732 = writer.prefix("MaxResults");
    if let Some(var_2733) = &input.max_results {
        scope_2732.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2733).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2734 = writer.prefix("NextToken");
    if let Some(var_2735) = &input.next_token {
        scope_2734.string(var_2735);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_instance_status(
    input: &crate::input::DescribeInstanceStatusInput,
) -> 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, "DescribeInstanceStatus", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2736 = writer.prefix("Filter");
    if let Some(var_2737) = &input.filters {
        let mut list_2739 = scope_2736.start_list(true, Some("Filter"));
        for item_2738 in var_2737 {
            #[allow(unused_mut)]
            let mut entry_2740 = list_2739.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2740, item_2738)?;
        }
        list_2739.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2741 = writer.prefix("InstanceId");
    if let Some(var_2742) = &input.instance_ids {
        let mut list_2744 = scope_2741.start_list(true, Some("InstanceId"));
        for item_2743 in var_2742 {
            #[allow(unused_mut)]
            let mut entry_2745 = list_2744.entry();
            entry_2745.string(item_2743);
        }
        list_2744.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2746 = writer.prefix("MaxResults");
    if let Some(var_2747) = &input.max_results {
        scope_2746.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2747).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2748 = writer.prefix("NextToken");
    if let Some(var_2749) = &input.next_token {
        scope_2748.string(var_2749);
    }
    #[allow(unused_mut)]
    let mut scope_2750 = writer.prefix("DryRun");
    if let Some(var_2751) = &input.dry_run {
        scope_2750.boolean(*var_2751);
    }
    #[allow(unused_mut)]
    let mut scope_2752 = writer.prefix("IncludeAllInstances");
    if let Some(var_2753) = &input.include_all_instances {
        scope_2752.boolean(*var_2753);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_instance_type_offerings(
    input: &crate::input::DescribeInstanceTypeOfferingsInput,
) -> 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, "DescribeInstanceTypeOfferings", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2754 = writer.prefix("DryRun");
    if let Some(var_2755) = &input.dry_run {
        scope_2754.boolean(*var_2755);
    }
    #[allow(unused_mut)]
    let mut scope_2756 = writer.prefix("LocationType");
    if let Some(var_2757) = &input.location_type {
        scope_2756.string(var_2757.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_2758 = writer.prefix("Filter");
    if let Some(var_2759) = &input.filters {
        let mut list_2761 = scope_2758.start_list(true, Some("Filter"));
        for item_2760 in var_2759 {
            #[allow(unused_mut)]
            let mut entry_2762 = list_2761.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2762, item_2760)?;
        }
        list_2761.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2763 = writer.prefix("MaxResults");
    if let Some(var_2764) = &input.max_results {
        scope_2763.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2764).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2765 = writer.prefix("NextToken");
    if let Some(var_2766) = &input.next_token {
        scope_2765.string(var_2766);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_instance_types(
    input: &crate::input::DescribeInstanceTypesInput,
) -> 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, "DescribeInstanceTypes", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2767 = writer.prefix("DryRun");
    if let Some(var_2768) = &input.dry_run {
        scope_2767.boolean(*var_2768);
    }
    #[allow(unused_mut)]
    let mut scope_2769 = writer.prefix("InstanceType");
    if let Some(var_2770) = &input.instance_types {
        let mut list_2772 = scope_2769.start_list(true, None);
        for item_2771 in var_2770 {
            #[allow(unused_mut)]
            let mut entry_2773 = list_2772.entry();
            entry_2773.string(item_2771.as_str());
        }
        list_2772.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2774 = writer.prefix("Filter");
    if let Some(var_2775) = &input.filters {
        let mut list_2777 = scope_2774.start_list(true, Some("Filter"));
        for item_2776 in var_2775 {
            #[allow(unused_mut)]
            let mut entry_2778 = list_2777.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2778, item_2776)?;
        }
        list_2777.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2779 = writer.prefix("MaxResults");
    if let Some(var_2780) = &input.max_results {
        scope_2779.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2780).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2781 = writer.prefix("NextToken");
    if let Some(var_2782) = &input.next_token {
        scope_2781.string(var_2782);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_internet_gateways(
    input: &crate::input::DescribeInternetGatewaysInput,
) -> 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, "DescribeInternetGateways", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2783 = writer.prefix("Filter");
    if let Some(var_2784) = &input.filters {
        let mut list_2786 = scope_2783.start_list(true, Some("Filter"));
        for item_2785 in var_2784 {
            #[allow(unused_mut)]
            let mut entry_2787 = list_2786.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2787, item_2785)?;
        }
        list_2786.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2788 = writer.prefix("DryRun");
    if let Some(var_2789) = &input.dry_run {
        scope_2788.boolean(*var_2789);
    }
    #[allow(unused_mut)]
    let mut scope_2790 = writer.prefix("InternetGatewayId");
    if let Some(var_2791) = &input.internet_gateway_ids {
        let mut list_2793 = scope_2790.start_list(true, Some("item"));
        for item_2792 in var_2791 {
            #[allow(unused_mut)]
            let mut entry_2794 = list_2793.entry();
            entry_2794.string(item_2792);
        }
        list_2793.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2795 = writer.prefix("NextToken");
    if let Some(var_2796) = &input.next_token {
        scope_2795.string(var_2796);
    }
    #[allow(unused_mut)]
    let mut scope_2797 = writer.prefix("MaxResults");
    if let Some(var_2798) = &input.max_results {
        scope_2797.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2798).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_ipam_pools(
    input: &crate::input::DescribeIpamPoolsInput,
) -> 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, "DescribeIpamPools", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2799 = writer.prefix("DryRun");
    if let Some(var_2800) = &input.dry_run {
        scope_2799.boolean(*var_2800);
    }
    #[allow(unused_mut)]
    let mut scope_2801 = writer.prefix("Filter");
    if let Some(var_2802) = &input.filters {
        let mut list_2804 = scope_2801.start_list(true, Some("Filter"));
        for item_2803 in var_2802 {
            #[allow(unused_mut)]
            let mut entry_2805 = list_2804.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2805, item_2803)?;
        }
        list_2804.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2806 = writer.prefix("MaxResults");
    if let Some(var_2807) = &input.max_results {
        scope_2806.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2807).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2808 = writer.prefix("NextToken");
    if let Some(var_2809) = &input.next_token {
        scope_2808.string(var_2809);
    }
    #[allow(unused_mut)]
    let mut scope_2810 = writer.prefix("IpamPoolId");
    if let Some(var_2811) = &input.ipam_pool_ids {
        let mut list_2813 = scope_2810.start_list(true, Some("item"));
        for item_2812 in var_2811 {
            #[allow(unused_mut)]
            let mut entry_2814 = list_2813.entry();
            entry_2814.string(item_2812);
        }
        list_2813.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_ipams(
    input: &crate::input::DescribeIpamsInput,
) -> 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, "DescribeIpams", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2815 = writer.prefix("DryRun");
    if let Some(var_2816) = &input.dry_run {
        scope_2815.boolean(*var_2816);
    }
    #[allow(unused_mut)]
    let mut scope_2817 = writer.prefix("Filter");
    if let Some(var_2818) = &input.filters {
        let mut list_2820 = scope_2817.start_list(true, Some("Filter"));
        for item_2819 in var_2818 {
            #[allow(unused_mut)]
            let mut entry_2821 = list_2820.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2821, item_2819)?;
        }
        list_2820.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2822 = writer.prefix("MaxResults");
    if let Some(var_2823) = &input.max_results {
        scope_2822.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2823).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2824 = writer.prefix("NextToken");
    if let Some(var_2825) = &input.next_token {
        scope_2824.string(var_2825);
    }
    #[allow(unused_mut)]
    let mut scope_2826 = writer.prefix("IpamId");
    if let Some(var_2827) = &input.ipam_ids {
        let mut list_2829 = scope_2826.start_list(true, Some("item"));
        for item_2828 in var_2827 {
            #[allow(unused_mut)]
            let mut entry_2830 = list_2829.entry();
            entry_2830.string(item_2828);
        }
        list_2829.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_ipam_scopes(
    input: &crate::input::DescribeIpamScopesInput,
) -> 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, "DescribeIpamScopes", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2831 = writer.prefix("DryRun");
    if let Some(var_2832) = &input.dry_run {
        scope_2831.boolean(*var_2832);
    }
    #[allow(unused_mut)]
    let mut scope_2833 = writer.prefix("Filter");
    if let Some(var_2834) = &input.filters {
        let mut list_2836 = scope_2833.start_list(true, Some("Filter"));
        for item_2835 in var_2834 {
            #[allow(unused_mut)]
            let mut entry_2837 = list_2836.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2837, item_2835)?;
        }
        list_2836.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2838 = writer.prefix("MaxResults");
    if let Some(var_2839) = &input.max_results {
        scope_2838.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2839).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2840 = writer.prefix("NextToken");
    if let Some(var_2841) = &input.next_token {
        scope_2840.string(var_2841);
    }
    #[allow(unused_mut)]
    let mut scope_2842 = writer.prefix("IpamScopeId");
    if let Some(var_2843) = &input.ipam_scope_ids {
        let mut list_2845 = scope_2842.start_list(true, Some("item"));
        for item_2844 in var_2843 {
            #[allow(unused_mut)]
            let mut entry_2846 = list_2845.entry();
            entry_2846.string(item_2844);
        }
        list_2845.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_ipv6_pools(
    input: &crate::input::DescribeIpv6PoolsInput,
) -> 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, "DescribeIpv6Pools", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2847 = writer.prefix("PoolId");
    if let Some(var_2848) = &input.pool_ids {
        let mut list_2850 = scope_2847.start_list(true, Some("item"));
        for item_2849 in var_2848 {
            #[allow(unused_mut)]
            let mut entry_2851 = list_2850.entry();
            entry_2851.string(item_2849);
        }
        list_2850.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2852 = writer.prefix("NextToken");
    if let Some(var_2853) = &input.next_token {
        scope_2852.string(var_2853);
    }
    #[allow(unused_mut)]
    let mut scope_2854 = writer.prefix("MaxResults");
    if let Some(var_2855) = &input.max_results {
        scope_2854.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2855).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2856 = writer.prefix("DryRun");
    if let Some(var_2857) = &input.dry_run {
        scope_2856.boolean(*var_2857);
    }
    #[allow(unused_mut)]
    let mut scope_2858 = writer.prefix("Filter");
    if let Some(var_2859) = &input.filters {
        let mut list_2861 = scope_2858.start_list(true, Some("Filter"));
        for item_2860 in var_2859 {
            #[allow(unused_mut)]
            let mut entry_2862 = list_2861.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2862, item_2860)?;
        }
        list_2861.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_key_pairs(
    input: &crate::input::DescribeKeyPairsInput,
) -> 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, "DescribeKeyPairs", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2863 = writer.prefix("Filter");
    if let Some(var_2864) = &input.filters {
        let mut list_2866 = scope_2863.start_list(true, Some("Filter"));
        for item_2865 in var_2864 {
            #[allow(unused_mut)]
            let mut entry_2867 = list_2866.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2867, item_2865)?;
        }
        list_2866.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2868 = writer.prefix("KeyName");
    if let Some(var_2869) = &input.key_names {
        let mut list_2871 = scope_2868.start_list(true, Some("KeyName"));
        for item_2870 in var_2869 {
            #[allow(unused_mut)]
            let mut entry_2872 = list_2871.entry();
            entry_2872.string(item_2870);
        }
        list_2871.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2873 = writer.prefix("KeyPairId");
    if let Some(var_2874) = &input.key_pair_ids {
        let mut list_2876 = scope_2873.start_list(true, Some("KeyPairId"));
        for item_2875 in var_2874 {
            #[allow(unused_mut)]
            let mut entry_2877 = list_2876.entry();
            entry_2877.string(item_2875);
        }
        list_2876.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2878 = writer.prefix("DryRun");
    if let Some(var_2879) = &input.dry_run {
        scope_2878.boolean(*var_2879);
    }
    #[allow(unused_mut)]
    let mut scope_2880 = writer.prefix("IncludePublicKey");
    if let Some(var_2881) = &input.include_public_key {
        scope_2880.boolean(*var_2881);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_launch_templates(
    input: &crate::input::DescribeLaunchTemplatesInput,
) -> 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, "DescribeLaunchTemplates", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2882 = writer.prefix("DryRun");
    if let Some(var_2883) = &input.dry_run {
        scope_2882.boolean(*var_2883);
    }
    #[allow(unused_mut)]
    let mut scope_2884 = writer.prefix("LaunchTemplateId");
    if let Some(var_2885) = &input.launch_template_ids {
        let mut list_2887 = scope_2884.start_list(true, Some("item"));
        for item_2886 in var_2885 {
            #[allow(unused_mut)]
            let mut entry_2888 = list_2887.entry();
            entry_2888.string(item_2886);
        }
        list_2887.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2889 = writer.prefix("LaunchTemplateName");
    if let Some(var_2890) = &input.launch_template_names {
        let mut list_2892 = scope_2889.start_list(true, Some("item"));
        for item_2891 in var_2890 {
            #[allow(unused_mut)]
            let mut entry_2893 = list_2892.entry();
            entry_2893.string(item_2891);
        }
        list_2892.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2894 = writer.prefix("Filter");
    if let Some(var_2895) = &input.filters {
        let mut list_2897 = scope_2894.start_list(true, Some("Filter"));
        for item_2896 in var_2895 {
            #[allow(unused_mut)]
            let mut entry_2898 = list_2897.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2898, item_2896)?;
        }
        list_2897.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2899 = writer.prefix("NextToken");
    if let Some(var_2900) = &input.next_token {
        scope_2899.string(var_2900);
    }
    #[allow(unused_mut)]
    let mut scope_2901 = writer.prefix("MaxResults");
    if let Some(var_2902) = &input.max_results {
        scope_2901.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2902).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_launch_template_versions(
    input: &crate::input::DescribeLaunchTemplateVersionsInput,
) -> 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,
        "DescribeLaunchTemplateVersions",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2903 = writer.prefix("DryRun");
    if let Some(var_2904) = &input.dry_run {
        scope_2903.boolean(*var_2904);
    }
    #[allow(unused_mut)]
    let mut scope_2905 = writer.prefix("LaunchTemplateId");
    if let Some(var_2906) = &input.launch_template_id {
        scope_2905.string(var_2906);
    }
    #[allow(unused_mut)]
    let mut scope_2907 = writer.prefix("LaunchTemplateName");
    if let Some(var_2908) = &input.launch_template_name {
        scope_2907.string(var_2908);
    }
    #[allow(unused_mut)]
    let mut scope_2909 = writer.prefix("LaunchTemplateVersion");
    if let Some(var_2910) = &input.versions {
        let mut list_2912 = scope_2909.start_list(true, Some("item"));
        for item_2911 in var_2910 {
            #[allow(unused_mut)]
            let mut entry_2913 = list_2912.entry();
            entry_2913.string(item_2911);
        }
        list_2912.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2914 = writer.prefix("MinVersion");
    if let Some(var_2915) = &input.min_version {
        scope_2914.string(var_2915);
    }
    #[allow(unused_mut)]
    let mut scope_2916 = writer.prefix("MaxVersion");
    if let Some(var_2917) = &input.max_version {
        scope_2916.string(var_2917);
    }
    #[allow(unused_mut)]
    let mut scope_2918 = writer.prefix("NextToken");
    if let Some(var_2919) = &input.next_token {
        scope_2918.string(var_2919);
    }
    #[allow(unused_mut)]
    let mut scope_2920 = writer.prefix("MaxResults");
    if let Some(var_2921) = &input.max_results {
        scope_2920.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2921).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2922 = writer.prefix("Filter");
    if let Some(var_2923) = &input.filters {
        let mut list_2925 = scope_2922.start_list(true, Some("Filter"));
        for item_2924 in var_2923 {
            #[allow(unused_mut)]
            let mut entry_2926 = list_2925.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2926, item_2924)?;
        }
        list_2925.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_local_gateway_route_tables(
    input: &crate::input::DescribeLocalGatewayRouteTablesInput,
) -> 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,
        "DescribeLocalGatewayRouteTables",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2927 = writer.prefix("LocalGatewayRouteTableId");
    if let Some(var_2928) = &input.local_gateway_route_table_ids {
        let mut list_2930 = scope_2927.start_list(true, Some("item"));
        for item_2929 in var_2928 {
            #[allow(unused_mut)]
            let mut entry_2931 = list_2930.entry();
            entry_2931.string(item_2929);
        }
        list_2930.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2932 = writer.prefix("Filter");
    if let Some(var_2933) = &input.filters {
        let mut list_2935 = scope_2932.start_list(true, Some("Filter"));
        for item_2934 in var_2933 {
            #[allow(unused_mut)]
            let mut entry_2936 = list_2935.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2936, item_2934)?;
        }
        list_2935.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2937 = writer.prefix("MaxResults");
    if let Some(var_2938) = &input.max_results {
        scope_2937.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2938).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2939 = writer.prefix("NextToken");
    if let Some(var_2940) = &input.next_token {
        scope_2939.string(var_2940);
    }
    #[allow(unused_mut)]
    let mut scope_2941 = writer.prefix("DryRun");
    if let Some(var_2942) = &input.dry_run {
        scope_2941.boolean(*var_2942);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_local_gateway_route_table_virtual_interface_group_associations(
    input: &crate::input::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput,
) -> 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,
        "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2943 = writer.prefix("LocalGatewayRouteTableVirtualInterfaceGroupAssociationId");
    if let Some(var_2944) = &input.local_gateway_route_table_virtual_interface_group_association_ids
    {
        let mut list_2946 = scope_2943.start_list(true, Some("item"));
        for item_2945 in var_2944 {
            #[allow(unused_mut)]
            let mut entry_2947 = list_2946.entry();
            entry_2947.string(item_2945);
        }
        list_2946.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2948 = writer.prefix("Filter");
    if let Some(var_2949) = &input.filters {
        let mut list_2951 = scope_2948.start_list(true, Some("Filter"));
        for item_2950 in var_2949 {
            #[allow(unused_mut)]
            let mut entry_2952 = list_2951.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2952, item_2950)?;
        }
        list_2951.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2953 = writer.prefix("MaxResults");
    if let Some(var_2954) = &input.max_results {
        scope_2953.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2954).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2955 = writer.prefix("NextToken");
    if let Some(var_2956) = &input.next_token {
        scope_2955.string(var_2956);
    }
    #[allow(unused_mut)]
    let mut scope_2957 = writer.prefix("DryRun");
    if let Some(var_2958) = &input.dry_run {
        scope_2957.boolean(*var_2958);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_local_gateway_route_table_vpc_associations(
    input: &crate::input::DescribeLocalGatewayRouteTableVpcAssociationsInput,
) -> 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,
        "DescribeLocalGatewayRouteTableVpcAssociations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2959 = writer.prefix("LocalGatewayRouteTableVpcAssociationId");
    if let Some(var_2960) = &input.local_gateway_route_table_vpc_association_ids {
        let mut list_2962 = scope_2959.start_list(true, Some("item"));
        for item_2961 in var_2960 {
            #[allow(unused_mut)]
            let mut entry_2963 = list_2962.entry();
            entry_2963.string(item_2961);
        }
        list_2962.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2964 = writer.prefix("Filter");
    if let Some(var_2965) = &input.filters {
        let mut list_2967 = scope_2964.start_list(true, Some("Filter"));
        for item_2966 in var_2965 {
            #[allow(unused_mut)]
            let mut entry_2968 = list_2967.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2968, item_2966)?;
        }
        list_2967.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2969 = writer.prefix("MaxResults");
    if let Some(var_2970) = &input.max_results {
        scope_2969.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2970).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2971 = writer.prefix("NextToken");
    if let Some(var_2972) = &input.next_token {
        scope_2971.string(var_2972);
    }
    #[allow(unused_mut)]
    let mut scope_2973 = writer.prefix("DryRun");
    if let Some(var_2974) = &input.dry_run {
        scope_2973.boolean(*var_2974);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_local_gateways(
    input: &crate::input::DescribeLocalGatewaysInput,
) -> 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, "DescribeLocalGateways", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2975 = writer.prefix("LocalGatewayId");
    if let Some(var_2976) = &input.local_gateway_ids {
        let mut list_2978 = scope_2975.start_list(true, Some("item"));
        for item_2977 in var_2976 {
            #[allow(unused_mut)]
            let mut entry_2979 = list_2978.entry();
            entry_2979.string(item_2977);
        }
        list_2978.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2980 = writer.prefix("Filter");
    if let Some(var_2981) = &input.filters {
        let mut list_2983 = scope_2980.start_list(true, Some("Filter"));
        for item_2982 in var_2981 {
            #[allow(unused_mut)]
            let mut entry_2984 = list_2983.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2984, item_2982)?;
        }
        list_2983.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2985 = writer.prefix("MaxResults");
    if let Some(var_2986) = &input.max_results {
        scope_2985.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2986).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2987 = writer.prefix("NextToken");
    if let Some(var_2988) = &input.next_token {
        scope_2987.string(var_2988);
    }
    #[allow(unused_mut)]
    let mut scope_2989 = writer.prefix("DryRun");
    if let Some(var_2990) = &input.dry_run {
        scope_2989.boolean(*var_2990);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_local_gateway_virtual_interface_groups(
    input: &crate::input::DescribeLocalGatewayVirtualInterfaceGroupsInput,
) -> 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,
        "DescribeLocalGatewayVirtualInterfaceGroups",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2991 = writer.prefix("LocalGatewayVirtualInterfaceGroupId");
    if let Some(var_2992) = &input.local_gateway_virtual_interface_group_ids {
        let mut list_2994 = scope_2991.start_list(true, Some("item"));
        for item_2993 in var_2992 {
            #[allow(unused_mut)]
            let mut entry_2995 = list_2994.entry();
            entry_2995.string(item_2993);
        }
        list_2994.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2996 = writer.prefix("Filter");
    if let Some(var_2997) = &input.filters {
        let mut list_2999 = scope_2996.start_list(true, Some("Filter"));
        for item_2998 in var_2997 {
            #[allow(unused_mut)]
            let mut entry_3000 = list_2999.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3000, item_2998)?;
        }
        list_2999.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3001 = writer.prefix("MaxResults");
    if let Some(var_3002) = &input.max_results {
        scope_3001.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3002).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3003 = writer.prefix("NextToken");
    if let Some(var_3004) = &input.next_token {
        scope_3003.string(var_3004);
    }
    #[allow(unused_mut)]
    let mut scope_3005 = writer.prefix("DryRun");
    if let Some(var_3006) = &input.dry_run {
        scope_3005.boolean(*var_3006);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_local_gateway_virtual_interfaces(
    input: &crate::input::DescribeLocalGatewayVirtualInterfacesInput,
) -> 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,
        "DescribeLocalGatewayVirtualInterfaces",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3007 = writer.prefix("LocalGatewayVirtualInterfaceId");
    if let Some(var_3008) = &input.local_gateway_virtual_interface_ids {
        let mut list_3010 = scope_3007.start_list(true, Some("item"));
        for item_3009 in var_3008 {
            #[allow(unused_mut)]
            let mut entry_3011 = list_3010.entry();
            entry_3011.string(item_3009);
        }
        list_3010.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3012 = writer.prefix("Filter");
    if let Some(var_3013) = &input.filters {
        let mut list_3015 = scope_3012.start_list(true, Some("Filter"));
        for item_3014 in var_3013 {
            #[allow(unused_mut)]
            let mut entry_3016 = list_3015.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3016, item_3014)?;
        }
        list_3015.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3017 = writer.prefix("MaxResults");
    if let Some(var_3018) = &input.max_results {
        scope_3017.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3018).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3019 = writer.prefix("NextToken");
    if let Some(var_3020) = &input.next_token {
        scope_3019.string(var_3020);
    }
    #[allow(unused_mut)]
    let mut scope_3021 = writer.prefix("DryRun");
    if let Some(var_3022) = &input.dry_run {
        scope_3021.boolean(*var_3022);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_managed_prefix_lists(
    input: &crate::input::DescribeManagedPrefixListsInput,
) -> 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, "DescribeManagedPrefixLists", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3023 = writer.prefix("DryRun");
    if let Some(var_3024) = &input.dry_run {
        scope_3023.boolean(*var_3024);
    }
    #[allow(unused_mut)]
    let mut scope_3025 = writer.prefix("Filter");
    if let Some(var_3026) = &input.filters {
        let mut list_3028 = scope_3025.start_list(true, Some("Filter"));
        for item_3027 in var_3026 {
            #[allow(unused_mut)]
            let mut entry_3029 = list_3028.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3029, item_3027)?;
        }
        list_3028.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3030 = writer.prefix("MaxResults");
    if let Some(var_3031) = &input.max_results {
        scope_3030.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3031).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3032 = writer.prefix("NextToken");
    if let Some(var_3033) = &input.next_token {
        scope_3032.string(var_3033);
    }
    #[allow(unused_mut)]
    let mut scope_3034 = writer.prefix("PrefixListId");
    if let Some(var_3035) = &input.prefix_list_ids {
        let mut list_3037 = scope_3034.start_list(true, Some("item"));
        for item_3036 in var_3035 {
            #[allow(unused_mut)]
            let mut entry_3038 = list_3037.entry();
            entry_3038.string(item_3036);
        }
        list_3037.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_moving_addresses(
    input: &crate::input::DescribeMovingAddressesInput,
) -> 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, "DescribeMovingAddresses", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3039 = writer.prefix("Filter");
    if let Some(var_3040) = &input.filters {
        let mut list_3042 = scope_3039.start_list(true, Some("Filter"));
        for item_3041 in var_3040 {
            #[allow(unused_mut)]
            let mut entry_3043 = list_3042.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3043, item_3041)?;
        }
        list_3042.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3044 = writer.prefix("DryRun");
    if let Some(var_3045) = &input.dry_run {
        scope_3044.boolean(*var_3045);
    }
    #[allow(unused_mut)]
    let mut scope_3046 = writer.prefix("MaxResults");
    if let Some(var_3047) = &input.max_results {
        scope_3046.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3047).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3048 = writer.prefix("NextToken");
    if let Some(var_3049) = &input.next_token {
        scope_3048.string(var_3049);
    }
    #[allow(unused_mut)]
    let mut scope_3050 = writer.prefix("PublicIp");
    if let Some(var_3051) = &input.public_ips {
        let mut list_3053 = scope_3050.start_list(true, Some("item"));
        for item_3052 in var_3051 {
            #[allow(unused_mut)]
            let mut entry_3054 = list_3053.entry();
            entry_3054.string(item_3052);
        }
        list_3053.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_nat_gateways(
    input: &crate::input::DescribeNatGatewaysInput,
) -> 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, "DescribeNatGateways", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3055 = writer.prefix("DryRun");
    if let Some(var_3056) = &input.dry_run {
        scope_3055.boolean(*var_3056);
    }
    #[allow(unused_mut)]
    let mut scope_3057 = writer.prefix("Filter");
    if let Some(var_3058) = &input.filter {
        let mut list_3060 = scope_3057.start_list(true, Some("Filter"));
        for item_3059 in var_3058 {
            #[allow(unused_mut)]
            let mut entry_3061 = list_3060.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3061, item_3059)?;
        }
        list_3060.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3062 = writer.prefix("MaxResults");
    if let Some(var_3063) = &input.max_results {
        scope_3062.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3063).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3064 = writer.prefix("NatGatewayId");
    if let Some(var_3065) = &input.nat_gateway_ids {
        let mut list_3067 = scope_3064.start_list(true, Some("item"));
        for item_3066 in var_3065 {
            #[allow(unused_mut)]
            let mut entry_3068 = list_3067.entry();
            entry_3068.string(item_3066);
        }
        list_3067.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3069 = writer.prefix("NextToken");
    if let Some(var_3070) = &input.next_token {
        scope_3069.string(var_3070);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_network_acls(
    input: &crate::input::DescribeNetworkAclsInput,
) -> 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, "DescribeNetworkAcls", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3071 = writer.prefix("Filter");
    if let Some(var_3072) = &input.filters {
        let mut list_3074 = scope_3071.start_list(true, Some("Filter"));
        for item_3073 in var_3072 {
            #[allow(unused_mut)]
            let mut entry_3075 = list_3074.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3075, item_3073)?;
        }
        list_3074.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3076 = writer.prefix("DryRun");
    if let Some(var_3077) = &input.dry_run {
        scope_3076.boolean(*var_3077);
    }
    #[allow(unused_mut)]
    let mut scope_3078 = writer.prefix("NetworkAclId");
    if let Some(var_3079) = &input.network_acl_ids {
        let mut list_3081 = scope_3078.start_list(true, Some("item"));
        for item_3080 in var_3079 {
            #[allow(unused_mut)]
            let mut entry_3082 = list_3081.entry();
            entry_3082.string(item_3080);
        }
        list_3081.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3083 = writer.prefix("NextToken");
    if let Some(var_3084) = &input.next_token {
        scope_3083.string(var_3084);
    }
    #[allow(unused_mut)]
    let mut scope_3085 = writer.prefix("MaxResults");
    if let Some(var_3086) = &input.max_results {
        scope_3085.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3086).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_network_insights_access_scope_analyses(
    input: &crate::input::DescribeNetworkInsightsAccessScopeAnalysesInput,
) -> 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,
        "DescribeNetworkInsightsAccessScopeAnalyses",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3087 = writer.prefix("NetworkInsightsAccessScopeAnalysisId");
    if let Some(var_3088) = &input.network_insights_access_scope_analysis_ids {
        let mut list_3090 = scope_3087.start_list(true, Some("item"));
        for item_3089 in var_3088 {
            #[allow(unused_mut)]
            let mut entry_3091 = list_3090.entry();
            entry_3091.string(item_3089);
        }
        list_3090.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3092 = writer.prefix("NetworkInsightsAccessScopeId");
    if let Some(var_3093) = &input.network_insights_access_scope_id {
        scope_3092.string(var_3093);
    }
    #[allow(unused_mut)]
    let mut scope_3094 = writer.prefix("AnalysisStartTimeBegin");
    if let Some(var_3095) = &input.analysis_start_time_begin {
        scope_3094.date_time(var_3095, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_3096 = writer.prefix("AnalysisStartTimeEnd");
    if let Some(var_3097) = &input.analysis_start_time_end {
        scope_3096.date_time(var_3097, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_3098 = writer.prefix("Filter");
    if let Some(var_3099) = &input.filters {
        let mut list_3101 = scope_3098.start_list(true, Some("Filter"));
        for item_3100 in var_3099 {
            #[allow(unused_mut)]
            let mut entry_3102 = list_3101.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3102, item_3100)?;
        }
        list_3101.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3103 = writer.prefix("MaxResults");
    if let Some(var_3104) = &input.max_results {
        scope_3103.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3104).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3105 = writer.prefix("DryRun");
    if let Some(var_3106) = &input.dry_run {
        scope_3105.boolean(*var_3106);
    }
    #[allow(unused_mut)]
    let mut scope_3107 = writer.prefix("NextToken");
    if let Some(var_3108) = &input.next_token {
        scope_3107.string(var_3108);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_network_insights_access_scopes(
    input: &crate::input::DescribeNetworkInsightsAccessScopesInput,
) -> 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,
        "DescribeNetworkInsightsAccessScopes",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3109 = writer.prefix("NetworkInsightsAccessScopeId");
    if let Some(var_3110) = &input.network_insights_access_scope_ids {
        let mut list_3112 = scope_3109.start_list(true, Some("item"));
        for item_3111 in var_3110 {
            #[allow(unused_mut)]
            let mut entry_3113 = list_3112.entry();
            entry_3113.string(item_3111);
        }
        list_3112.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3114 = writer.prefix("Filter");
    if let Some(var_3115) = &input.filters {
        let mut list_3117 = scope_3114.start_list(true, Some("Filter"));
        for item_3116 in var_3115 {
            #[allow(unused_mut)]
            let mut entry_3118 = list_3117.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3118, item_3116)?;
        }
        list_3117.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3119 = writer.prefix("MaxResults");
    if let Some(var_3120) = &input.max_results {
        scope_3119.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3120).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3121 = writer.prefix("DryRun");
    if let Some(var_3122) = &input.dry_run {
        scope_3121.boolean(*var_3122);
    }
    #[allow(unused_mut)]
    let mut scope_3123 = writer.prefix("NextToken");
    if let Some(var_3124) = &input.next_token {
        scope_3123.string(var_3124);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_network_insights_analyses(
    input: &crate::input::DescribeNetworkInsightsAnalysesInput,
) -> 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,
        "DescribeNetworkInsightsAnalyses",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3125 = writer.prefix("NetworkInsightsAnalysisId");
    if let Some(var_3126) = &input.network_insights_analysis_ids {
        let mut list_3128 = scope_3125.start_list(true, Some("item"));
        for item_3127 in var_3126 {
            #[allow(unused_mut)]
            let mut entry_3129 = list_3128.entry();
            entry_3129.string(item_3127);
        }
        list_3128.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3130 = writer.prefix("NetworkInsightsPathId");
    if let Some(var_3131) = &input.network_insights_path_id {
        scope_3130.string(var_3131);
    }
    #[allow(unused_mut)]
    let mut scope_3132 = writer.prefix("AnalysisStartTime");
    if let Some(var_3133) = &input.analysis_start_time {
        scope_3132.date_time(var_3133, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_3134 = writer.prefix("AnalysisEndTime");
    if let Some(var_3135) = &input.analysis_end_time {
        scope_3134.date_time(var_3135, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_3136 = writer.prefix("Filter");
    if let Some(var_3137) = &input.filters {
        let mut list_3139 = scope_3136.start_list(true, Some("Filter"));
        for item_3138 in var_3137 {
            #[allow(unused_mut)]
            let mut entry_3140 = list_3139.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3140, item_3138)?;
        }
        list_3139.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3141 = writer.prefix("MaxResults");
    if let Some(var_3142) = &input.max_results {
        scope_3141.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3142).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3143 = writer.prefix("DryRun");
    if let Some(var_3144) = &input.dry_run {
        scope_3143.boolean(*var_3144);
    }
    #[allow(unused_mut)]
    let mut scope_3145 = writer.prefix("NextToken");
    if let Some(var_3146) = &input.next_token {
        scope_3145.string(var_3146);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_network_insights_paths(
    input: &crate::input::DescribeNetworkInsightsPathsInput,
) -> 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, "DescribeNetworkInsightsPaths", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3147 = writer.prefix("NetworkInsightsPathId");
    if let Some(var_3148) = &input.network_insights_path_ids {
        let mut list_3150 = scope_3147.start_list(true, Some("item"));
        for item_3149 in var_3148 {
            #[allow(unused_mut)]
            let mut entry_3151 = list_3150.entry();
            entry_3151.string(item_3149);
        }
        list_3150.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3152 = writer.prefix("Filter");
    if let Some(var_3153) = &input.filters {
        let mut list_3155 = scope_3152.start_list(true, Some("Filter"));
        for item_3154 in var_3153 {
            #[allow(unused_mut)]
            let mut entry_3156 = list_3155.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3156, item_3154)?;
        }
        list_3155.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3157 = writer.prefix("MaxResults");
    if let Some(var_3158) = &input.max_results {
        scope_3157.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3158).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3159 = writer.prefix("DryRun");
    if let Some(var_3160) = &input.dry_run {
        scope_3159.boolean(*var_3160);
    }
    #[allow(unused_mut)]
    let mut scope_3161 = writer.prefix("NextToken");
    if let Some(var_3162) = &input.next_token {
        scope_3161.string(var_3162);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_network_interface_attribute(
    input: &crate::input::DescribeNetworkInterfaceAttributeInput,
) -> 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,
        "DescribeNetworkInterfaceAttribute",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3163 = writer.prefix("Attribute");
    if let Some(var_3164) = &input.attribute {
        scope_3163.string(var_3164.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_3165 = writer.prefix("DryRun");
    if let Some(var_3166) = &input.dry_run {
        scope_3165.boolean(*var_3166);
    }
    #[allow(unused_mut)]
    let mut scope_3167 = writer.prefix("NetworkInterfaceId");
    if let Some(var_3168) = &input.network_interface_id {
        scope_3167.string(var_3168);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_network_interface_permissions(
    input: &crate::input::DescribeNetworkInterfacePermissionsInput,
) -> 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,
        "DescribeNetworkInterfacePermissions",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3169 = writer.prefix("NetworkInterfacePermissionId");
    if let Some(var_3170) = &input.network_interface_permission_ids {
        let mut list_3172 = scope_3169.start_list(true, None);
        for item_3171 in var_3170 {
            #[allow(unused_mut)]
            let mut entry_3173 = list_3172.entry();
            entry_3173.string(item_3171);
        }
        list_3172.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3174 = writer.prefix("Filter");
    if let Some(var_3175) = &input.filters {
        let mut list_3177 = scope_3174.start_list(true, Some("Filter"));
        for item_3176 in var_3175 {
            #[allow(unused_mut)]
            let mut entry_3178 = list_3177.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3178, item_3176)?;
        }
        list_3177.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3179 = writer.prefix("NextToken");
    if let Some(var_3180) = &input.next_token {
        scope_3179.string(var_3180);
    }
    #[allow(unused_mut)]
    let mut scope_3181 = writer.prefix("MaxResults");
    if let Some(var_3182) = &input.max_results {
        scope_3181.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3182).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_network_interfaces(
    input: &crate::input::DescribeNetworkInterfacesInput,
) -> 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, "DescribeNetworkInterfaces", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3183 = writer.prefix("Filter");
    if let Some(var_3184) = &input.filters {
        let mut list_3186 = scope_3183.start_list(true, Some("Filter"));
        for item_3185 in var_3184 {
            #[allow(unused_mut)]
            let mut entry_3187 = list_3186.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3187, item_3185)?;
        }
        list_3186.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3188 = writer.prefix("DryRun");
    if let Some(var_3189) = &input.dry_run {
        scope_3188.boolean(*var_3189);
    }
    #[allow(unused_mut)]
    let mut scope_3190 = writer.prefix("NetworkInterfaceId");
    if let Some(var_3191) = &input.network_interface_ids {
        let mut list_3193 = scope_3190.start_list(true, Some("item"));
        for item_3192 in var_3191 {
            #[allow(unused_mut)]
            let mut entry_3194 = list_3193.entry();
            entry_3194.string(item_3192);
        }
        list_3193.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3195 = writer.prefix("NextToken");
    if let Some(var_3196) = &input.next_token {
        scope_3195.string(var_3196);
    }
    #[allow(unused_mut)]
    let mut scope_3197 = writer.prefix("MaxResults");
    if let Some(var_3198) = &input.max_results {
        scope_3197.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3198).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_placement_groups(
    input: &crate::input::DescribePlacementGroupsInput,
) -> 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, "DescribePlacementGroups", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3199 = writer.prefix("Filter");
    if let Some(var_3200) = &input.filters {
        let mut list_3202 = scope_3199.start_list(true, Some("Filter"));
        for item_3201 in var_3200 {
            #[allow(unused_mut)]
            let mut entry_3203 = list_3202.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3203, item_3201)?;
        }
        list_3202.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3204 = writer.prefix("DryRun");
    if let Some(var_3205) = &input.dry_run {
        scope_3204.boolean(*var_3205);
    }
    #[allow(unused_mut)]
    let mut scope_3206 = writer.prefix("GroupName");
    if let Some(var_3207) = &input.group_names {
        let mut list_3209 = scope_3206.start_list(true, None);
        for item_3208 in var_3207 {
            #[allow(unused_mut)]
            let mut entry_3210 = list_3209.entry();
            entry_3210.string(item_3208);
        }
        list_3209.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3211 = writer.prefix("GroupId");
    if let Some(var_3212) = &input.group_ids {
        let mut list_3214 = scope_3211.start_list(true, Some("GroupId"));
        for item_3213 in var_3212 {
            #[allow(unused_mut)]
            let mut entry_3215 = list_3214.entry();
            entry_3215.string(item_3213);
        }
        list_3214.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_prefix_lists(
    input: &crate::input::DescribePrefixListsInput,
) -> 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, "DescribePrefixLists", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3216 = writer.prefix("DryRun");
    if let Some(var_3217) = &input.dry_run {
        scope_3216.boolean(*var_3217);
    }
    #[allow(unused_mut)]
    let mut scope_3218 = writer.prefix("Filter");
    if let Some(var_3219) = &input.filters {
        let mut list_3221 = scope_3218.start_list(true, Some("Filter"));
        for item_3220 in var_3219 {
            #[allow(unused_mut)]
            let mut entry_3222 = list_3221.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3222, item_3220)?;
        }
        list_3221.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3223 = writer.prefix("MaxResults");
    if let Some(var_3224) = &input.max_results {
        scope_3223.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3224).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3225 = writer.prefix("NextToken");
    if let Some(var_3226) = &input.next_token {
        scope_3225.string(var_3226);
    }
    #[allow(unused_mut)]
    let mut scope_3227 = writer.prefix("PrefixListId");
    if let Some(var_3228) = &input.prefix_list_ids {
        let mut list_3230 = scope_3227.start_list(true, Some("item"));
        for item_3229 in var_3228 {
            #[allow(unused_mut)]
            let mut entry_3231 = list_3230.entry();
            entry_3231.string(item_3229);
        }
        list_3230.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_principal_id_format(
    input: &crate::input::DescribePrincipalIdFormatInput,
) -> 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, "DescribePrincipalIdFormat", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3232 = writer.prefix("DryRun");
    if let Some(var_3233) = &input.dry_run {
        scope_3232.boolean(*var_3233);
    }
    #[allow(unused_mut)]
    let mut scope_3234 = writer.prefix("Resource");
    if let Some(var_3235) = &input.resources {
        let mut list_3237 = scope_3234.start_list(true, Some("item"));
        for item_3236 in var_3235 {
            #[allow(unused_mut)]
            let mut entry_3238 = list_3237.entry();
            entry_3238.string(item_3236);
        }
        list_3237.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3239 = writer.prefix("MaxResults");
    if let Some(var_3240) = &input.max_results {
        scope_3239.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3240).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3241 = writer.prefix("NextToken");
    if let Some(var_3242) = &input.next_token {
        scope_3241.string(var_3242);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_public_ipv4_pools(
    input: &crate::input::DescribePublicIpv4PoolsInput,
) -> 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, "DescribePublicIpv4Pools", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3243 = writer.prefix("PoolId");
    if let Some(var_3244) = &input.pool_ids {
        let mut list_3246 = scope_3243.start_list(true, Some("item"));
        for item_3245 in var_3244 {
            #[allow(unused_mut)]
            let mut entry_3247 = list_3246.entry();
            entry_3247.string(item_3245);
        }
        list_3246.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3248 = writer.prefix("NextToken");
    if let Some(var_3249) = &input.next_token {
        scope_3248.string(var_3249);
    }
    #[allow(unused_mut)]
    let mut scope_3250 = writer.prefix("MaxResults");
    if let Some(var_3251) = &input.max_results {
        scope_3250.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3251).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3252 = writer.prefix("Filter");
    if let Some(var_3253) = &input.filters {
        let mut list_3255 = scope_3252.start_list(true, Some("Filter"));
        for item_3254 in var_3253 {
            #[allow(unused_mut)]
            let mut entry_3256 = list_3255.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3256, item_3254)?;
        }
        list_3255.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_regions(
    input: &crate::input::DescribeRegionsInput,
) -> 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, "DescribeRegions", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3257 = writer.prefix("Filter");
    if let Some(var_3258) = &input.filters {
        let mut list_3260 = scope_3257.start_list(true, Some("Filter"));
        for item_3259 in var_3258 {
            #[allow(unused_mut)]
            let mut entry_3261 = list_3260.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3261, item_3259)?;
        }
        list_3260.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3262 = writer.prefix("RegionName");
    if let Some(var_3263) = &input.region_names {
        let mut list_3265 = scope_3262.start_list(true, Some("RegionName"));
        for item_3264 in var_3263 {
            #[allow(unused_mut)]
            let mut entry_3266 = list_3265.entry();
            entry_3266.string(item_3264);
        }
        list_3265.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3267 = writer.prefix("DryRun");
    if let Some(var_3268) = &input.dry_run {
        scope_3267.boolean(*var_3268);
    }
    #[allow(unused_mut)]
    let mut scope_3269 = writer.prefix("AllRegions");
    if let Some(var_3270) = &input.all_regions {
        scope_3269.boolean(*var_3270);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_replace_root_volume_tasks(
    input: &crate::input::DescribeReplaceRootVolumeTasksInput,
) -> 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,
        "DescribeReplaceRootVolumeTasks",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3271 = writer.prefix("ReplaceRootVolumeTaskId");
    if let Some(var_3272) = &input.replace_root_volume_task_ids {
        let mut list_3274 = scope_3271.start_list(true, Some("ReplaceRootVolumeTaskId"));
        for item_3273 in var_3272 {
            #[allow(unused_mut)]
            let mut entry_3275 = list_3274.entry();
            entry_3275.string(item_3273);
        }
        list_3274.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3276 = writer.prefix("Filter");
    if let Some(var_3277) = &input.filters {
        let mut list_3279 = scope_3276.start_list(true, Some("Filter"));
        for item_3278 in var_3277 {
            #[allow(unused_mut)]
            let mut entry_3280 = list_3279.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3280, item_3278)?;
        }
        list_3279.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3281 = writer.prefix("MaxResults");
    if let Some(var_3282) = &input.max_results {
        scope_3281.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3282).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3283 = writer.prefix("NextToken");
    if let Some(var_3284) = &input.next_token {
        scope_3283.string(var_3284);
    }
    #[allow(unused_mut)]
    let mut scope_3285 = writer.prefix("DryRun");
    if let Some(var_3286) = &input.dry_run {
        scope_3285.boolean(*var_3286);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_reserved_instances(
    input: &crate::input::DescribeReservedInstancesInput,
) -> 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, "DescribeReservedInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3287 = writer.prefix("Filter");
    if let Some(var_3288) = &input.filters {
        let mut list_3290 = scope_3287.start_list(true, Some("Filter"));
        for item_3289 in var_3288 {
            #[allow(unused_mut)]
            let mut entry_3291 = list_3290.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3291, item_3289)?;
        }
        list_3290.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3292 = writer.prefix("OfferingClass");
    if let Some(var_3293) = &input.offering_class {
        scope_3292.string(var_3293.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_3294 = writer.prefix("ReservedInstancesId");
    if let Some(var_3295) = &input.reserved_instances_ids {
        let mut list_3297 = scope_3294.start_list(true, Some("ReservedInstancesId"));
        for item_3296 in var_3295 {
            #[allow(unused_mut)]
            let mut entry_3298 = list_3297.entry();
            entry_3298.string(item_3296);
        }
        list_3297.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3299 = writer.prefix("DryRun");
    if let Some(var_3300) = &input.dry_run {
        scope_3299.boolean(*var_3300);
    }
    #[allow(unused_mut)]
    let mut scope_3301 = writer.prefix("OfferingType");
    if let Some(var_3302) = &input.offering_type {
        scope_3301.string(var_3302.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_reserved_instances_listings(
    input: &crate::input::DescribeReservedInstancesListingsInput,
) -> 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,
        "DescribeReservedInstancesListings",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3303 = writer.prefix("Filter");
    if let Some(var_3304) = &input.filters {
        let mut list_3306 = scope_3303.start_list(true, Some("Filter"));
        for item_3305 in var_3304 {
            #[allow(unused_mut)]
            let mut entry_3307 = list_3306.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3307, item_3305)?;
        }
        list_3306.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3308 = writer.prefix("ReservedInstancesId");
    if let Some(var_3309) = &input.reserved_instances_id {
        scope_3308.string(var_3309);
    }
    #[allow(unused_mut)]
    let mut scope_3310 = writer.prefix("ReservedInstancesListingId");
    if let Some(var_3311) = &input.reserved_instances_listing_id {
        scope_3310.string(var_3311);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_reserved_instances_modifications(
    input: &crate::input::DescribeReservedInstancesModificationsInput,
) -> 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,
        "DescribeReservedInstancesModifications",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3312 = writer.prefix("Filter");
    if let Some(var_3313) = &input.filters {
        let mut list_3315 = scope_3312.start_list(true, Some("Filter"));
        for item_3314 in var_3313 {
            #[allow(unused_mut)]
            let mut entry_3316 = list_3315.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3316, item_3314)?;
        }
        list_3315.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3317 = writer.prefix("ReservedInstancesModificationId");
    if let Some(var_3318) = &input.reserved_instances_modification_ids {
        let mut list_3320 = scope_3317.start_list(true, Some("ReservedInstancesModificationId"));
        for item_3319 in var_3318 {
            #[allow(unused_mut)]
            let mut entry_3321 = list_3320.entry();
            entry_3321.string(item_3319);
        }
        list_3320.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3322 = writer.prefix("NextToken");
    if let Some(var_3323) = &input.next_token {
        scope_3322.string(var_3323);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_reserved_instances_offerings(
    input: &crate::input::DescribeReservedInstancesOfferingsInput,
) -> 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,
        "DescribeReservedInstancesOfferings",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3324 = writer.prefix("AvailabilityZone");
    if let Some(var_3325) = &input.availability_zone {
        scope_3324.string(var_3325);
    }
    #[allow(unused_mut)]
    let mut scope_3326 = writer.prefix("Filter");
    if let Some(var_3327) = &input.filters {
        let mut list_3329 = scope_3326.start_list(true, Some("Filter"));
        for item_3328 in var_3327 {
            #[allow(unused_mut)]
            let mut entry_3330 = list_3329.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3330, item_3328)?;
        }
        list_3329.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3331 = writer.prefix("IncludeMarketplace");
    if let Some(var_3332) = &input.include_marketplace {
        scope_3331.boolean(*var_3332);
    }
    #[allow(unused_mut)]
    let mut scope_3333 = writer.prefix("InstanceType");
    if let Some(var_3334) = &input.instance_type {
        scope_3333.string(var_3334.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_3335 = writer.prefix("MaxDuration");
    if let Some(var_3336) = &input.max_duration {
        scope_3335.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3336).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3337 = writer.prefix("MaxInstanceCount");
    if let Some(var_3338) = &input.max_instance_count {
        scope_3337.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3338).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3339 = writer.prefix("MinDuration");
    if let Some(var_3340) = &input.min_duration {
        scope_3339.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3340).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3341 = writer.prefix("OfferingClass");
    if let Some(var_3342) = &input.offering_class {
        scope_3341.string(var_3342.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_3343 = writer.prefix("ProductDescription");
    if let Some(var_3344) = &input.product_description {
        scope_3343.string(var_3344.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_3345 = writer.prefix("ReservedInstancesOfferingId");
    if let Some(var_3346) = &input.reserved_instances_offering_ids {
        let mut list_3348 = scope_3345.start_list(true, None);
        for item_3347 in var_3346 {
            #[allow(unused_mut)]
            let mut entry_3349 = list_3348.entry();
            entry_3349.string(item_3347);
        }
        list_3348.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3350 = writer.prefix("DryRun");
    if let Some(var_3351) = &input.dry_run {
        scope_3350.boolean(*var_3351);
    }
    #[allow(unused_mut)]
    let mut scope_3352 = writer.prefix("InstanceTenancy");
    if let Some(var_3353) = &input.instance_tenancy {
        scope_3352.string(var_3353.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_3354 = writer.prefix("MaxResults");
    if let Some(var_3355) = &input.max_results {
        scope_3354.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3355).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3356 = writer.prefix("NextToken");
    if let Some(var_3357) = &input.next_token {
        scope_3356.string(var_3357);
    }
    #[allow(unused_mut)]
    let mut scope_3358 = writer.prefix("OfferingType");
    if let Some(var_3359) = &input.offering_type {
        scope_3358.string(var_3359.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_route_tables(
    input: &crate::input::DescribeRouteTablesInput,
) -> 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, "DescribeRouteTables", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3360 = writer.prefix("Filter");
    if let Some(var_3361) = &input.filters {
        let mut list_3363 = scope_3360.start_list(true, Some("Filter"));
        for item_3362 in var_3361 {
            #[allow(unused_mut)]
            let mut entry_3364 = list_3363.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3364, item_3362)?;
        }
        list_3363.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3365 = writer.prefix("DryRun");
    if let Some(var_3366) = &input.dry_run {
        scope_3365.boolean(*var_3366);
    }
    #[allow(unused_mut)]
    let mut scope_3367 = writer.prefix("RouteTableId");
    if let Some(var_3368) = &input.route_table_ids {
        let mut list_3370 = scope_3367.start_list(true, Some("item"));
        for item_3369 in var_3368 {
            #[allow(unused_mut)]
            let mut entry_3371 = list_3370.entry();
            entry_3371.string(item_3369);
        }
        list_3370.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3372 = writer.prefix("NextToken");
    if let Some(var_3373) = &input.next_token {
        scope_3372.string(var_3373);
    }
    #[allow(unused_mut)]
    let mut scope_3374 = writer.prefix("MaxResults");
    if let Some(var_3375) = &input.max_results {
        scope_3374.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3375).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_scheduled_instance_availability(
    input: &crate::input::DescribeScheduledInstanceAvailabilityInput,
) -> 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,
        "DescribeScheduledInstanceAvailability",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3376 = writer.prefix("DryRun");
    if let Some(var_3377) = &input.dry_run {
        scope_3376.boolean(*var_3377);
    }
    #[allow(unused_mut)]
    let mut scope_3378 = writer.prefix("Filter");
    if let Some(var_3379) = &input.filters {
        let mut list_3381 = scope_3378.start_list(true, Some("Filter"));
        for item_3380 in var_3379 {
            #[allow(unused_mut)]
            let mut entry_3382 = list_3381.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3382, item_3380)?;
        }
        list_3381.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3383 = writer.prefix("FirstSlotStartTimeRange");
    if let Some(var_3384) = &input.first_slot_start_time_range {
        crate::query_ser::serialize_structure_crate_model_slot_date_time_range_request(
            scope_3383, var_3384,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_3385 = writer.prefix("MaxResults");
    if let Some(var_3386) = &input.max_results {
        scope_3385.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3386).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3387 = writer.prefix("MaxSlotDurationInHours");
    if let Some(var_3388) = &input.max_slot_duration_in_hours {
        scope_3387.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3388).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3389 = writer.prefix("MinSlotDurationInHours");
    if let Some(var_3390) = &input.min_slot_duration_in_hours {
        scope_3389.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3390).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3391 = writer.prefix("NextToken");
    if let Some(var_3392) = &input.next_token {
        scope_3391.string(var_3392);
    }
    #[allow(unused_mut)]
    let mut scope_3393 = writer.prefix("Recurrence");
    if let Some(var_3394) = &input.recurrence {
        crate::query_ser::serialize_structure_crate_model_scheduled_instance_recurrence_request(
            scope_3393, var_3394,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_scheduled_instances(
    input: &crate::input::DescribeScheduledInstancesInput,
) -> 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, "DescribeScheduledInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3395 = writer.prefix("DryRun");
    if let Some(var_3396) = &input.dry_run {
        scope_3395.boolean(*var_3396);
    }
    #[allow(unused_mut)]
    let mut scope_3397 = writer.prefix("Filter");
    if let Some(var_3398) = &input.filters {
        let mut list_3400 = scope_3397.start_list(true, Some("Filter"));
        for item_3399 in var_3398 {
            #[allow(unused_mut)]
            let mut entry_3401 = list_3400.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3401, item_3399)?;
        }
        list_3400.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3402 = writer.prefix("MaxResults");
    if let Some(var_3403) = &input.max_results {
        scope_3402.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3403).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3404 = writer.prefix("NextToken");
    if let Some(var_3405) = &input.next_token {
        scope_3404.string(var_3405);
    }
    #[allow(unused_mut)]
    let mut scope_3406 = writer.prefix("ScheduledInstanceId");
    if let Some(var_3407) = &input.scheduled_instance_ids {
        let mut list_3409 = scope_3406.start_list(true, Some("ScheduledInstanceId"));
        for item_3408 in var_3407 {
            #[allow(unused_mut)]
            let mut entry_3410 = list_3409.entry();
            entry_3410.string(item_3408);
        }
        list_3409.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3411 = writer.prefix("SlotStartTimeRange");
    if let Some(var_3412) = &input.slot_start_time_range {
        crate::query_ser::serialize_structure_crate_model_slot_start_time_range_request(
            scope_3411, var_3412,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_security_group_references(
    input: &crate::input::DescribeSecurityGroupReferencesInput,
) -> 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,
        "DescribeSecurityGroupReferences",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3413 = writer.prefix("DryRun");
    if let Some(var_3414) = &input.dry_run {
        scope_3413.boolean(*var_3414);
    }
    #[allow(unused_mut)]
    let mut scope_3415 = writer.prefix("GroupId");
    if let Some(var_3416) = &input.group_id {
        let mut list_3418 = scope_3415.start_list(true, Some("item"));
        for item_3417 in var_3416 {
            #[allow(unused_mut)]
            let mut entry_3419 = list_3418.entry();
            entry_3419.string(item_3417);
        }
        list_3418.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_security_group_rules(
    input: &crate::input::DescribeSecurityGroupRulesInput,
) -> 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, "DescribeSecurityGroupRules", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3420 = writer.prefix("Filter");
    if let Some(var_3421) = &input.filters {
        let mut list_3423 = scope_3420.start_list(true, Some("Filter"));
        for item_3422 in var_3421 {
            #[allow(unused_mut)]
            let mut entry_3424 = list_3423.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3424, item_3422)?;
        }
        list_3423.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3425 = writer.prefix("SecurityGroupRuleId");
    if let Some(var_3426) = &input.security_group_rule_ids {
        let mut list_3428 = scope_3425.start_list(true, Some("item"));
        for item_3427 in var_3426 {
            #[allow(unused_mut)]
            let mut entry_3429 = list_3428.entry();
            entry_3429.string(item_3427);
        }
        list_3428.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3430 = writer.prefix("DryRun");
    if let Some(var_3431) = &input.dry_run {
        scope_3430.boolean(*var_3431);
    }
    #[allow(unused_mut)]
    let mut scope_3432 = writer.prefix("NextToken");
    if let Some(var_3433) = &input.next_token {
        scope_3432.string(var_3433);
    }
    #[allow(unused_mut)]
    let mut scope_3434 = writer.prefix("MaxResults");
    if let Some(var_3435) = &input.max_results {
        scope_3434.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3435).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_security_groups(
    input: &crate::input::DescribeSecurityGroupsInput,
) -> 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, "DescribeSecurityGroups", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3436 = writer.prefix("Filter");
    if let Some(var_3437) = &input.filters {
        let mut list_3439 = scope_3436.start_list(true, Some("Filter"));
        for item_3438 in var_3437 {
            #[allow(unused_mut)]
            let mut entry_3440 = list_3439.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3440, item_3438)?;
        }
        list_3439.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3441 = writer.prefix("GroupId");
    if let Some(var_3442) = &input.group_ids {
        let mut list_3444 = scope_3441.start_list(true, Some("groupId"));
        for item_3443 in var_3442 {
            #[allow(unused_mut)]
            let mut entry_3445 = list_3444.entry();
            entry_3445.string(item_3443);
        }
        list_3444.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3446 = writer.prefix("GroupName");
    if let Some(var_3447) = &input.group_names {
        let mut list_3449 = scope_3446.start_list(true, Some("GroupName"));
        for item_3448 in var_3447 {
            #[allow(unused_mut)]
            let mut entry_3450 = list_3449.entry();
            entry_3450.string(item_3448);
        }
        list_3449.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3451 = writer.prefix("DryRun");
    if let Some(var_3452) = &input.dry_run {
        scope_3451.boolean(*var_3452);
    }
    #[allow(unused_mut)]
    let mut scope_3453 = writer.prefix("NextToken");
    if let Some(var_3454) = &input.next_token {
        scope_3453.string(var_3454);
    }
    #[allow(unused_mut)]
    let mut scope_3455 = writer.prefix("MaxResults");
    if let Some(var_3456) = &input.max_results {
        scope_3455.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3456).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_snapshot_attribute(
    input: &crate::input::DescribeSnapshotAttributeInput,
) -> 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, "DescribeSnapshotAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3457 = writer.prefix("Attribute");
    if let Some(var_3458) = &input.attribute {
        scope_3457.string(var_3458.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_3459 = writer.prefix("SnapshotId");
    if let Some(var_3460) = &input.snapshot_id {
        scope_3459.string(var_3460);
    }
    #[allow(unused_mut)]
    let mut scope_3461 = writer.prefix("DryRun");
    if let Some(var_3462) = &input.dry_run {
        scope_3461.boolean(*var_3462);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_snapshots(
    input: &crate::input::DescribeSnapshotsInput,
) -> 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, "DescribeSnapshots", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3463 = writer.prefix("Filter");
    if let Some(var_3464) = &input.filters {
        let mut list_3466 = scope_3463.start_list(true, Some("Filter"));
        for item_3465 in var_3464 {
            #[allow(unused_mut)]
            let mut entry_3467 = list_3466.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3467, item_3465)?;
        }
        list_3466.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3468 = writer.prefix("MaxResults");
    if let Some(var_3469) = &input.max_results {
        scope_3468.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3469).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3470 = writer.prefix("NextToken");
    if let Some(var_3471) = &input.next_token {
        scope_3470.string(var_3471);
    }
    #[allow(unused_mut)]
    let mut scope_3472 = writer.prefix("Owner");
    if let Some(var_3473) = &input.owner_ids {
        let mut list_3475 = scope_3472.start_list(true, Some("Owner"));
        for item_3474 in var_3473 {
            #[allow(unused_mut)]
            let mut entry_3476 = list_3475.entry();
            entry_3476.string(item_3474);
        }
        list_3475.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3477 = writer.prefix("RestorableBy");
    if let Some(var_3478) = &input.restorable_by_user_ids {
        let mut list_3480 = scope_3477.start_list(true, None);
        for item_3479 in var_3478 {
            #[allow(unused_mut)]
            let mut entry_3481 = list_3480.entry();
            entry_3481.string(item_3479);
        }
        list_3480.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3482 = writer.prefix("SnapshotId");
    if let Some(var_3483) = &input.snapshot_ids {
        let mut list_3485 = scope_3482.start_list(true, Some("SnapshotId"));
        for item_3484 in var_3483 {
            #[allow(unused_mut)]
            let mut entry_3486 = list_3485.entry();
            entry_3486.string(item_3484);
        }
        list_3485.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3487 = writer.prefix("DryRun");
    if let Some(var_3488) = &input.dry_run {
        scope_3487.boolean(*var_3488);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_snapshot_tier_status(
    input: &crate::input::DescribeSnapshotTierStatusInput,
) -> 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, "DescribeSnapshotTierStatus", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3489 = writer.prefix("Filter");
    if let Some(var_3490) = &input.filters {
        let mut list_3492 = scope_3489.start_list(true, Some("Filter"));
        for item_3491 in var_3490 {
            #[allow(unused_mut)]
            let mut entry_3493 = list_3492.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3493, item_3491)?;
        }
        list_3492.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3494 = writer.prefix("DryRun");
    if let Some(var_3495) = &input.dry_run {
        scope_3494.boolean(*var_3495);
    }
    #[allow(unused_mut)]
    let mut scope_3496 = writer.prefix("NextToken");
    if let Some(var_3497) = &input.next_token {
        scope_3496.string(var_3497);
    }
    #[allow(unused_mut)]
    let mut scope_3498 = writer.prefix("MaxResults");
    if let Some(var_3499) = &input.max_results {
        scope_3498.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3499).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

pub fn serialize_operation_crate_operation_describe_spot_fleet_instances(
    input: &crate::input::DescribeSpotFleetInstancesInput,
) -> 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, "DescribeSpotFleetInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3502 = writer.prefix("DryRun");
    if let Some(var_3503) = &input.dry_run {
        scope_3502.boolean(*var_3503);
    }
    #[allow(unused_mut)]
    let mut scope_3504 = writer.prefix("MaxResults");
    if let Some(var_3505) = &input.max_results {
        scope_3504.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3505).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3506 = writer.prefix("NextToken");
    if let Some(var_3507) = &input.next_token {
        scope_3506.string(var_3507);
    }
    #[allow(unused_mut)]
    let mut scope_3508 = writer.prefix("SpotFleetRequestId");
    if let Some(var_3509) = &input.spot_fleet_request_id {
        scope_3508.string(var_3509);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_spot_fleet_request_history(
    input: &crate::input::DescribeSpotFleetRequestHistoryInput,
) -> 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,
        "DescribeSpotFleetRequestHistory",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3510 = writer.prefix("DryRun");
    if let Some(var_3511) = &input.dry_run {
        scope_3510.boolean(*var_3511);
    }
    #[allow(unused_mut)]
    let mut scope_3512 = writer.prefix("EventType");
    if let Some(var_3513) = &input.event_type {
        scope_3512.string(var_3513.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_3514 = writer.prefix("MaxResults");
    if let Some(var_3515) = &input.max_results {
        scope_3514.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3515).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3516 = writer.prefix("NextToken");
    if let Some(var_3517) = &input.next_token {
        scope_3516.string(var_3517);
    }
    #[allow(unused_mut)]
    let mut scope_3518 = writer.prefix("SpotFleetRequestId");
    if let Some(var_3519) = &input.spot_fleet_request_id {
        scope_3518.string(var_3519);
    }
    #[allow(unused_mut)]
    let mut scope_3520 = writer.prefix("StartTime");
    if let Some(var_3521) = &input.start_time {
        scope_3520.date_time(var_3521, aws_smithy_types::date_time::Format::DateTime)?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_spot_fleet_requests(
    input: &crate::input::DescribeSpotFleetRequestsInput,
) -> 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, "DescribeSpotFleetRequests", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3522 = writer.prefix("DryRun");
    if let Some(var_3523) = &input.dry_run {
        scope_3522.boolean(*var_3523);
    }
    #[allow(unused_mut)]
    let mut scope_3524 = writer.prefix("MaxResults");
    if let Some(var_3525) = &input.max_results {
        scope_3524.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3525).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3526 = writer.prefix("NextToken");
    if let Some(var_3527) = &input.next_token {
        scope_3526.string(var_3527);
    }
    #[allow(unused_mut)]
    let mut scope_3528 = writer.prefix("SpotFleetRequestId");
    if let Some(var_3529) = &input.spot_fleet_request_ids {
        let mut list_3531 = scope_3528.start_list(true, Some("item"));
        for item_3530 in var_3529 {
            #[allow(unused_mut)]
            let mut entry_3532 = list_3531.entry();
            entry_3532.string(item_3530);
        }
        list_3531.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_spot_instance_requests(
    input: &crate::input::DescribeSpotInstanceRequestsInput,
) -> 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, "DescribeSpotInstanceRequests", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3533 = writer.prefix("Filter");
    if let Some(var_3534) = &input.filters {
        let mut list_3536 = scope_3533.start_list(true, Some("Filter"));
        for item_3535 in var_3534 {
            #[allow(unused_mut)]
            let mut entry_3537 = list_3536.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3537, item_3535)?;
        }
        list_3536.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3538 = writer.prefix("DryRun");
    if let Some(var_3539) = &input.dry_run {
        scope_3538.boolean(*var_3539);
    }
    #[allow(unused_mut)]
    let mut scope_3540 = writer.prefix("SpotInstanceRequestId");
    if let Some(var_3541) = &input.spot_instance_request_ids {
        let mut list_3543 = scope_3540.start_list(true, Some("SpotInstanceRequestId"));
        for item_3542 in var_3541 {
            #[allow(unused_mut)]
            let mut entry_3544 = list_3543.entry();
            entry_3544.string(item_3542);
        }
        list_3543.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3545 = writer.prefix("NextToken");
    if let Some(var_3546) = &input.next_token {
        scope_3545.string(var_3546);
    }
    #[allow(unused_mut)]
    let mut scope_3547 = writer.prefix("MaxResults");
    if let Some(var_3548) = &input.max_results {
        scope_3547.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3548).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_spot_price_history(
    input: &crate::input::DescribeSpotPriceHistoryInput,
) -> 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, "DescribeSpotPriceHistory", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3549 = writer.prefix("Filter");
    if let Some(var_3550) = &input.filters {
        let mut list_3552 = scope_3549.start_list(true, Some("Filter"));
        for item_3551 in var_3550 {
            #[allow(unused_mut)]
            let mut entry_3553 = list_3552.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3553, item_3551)?;
        }
        list_3552.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3554 = writer.prefix("AvailabilityZone");
    if let Some(var_3555) = &input.availability_zone {
        scope_3554.string(var_3555);
    }
    #[allow(unused_mut)]
    let mut scope_3556 = writer.prefix("DryRun");
    if let Some(var_3557) = &input.dry_run {
        scope_3556.boolean(*var_3557);
    }
    #[allow(unused_mut)]
    let mut scope_3558 = writer.prefix("EndTime");
    if let Some(var_3559) = &input.end_time {
        scope_3558.date_time(var_3559, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_3560 = writer.prefix("InstanceType");
    if let Some(var_3561) = &input.instance_types {
        let mut list_3563 = scope_3560.start_list(true, None);
        for item_3562 in var_3561 {
            #[allow(unused_mut)]
            let mut entry_3564 = list_3563.entry();
            entry_3564.string(item_3562.as_str());
        }
        list_3563.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3565 = writer.prefix("MaxResults");
    if let Some(var_3566) = &input.max_results {
        scope_3565.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3566).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3567 = writer.prefix("NextToken");
    if let Some(var_3568) = &input.next_token {
        scope_3567.string(var_3568);
    }
    #[allow(unused_mut)]
    let mut scope_3569 = writer.prefix("ProductDescription");
    if let Some(var_3570) = &input.product_descriptions {
        let mut list_3572 = scope_3569.start_list(true, None);
        for item_3571 in var_3570 {
            #[allow(unused_mut)]
            let mut entry_3573 = list_3572.entry();
            entry_3573.string(item_3571);
        }
        list_3572.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3574 = writer.prefix("StartTime");
    if let Some(var_3575) = &input.start_time {
        scope_3574.date_time(var_3575, aws_smithy_types::date_time::Format::DateTime)?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_stale_security_groups(
    input: &crate::input::DescribeStaleSecurityGroupsInput,
) -> 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, "DescribeStaleSecurityGroups", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3576 = writer.prefix("DryRun");
    if let Some(var_3577) = &input.dry_run {
        scope_3576.boolean(*var_3577);
    }
    #[allow(unused_mut)]
    let mut scope_3578 = writer.prefix("MaxResults");
    if let Some(var_3579) = &input.max_results {
        scope_3578.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3579).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3580 = writer.prefix("NextToken");
    if let Some(var_3581) = &input.next_token {
        scope_3580.string(var_3581);
    }
    #[allow(unused_mut)]
    let mut scope_3582 = writer.prefix("VpcId");
    if let Some(var_3583) = &input.vpc_id {
        scope_3582.string(var_3583);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_store_image_tasks(
    input: &crate::input::DescribeStoreImageTasksInput,
) -> 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, "DescribeStoreImageTasks", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3584 = writer.prefix("ImageId");
    if let Some(var_3585) = &input.image_ids {
        let mut list_3587 = scope_3584.start_list(true, Some("item"));
        for item_3586 in var_3585 {
            #[allow(unused_mut)]
            let mut entry_3588 = list_3587.entry();
            entry_3588.string(item_3586);
        }
        list_3587.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3589 = writer.prefix("DryRun");
    if let Some(var_3590) = &input.dry_run {
        scope_3589.boolean(*var_3590);
    }
    #[allow(unused_mut)]
    let mut scope_3591 = writer.prefix("Filter");
    if let Some(var_3592) = &input.filters {
        let mut list_3594 = scope_3591.start_list(true, Some("Filter"));
        for item_3593 in var_3592 {
            #[allow(unused_mut)]
            let mut entry_3595 = list_3594.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3595, item_3593)?;
        }
        list_3594.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3596 = writer.prefix("NextToken");
    if let Some(var_3597) = &input.next_token {
        scope_3596.string(var_3597);
    }
    #[allow(unused_mut)]
    let mut scope_3598 = writer.prefix("MaxResults");
    if let Some(var_3599) = &input.max_results {
        scope_3598.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3599).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_subnets(
    input: &crate::input::DescribeSubnetsInput,
) -> 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, "DescribeSubnets", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3600 = writer.prefix("Filter");
    if let Some(var_3601) = &input.filters {
        let mut list_3603 = scope_3600.start_list(true, Some("Filter"));
        for item_3602 in var_3601 {
            #[allow(unused_mut)]
            let mut entry_3604 = list_3603.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3604, item_3602)?;
        }
        list_3603.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3605 = writer.prefix("SubnetId");
    if let Some(var_3606) = &input.subnet_ids {
        let mut list_3608 = scope_3605.start_list(true, Some("SubnetId"));
        for item_3607 in var_3606 {
            #[allow(unused_mut)]
            let mut entry_3609 = list_3608.entry();
            entry_3609.string(item_3607);
        }
        list_3608.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3610 = writer.prefix("DryRun");
    if let Some(var_3611) = &input.dry_run {
        scope_3610.boolean(*var_3611);
    }
    #[allow(unused_mut)]
    let mut scope_3612 = writer.prefix("NextToken");
    if let Some(var_3613) = &input.next_token {
        scope_3612.string(var_3613);
    }
    #[allow(unused_mut)]
    let mut scope_3614 = writer.prefix("MaxResults");
    if let Some(var_3615) = &input.max_results {
        scope_3614.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3615).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_tags(
    input: &crate::input::DescribeTagsInput,
) -> 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, "DescribeTags", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3616 = writer.prefix("DryRun");
    if let Some(var_3617) = &input.dry_run {
        scope_3616.boolean(*var_3617);
    }
    #[allow(unused_mut)]
    let mut scope_3618 = writer.prefix("Filter");
    if let Some(var_3619) = &input.filters {
        let mut list_3621 = scope_3618.start_list(true, Some("Filter"));
        for item_3620 in var_3619 {
            #[allow(unused_mut)]
            let mut entry_3622 = list_3621.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3622, item_3620)?;
        }
        list_3621.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3623 = writer.prefix("MaxResults");
    if let Some(var_3624) = &input.max_results {
        scope_3623.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3624).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3625 = writer.prefix("NextToken");
    if let Some(var_3626) = &input.next_token {
        scope_3625.string(var_3626);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_traffic_mirror_filters(
    input: &crate::input::DescribeTrafficMirrorFiltersInput,
) -> 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, "DescribeTrafficMirrorFilters", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3627 = writer.prefix("TrafficMirrorFilterId");
    if let Some(var_3628) = &input.traffic_mirror_filter_ids {
        let mut list_3630 = scope_3627.start_list(true, Some("item"));
        for item_3629 in var_3628 {
            #[allow(unused_mut)]
            let mut entry_3631 = list_3630.entry();
            entry_3631.string(item_3629);
        }
        list_3630.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3632 = writer.prefix("DryRun");
    if let Some(var_3633) = &input.dry_run {
        scope_3632.boolean(*var_3633);
    }
    #[allow(unused_mut)]
    let mut scope_3634 = writer.prefix("Filter");
    if let Some(var_3635) = &input.filters {
        let mut list_3637 = scope_3634.start_list(true, Some("Filter"));
        for item_3636 in var_3635 {
            #[allow(unused_mut)]
            let mut entry_3638 = list_3637.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3638, item_3636)?;
        }
        list_3637.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3639 = writer.prefix("MaxResults");
    if let Some(var_3640) = &input.max_results {
        scope_3639.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3640).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3641 = writer.prefix("NextToken");
    if let Some(var_3642) = &input.next_token {
        scope_3641.string(var_3642);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_traffic_mirror_sessions(
    input: &crate::input::DescribeTrafficMirrorSessionsInput,
) -> 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, "DescribeTrafficMirrorSessions", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3643 = writer.prefix("TrafficMirrorSessionId");
    if let Some(var_3644) = &input.traffic_mirror_session_ids {
        let mut list_3646 = scope_3643.start_list(true, Some("item"));
        for item_3645 in var_3644 {
            #[allow(unused_mut)]
            let mut entry_3647 = list_3646.entry();
            entry_3647.string(item_3645);
        }
        list_3646.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3648 = writer.prefix("DryRun");
    if let Some(var_3649) = &input.dry_run {
        scope_3648.boolean(*var_3649);
    }
    #[allow(unused_mut)]
    let mut scope_3650 = writer.prefix("Filter");
    if let Some(var_3651) = &input.filters {
        let mut list_3653 = scope_3650.start_list(true, Some("Filter"));
        for item_3652 in var_3651 {
            #[allow(unused_mut)]
            let mut entry_3654 = list_3653.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3654, item_3652)?;
        }
        list_3653.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3655 = writer.prefix("MaxResults");
    if let Some(var_3656) = &input.max_results {
        scope_3655.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3656).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3657 = writer.prefix("NextToken");
    if let Some(var_3658) = &input.next_token {
        scope_3657.string(var_3658);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_traffic_mirror_targets(
    input: &crate::input::DescribeTrafficMirrorTargetsInput,
) -> 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, "DescribeTrafficMirrorTargets", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3659 = writer.prefix("TrafficMirrorTargetId");
    if let Some(var_3660) = &input.traffic_mirror_target_ids {
        let mut list_3662 = scope_3659.start_list(true, Some("item"));
        for item_3661 in var_3660 {
            #[allow(unused_mut)]
            let mut entry_3663 = list_3662.entry();
            entry_3663.string(item_3661);
        }
        list_3662.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3664 = writer.prefix("DryRun");
    if let Some(var_3665) = &input.dry_run {
        scope_3664.boolean(*var_3665);
    }
    #[allow(unused_mut)]
    let mut scope_3666 = writer.prefix("Filter");
    if let Some(var_3667) = &input.filters {
        let mut list_3669 = scope_3666.start_list(true, Some("Filter"));
        for item_3668 in var_3667 {
            #[allow(unused_mut)]
            let mut entry_3670 = list_3669.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3670, item_3668)?;
        }
        list_3669.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3671 = writer.prefix("MaxResults");
    if let Some(var_3672) = &input.max_results {
        scope_3671.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3672).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3673 = writer.prefix("NextToken");
    if let Some(var_3674) = &input.next_token {
        scope_3673.string(var_3674);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_transit_gateway_attachments(
    input: &crate::input::DescribeTransitGatewayAttachmentsInput,
) -> 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,
        "DescribeTransitGatewayAttachments",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3675 = writer.prefix("TransitGatewayAttachmentIds");
    if let Some(var_3676) = &input.transit_gateway_attachment_ids {
        let mut list_3678 = scope_3675.start_list(true, None);
        for item_3677 in var_3676 {
            #[allow(unused_mut)]
            let mut entry_3679 = list_3678.entry();
            entry_3679.string(item_3677);
        }
        list_3678.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3680 = writer.prefix("Filter");
    if let Some(var_3681) = &input.filters {
        let mut list_3683 = scope_3680.start_list(true, Some("Filter"));
        for item_3682 in var_3681 {
            #[allow(unused_mut)]
            let mut entry_3684 = list_3683.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3684, item_3682)?;
        }
        list_3683.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3685 = writer.prefix("MaxResults");
    if let Some(var_3686) = &input.max_results {
        scope_3685.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3686).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3687 = writer.prefix("NextToken");
    if let Some(var_3688) = &input.next_token {
        scope_3687.string(var_3688);
    }
    #[allow(unused_mut)]
    let mut scope_3689 = writer.prefix("DryRun");
    if let Some(var_3690) = &input.dry_run {
        scope_3689.boolean(*var_3690);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_transit_gateway_connect_peers(
    input: &crate::input::DescribeTransitGatewayConnectPeersInput,
) -> 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,
        "DescribeTransitGatewayConnectPeers",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3691 = writer.prefix("TransitGatewayConnectPeerIds");
    if let Some(var_3692) = &input.transit_gateway_connect_peer_ids {
        let mut list_3694 = scope_3691.start_list(true, Some("item"));
        for item_3693 in var_3692 {
            #[allow(unused_mut)]
            let mut entry_3695 = list_3694.entry();
            entry_3695.string(item_3693);
        }
        list_3694.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3696 = writer.prefix("Filter");
    if let Some(var_3697) = &input.filters {
        let mut list_3699 = scope_3696.start_list(true, Some("Filter"));
        for item_3698 in var_3697 {
            #[allow(unused_mut)]
            let mut entry_3700 = list_3699.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3700, item_3698)?;
        }
        list_3699.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3701 = writer.prefix("MaxResults");
    if let Some(var_3702) = &input.max_results {
        scope_3701.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3702).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3703 = writer.prefix("NextToken");
    if let Some(var_3704) = &input.next_token {
        scope_3703.string(var_3704);
    }
    #[allow(unused_mut)]
    let mut scope_3705 = writer.prefix("DryRun");
    if let Some(var_3706) = &input.dry_run {
        scope_3705.boolean(*var_3706);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_transit_gateway_connects(
    input: &crate::input::DescribeTransitGatewayConnectsInput,
) -> 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,
        "DescribeTransitGatewayConnects",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3707 = writer.prefix("TransitGatewayAttachmentIds");
    if let Some(var_3708) = &input.transit_gateway_attachment_ids {
        let mut list_3710 = scope_3707.start_list(true, None);
        for item_3709 in var_3708 {
            #[allow(unused_mut)]
            let mut entry_3711 = list_3710.entry();
            entry_3711.string(item_3709);
        }
        list_3710.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3712 = writer.prefix("Filter");
    if let Some(var_3713) = &input.filters {
        let mut list_3715 = scope_3712.start_list(true, Some("Filter"));
        for item_3714 in var_3713 {
            #[allow(unused_mut)]
            let mut entry_3716 = list_3715.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3716, item_3714)?;
        }
        list_3715.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3717 = writer.prefix("MaxResults");
    if let Some(var_3718) = &input.max_results {
        scope_3717.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3718).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3719 = writer.prefix("NextToken");
    if let Some(var_3720) = &input.next_token {
        scope_3719.string(var_3720);
    }
    #[allow(unused_mut)]
    let mut scope_3721 = writer.prefix("DryRun");
    if let Some(var_3722) = &input.dry_run {
        scope_3721.boolean(*var_3722);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_transit_gateway_multicast_domains(
    input: &crate::input::DescribeTransitGatewayMulticastDomainsInput,
) -> 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,
        "DescribeTransitGatewayMulticastDomains",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3723 = writer.prefix("TransitGatewayMulticastDomainIds");
    if let Some(var_3724) = &input.transit_gateway_multicast_domain_ids {
        let mut list_3726 = scope_3723.start_list(true, Some("item"));
        for item_3725 in var_3724 {
            #[allow(unused_mut)]
            let mut entry_3727 = list_3726.entry();
            entry_3727.string(item_3725);
        }
        list_3726.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3728 = writer.prefix("Filter");
    if let Some(var_3729) = &input.filters {
        let mut list_3731 = scope_3728.start_list(true, Some("Filter"));
        for item_3730 in var_3729 {
            #[allow(unused_mut)]
            let mut entry_3732 = list_3731.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3732, item_3730)?;
        }
        list_3731.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3733 = writer.prefix("MaxResults");
    if let Some(var_3734) = &input.max_results {
        scope_3733.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3734).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3735 = writer.prefix("NextToken");
    if let Some(var_3736) = &input.next_token {
        scope_3735.string(var_3736);
    }
    #[allow(unused_mut)]
    let mut scope_3737 = writer.prefix("DryRun");
    if let Some(var_3738) = &input.dry_run {
        scope_3737.boolean(*var_3738);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_transit_gateway_peering_attachments(
    input: &crate::input::DescribeTransitGatewayPeeringAttachmentsInput,
) -> 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,
        "DescribeTransitGatewayPeeringAttachments",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3739 = writer.prefix("TransitGatewayAttachmentIds");
    if let Some(var_3740) = &input.transit_gateway_attachment_ids {
        let mut list_3742 = scope_3739.start_list(true, None);
        for item_3741 in var_3740 {
            #[allow(unused_mut)]
            let mut entry_3743 = list_3742.entry();
            entry_3743.string(item_3741);
        }
        list_3742.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3744 = writer.prefix("Filter");
    if let Some(var_3745) = &input.filters {
        let mut list_3747 = scope_3744.start_list(true, Some("Filter"));
        for item_3746 in var_3745 {
            #[allow(unused_mut)]
            let mut entry_3748 = list_3747.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3748, item_3746)?;
        }
        list_3747.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3749 = writer.prefix("MaxResults");
    if let Some(var_3750) = &input.max_results {
        scope_3749.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3750).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3751 = writer.prefix("NextToken");
    if let Some(var_3752) = &input.next_token {
        scope_3751.string(var_3752);
    }
    #[allow(unused_mut)]
    let mut scope_3753 = writer.prefix("DryRun");
    if let Some(var_3754) = &input.dry_run {
        scope_3753.boolean(*var_3754);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_transit_gateway_policy_tables(
    input: &crate::input::DescribeTransitGatewayPolicyTablesInput,
) -> 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,
        "DescribeTransitGatewayPolicyTables",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3755 = writer.prefix("TransitGatewayPolicyTableIds");
    if let Some(var_3756) = &input.transit_gateway_policy_table_ids {
        let mut list_3758 = scope_3755.start_list(true, Some("item"));
        for item_3757 in var_3756 {
            #[allow(unused_mut)]
            let mut entry_3759 = list_3758.entry();
            entry_3759.string(item_3757);
        }
        list_3758.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3760 = writer.prefix("Filter");
    if let Some(var_3761) = &input.filters {
        let mut list_3763 = scope_3760.start_list(true, Some("Filter"));
        for item_3762 in var_3761 {
            #[allow(unused_mut)]
            let mut entry_3764 = list_3763.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3764, item_3762)?;
        }
        list_3763.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3765 = writer.prefix("MaxResults");
    if let Some(var_3766) = &input.max_results {
        scope_3765.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3766).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3767 = writer.prefix("NextToken");
    if let Some(var_3768) = &input.next_token {
        scope_3767.string(var_3768);
    }
    #[allow(unused_mut)]
    let mut scope_3769 = writer.prefix("DryRun");
    if let Some(var_3770) = &input.dry_run {
        scope_3769.boolean(*var_3770);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_transit_gateway_route_table_announcements(
    input: &crate::input::DescribeTransitGatewayRouteTableAnnouncementsInput,
) -> 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,
        "DescribeTransitGatewayRouteTableAnnouncements",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3771 = writer.prefix("TransitGatewayRouteTableAnnouncementIds");
    if let Some(var_3772) = &input.transit_gateway_route_table_announcement_ids {
        let mut list_3774 = scope_3771.start_list(true, Some("item"));
        for item_3773 in var_3772 {
            #[allow(unused_mut)]
            let mut entry_3775 = list_3774.entry();
            entry_3775.string(item_3773);
        }
        list_3774.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3776 = writer.prefix("Filter");
    if let Some(var_3777) = &input.filters {
        let mut list_3779 = scope_3776.start_list(true, Some("Filter"));
        for item_3778 in var_3777 {
            #[allow(unused_mut)]
            let mut entry_3780 = list_3779.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3780, item_3778)?;
        }
        list_3779.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3781 = writer.prefix("MaxResults");
    if let Some(var_3782) = &input.max_results {
        scope_3781.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3782).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3783 = writer.prefix("NextToken");
    if let Some(var_3784) = &input.next_token {
        scope_3783.string(var_3784);
    }
    #[allow(unused_mut)]
    let mut scope_3785 = writer.prefix("DryRun");
    if let Some(var_3786) = &input.dry_run {
        scope_3785.boolean(*var_3786);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_transit_gateway_route_tables(
    input: &crate::input::DescribeTransitGatewayRouteTablesInput,
) -> 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,
        "DescribeTransitGatewayRouteTables",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3787 = writer.prefix("TransitGatewayRouteTableIds");
    if let Some(var_3788) = &input.transit_gateway_route_table_ids {
        let mut list_3790 = scope_3787.start_list(true, Some("item"));
        for item_3789 in var_3788 {
            #[allow(unused_mut)]
            let mut entry_3791 = list_3790.entry();
            entry_3791.string(item_3789);
        }
        list_3790.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3792 = writer.prefix("Filter");
    if let Some(var_3793) = &input.filters {
        let mut list_3795 = scope_3792.start_list(true, Some("Filter"));
        for item_3794 in var_3793 {
            #[allow(unused_mut)]
            let mut entry_3796 = list_3795.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3796, item_3794)?;
        }
        list_3795.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3797 = writer.prefix("MaxResults");
    if let Some(var_3798) = &input.max_results {
        scope_3797.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3798).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3799 = writer.prefix("NextToken");
    if let Some(var_3800) = &input.next_token {
        scope_3799.string(var_3800);
    }
    #[allow(unused_mut)]
    let mut scope_3801 = writer.prefix("DryRun");
    if let Some(var_3802) = &input.dry_run {
        scope_3801.boolean(*var_3802);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_transit_gateways(
    input: &crate::input::DescribeTransitGatewaysInput,
) -> 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, "DescribeTransitGateways", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3803 = writer.prefix("TransitGatewayIds");
    if let Some(var_3804) = &input.transit_gateway_ids {
        let mut list_3806 = scope_3803.start_list(true, Some("item"));
        for item_3805 in var_3804 {
            #[allow(unused_mut)]
            let mut entry_3807 = list_3806.entry();
            entry_3807.string(item_3805);
        }
        list_3806.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3808 = writer.prefix("Filter");
    if let Some(var_3809) = &input.filters {
        let mut list_3811 = scope_3808.start_list(true, Some("Filter"));
        for item_3810 in var_3809 {
            #[allow(unused_mut)]
            let mut entry_3812 = list_3811.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3812, item_3810)?;
        }
        list_3811.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3813 = writer.prefix("MaxResults");
    if let Some(var_3814) = &input.max_results {
        scope_3813.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3814).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3815 = writer.prefix("NextToken");
    if let Some(var_3816) = &input.next_token {
        scope_3815.string(var_3816);
    }
    #[allow(unused_mut)]
    let mut scope_3817 = writer.prefix("DryRun");
    if let Some(var_3818) = &input.dry_run {
        scope_3817.boolean(*var_3818);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_transit_gateway_vpc_attachments(
    input: &crate::input::DescribeTransitGatewayVpcAttachmentsInput,
) -> 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,
        "DescribeTransitGatewayVpcAttachments",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3819 = writer.prefix("TransitGatewayAttachmentIds");
    if let Some(var_3820) = &input.transit_gateway_attachment_ids {
        let mut list_3822 = scope_3819.start_list(true, None);
        for item_3821 in var_3820 {
            #[allow(unused_mut)]
            let mut entry_3823 = list_3822.entry();
            entry_3823.string(item_3821);
        }
        list_3822.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3824 = writer.prefix("Filter");
    if let Some(var_3825) = &input.filters {
        let mut list_3827 = scope_3824.start_list(true, Some("Filter"));
        for item_3826 in var_3825 {
            #[allow(unused_mut)]
            let mut entry_3828 = list_3827.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3828, item_3826)?;
        }
        list_3827.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3829 = writer.prefix("MaxResults");
    if let Some(var_3830) = &input.max_results {
        scope_3829.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3830).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3831 = writer.prefix("NextToken");
    if let Some(var_3832) = &input.next_token {
        scope_3831.string(var_3832);
    }
    #[allow(unused_mut)]
    let mut scope_3833 = writer.prefix("DryRun");
    if let Some(var_3834) = &input.dry_run {
        scope_3833.boolean(*var_3834);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_trunk_interface_associations(
    input: &crate::input::DescribeTrunkInterfaceAssociationsInput,
) -> 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,
        "DescribeTrunkInterfaceAssociations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3835 = writer.prefix("AssociationId");
    if let Some(var_3836) = &input.association_ids {
        let mut list_3838 = scope_3835.start_list(true, Some("item"));
        for item_3837 in var_3836 {
            #[allow(unused_mut)]
            let mut entry_3839 = list_3838.entry();
            entry_3839.string(item_3837);
        }
        list_3838.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3840 = writer.prefix("DryRun");
    if let Some(var_3841) = &input.dry_run {
        scope_3840.boolean(*var_3841);
    }
    #[allow(unused_mut)]
    let mut scope_3842 = writer.prefix("Filter");
    if let Some(var_3843) = &input.filters {
        let mut list_3845 = scope_3842.start_list(true, Some("Filter"));
        for item_3844 in var_3843 {
            #[allow(unused_mut)]
            let mut entry_3846 = list_3845.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3846, item_3844)?;
        }
        list_3845.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3847 = writer.prefix("NextToken");
    if let Some(var_3848) = &input.next_token {
        scope_3847.string(var_3848);
    }
    #[allow(unused_mut)]
    let mut scope_3849 = writer.prefix("MaxResults");
    if let Some(var_3850) = &input.max_results {
        scope_3849.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3850).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_volume_attribute(
    input: &crate::input::DescribeVolumeAttributeInput,
) -> 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, "DescribeVolumeAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3851 = writer.prefix("Attribute");
    if let Some(var_3852) = &input.attribute {
        scope_3851.string(var_3852.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_3853 = writer.prefix("VolumeId");
    if let Some(var_3854) = &input.volume_id {
        scope_3853.string(var_3854);
    }
    #[allow(unused_mut)]
    let mut scope_3855 = writer.prefix("DryRun");
    if let Some(var_3856) = &input.dry_run {
        scope_3855.boolean(*var_3856);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_volumes(
    input: &crate::input::DescribeVolumesInput,
) -> 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, "DescribeVolumes", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3857 = writer.prefix("Filter");
    if let Some(var_3858) = &input.filters {
        let mut list_3860 = scope_3857.start_list(true, Some("Filter"));
        for item_3859 in var_3858 {
            #[allow(unused_mut)]
            let mut entry_3861 = list_3860.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3861, item_3859)?;
        }
        list_3860.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3862 = writer.prefix("VolumeId");
    if let Some(var_3863) = &input.volume_ids {
        let mut list_3865 = scope_3862.start_list(true, Some("VolumeId"));
        for item_3864 in var_3863 {
            #[allow(unused_mut)]
            let mut entry_3866 = list_3865.entry();
            entry_3866.string(item_3864);
        }
        list_3865.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3867 = writer.prefix("DryRun");
    if let Some(var_3868) = &input.dry_run {
        scope_3867.boolean(*var_3868);
    }
    #[allow(unused_mut)]
    let mut scope_3869 = writer.prefix("MaxResults");
    if let Some(var_3870) = &input.max_results {
        scope_3869.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3870).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3871 = writer.prefix("NextToken");
    if let Some(var_3872) = &input.next_token {
        scope_3871.string(var_3872);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_volumes_modifications(
    input: &crate::input::DescribeVolumesModificationsInput,
) -> 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, "DescribeVolumesModifications", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3873 = writer.prefix("DryRun");
    if let Some(var_3874) = &input.dry_run {
        scope_3873.boolean(*var_3874);
    }
    #[allow(unused_mut)]
    let mut scope_3875 = writer.prefix("VolumeId");
    if let Some(var_3876) = &input.volume_ids {
        let mut list_3878 = scope_3875.start_list(true, Some("VolumeId"));
        for item_3877 in var_3876 {
            #[allow(unused_mut)]
            let mut entry_3879 = list_3878.entry();
            entry_3879.string(item_3877);
        }
        list_3878.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3880 = writer.prefix("Filter");
    if let Some(var_3881) = &input.filters {
        let mut list_3883 = scope_3880.start_list(true, Some("Filter"));
        for item_3882 in var_3881 {
            #[allow(unused_mut)]
            let mut entry_3884 = list_3883.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3884, item_3882)?;
        }
        list_3883.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3885 = writer.prefix("NextToken");
    if let Some(var_3886) = &input.next_token {
        scope_3885.string(var_3886);
    }
    #[allow(unused_mut)]
    let mut scope_3887 = writer.prefix("MaxResults");
    if let Some(var_3888) = &input.max_results {
        scope_3887.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3888).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_volume_status(
    input: &crate::input::DescribeVolumeStatusInput,
) -> 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, "DescribeVolumeStatus", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3889 = writer.prefix("Filter");
    if let Some(var_3890) = &input.filters {
        let mut list_3892 = scope_3889.start_list(true, Some("Filter"));
        for item_3891 in var_3890 {
            #[allow(unused_mut)]
            let mut entry_3893 = list_3892.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3893, item_3891)?;
        }
        list_3892.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3894 = writer.prefix("MaxResults");
    if let Some(var_3895) = &input.max_results {
        scope_3894.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3895).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3896 = writer.prefix("NextToken");
    if let Some(var_3897) = &input.next_token {
        scope_3896.string(var_3897);
    }
    #[allow(unused_mut)]
    let mut scope_3898 = writer.prefix("VolumeId");
    if let Some(var_3899) = &input.volume_ids {
        let mut list_3901 = scope_3898.start_list(true, Some("VolumeId"));
        for item_3900 in var_3899 {
            #[allow(unused_mut)]
            let mut entry_3902 = list_3901.entry();
            entry_3902.string(item_3900);
        }
        list_3901.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3903 = writer.prefix("DryRun");
    if let Some(var_3904) = &input.dry_run {
        scope_3903.boolean(*var_3904);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpc_attribute(
    input: &crate::input::DescribeVpcAttributeInput,
) -> 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, "DescribeVpcAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3905 = writer.prefix("Attribute");
    if let Some(var_3906) = &input.attribute {
        scope_3905.string(var_3906.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_3907 = writer.prefix("VpcId");
    if let Some(var_3908) = &input.vpc_id {
        scope_3907.string(var_3908);
    }
    #[allow(unused_mut)]
    let mut scope_3909 = writer.prefix("DryRun");
    if let Some(var_3910) = &input.dry_run {
        scope_3909.boolean(*var_3910);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpc_classic_link(
    input: &crate::input::DescribeVpcClassicLinkInput,
) -> 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, "DescribeVpcClassicLink", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3911 = writer.prefix("Filter");
    if let Some(var_3912) = &input.filters {
        let mut list_3914 = scope_3911.start_list(true, Some("Filter"));
        for item_3913 in var_3912 {
            #[allow(unused_mut)]
            let mut entry_3915 = list_3914.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3915, item_3913)?;
        }
        list_3914.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3916 = writer.prefix("DryRun");
    if let Some(var_3917) = &input.dry_run {
        scope_3916.boolean(*var_3917);
    }
    #[allow(unused_mut)]
    let mut scope_3918 = writer.prefix("VpcId");
    if let Some(var_3919) = &input.vpc_ids {
        let mut list_3921 = scope_3918.start_list(true, Some("VpcId"));
        for item_3920 in var_3919 {
            #[allow(unused_mut)]
            let mut entry_3922 = list_3921.entry();
            entry_3922.string(item_3920);
        }
        list_3921.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpc_classic_link_dns_support(
    input: &crate::input::DescribeVpcClassicLinkDnsSupportInput,
) -> 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,
        "DescribeVpcClassicLinkDnsSupport",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3923 = writer.prefix("MaxResults");
    if let Some(var_3924) = &input.max_results {
        scope_3923.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3924).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3925 = writer.prefix("NextToken");
    if let Some(var_3926) = &input.next_token {
        scope_3925.string(var_3926);
    }
    #[allow(unused_mut)]
    let mut scope_3927 = writer.prefix("VpcIds");
    if let Some(var_3928) = &input.vpc_ids {
        let mut list_3930 = scope_3927.start_list(true, Some("VpcId"));
        for item_3929 in var_3928 {
            #[allow(unused_mut)]
            let mut entry_3931 = list_3930.entry();
            entry_3931.string(item_3929);
        }
        list_3930.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpc_endpoint_connection_notifications(
    input: &crate::input::DescribeVpcEndpointConnectionNotificationsInput,
) -> 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,
        "DescribeVpcEndpointConnectionNotifications",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3932 = writer.prefix("DryRun");
    if let Some(var_3933) = &input.dry_run {
        scope_3932.boolean(*var_3933);
    }
    #[allow(unused_mut)]
    let mut scope_3934 = writer.prefix("ConnectionNotificationId");
    if let Some(var_3935) = &input.connection_notification_id {
        scope_3934.string(var_3935);
    }
    #[allow(unused_mut)]
    let mut scope_3936 = writer.prefix("Filter");
    if let Some(var_3937) = &input.filters {
        let mut list_3939 = scope_3936.start_list(true, Some("Filter"));
        for item_3938 in var_3937 {
            #[allow(unused_mut)]
            let mut entry_3940 = list_3939.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3940, item_3938)?;
        }
        list_3939.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3941 = writer.prefix("MaxResults");
    if let Some(var_3942) = &input.max_results {
        scope_3941.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3942).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3943 = writer.prefix("NextToken");
    if let Some(var_3944) = &input.next_token {
        scope_3943.string(var_3944);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpc_endpoint_connections(
    input: &crate::input::DescribeVpcEndpointConnectionsInput,
) -> 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,
        "DescribeVpcEndpointConnections",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3945 = writer.prefix("DryRun");
    if let Some(var_3946) = &input.dry_run {
        scope_3945.boolean(*var_3946);
    }
    #[allow(unused_mut)]
    let mut scope_3947 = writer.prefix("Filter");
    if let Some(var_3948) = &input.filters {
        let mut list_3950 = scope_3947.start_list(true, Some("Filter"));
        for item_3949 in var_3948 {
            #[allow(unused_mut)]
            let mut entry_3951 = list_3950.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3951, item_3949)?;
        }
        list_3950.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3952 = writer.prefix("MaxResults");
    if let Some(var_3953) = &input.max_results {
        scope_3952.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3953).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3954 = writer.prefix("NextToken");
    if let Some(var_3955) = &input.next_token {
        scope_3954.string(var_3955);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpc_endpoints(
    input: &crate::input::DescribeVpcEndpointsInput,
) -> 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, "DescribeVpcEndpoints", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_3956 = writer.prefix("DryRun");
    if let Some(var_3957) = &input.dry_run {
        scope_3956.boolean(*var_3957);
    }
    #[allow(unused_mut)]
    let mut scope_3958 = writer.prefix("VpcEndpointId");
    if let Some(var_3959) = &input.vpc_endpoint_ids {
        let mut list_3961 = scope_3958.start_list(true, Some("item"));
        for item_3960 in var_3959 {
            #[allow(unused_mut)]
            let mut entry_3962 = list_3961.entry();
            entry_3962.string(item_3960);
        }
        list_3961.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3963 = writer.prefix("Filter");
    if let Some(var_3964) = &input.filters {
        let mut list_3966 = scope_3963.start_list(true, Some("Filter"));
        for item_3965 in var_3964 {
            #[allow(unused_mut)]
            let mut entry_3967 = list_3966.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3967, item_3965)?;
        }
        list_3966.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3968 = writer.prefix("MaxResults");
    if let Some(var_3969) = &input.max_results {
        scope_3968.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3969).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3970 = writer.prefix("NextToken");
    if let Some(var_3971) = &input.next_token {
        scope_3970.string(var_3971);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpc_endpoint_service_configurations(
    input: &crate::input::DescribeVpcEndpointServiceConfigurationsInput,
) -> 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,
        "DescribeVpcEndpointServiceConfigurations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3972 = writer.prefix("DryRun");
    if let Some(var_3973) = &input.dry_run {
        scope_3972.boolean(*var_3973);
    }
    #[allow(unused_mut)]
    let mut scope_3974 = writer.prefix("ServiceId");
    if let Some(var_3975) = &input.service_ids {
        let mut list_3977 = scope_3974.start_list(true, Some("item"));
        for item_3976 in var_3975 {
            #[allow(unused_mut)]
            let mut entry_3978 = list_3977.entry();
            entry_3978.string(item_3976);
        }
        list_3977.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3979 = writer.prefix("Filter");
    if let Some(var_3980) = &input.filters {
        let mut list_3982 = scope_3979.start_list(true, Some("Filter"));
        for item_3981 in var_3980 {
            #[allow(unused_mut)]
            let mut entry_3983 = list_3982.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3983, item_3981)?;
        }
        list_3982.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3984 = writer.prefix("MaxResults");
    if let Some(var_3985) = &input.max_results {
        scope_3984.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3985).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3986 = writer.prefix("NextToken");
    if let Some(var_3987) = &input.next_token {
        scope_3986.string(var_3987);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpc_endpoint_service_permissions(
    input: &crate::input::DescribeVpcEndpointServicePermissionsInput,
) -> 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,
        "DescribeVpcEndpointServicePermissions",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_3988 = writer.prefix("DryRun");
    if let Some(var_3989) = &input.dry_run {
        scope_3988.boolean(*var_3989);
    }
    #[allow(unused_mut)]
    let mut scope_3990 = writer.prefix("ServiceId");
    if let Some(var_3991) = &input.service_id {
        scope_3990.string(var_3991);
    }
    #[allow(unused_mut)]
    let mut scope_3992 = writer.prefix("Filter");
    if let Some(var_3993) = &input.filters {
        let mut list_3995 = scope_3992.start_list(true, Some("Filter"));
        for item_3994 in var_3993 {
            #[allow(unused_mut)]
            let mut entry_3996 = list_3995.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_3996, item_3994)?;
        }
        list_3995.finish();
    }
    #[allow(unused_mut)]
    let mut scope_3997 = writer.prefix("MaxResults");
    if let Some(var_3998) = &input.max_results {
        scope_3997.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_3998).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_3999 = writer.prefix("NextToken");
    if let Some(var_4000) = &input.next_token {
        scope_3999.string(var_4000);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpc_endpoint_services(
    input: &crate::input::DescribeVpcEndpointServicesInput,
) -> 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, "DescribeVpcEndpointServices", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4001 = writer.prefix("DryRun");
    if let Some(var_4002) = &input.dry_run {
        scope_4001.boolean(*var_4002);
    }
    #[allow(unused_mut)]
    let mut scope_4003 = writer.prefix("ServiceName");
    if let Some(var_4004) = &input.service_names {
        let mut list_4006 = scope_4003.start_list(true, Some("item"));
        for item_4005 in var_4004 {
            #[allow(unused_mut)]
            let mut entry_4007 = list_4006.entry();
            entry_4007.string(item_4005);
        }
        list_4006.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4008 = writer.prefix("Filter");
    if let Some(var_4009) = &input.filters {
        let mut list_4011 = scope_4008.start_list(true, Some("Filter"));
        for item_4010 in var_4009 {
            #[allow(unused_mut)]
            let mut entry_4012 = list_4011.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4012, item_4010)?;
        }
        list_4011.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4013 = writer.prefix("MaxResults");
    if let Some(var_4014) = &input.max_results {
        scope_4013.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4014).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4015 = writer.prefix("NextToken");
    if let Some(var_4016) = &input.next_token {
        scope_4015.string(var_4016);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpc_peering_connections(
    input: &crate::input::DescribeVpcPeeringConnectionsInput,
) -> 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, "DescribeVpcPeeringConnections", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4017 = writer.prefix("Filter");
    if let Some(var_4018) = &input.filters {
        let mut list_4020 = scope_4017.start_list(true, Some("Filter"));
        for item_4019 in var_4018 {
            #[allow(unused_mut)]
            let mut entry_4021 = list_4020.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4021, item_4019)?;
        }
        list_4020.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4022 = writer.prefix("DryRun");
    if let Some(var_4023) = &input.dry_run {
        scope_4022.boolean(*var_4023);
    }
    #[allow(unused_mut)]
    let mut scope_4024 = writer.prefix("VpcPeeringConnectionId");
    if let Some(var_4025) = &input.vpc_peering_connection_ids {
        let mut list_4027 = scope_4024.start_list(true, Some("item"));
        for item_4026 in var_4025 {
            #[allow(unused_mut)]
            let mut entry_4028 = list_4027.entry();
            entry_4028.string(item_4026);
        }
        list_4027.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4029 = writer.prefix("NextToken");
    if let Some(var_4030) = &input.next_token {
        scope_4029.string(var_4030);
    }
    #[allow(unused_mut)]
    let mut scope_4031 = writer.prefix("MaxResults");
    if let Some(var_4032) = &input.max_results {
        scope_4031.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4032).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpcs(
    input: &crate::input::DescribeVpcsInput,
) -> 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, "DescribeVpcs", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4033 = writer.prefix("Filter");
    if let Some(var_4034) = &input.filters {
        let mut list_4036 = scope_4033.start_list(true, Some("Filter"));
        for item_4035 in var_4034 {
            #[allow(unused_mut)]
            let mut entry_4037 = list_4036.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4037, item_4035)?;
        }
        list_4036.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4038 = writer.prefix("VpcId");
    if let Some(var_4039) = &input.vpc_ids {
        let mut list_4041 = scope_4038.start_list(true, Some("VpcId"));
        for item_4040 in var_4039 {
            #[allow(unused_mut)]
            let mut entry_4042 = list_4041.entry();
            entry_4042.string(item_4040);
        }
        list_4041.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4043 = writer.prefix("DryRun");
    if let Some(var_4044) = &input.dry_run {
        scope_4043.boolean(*var_4044);
    }
    #[allow(unused_mut)]
    let mut scope_4045 = writer.prefix("NextToken");
    if let Some(var_4046) = &input.next_token {
        scope_4045.string(var_4046);
    }
    #[allow(unused_mut)]
    let mut scope_4047 = writer.prefix("MaxResults");
    if let Some(var_4048) = &input.max_results {
        scope_4047.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4048).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpn_connections(
    input: &crate::input::DescribeVpnConnectionsInput,
) -> 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, "DescribeVpnConnections", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4049 = writer.prefix("Filter");
    if let Some(var_4050) = &input.filters {
        let mut list_4052 = scope_4049.start_list(true, Some("Filter"));
        for item_4051 in var_4050 {
            #[allow(unused_mut)]
            let mut entry_4053 = list_4052.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4053, item_4051)?;
        }
        list_4052.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4054 = writer.prefix("VpnConnectionId");
    if let Some(var_4055) = &input.vpn_connection_ids {
        let mut list_4057 = scope_4054.start_list(true, Some("VpnConnectionId"));
        for item_4056 in var_4055 {
            #[allow(unused_mut)]
            let mut entry_4058 = list_4057.entry();
            entry_4058.string(item_4056);
        }
        list_4057.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4059 = writer.prefix("DryRun");
    if let Some(var_4060) = &input.dry_run {
        scope_4059.boolean(*var_4060);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_vpn_gateways(
    input: &crate::input::DescribeVpnGatewaysInput,
) -> 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, "DescribeVpnGateways", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4061 = writer.prefix("Filter");
    if let Some(var_4062) = &input.filters {
        let mut list_4064 = scope_4061.start_list(true, Some("Filter"));
        for item_4063 in var_4062 {
            #[allow(unused_mut)]
            let mut entry_4065 = list_4064.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4065, item_4063)?;
        }
        list_4064.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4066 = writer.prefix("VpnGatewayId");
    if let Some(var_4067) = &input.vpn_gateway_ids {
        let mut list_4069 = scope_4066.start_list(true, Some("VpnGatewayId"));
        for item_4068 in var_4067 {
            #[allow(unused_mut)]
            let mut entry_4070 = list_4069.entry();
            entry_4070.string(item_4068);
        }
        list_4069.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4071 = writer.prefix("DryRun");
    if let Some(var_4072) = &input.dry_run {
        scope_4071.boolean(*var_4072);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_detach_classic_link_vpc(
    input: &crate::input::DetachClassicLinkVpcInput,
) -> 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, "DetachClassicLinkVpc", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4073 = writer.prefix("DryRun");
    if let Some(var_4074) = &input.dry_run {
        scope_4073.boolean(*var_4074);
    }
    #[allow(unused_mut)]
    let mut scope_4075 = writer.prefix("InstanceId");
    if let Some(var_4076) = &input.instance_id {
        scope_4075.string(var_4076);
    }
    #[allow(unused_mut)]
    let mut scope_4077 = writer.prefix("VpcId");
    if let Some(var_4078) = &input.vpc_id {
        scope_4077.string(var_4078);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_detach_internet_gateway(
    input: &crate::input::DetachInternetGatewayInput,
) -> 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, "DetachInternetGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4079 = writer.prefix("DryRun");
    if let Some(var_4080) = &input.dry_run {
        scope_4079.boolean(*var_4080);
    }
    #[allow(unused_mut)]
    let mut scope_4081 = writer.prefix("InternetGatewayId");
    if let Some(var_4082) = &input.internet_gateway_id {
        scope_4081.string(var_4082);
    }
    #[allow(unused_mut)]
    let mut scope_4083 = writer.prefix("VpcId");
    if let Some(var_4084) = &input.vpc_id {
        scope_4083.string(var_4084);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_detach_network_interface(
    input: &crate::input::DetachNetworkInterfaceInput,
) -> 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, "DetachNetworkInterface", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4085 = writer.prefix("AttachmentId");
    if let Some(var_4086) = &input.attachment_id {
        scope_4085.string(var_4086);
    }
    #[allow(unused_mut)]
    let mut scope_4087 = writer.prefix("DryRun");
    if let Some(var_4088) = &input.dry_run {
        scope_4087.boolean(*var_4088);
    }
    #[allow(unused_mut)]
    let mut scope_4089 = writer.prefix("Force");
    if let Some(var_4090) = &input.force {
        scope_4089.boolean(*var_4090);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_detach_volume(
    input: &crate::input::DetachVolumeInput,
) -> 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, "DetachVolume", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4091 = writer.prefix("Device");
    if let Some(var_4092) = &input.device {
        scope_4091.string(var_4092);
    }
    #[allow(unused_mut)]
    let mut scope_4093 = writer.prefix("Force");
    if let Some(var_4094) = &input.force {
        scope_4093.boolean(*var_4094);
    }
    #[allow(unused_mut)]
    let mut scope_4095 = writer.prefix("InstanceId");
    if let Some(var_4096) = &input.instance_id {
        scope_4095.string(var_4096);
    }
    #[allow(unused_mut)]
    let mut scope_4097 = writer.prefix("VolumeId");
    if let Some(var_4098) = &input.volume_id {
        scope_4097.string(var_4098);
    }
    #[allow(unused_mut)]
    let mut scope_4099 = writer.prefix("DryRun");
    if let Some(var_4100) = &input.dry_run {
        scope_4099.boolean(*var_4100);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_detach_vpn_gateway(
    input: &crate::input::DetachVpnGatewayInput,
) -> 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, "DetachVpnGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4101 = writer.prefix("VpcId");
    if let Some(var_4102) = &input.vpc_id {
        scope_4101.string(var_4102);
    }
    #[allow(unused_mut)]
    let mut scope_4103 = writer.prefix("VpnGatewayId");
    if let Some(var_4104) = &input.vpn_gateway_id {
        scope_4103.string(var_4104);
    }
    #[allow(unused_mut)]
    let mut scope_4105 = writer.prefix("DryRun");
    if let Some(var_4106) = &input.dry_run {
        scope_4105.boolean(*var_4106);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

pub fn serialize_operation_crate_operation_disable_fast_launch(
    input: &crate::input::DisableFastLaunchInput,
) -> 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, "DisableFastLaunch", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4109 = writer.prefix("ImageId");
    if let Some(var_4110) = &input.image_id {
        scope_4109.string(var_4110);
    }
    #[allow(unused_mut)]
    let mut scope_4111 = writer.prefix("Force");
    if let Some(var_4112) = &input.force {
        scope_4111.boolean(*var_4112);
    }
    #[allow(unused_mut)]
    let mut scope_4113 = writer.prefix("DryRun");
    if let Some(var_4114) = &input.dry_run {
        scope_4113.boolean(*var_4114);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disable_fast_snapshot_restores(
    input: &crate::input::DisableFastSnapshotRestoresInput,
) -> 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, "DisableFastSnapshotRestores", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4115 = writer.prefix("AvailabilityZone");
    if let Some(var_4116) = &input.availability_zones {
        let mut list_4118 = scope_4115.start_list(true, Some("AvailabilityZone"));
        for item_4117 in var_4116 {
            #[allow(unused_mut)]
            let mut entry_4119 = list_4118.entry();
            entry_4119.string(item_4117);
        }
        list_4118.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4120 = writer.prefix("SourceSnapshotId");
    if let Some(var_4121) = &input.source_snapshot_ids {
        let mut list_4123 = scope_4120.start_list(true, Some("SnapshotId"));
        for item_4122 in var_4121 {
            #[allow(unused_mut)]
            let mut entry_4124 = list_4123.entry();
            entry_4124.string(item_4122);
        }
        list_4123.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4125 = writer.prefix("DryRun");
    if let Some(var_4126) = &input.dry_run {
        scope_4125.boolean(*var_4126);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disable_image_deprecation(
    input: &crate::input::DisableImageDeprecationInput,
) -> 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, "DisableImageDeprecation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4127 = writer.prefix("ImageId");
    if let Some(var_4128) = &input.image_id {
        scope_4127.string(var_4128);
    }
    #[allow(unused_mut)]
    let mut scope_4129 = writer.prefix("DryRun");
    if let Some(var_4130) = &input.dry_run {
        scope_4129.boolean(*var_4130);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disable_ipam_organization_admin_account(
    input: &crate::input::DisableIpamOrganizationAdminAccountInput,
) -> 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,
        "DisableIpamOrganizationAdminAccount",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4131 = writer.prefix("DryRun");
    if let Some(var_4132) = &input.dry_run {
        scope_4131.boolean(*var_4132);
    }
    #[allow(unused_mut)]
    let mut scope_4133 = writer.prefix("DelegatedAdminAccountId");
    if let Some(var_4134) = &input.delegated_admin_account_id {
        scope_4133.string(var_4134);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

pub fn serialize_operation_crate_operation_disable_transit_gateway_route_table_propagation(
    input: &crate::input::DisableTransitGatewayRouteTablePropagationInput,
) -> 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,
        "DisableTransitGatewayRouteTablePropagation",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4137 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_4138) = &input.transit_gateway_route_table_id {
        scope_4137.string(var_4138);
    }
    #[allow(unused_mut)]
    let mut scope_4139 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_4140) = &input.transit_gateway_attachment_id {
        scope_4139.string(var_4140);
    }
    #[allow(unused_mut)]
    let mut scope_4141 = writer.prefix("DryRun");
    if let Some(var_4142) = &input.dry_run {
        scope_4141.boolean(*var_4142);
    }
    #[allow(unused_mut)]
    let mut scope_4143 = writer.prefix("TransitGatewayRouteTableAnnouncementId");
    if let Some(var_4144) = &input.transit_gateway_route_table_announcement_id {
        scope_4143.string(var_4144);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disable_vgw_route_propagation(
    input: &crate::input::DisableVgwRoutePropagationInput,
) -> 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, "DisableVgwRoutePropagation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4145 = writer.prefix("GatewayId");
    if let Some(var_4146) = &input.gateway_id {
        scope_4145.string(var_4146);
    }
    #[allow(unused_mut)]
    let mut scope_4147 = writer.prefix("RouteTableId");
    if let Some(var_4148) = &input.route_table_id {
        scope_4147.string(var_4148);
    }
    #[allow(unused_mut)]
    let mut scope_4149 = writer.prefix("DryRun");
    if let Some(var_4150) = &input.dry_run {
        scope_4149.boolean(*var_4150);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disable_vpc_classic_link(
    input: &crate::input::DisableVpcClassicLinkInput,
) -> 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, "DisableVpcClassicLink", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4151 = writer.prefix("DryRun");
    if let Some(var_4152) = &input.dry_run {
        scope_4151.boolean(*var_4152);
    }
    #[allow(unused_mut)]
    let mut scope_4153 = writer.prefix("VpcId");
    if let Some(var_4154) = &input.vpc_id {
        scope_4153.string(var_4154);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disable_vpc_classic_link_dns_support(
    input: &crate::input::DisableVpcClassicLinkDnsSupportInput,
) -> 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,
        "DisableVpcClassicLinkDnsSupport",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4155 = writer.prefix("VpcId");
    if let Some(var_4156) = &input.vpc_id {
        scope_4155.string(var_4156);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_address(
    input: &crate::input::DisassociateAddressInput,
) -> 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, "DisassociateAddress", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4157 = writer.prefix("AssociationId");
    if let Some(var_4158) = &input.association_id {
        scope_4157.string(var_4158);
    }
    #[allow(unused_mut)]
    let mut scope_4159 = writer.prefix("PublicIp");
    if let Some(var_4160) = &input.public_ip {
        scope_4159.string(var_4160);
    }
    #[allow(unused_mut)]
    let mut scope_4161 = writer.prefix("DryRun");
    if let Some(var_4162) = &input.dry_run {
        scope_4161.boolean(*var_4162);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_client_vpn_target_network(
    input: &crate::input::DisassociateClientVpnTargetNetworkInput,
) -> 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,
        "DisassociateClientVpnTargetNetwork",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4163 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_4164) = &input.client_vpn_endpoint_id {
        scope_4163.string(var_4164);
    }
    #[allow(unused_mut)]
    let mut scope_4165 = writer.prefix("AssociationId");
    if let Some(var_4166) = &input.association_id {
        scope_4165.string(var_4166);
    }
    #[allow(unused_mut)]
    let mut scope_4167 = writer.prefix("DryRun");
    if let Some(var_4168) = &input.dry_run {
        scope_4167.boolean(*var_4168);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_enclave_certificate_iam_role(
    input: &crate::input::DisassociateEnclaveCertificateIamRoleInput,
) -> 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,
        "DisassociateEnclaveCertificateIamRole",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4169 = writer.prefix("CertificateArn");
    if let Some(var_4170) = &input.certificate_arn {
        scope_4169.string(var_4170);
    }
    #[allow(unused_mut)]
    let mut scope_4171 = writer.prefix("RoleArn");
    if let Some(var_4172) = &input.role_arn {
        scope_4171.string(var_4172);
    }
    #[allow(unused_mut)]
    let mut scope_4173 = writer.prefix("DryRun");
    if let Some(var_4174) = &input.dry_run {
        scope_4173.boolean(*var_4174);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_iam_instance_profile(
    input: &crate::input::DisassociateIamInstanceProfileInput,
) -> 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,
        "DisassociateIamInstanceProfile",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4175 = writer.prefix("AssociationId");
    if let Some(var_4176) = &input.association_id {
        scope_4175.string(var_4176);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_instance_event_window(
    input: &crate::input::DisassociateInstanceEventWindowInput,
) -> 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,
        "DisassociateInstanceEventWindow",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4177 = writer.prefix("DryRun");
    if let Some(var_4178) = &input.dry_run {
        scope_4177.boolean(*var_4178);
    }
    #[allow(unused_mut)]
    let mut scope_4179 = writer.prefix("InstanceEventWindowId");
    if let Some(var_4180) = &input.instance_event_window_id {
        scope_4179.string(var_4180);
    }
    #[allow(unused_mut)]
    let mut scope_4181 = writer.prefix("AssociationTarget");
    if let Some(var_4182) = &input.association_target {
        crate::query_ser::serialize_structure_crate_model_instance_event_window_disassociation_request(scope_4181, var_4182)?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_route_table(
    input: &crate::input::DisassociateRouteTableInput,
) -> 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, "DisassociateRouteTable", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4183 = writer.prefix("AssociationId");
    if let Some(var_4184) = &input.association_id {
        scope_4183.string(var_4184);
    }
    #[allow(unused_mut)]
    let mut scope_4185 = writer.prefix("DryRun");
    if let Some(var_4186) = &input.dry_run {
        scope_4185.boolean(*var_4186);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_subnet_cidr_block(
    input: &crate::input::DisassociateSubnetCidrBlockInput,
) -> 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, "DisassociateSubnetCidrBlock", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4187 = writer.prefix("AssociationId");
    if let Some(var_4188) = &input.association_id {
        scope_4187.string(var_4188);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_transit_gateway_multicast_domain(
    input: &crate::input::DisassociateTransitGatewayMulticastDomainInput,
) -> 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,
        "DisassociateTransitGatewayMulticastDomain",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4189 = writer.prefix("TransitGatewayMulticastDomainId");
    if let Some(var_4190) = &input.transit_gateway_multicast_domain_id {
        scope_4189.string(var_4190);
    }
    #[allow(unused_mut)]
    let mut scope_4191 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_4192) = &input.transit_gateway_attachment_id {
        scope_4191.string(var_4192);
    }
    #[allow(unused_mut)]
    let mut scope_4193 = writer.prefix("SubnetIds");
    if let Some(var_4194) = &input.subnet_ids {
        let mut list_4196 = scope_4193.start_list(true, Some("item"));
        for item_4195 in var_4194 {
            #[allow(unused_mut)]
            let mut entry_4197 = list_4196.entry();
            entry_4197.string(item_4195);
        }
        list_4196.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4198 = writer.prefix("DryRun");
    if let Some(var_4199) = &input.dry_run {
        scope_4198.boolean(*var_4199);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_transit_gateway_policy_table(
    input: &crate::input::DisassociateTransitGatewayPolicyTableInput,
) -> 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,
        "DisassociateTransitGatewayPolicyTable",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4200 = writer.prefix("TransitGatewayPolicyTableId");
    if let Some(var_4201) = &input.transit_gateway_policy_table_id {
        scope_4200.string(var_4201);
    }
    #[allow(unused_mut)]
    let mut scope_4202 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_4203) = &input.transit_gateway_attachment_id {
        scope_4202.string(var_4203);
    }
    #[allow(unused_mut)]
    let mut scope_4204 = writer.prefix("DryRun");
    if let Some(var_4205) = &input.dry_run {
        scope_4204.boolean(*var_4205);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_transit_gateway_route_table(
    input: &crate::input::DisassociateTransitGatewayRouteTableInput,
) -> 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,
        "DisassociateTransitGatewayRouteTable",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4206 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_4207) = &input.transit_gateway_route_table_id {
        scope_4206.string(var_4207);
    }
    #[allow(unused_mut)]
    let mut scope_4208 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_4209) = &input.transit_gateway_attachment_id {
        scope_4208.string(var_4209);
    }
    #[allow(unused_mut)]
    let mut scope_4210 = writer.prefix("DryRun");
    if let Some(var_4211) = &input.dry_run {
        scope_4210.boolean(*var_4211);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_trunk_interface(
    input: &crate::input::DisassociateTrunkInterfaceInput,
) -> 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, "DisassociateTrunkInterface", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4212 = writer.prefix("AssociationId");
    if let Some(var_4213) = &input.association_id {
        scope_4212.string(var_4213);
    }
    #[allow(unused_mut)]
    let mut scope_4214 = writer.prefix("ClientToken");
    if let Some(var_4215) = &input.client_token {
        scope_4214.string(var_4215);
    }
    #[allow(unused_mut)]
    let mut scope_4216 = writer.prefix("DryRun");
    if let Some(var_4217) = &input.dry_run {
        scope_4216.boolean(*var_4217);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_disassociate_vpc_cidr_block(
    input: &crate::input::DisassociateVpcCidrBlockInput,
) -> 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, "DisassociateVpcCidrBlock", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4218 = writer.prefix("AssociationId");
    if let Some(var_4219) = &input.association_id {
        scope_4218.string(var_4219);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

pub fn serialize_operation_crate_operation_enable_fast_launch(
    input: &crate::input::EnableFastLaunchInput,
) -> 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, "EnableFastLaunch", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4222 = writer.prefix("ImageId");
    if let Some(var_4223) = &input.image_id {
        scope_4222.string(var_4223);
    }
    #[allow(unused_mut)]
    let mut scope_4224 = writer.prefix("ResourceType");
    if let Some(var_4225) = &input.resource_type {
        scope_4224.string(var_4225);
    }
    #[allow(unused_mut)]
    let mut scope_4226 = writer.prefix("SnapshotConfiguration");
    if let Some(var_4227) = &input.snapshot_configuration {
        crate::query_ser::serialize_structure_crate_model_fast_launch_snapshot_configuration_request(scope_4226, var_4227)?;
    }
    #[allow(unused_mut)]
    let mut scope_4228 = writer.prefix("LaunchTemplate");
    if let Some(var_4229) = &input.launch_template {
        crate::query_ser::serialize_structure_crate_model_fast_launch_launch_template_specification_request(scope_4228, var_4229)?;
    }
    #[allow(unused_mut)]
    let mut scope_4230 = writer.prefix("MaxParallelLaunches");
    if let Some(var_4231) = &input.max_parallel_launches {
        scope_4230.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4231).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4232 = writer.prefix("DryRun");
    if let Some(var_4233) = &input.dry_run {
        scope_4232.boolean(*var_4233);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_enable_fast_snapshot_restores(
    input: &crate::input::EnableFastSnapshotRestoresInput,
) -> 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, "EnableFastSnapshotRestores", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4234 = writer.prefix("AvailabilityZone");
    if let Some(var_4235) = &input.availability_zones {
        let mut list_4237 = scope_4234.start_list(true, Some("AvailabilityZone"));
        for item_4236 in var_4235 {
            #[allow(unused_mut)]
            let mut entry_4238 = list_4237.entry();
            entry_4238.string(item_4236);
        }
        list_4237.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4239 = writer.prefix("SourceSnapshotId");
    if let Some(var_4240) = &input.source_snapshot_ids {
        let mut list_4242 = scope_4239.start_list(true, Some("SnapshotId"));
        for item_4241 in var_4240 {
            #[allow(unused_mut)]
            let mut entry_4243 = list_4242.entry();
            entry_4243.string(item_4241);
        }
        list_4242.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4244 = writer.prefix("DryRun");
    if let Some(var_4245) = &input.dry_run {
        scope_4244.boolean(*var_4245);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_enable_image_deprecation(
    input: &crate::input::EnableImageDeprecationInput,
) -> 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, "EnableImageDeprecation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4246 = writer.prefix("ImageId");
    if let Some(var_4247) = &input.image_id {
        scope_4246.string(var_4247);
    }
    #[allow(unused_mut)]
    let mut scope_4248 = writer.prefix("DeprecateAt");
    if let Some(var_4249) = &input.deprecate_at {
        scope_4248.date_time(var_4249, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_4250 = writer.prefix("DryRun");
    if let Some(var_4251) = &input.dry_run {
        scope_4250.boolean(*var_4251);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_enable_ipam_organization_admin_account(
    input: &crate::input::EnableIpamOrganizationAdminAccountInput,
) -> 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,
        "EnableIpamOrganizationAdminAccount",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4252 = writer.prefix("DryRun");
    if let Some(var_4253) = &input.dry_run {
        scope_4252.boolean(*var_4253);
    }
    #[allow(unused_mut)]
    let mut scope_4254 = writer.prefix("DelegatedAdminAccountId");
    if let Some(var_4255) = &input.delegated_admin_account_id {
        scope_4254.string(var_4255);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

pub fn serialize_operation_crate_operation_enable_transit_gateway_route_table_propagation(
    input: &crate::input::EnableTransitGatewayRouteTablePropagationInput,
) -> 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,
        "EnableTransitGatewayRouteTablePropagation",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4258 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_4259) = &input.transit_gateway_route_table_id {
        scope_4258.string(var_4259);
    }
    #[allow(unused_mut)]
    let mut scope_4260 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_4261) = &input.transit_gateway_attachment_id {
        scope_4260.string(var_4261);
    }
    #[allow(unused_mut)]
    let mut scope_4262 = writer.prefix("DryRun");
    if let Some(var_4263) = &input.dry_run {
        scope_4262.boolean(*var_4263);
    }
    #[allow(unused_mut)]
    let mut scope_4264 = writer.prefix("TransitGatewayRouteTableAnnouncementId");
    if let Some(var_4265) = &input.transit_gateway_route_table_announcement_id {
        scope_4264.string(var_4265);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_enable_vgw_route_propagation(
    input: &crate::input::EnableVgwRoutePropagationInput,
) -> 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, "EnableVgwRoutePropagation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4266 = writer.prefix("GatewayId");
    if let Some(var_4267) = &input.gateway_id {
        scope_4266.string(var_4267);
    }
    #[allow(unused_mut)]
    let mut scope_4268 = writer.prefix("RouteTableId");
    if let Some(var_4269) = &input.route_table_id {
        scope_4268.string(var_4269);
    }
    #[allow(unused_mut)]
    let mut scope_4270 = writer.prefix("DryRun");
    if let Some(var_4271) = &input.dry_run {
        scope_4270.boolean(*var_4271);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_enable_volume_io(
    input: &crate::input::EnableVolumeIoInput,
) -> 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, "EnableVolumeIO", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4272 = writer.prefix("DryRun");
    if let Some(var_4273) = &input.dry_run {
        scope_4272.boolean(*var_4273);
    }
    #[allow(unused_mut)]
    let mut scope_4274 = writer.prefix("VolumeId");
    if let Some(var_4275) = &input.volume_id {
        scope_4274.string(var_4275);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_enable_vpc_classic_link(
    input: &crate::input::EnableVpcClassicLinkInput,
) -> 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, "EnableVpcClassicLink", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4276 = writer.prefix("DryRun");
    if let Some(var_4277) = &input.dry_run {
        scope_4276.boolean(*var_4277);
    }
    #[allow(unused_mut)]
    let mut scope_4278 = writer.prefix("VpcId");
    if let Some(var_4279) = &input.vpc_id {
        scope_4278.string(var_4279);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_enable_vpc_classic_link_dns_support(
    input: &crate::input::EnableVpcClassicLinkDnsSupportInput,
) -> 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,
        "EnableVpcClassicLinkDnsSupport",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4280 = writer.prefix("VpcId");
    if let Some(var_4281) = &input.vpc_id {
        scope_4280.string(var_4281);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_export_client_vpn_client_certificate_revocation_list(
    input: &crate::input::ExportClientVpnClientCertificateRevocationListInput,
) -> 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,
        "ExportClientVpnClientCertificateRevocationList",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4282 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_4283) = &input.client_vpn_endpoint_id {
        scope_4282.string(var_4283);
    }
    #[allow(unused_mut)]
    let mut scope_4284 = writer.prefix("DryRun");
    if let Some(var_4285) = &input.dry_run {
        scope_4284.boolean(*var_4285);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_export_client_vpn_client_configuration(
    input: &crate::input::ExportClientVpnClientConfigurationInput,
) -> 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,
        "ExportClientVpnClientConfiguration",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4286 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_4287) = &input.client_vpn_endpoint_id {
        scope_4286.string(var_4287);
    }
    #[allow(unused_mut)]
    let mut scope_4288 = writer.prefix("DryRun");
    if let Some(var_4289) = &input.dry_run {
        scope_4288.boolean(*var_4289);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_export_image(
    input: &crate::input::ExportImageInput,
) -> 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, "ExportImage", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4290 = writer.prefix("ClientToken");
    if let Some(var_4291) = &input.client_token {
        scope_4290.string(var_4291);
    }
    #[allow(unused_mut)]
    let mut scope_4292 = writer.prefix("Description");
    if let Some(var_4293) = &input.description {
        scope_4292.string(var_4293);
    }
    #[allow(unused_mut)]
    let mut scope_4294 = writer.prefix("DiskImageFormat");
    if let Some(var_4295) = &input.disk_image_format {
        scope_4294.string(var_4295.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4296 = writer.prefix("DryRun");
    if let Some(var_4297) = &input.dry_run {
        scope_4296.boolean(*var_4297);
    }
    #[allow(unused_mut)]
    let mut scope_4298 = writer.prefix("ImageId");
    if let Some(var_4299) = &input.image_id {
        scope_4298.string(var_4299);
    }
    #[allow(unused_mut)]
    let mut scope_4300 = writer.prefix("S3ExportLocation");
    if let Some(var_4301) = &input.s3_export_location {
        crate::query_ser::serialize_structure_crate_model_export_task_s3_location_request(
            scope_4300, var_4301,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4302 = writer.prefix("RoleName");
    if let Some(var_4303) = &input.role_name {
        scope_4302.string(var_4303);
    }
    #[allow(unused_mut)]
    let mut scope_4304 = writer.prefix("TagSpecification");
    if let Some(var_4305) = &input.tag_specifications {
        let mut list_4307 = scope_4304.start_list(true, Some("item"));
        for item_4306 in var_4305 {
            #[allow(unused_mut)]
            let mut entry_4308 = list_4307.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_4308, item_4306,
            )?;
        }
        list_4307.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_export_transit_gateway_routes(
    input: &crate::input::ExportTransitGatewayRoutesInput,
) -> 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, "ExportTransitGatewayRoutes", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4309 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_4310) = &input.transit_gateway_route_table_id {
        scope_4309.string(var_4310);
    }
    #[allow(unused_mut)]
    let mut scope_4311 = writer.prefix("Filter");
    if let Some(var_4312) = &input.filters {
        let mut list_4314 = scope_4311.start_list(true, Some("Filter"));
        for item_4313 in var_4312 {
            #[allow(unused_mut)]
            let mut entry_4315 = list_4314.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4315, item_4313)?;
        }
        list_4314.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4316 = writer.prefix("S3Bucket");
    if let Some(var_4317) = &input.s3_bucket {
        scope_4316.string(var_4317);
    }
    #[allow(unused_mut)]
    let mut scope_4318 = writer.prefix("DryRun");
    if let Some(var_4319) = &input.dry_run {
        scope_4318.boolean(*var_4319);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_associated_enclave_certificate_iam_roles(
    input: &crate::input::GetAssociatedEnclaveCertificateIamRolesInput,
) -> 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,
        "GetAssociatedEnclaveCertificateIamRoles",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4320 = writer.prefix("CertificateArn");
    if let Some(var_4321) = &input.certificate_arn {
        scope_4320.string(var_4321);
    }
    #[allow(unused_mut)]
    let mut scope_4322 = writer.prefix("DryRun");
    if let Some(var_4323) = &input.dry_run {
        scope_4322.boolean(*var_4323);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_associated_ipv6_pool_cidrs(
    input: &crate::input::GetAssociatedIpv6PoolCidrsInput,
) -> 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, "GetAssociatedIpv6PoolCidrs", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4324 = writer.prefix("PoolId");
    if let Some(var_4325) = &input.pool_id {
        scope_4324.string(var_4325);
    }
    #[allow(unused_mut)]
    let mut scope_4326 = writer.prefix("NextToken");
    if let Some(var_4327) = &input.next_token {
        scope_4326.string(var_4327);
    }
    #[allow(unused_mut)]
    let mut scope_4328 = writer.prefix("MaxResults");
    if let Some(var_4329) = &input.max_results {
        scope_4328.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4329).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4330 = writer.prefix("DryRun");
    if let Some(var_4331) = &input.dry_run {
        scope_4330.boolean(*var_4331);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_capacity_reservation_usage(
    input: &crate::input::GetCapacityReservationUsageInput,
) -> 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, "GetCapacityReservationUsage", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4332 = writer.prefix("CapacityReservationId");
    if let Some(var_4333) = &input.capacity_reservation_id {
        scope_4332.string(var_4333);
    }
    #[allow(unused_mut)]
    let mut scope_4334 = writer.prefix("NextToken");
    if let Some(var_4335) = &input.next_token {
        scope_4334.string(var_4335);
    }
    #[allow(unused_mut)]
    let mut scope_4336 = writer.prefix("MaxResults");
    if let Some(var_4337) = &input.max_results {
        scope_4336.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4337).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4338 = writer.prefix("DryRun");
    if let Some(var_4339) = &input.dry_run {
        scope_4338.boolean(*var_4339);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_coip_pool_usage(
    input: &crate::input::GetCoipPoolUsageInput,
) -> 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, "GetCoipPoolUsage", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4340 = writer.prefix("PoolId");
    if let Some(var_4341) = &input.pool_id {
        scope_4340.string(var_4341);
    }
    #[allow(unused_mut)]
    let mut scope_4342 = writer.prefix("Filter");
    if let Some(var_4343) = &input.filters {
        let mut list_4345 = scope_4342.start_list(true, Some("Filter"));
        for item_4344 in var_4343 {
            #[allow(unused_mut)]
            let mut entry_4346 = list_4345.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4346, item_4344)?;
        }
        list_4345.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4347 = writer.prefix("MaxResults");
    if let Some(var_4348) = &input.max_results {
        scope_4347.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4348).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4349 = writer.prefix("NextToken");
    if let Some(var_4350) = &input.next_token {
        scope_4349.string(var_4350);
    }
    #[allow(unused_mut)]
    let mut scope_4351 = writer.prefix("DryRun");
    if let Some(var_4352) = &input.dry_run {
        scope_4351.boolean(*var_4352);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_console_output(
    input: &crate::input::GetConsoleOutputInput,
) -> 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, "GetConsoleOutput", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4353 = writer.prefix("InstanceId");
    if let Some(var_4354) = &input.instance_id {
        scope_4353.string(var_4354);
    }
    #[allow(unused_mut)]
    let mut scope_4355 = writer.prefix("DryRun");
    if let Some(var_4356) = &input.dry_run {
        scope_4355.boolean(*var_4356);
    }
    #[allow(unused_mut)]
    let mut scope_4357 = writer.prefix("Latest");
    if let Some(var_4358) = &input.latest {
        scope_4357.boolean(*var_4358);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_console_screenshot(
    input: &crate::input::GetConsoleScreenshotInput,
) -> 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, "GetConsoleScreenshot", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4359 = writer.prefix("DryRun");
    if let Some(var_4360) = &input.dry_run {
        scope_4359.boolean(*var_4360);
    }
    #[allow(unused_mut)]
    let mut scope_4361 = writer.prefix("InstanceId");
    if let Some(var_4362) = &input.instance_id {
        scope_4361.string(var_4362);
    }
    #[allow(unused_mut)]
    let mut scope_4363 = writer.prefix("WakeUp");
    if let Some(var_4364) = &input.wake_up {
        scope_4363.boolean(*var_4364);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_default_credit_specification(
    input: &crate::input::GetDefaultCreditSpecificationInput,
) -> 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, "GetDefaultCreditSpecification", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4365 = writer.prefix("DryRun");
    if let Some(var_4366) = &input.dry_run {
        scope_4365.boolean(*var_4366);
    }
    #[allow(unused_mut)]
    let mut scope_4367 = writer.prefix("InstanceFamily");
    if let Some(var_4368) = &input.instance_family {
        scope_4367.string(var_4368.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

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

pub fn serialize_operation_crate_operation_get_flow_logs_integration_template(
    input: &crate::input::GetFlowLogsIntegrationTemplateInput,
) -> 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,
        "GetFlowLogsIntegrationTemplate",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4373 = writer.prefix("DryRun");
    if let Some(var_4374) = &input.dry_run {
        scope_4373.boolean(*var_4374);
    }
    #[allow(unused_mut)]
    let mut scope_4375 = writer.prefix("FlowLogId");
    if let Some(var_4376) = &input.flow_log_id {
        scope_4375.string(var_4376);
    }
    #[allow(unused_mut)]
    let mut scope_4377 = writer.prefix("ConfigDeliveryS3DestinationArn");
    if let Some(var_4378) = &input.config_delivery_s3_destination_arn {
        scope_4377.string(var_4378);
    }
    #[allow(unused_mut)]
    let mut scope_4379 = writer.prefix("IntegrateService");
    if let Some(var_4380) = &input.integrate_services {
        crate::query_ser::serialize_structure_crate_model_integrate_services(scope_4379, var_4380)?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_groups_for_capacity_reservation(
    input: &crate::input::GetGroupsForCapacityReservationInput,
) -> 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,
        "GetGroupsForCapacityReservation",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4381 = writer.prefix("CapacityReservationId");
    if let Some(var_4382) = &input.capacity_reservation_id {
        scope_4381.string(var_4382);
    }
    #[allow(unused_mut)]
    let mut scope_4383 = writer.prefix("NextToken");
    if let Some(var_4384) = &input.next_token {
        scope_4383.string(var_4384);
    }
    #[allow(unused_mut)]
    let mut scope_4385 = writer.prefix("MaxResults");
    if let Some(var_4386) = &input.max_results {
        scope_4385.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4386).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4387 = writer.prefix("DryRun");
    if let Some(var_4388) = &input.dry_run {
        scope_4387.boolean(*var_4388);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_host_reservation_purchase_preview(
    input: &crate::input::GetHostReservationPurchasePreviewInput,
) -> 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,
        "GetHostReservationPurchasePreview",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4389 = writer.prefix("HostIdSet");
    if let Some(var_4390) = &input.host_id_set {
        let mut list_4392 = scope_4389.start_list(true, Some("item"));
        for item_4391 in var_4390 {
            #[allow(unused_mut)]
            let mut entry_4393 = list_4392.entry();
            entry_4393.string(item_4391);
        }
        list_4392.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4394 = writer.prefix("OfferingId");
    if let Some(var_4395) = &input.offering_id {
        scope_4394.string(var_4395);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_instance_types_from_instance_requirements(
    input: &crate::input::GetInstanceTypesFromInstanceRequirementsInput,
) -> 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,
        "GetInstanceTypesFromInstanceRequirements",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4396 = writer.prefix("DryRun");
    if let Some(var_4397) = &input.dry_run {
        scope_4396.boolean(*var_4397);
    }
    #[allow(unused_mut)]
    let mut scope_4398 = writer.prefix("ArchitectureType");
    if let Some(var_4399) = &input.architecture_types {
        let mut list_4401 = scope_4398.start_list(true, Some("item"));
        for item_4400 in var_4399 {
            #[allow(unused_mut)]
            let mut entry_4402 = list_4401.entry();
            entry_4402.string(item_4400.as_str());
        }
        list_4401.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4403 = writer.prefix("VirtualizationType");
    if let Some(var_4404) = &input.virtualization_types {
        let mut list_4406 = scope_4403.start_list(true, Some("item"));
        for item_4405 in var_4404 {
            #[allow(unused_mut)]
            let mut entry_4407 = list_4406.entry();
            entry_4407.string(item_4405.as_str());
        }
        list_4406.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4408 = writer.prefix("InstanceRequirements");
    if let Some(var_4409) = &input.instance_requirements {
        crate::query_ser::serialize_structure_crate_model_instance_requirements_request(
            scope_4408, var_4409,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4410 = writer.prefix("MaxResults");
    if let Some(var_4411) = &input.max_results {
        scope_4410.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4411).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4412 = writer.prefix("NextToken");
    if let Some(var_4413) = &input.next_token {
        scope_4412.string(var_4413);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_instance_uefi_data(
    input: &crate::input::GetInstanceUefiDataInput,
) -> 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, "GetInstanceUefiData", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4414 = writer.prefix("InstanceId");
    if let Some(var_4415) = &input.instance_id {
        scope_4414.string(var_4415);
    }
    #[allow(unused_mut)]
    let mut scope_4416 = writer.prefix("DryRun");
    if let Some(var_4417) = &input.dry_run {
        scope_4416.boolean(*var_4417);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_ipam_address_history(
    input: &crate::input::GetIpamAddressHistoryInput,
) -> 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, "GetIpamAddressHistory", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4418 = writer.prefix("DryRun");
    if let Some(var_4419) = &input.dry_run {
        scope_4418.boolean(*var_4419);
    }
    #[allow(unused_mut)]
    let mut scope_4420 = writer.prefix("Cidr");
    if let Some(var_4421) = &input.cidr {
        scope_4420.string(var_4421);
    }
    #[allow(unused_mut)]
    let mut scope_4422 = writer.prefix("IpamScopeId");
    if let Some(var_4423) = &input.ipam_scope_id {
        scope_4422.string(var_4423);
    }
    #[allow(unused_mut)]
    let mut scope_4424 = writer.prefix("VpcId");
    if let Some(var_4425) = &input.vpc_id {
        scope_4424.string(var_4425);
    }
    #[allow(unused_mut)]
    let mut scope_4426 = writer.prefix("StartTime");
    if let Some(var_4427) = &input.start_time {
        scope_4426.date_time(var_4427, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_4428 = writer.prefix("EndTime");
    if let Some(var_4429) = &input.end_time {
        scope_4428.date_time(var_4429, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_4430 = writer.prefix("MaxResults");
    if let Some(var_4431) = &input.max_results {
        scope_4430.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4431).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4432 = writer.prefix("NextToken");
    if let Some(var_4433) = &input.next_token {
        scope_4432.string(var_4433);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_ipam_pool_allocations(
    input: &crate::input::GetIpamPoolAllocationsInput,
) -> 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, "GetIpamPoolAllocations", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4434 = writer.prefix("DryRun");
    if let Some(var_4435) = &input.dry_run {
        scope_4434.boolean(*var_4435);
    }
    #[allow(unused_mut)]
    let mut scope_4436 = writer.prefix("IpamPoolId");
    if let Some(var_4437) = &input.ipam_pool_id {
        scope_4436.string(var_4437);
    }
    #[allow(unused_mut)]
    let mut scope_4438 = writer.prefix("IpamPoolAllocationId");
    if let Some(var_4439) = &input.ipam_pool_allocation_id {
        scope_4438.string(var_4439);
    }
    #[allow(unused_mut)]
    let mut scope_4440 = writer.prefix("Filter");
    if let Some(var_4441) = &input.filters {
        let mut list_4443 = scope_4440.start_list(true, Some("Filter"));
        for item_4442 in var_4441 {
            #[allow(unused_mut)]
            let mut entry_4444 = list_4443.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4444, item_4442)?;
        }
        list_4443.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4445 = writer.prefix("MaxResults");
    if let Some(var_4446) = &input.max_results {
        scope_4445.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4446).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4447 = writer.prefix("NextToken");
    if let Some(var_4448) = &input.next_token {
        scope_4447.string(var_4448);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_ipam_pool_cidrs(
    input: &crate::input::GetIpamPoolCidrsInput,
) -> 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, "GetIpamPoolCidrs", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4449 = writer.prefix("DryRun");
    if let Some(var_4450) = &input.dry_run {
        scope_4449.boolean(*var_4450);
    }
    #[allow(unused_mut)]
    let mut scope_4451 = writer.prefix("IpamPoolId");
    if let Some(var_4452) = &input.ipam_pool_id {
        scope_4451.string(var_4452);
    }
    #[allow(unused_mut)]
    let mut scope_4453 = writer.prefix("Filter");
    if let Some(var_4454) = &input.filters {
        let mut list_4456 = scope_4453.start_list(true, Some("Filter"));
        for item_4455 in var_4454 {
            #[allow(unused_mut)]
            let mut entry_4457 = list_4456.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4457, item_4455)?;
        }
        list_4456.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4458 = writer.prefix("MaxResults");
    if let Some(var_4459) = &input.max_results {
        scope_4458.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4459).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4460 = writer.prefix("NextToken");
    if let Some(var_4461) = &input.next_token {
        scope_4460.string(var_4461);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_ipam_resource_cidrs(
    input: &crate::input::GetIpamResourceCidrsInput,
) -> 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, "GetIpamResourceCidrs", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4462 = writer.prefix("DryRun");
    if let Some(var_4463) = &input.dry_run {
        scope_4462.boolean(*var_4463);
    }
    #[allow(unused_mut)]
    let mut scope_4464 = writer.prefix("Filter");
    if let Some(var_4465) = &input.filters {
        let mut list_4467 = scope_4464.start_list(true, Some("Filter"));
        for item_4466 in var_4465 {
            #[allow(unused_mut)]
            let mut entry_4468 = list_4467.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4468, item_4466)?;
        }
        list_4467.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4469 = writer.prefix("MaxResults");
    if let Some(var_4470) = &input.max_results {
        scope_4469.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4470).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4471 = writer.prefix("NextToken");
    if let Some(var_4472) = &input.next_token {
        scope_4471.string(var_4472);
    }
    #[allow(unused_mut)]
    let mut scope_4473 = writer.prefix("IpamScopeId");
    if let Some(var_4474) = &input.ipam_scope_id {
        scope_4473.string(var_4474);
    }
    #[allow(unused_mut)]
    let mut scope_4475 = writer.prefix("IpamPoolId");
    if let Some(var_4476) = &input.ipam_pool_id {
        scope_4475.string(var_4476);
    }
    #[allow(unused_mut)]
    let mut scope_4477 = writer.prefix("ResourceId");
    if let Some(var_4478) = &input.resource_id {
        scope_4477.string(var_4478);
    }
    #[allow(unused_mut)]
    let mut scope_4479 = writer.prefix("ResourceType");
    if let Some(var_4480) = &input.resource_type {
        scope_4479.string(var_4480.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4481 = writer.prefix("ResourceTag");
    if let Some(var_4482) = &input.resource_tag {
        crate::query_ser::serialize_structure_crate_model_request_ipam_resource_tag(
            scope_4481, var_4482,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_4483 = writer.prefix("ResourceOwner");
    if let Some(var_4484) = &input.resource_owner {
        scope_4483.string(var_4484);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_launch_template_data(
    input: &crate::input::GetLaunchTemplateDataInput,
) -> 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, "GetLaunchTemplateData", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4485 = writer.prefix("DryRun");
    if let Some(var_4486) = &input.dry_run {
        scope_4485.boolean(*var_4486);
    }
    #[allow(unused_mut)]
    let mut scope_4487 = writer.prefix("InstanceId");
    if let Some(var_4488) = &input.instance_id {
        scope_4487.string(var_4488);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_managed_prefix_list_associations(
    input: &crate::input::GetManagedPrefixListAssociationsInput,
) -> 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,
        "GetManagedPrefixListAssociations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4489 = writer.prefix("DryRun");
    if let Some(var_4490) = &input.dry_run {
        scope_4489.boolean(*var_4490);
    }
    #[allow(unused_mut)]
    let mut scope_4491 = writer.prefix("PrefixListId");
    if let Some(var_4492) = &input.prefix_list_id {
        scope_4491.string(var_4492);
    }
    #[allow(unused_mut)]
    let mut scope_4493 = writer.prefix("MaxResults");
    if let Some(var_4494) = &input.max_results {
        scope_4493.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4494).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4495 = writer.prefix("NextToken");
    if let Some(var_4496) = &input.next_token {
        scope_4495.string(var_4496);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_managed_prefix_list_entries(
    input: &crate::input::GetManagedPrefixListEntriesInput,
) -> 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, "GetManagedPrefixListEntries", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4497 = writer.prefix("DryRun");
    if let Some(var_4498) = &input.dry_run {
        scope_4497.boolean(*var_4498);
    }
    #[allow(unused_mut)]
    let mut scope_4499 = writer.prefix("PrefixListId");
    if let Some(var_4500) = &input.prefix_list_id {
        scope_4499.string(var_4500);
    }
    #[allow(unused_mut)]
    let mut scope_4501 = writer.prefix("TargetVersion");
    if let Some(var_4502) = &input.target_version {
        scope_4501.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4502).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4503 = writer.prefix("MaxResults");
    if let Some(var_4504) = &input.max_results {
        scope_4503.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4504).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4505 = writer.prefix("NextToken");
    if let Some(var_4506) = &input.next_token {
        scope_4505.string(var_4506);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_network_insights_access_scope_analysis_findings(
    input: &crate::input::GetNetworkInsightsAccessScopeAnalysisFindingsInput,
) -> 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,
        "GetNetworkInsightsAccessScopeAnalysisFindings",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4507 = writer.prefix("NetworkInsightsAccessScopeAnalysisId");
    if let Some(var_4508) = &input.network_insights_access_scope_analysis_id {
        scope_4507.string(var_4508);
    }
    #[allow(unused_mut)]
    let mut scope_4509 = writer.prefix("MaxResults");
    if let Some(var_4510) = &input.max_results {
        scope_4509.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4510).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4511 = writer.prefix("NextToken");
    if let Some(var_4512) = &input.next_token {
        scope_4511.string(var_4512);
    }
    #[allow(unused_mut)]
    let mut scope_4513 = writer.prefix("DryRun");
    if let Some(var_4514) = &input.dry_run {
        scope_4513.boolean(*var_4514);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_network_insights_access_scope_content(
    input: &crate::input::GetNetworkInsightsAccessScopeContentInput,
) -> 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,
        "GetNetworkInsightsAccessScopeContent",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4515 = writer.prefix("NetworkInsightsAccessScopeId");
    if let Some(var_4516) = &input.network_insights_access_scope_id {
        scope_4515.string(var_4516);
    }
    #[allow(unused_mut)]
    let mut scope_4517 = writer.prefix("DryRun");
    if let Some(var_4518) = &input.dry_run {
        scope_4517.boolean(*var_4518);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_password_data(
    input: &crate::input::GetPasswordDataInput,
) -> 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, "GetPasswordData", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4519 = writer.prefix("InstanceId");
    if let Some(var_4520) = &input.instance_id {
        scope_4519.string(var_4520);
    }
    #[allow(unused_mut)]
    let mut scope_4521 = writer.prefix("DryRun");
    if let Some(var_4522) = &input.dry_run {
        scope_4521.boolean(*var_4522);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_reserved_instances_exchange_quote(
    input: &crate::input::GetReservedInstancesExchangeQuoteInput,
) -> 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,
        "GetReservedInstancesExchangeQuote",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4523 = writer.prefix("DryRun");
    if let Some(var_4524) = &input.dry_run {
        scope_4523.boolean(*var_4524);
    }
    #[allow(unused_mut)]
    let mut scope_4525 = writer.prefix("ReservedInstanceId");
    if let Some(var_4526) = &input.reserved_instance_ids {
        let mut list_4528 = scope_4525.start_list(true, Some("ReservedInstanceId"));
        for item_4527 in var_4526 {
            #[allow(unused_mut)]
            let mut entry_4529 = list_4528.entry();
            entry_4529.string(item_4527);
        }
        list_4528.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4530 = writer.prefix("TargetConfiguration");
    if let Some(var_4531) = &input.target_configurations {
        let mut list_4533 = scope_4530.start_list(true, Some("TargetConfigurationRequest"));
        for item_4532 in var_4531 {
            #[allow(unused_mut)]
            let mut entry_4534 = list_4533.entry();
            crate::query_ser::serialize_structure_crate_model_target_configuration_request(
                entry_4534, item_4532,
            )?;
        }
        list_4533.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

pub fn serialize_operation_crate_operation_get_spot_placement_scores(
    input: &crate::input::GetSpotPlacementScoresInput,
) -> 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, "GetSpotPlacementScores", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4537 = writer.prefix("InstanceType");
    if let Some(var_4538) = &input.instance_types {
        let mut list_4540 = scope_4537.start_list(true, None);
        for item_4539 in var_4538 {
            #[allow(unused_mut)]
            let mut entry_4541 = list_4540.entry();
            entry_4541.string(item_4539);
        }
        list_4540.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4542 = writer.prefix("TargetCapacity");
    if let Some(var_4543) = &input.target_capacity {
        scope_4542.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4543).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4544 = writer.prefix("TargetCapacityUnitType");
    if let Some(var_4545) = &input.target_capacity_unit_type {
        scope_4544.string(var_4545.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_4546 = writer.prefix("SingleAvailabilityZone");
    if let Some(var_4547) = &input.single_availability_zone {
        scope_4546.boolean(*var_4547);
    }
    #[allow(unused_mut)]
    let mut scope_4548 = writer.prefix("RegionName");
    if let Some(var_4549) = &input.region_names {
        let mut list_4551 = scope_4548.start_list(true, None);
        for item_4550 in var_4549 {
            #[allow(unused_mut)]
            let mut entry_4552 = list_4551.entry();
            entry_4552.string(item_4550);
        }
        list_4551.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4553 = writer.prefix("InstanceRequirementsWithMetadata");
    if let Some(var_4554) = &input.instance_requirements_with_metadata {
        crate::query_ser::serialize_structure_crate_model_instance_requirements_with_metadata_request(scope_4553, var_4554)?;
    }
    #[allow(unused_mut)]
    let mut scope_4555 = writer.prefix("DryRun");
    if let Some(var_4556) = &input.dry_run {
        scope_4555.boolean(*var_4556);
    }
    #[allow(unused_mut)]
    let mut scope_4557 = writer.prefix("MaxResults");
    if let Some(var_4558) = &input.max_results {
        scope_4557.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4558).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4559 = writer.prefix("NextToken");
    if let Some(var_4560) = &input.next_token {
        scope_4559.string(var_4560);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_subnet_cidr_reservations(
    input: &crate::input::GetSubnetCidrReservationsInput,
) -> 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, "GetSubnetCidrReservations", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4561 = writer.prefix("Filter");
    if let Some(var_4562) = &input.filters {
        let mut list_4564 = scope_4561.start_list(true, Some("Filter"));
        for item_4563 in var_4562 {
            #[allow(unused_mut)]
            let mut entry_4565 = list_4564.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4565, item_4563)?;
        }
        list_4564.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4566 = writer.prefix("SubnetId");
    if let Some(var_4567) = &input.subnet_id {
        scope_4566.string(var_4567);
    }
    #[allow(unused_mut)]
    let mut scope_4568 = writer.prefix("DryRun");
    if let Some(var_4569) = &input.dry_run {
        scope_4568.boolean(*var_4569);
    }
    #[allow(unused_mut)]
    let mut scope_4570 = writer.prefix("NextToken");
    if let Some(var_4571) = &input.next_token {
        scope_4570.string(var_4571);
    }
    #[allow(unused_mut)]
    let mut scope_4572 = writer.prefix("MaxResults");
    if let Some(var_4573) = &input.max_results {
        scope_4572.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4573).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_transit_gateway_attachment_propagations(
    input: &crate::input::GetTransitGatewayAttachmentPropagationsInput,
) -> 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,
        "GetTransitGatewayAttachmentPropagations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4574 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_4575) = &input.transit_gateway_attachment_id {
        scope_4574.string(var_4575);
    }
    #[allow(unused_mut)]
    let mut scope_4576 = writer.prefix("Filter");
    if let Some(var_4577) = &input.filters {
        let mut list_4579 = scope_4576.start_list(true, Some("Filter"));
        for item_4578 in var_4577 {
            #[allow(unused_mut)]
            let mut entry_4580 = list_4579.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4580, item_4578)?;
        }
        list_4579.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4581 = writer.prefix("MaxResults");
    if let Some(var_4582) = &input.max_results {
        scope_4581.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4582).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4583 = writer.prefix("NextToken");
    if let Some(var_4584) = &input.next_token {
        scope_4583.string(var_4584);
    }
    #[allow(unused_mut)]
    let mut scope_4585 = writer.prefix("DryRun");
    if let Some(var_4586) = &input.dry_run {
        scope_4585.boolean(*var_4586);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_transit_gateway_multicast_domain_associations(
    input: &crate::input::GetTransitGatewayMulticastDomainAssociationsInput,
) -> 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,
        "GetTransitGatewayMulticastDomainAssociations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4587 = writer.prefix("TransitGatewayMulticastDomainId");
    if let Some(var_4588) = &input.transit_gateway_multicast_domain_id {
        scope_4587.string(var_4588);
    }
    #[allow(unused_mut)]
    let mut scope_4589 = writer.prefix("Filter");
    if let Some(var_4590) = &input.filters {
        let mut list_4592 = scope_4589.start_list(true, Some("Filter"));
        for item_4591 in var_4590 {
            #[allow(unused_mut)]
            let mut entry_4593 = list_4592.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4593, item_4591)?;
        }
        list_4592.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4594 = writer.prefix("MaxResults");
    if let Some(var_4595) = &input.max_results {
        scope_4594.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4595).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4596 = writer.prefix("NextToken");
    if let Some(var_4597) = &input.next_token {
        scope_4596.string(var_4597);
    }
    #[allow(unused_mut)]
    let mut scope_4598 = writer.prefix("DryRun");
    if let Some(var_4599) = &input.dry_run {
        scope_4598.boolean(*var_4599);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_transit_gateway_policy_table_associations(
    input: &crate::input::GetTransitGatewayPolicyTableAssociationsInput,
) -> 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,
        "GetTransitGatewayPolicyTableAssociations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4600 = writer.prefix("TransitGatewayPolicyTableId");
    if let Some(var_4601) = &input.transit_gateway_policy_table_id {
        scope_4600.string(var_4601);
    }
    #[allow(unused_mut)]
    let mut scope_4602 = writer.prefix("Filter");
    if let Some(var_4603) = &input.filters {
        let mut list_4605 = scope_4602.start_list(true, Some("Filter"));
        for item_4604 in var_4603 {
            #[allow(unused_mut)]
            let mut entry_4606 = list_4605.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4606, item_4604)?;
        }
        list_4605.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4607 = writer.prefix("MaxResults");
    if let Some(var_4608) = &input.max_results {
        scope_4607.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4608).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4609 = writer.prefix("NextToken");
    if let Some(var_4610) = &input.next_token {
        scope_4609.string(var_4610);
    }
    #[allow(unused_mut)]
    let mut scope_4611 = writer.prefix("DryRun");
    if let Some(var_4612) = &input.dry_run {
        scope_4611.boolean(*var_4612);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_transit_gateway_policy_table_entries(
    input: &crate::input::GetTransitGatewayPolicyTableEntriesInput,
) -> 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,
        "GetTransitGatewayPolicyTableEntries",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4613 = writer.prefix("TransitGatewayPolicyTableId");
    if let Some(var_4614) = &input.transit_gateway_policy_table_id {
        scope_4613.string(var_4614);
    }
    #[allow(unused_mut)]
    let mut scope_4615 = writer.prefix("Filter");
    if let Some(var_4616) = &input.filters {
        let mut list_4618 = scope_4615.start_list(true, Some("Filter"));
        for item_4617 in var_4616 {
            #[allow(unused_mut)]
            let mut entry_4619 = list_4618.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4619, item_4617)?;
        }
        list_4618.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4620 = writer.prefix("MaxResults");
    if let Some(var_4621) = &input.max_results {
        scope_4620.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4621).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4622 = writer.prefix("NextToken");
    if let Some(var_4623) = &input.next_token {
        scope_4622.string(var_4623);
    }
    #[allow(unused_mut)]
    let mut scope_4624 = writer.prefix("DryRun");
    if let Some(var_4625) = &input.dry_run {
        scope_4624.boolean(*var_4625);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_transit_gateway_prefix_list_references(
    input: &crate::input::GetTransitGatewayPrefixListReferencesInput,
) -> 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,
        "GetTransitGatewayPrefixListReferences",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4626 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_4627) = &input.transit_gateway_route_table_id {
        scope_4626.string(var_4627);
    }
    #[allow(unused_mut)]
    let mut scope_4628 = writer.prefix("Filter");
    if let Some(var_4629) = &input.filters {
        let mut list_4631 = scope_4628.start_list(true, Some("Filter"));
        for item_4630 in var_4629 {
            #[allow(unused_mut)]
            let mut entry_4632 = list_4631.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4632, item_4630)?;
        }
        list_4631.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4633 = writer.prefix("MaxResults");
    if let Some(var_4634) = &input.max_results {
        scope_4633.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4634).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4635 = writer.prefix("NextToken");
    if let Some(var_4636) = &input.next_token {
        scope_4635.string(var_4636);
    }
    #[allow(unused_mut)]
    let mut scope_4637 = writer.prefix("DryRun");
    if let Some(var_4638) = &input.dry_run {
        scope_4637.boolean(*var_4638);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_transit_gateway_route_table_associations(
    input: &crate::input::GetTransitGatewayRouteTableAssociationsInput,
) -> 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,
        "GetTransitGatewayRouteTableAssociations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4639 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_4640) = &input.transit_gateway_route_table_id {
        scope_4639.string(var_4640);
    }
    #[allow(unused_mut)]
    let mut scope_4641 = writer.prefix("Filter");
    if let Some(var_4642) = &input.filters {
        let mut list_4644 = scope_4641.start_list(true, Some("Filter"));
        for item_4643 in var_4642 {
            #[allow(unused_mut)]
            let mut entry_4645 = list_4644.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4645, item_4643)?;
        }
        list_4644.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4646 = writer.prefix("MaxResults");
    if let Some(var_4647) = &input.max_results {
        scope_4646.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4647).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4648 = writer.prefix("NextToken");
    if let Some(var_4649) = &input.next_token {
        scope_4648.string(var_4649);
    }
    #[allow(unused_mut)]
    let mut scope_4650 = writer.prefix("DryRun");
    if let Some(var_4651) = &input.dry_run {
        scope_4650.boolean(*var_4651);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_transit_gateway_route_table_propagations(
    input: &crate::input::GetTransitGatewayRouteTablePropagationsInput,
) -> 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,
        "GetTransitGatewayRouteTablePropagations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4652 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_4653) = &input.transit_gateway_route_table_id {
        scope_4652.string(var_4653);
    }
    #[allow(unused_mut)]
    let mut scope_4654 = writer.prefix("Filter");
    if let Some(var_4655) = &input.filters {
        let mut list_4657 = scope_4654.start_list(true, Some("Filter"));
        for item_4656 in var_4655 {
            #[allow(unused_mut)]
            let mut entry_4658 = list_4657.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_4658, item_4656)?;
        }
        list_4657.finish();
    }
    #[allow(unused_mut)]
    let mut scope_4659 = writer.prefix("MaxResults");
    if let Some(var_4660) = &input.max_results {
        scope_4659.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4660).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4661 = writer.prefix("NextToken");
    if let Some(var_4662) = &input.next_token {
        scope_4661.string(var_4662);
    }
    #[allow(unused_mut)]
    let mut scope_4663 = writer.prefix("DryRun");
    if let Some(var_4664) = &input.dry_run {
        scope_4663.boolean(*var_4664);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_vpn_connection_device_sample_configuration(
    input: &crate::input::GetVpnConnectionDeviceSampleConfigurationInput,
) -> 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,
        "GetVpnConnectionDeviceSampleConfiguration",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4665 = writer.prefix("VpnConnectionId");
    if let Some(var_4666) = &input.vpn_connection_id {
        scope_4665.string(var_4666);
    }
    #[allow(unused_mut)]
    let mut scope_4667 = writer.prefix("VpnConnectionDeviceTypeId");
    if let Some(var_4668) = &input.vpn_connection_device_type_id {
        scope_4667.string(var_4668);
    }
    #[allow(unused_mut)]
    let mut scope_4669 = writer.prefix("InternetKeyExchangeVersion");
    if let Some(var_4670) = &input.internet_key_exchange_version {
        scope_4669.string(var_4670);
    }
    #[allow(unused_mut)]
    let mut scope_4671 = writer.prefix("DryRun");
    if let Some(var_4672) = &input.dry_run {
        scope_4671.boolean(*var_4672);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_vpn_connection_device_types(
    input: &crate::input::GetVpnConnectionDeviceTypesInput,
) -> 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, "GetVpnConnectionDeviceTypes", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4673 = writer.prefix("MaxResults");
    if let Some(var_4674) = &input.max_results {
        scope_4673.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_4674).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_4675 = writer.prefix("NextToken");
    if let Some(var_4676) = &input.next_token {
        scope_4675.string(var_4676);
    }
    #[allow(unused_mut)]
    let mut scope_4677 = writer.prefix("DryRun");
    if let Some(var_4678) = &input.dry_run {
        scope_4677.boolean(*var_4678);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_import_client_vpn_client_certificate_revocation_list(
    input: &crate::input::ImportClientVpnClientCertificateRevocationListInput,
) -> 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,
        "ImportClientVpnClientCertificateRevocationList",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4679 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_4680) = &input.client_vpn_endpoint_id {
        scope_4679.string(var_4680);
    }
    #[allow(unused_mut)]
    let mut scope_4681 = writer.prefix("CertificateRevocationList");
    if let Some(var_4682) = &input.certificate_revocation_list {
        scope_4681.string(var_4682);
    }
    #[allow(unused_mut)]
    let mut scope_4683 = writer.prefix("DryRun");
    if let Some(var_4684) = &input.dry_run {
        scope_4683.boolean(*var_4684);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn serialize_operation_crate_operation_register_instance_event_notification_attributes(
    input: &crate::input::RegisterInstanceEventNotificationAttributesInput,
) -> 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,
        "RegisterInstanceEventNotificationAttributes",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5732 = writer.prefix("DryRun");
    if let Some(var_5733) = &input.dry_run {
        scope_5732.boolean(*var_5733);
    }
    #[allow(unused_mut)]
    let mut scope_5734 = writer.prefix("InstanceTagAttribute");
    if let Some(var_5735) = &input.instance_tag_attribute {
        crate::query_ser::serialize_structure_crate_model_register_instance_tag_attribute_request(
            scope_5734, var_5735,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_register_transit_gateway_multicast_group_members(
    input: &crate::input::RegisterTransitGatewayMulticastGroupMembersInput,
) -> 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,
        "RegisterTransitGatewayMulticastGroupMembers",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5736 = writer.prefix("TransitGatewayMulticastDomainId");
    if let Some(var_5737) = &input.transit_gateway_multicast_domain_id {
        scope_5736.string(var_5737);
    }
    #[allow(unused_mut)]
    let mut scope_5738 = writer.prefix("GroupIpAddress");
    if let Some(var_5739) = &input.group_ip_address {
        scope_5738.string(var_5739);
    }
    #[allow(unused_mut)]
    let mut scope_5740 = writer.prefix("NetworkInterfaceIds");
    if let Some(var_5741) = &input.network_interface_ids {
        let mut list_5743 = scope_5740.start_list(true, Some("item"));
        for item_5742 in var_5741 {
            #[allow(unused_mut)]
            let mut entry_5744 = list_5743.entry();
            entry_5744.string(item_5742);
        }
        list_5743.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5745 = writer.prefix("DryRun");
    if let Some(var_5746) = &input.dry_run {
        scope_5745.boolean(*var_5746);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_register_transit_gateway_multicast_group_sources(
    input: &crate::input::RegisterTransitGatewayMulticastGroupSourcesInput,
) -> 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,
        "RegisterTransitGatewayMulticastGroupSources",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5747 = writer.prefix("TransitGatewayMulticastDomainId");
    if let Some(var_5748) = &input.transit_gateway_multicast_domain_id {
        scope_5747.string(var_5748);
    }
    #[allow(unused_mut)]
    let mut scope_5749 = writer.prefix("GroupIpAddress");
    if let Some(var_5750) = &input.group_ip_address {
        scope_5749.string(var_5750);
    }
    #[allow(unused_mut)]
    let mut scope_5751 = writer.prefix("NetworkInterfaceIds");
    if let Some(var_5752) = &input.network_interface_ids {
        let mut list_5754 = scope_5751.start_list(true, Some("item"));
        for item_5753 in var_5752 {
            #[allow(unused_mut)]
            let mut entry_5755 = list_5754.entry();
            entry_5755.string(item_5753);
        }
        list_5754.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5756 = writer.prefix("DryRun");
    if let Some(var_5757) = &input.dry_run {
        scope_5756.boolean(*var_5757);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reject_transit_gateway_multicast_domain_associations(
    input: &crate::input::RejectTransitGatewayMulticastDomainAssociationsInput,
) -> 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,
        "RejectTransitGatewayMulticastDomainAssociations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5758 = writer.prefix("TransitGatewayMulticastDomainId");
    if let Some(var_5759) = &input.transit_gateway_multicast_domain_id {
        scope_5758.string(var_5759);
    }
    #[allow(unused_mut)]
    let mut scope_5760 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_5761) = &input.transit_gateway_attachment_id {
        scope_5760.string(var_5761);
    }
    #[allow(unused_mut)]
    let mut scope_5762 = writer.prefix("SubnetIds");
    if let Some(var_5763) = &input.subnet_ids {
        let mut list_5765 = scope_5762.start_list(true, Some("item"));
        for item_5764 in var_5763 {
            #[allow(unused_mut)]
            let mut entry_5766 = list_5765.entry();
            entry_5766.string(item_5764);
        }
        list_5765.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5767 = writer.prefix("DryRun");
    if let Some(var_5768) = &input.dry_run {
        scope_5767.boolean(*var_5768);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reject_transit_gateway_peering_attachment(
    input: &crate::input::RejectTransitGatewayPeeringAttachmentInput,
) -> 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,
        "RejectTransitGatewayPeeringAttachment",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5769 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_5770) = &input.transit_gateway_attachment_id {
        scope_5769.string(var_5770);
    }
    #[allow(unused_mut)]
    let mut scope_5771 = writer.prefix("DryRun");
    if let Some(var_5772) = &input.dry_run {
        scope_5771.boolean(*var_5772);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reject_transit_gateway_vpc_attachment(
    input: &crate::input::RejectTransitGatewayVpcAttachmentInput,
) -> 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,
        "RejectTransitGatewayVpcAttachment",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5773 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_5774) = &input.transit_gateway_attachment_id {
        scope_5773.string(var_5774);
    }
    #[allow(unused_mut)]
    let mut scope_5775 = writer.prefix("DryRun");
    if let Some(var_5776) = &input.dry_run {
        scope_5775.boolean(*var_5776);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reject_vpc_endpoint_connections(
    input: &crate::input::RejectVpcEndpointConnectionsInput,
) -> 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, "RejectVpcEndpointConnections", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5777 = writer.prefix("DryRun");
    if let Some(var_5778) = &input.dry_run {
        scope_5777.boolean(*var_5778);
    }
    #[allow(unused_mut)]
    let mut scope_5779 = writer.prefix("ServiceId");
    if let Some(var_5780) = &input.service_id {
        scope_5779.string(var_5780);
    }
    #[allow(unused_mut)]
    let mut scope_5781 = writer.prefix("VpcEndpointId");
    if let Some(var_5782) = &input.vpc_endpoint_ids {
        let mut list_5784 = scope_5781.start_list(true, Some("item"));
        for item_5783 in var_5782 {
            #[allow(unused_mut)]
            let mut entry_5785 = list_5784.entry();
            entry_5785.string(item_5783);
        }
        list_5784.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reject_vpc_peering_connection(
    input: &crate::input::RejectVpcPeeringConnectionInput,
) -> 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, "RejectVpcPeeringConnection", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5786 = writer.prefix("DryRun");
    if let Some(var_5787) = &input.dry_run {
        scope_5786.boolean(*var_5787);
    }
    #[allow(unused_mut)]
    let mut scope_5788 = writer.prefix("VpcPeeringConnectionId");
    if let Some(var_5789) = &input.vpc_peering_connection_id {
        scope_5788.string(var_5789);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_release_address(
    input: &crate::input::ReleaseAddressInput,
) -> 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, "ReleaseAddress", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5790 = writer.prefix("AllocationId");
    if let Some(var_5791) = &input.allocation_id {
        scope_5790.string(var_5791);
    }
    #[allow(unused_mut)]
    let mut scope_5792 = writer.prefix("PublicIp");
    if let Some(var_5793) = &input.public_ip {
        scope_5792.string(var_5793);
    }
    #[allow(unused_mut)]
    let mut scope_5794 = writer.prefix("NetworkBorderGroup");
    if let Some(var_5795) = &input.network_border_group {
        scope_5794.string(var_5795);
    }
    #[allow(unused_mut)]
    let mut scope_5796 = writer.prefix("DryRun");
    if let Some(var_5797) = &input.dry_run {
        scope_5796.boolean(*var_5797);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_release_hosts(
    input: &crate::input::ReleaseHostsInput,
) -> 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, "ReleaseHosts", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5798 = writer.prefix("HostId");
    if let Some(var_5799) = &input.host_ids {
        let mut list_5801 = scope_5798.start_list(true, Some("item"));
        for item_5800 in var_5799 {
            #[allow(unused_mut)]
            let mut entry_5802 = list_5801.entry();
            entry_5802.string(item_5800);
        }
        list_5801.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_release_ipam_pool_allocation(
    input: &crate::input::ReleaseIpamPoolAllocationInput,
) -> 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, "ReleaseIpamPoolAllocation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5803 = writer.prefix("DryRun");
    if let Some(var_5804) = &input.dry_run {
        scope_5803.boolean(*var_5804);
    }
    #[allow(unused_mut)]
    let mut scope_5805 = writer.prefix("IpamPoolId");
    if let Some(var_5806) = &input.ipam_pool_id {
        scope_5805.string(var_5806);
    }
    #[allow(unused_mut)]
    let mut scope_5807 = writer.prefix("Cidr");
    if let Some(var_5808) = &input.cidr {
        scope_5807.string(var_5808);
    }
    #[allow(unused_mut)]
    let mut scope_5809 = writer.prefix("IpamPoolAllocationId");
    if let Some(var_5810) = &input.ipam_pool_allocation_id {
        scope_5809.string(var_5810);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_replace_iam_instance_profile_association(
    input: &crate::input::ReplaceIamInstanceProfileAssociationInput,
) -> 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,
        "ReplaceIamInstanceProfileAssociation",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5811 = writer.prefix("IamInstanceProfile");
    if let Some(var_5812) = &input.iam_instance_profile {
        crate::query_ser::serialize_structure_crate_model_iam_instance_profile_specification(
            scope_5811, var_5812,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5813 = writer.prefix("AssociationId");
    if let Some(var_5814) = &input.association_id {
        scope_5813.string(var_5814);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_replace_network_acl_association(
    input: &crate::input::ReplaceNetworkAclAssociationInput,
) -> 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, "ReplaceNetworkAclAssociation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5815 = writer.prefix("AssociationId");
    if let Some(var_5816) = &input.association_id {
        scope_5815.string(var_5816);
    }
    #[allow(unused_mut)]
    let mut scope_5817 = writer.prefix("DryRun");
    if let Some(var_5818) = &input.dry_run {
        scope_5817.boolean(*var_5818);
    }
    #[allow(unused_mut)]
    let mut scope_5819 = writer.prefix("NetworkAclId");
    if let Some(var_5820) = &input.network_acl_id {
        scope_5819.string(var_5820);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_replace_network_acl_entry(
    input: &crate::input::ReplaceNetworkAclEntryInput,
) -> 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, "ReplaceNetworkAclEntry", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5821 = writer.prefix("CidrBlock");
    if let Some(var_5822) = &input.cidr_block {
        scope_5821.string(var_5822);
    }
    #[allow(unused_mut)]
    let mut scope_5823 = writer.prefix("DryRun");
    if let Some(var_5824) = &input.dry_run {
        scope_5823.boolean(*var_5824);
    }
    #[allow(unused_mut)]
    let mut scope_5825 = writer.prefix("Egress");
    if let Some(var_5826) = &input.egress {
        scope_5825.boolean(*var_5826);
    }
    #[allow(unused_mut)]
    let mut scope_5827 = writer.prefix("Icmp");
    if let Some(var_5828) = &input.icmp_type_code {
        crate::query_ser::serialize_structure_crate_model_icmp_type_code(scope_5827, var_5828)?;
    }
    #[allow(unused_mut)]
    let mut scope_5829 = writer.prefix("Ipv6CidrBlock");
    if let Some(var_5830) = &input.ipv6_cidr_block {
        scope_5829.string(var_5830);
    }
    #[allow(unused_mut)]
    let mut scope_5831 = writer.prefix("NetworkAclId");
    if let Some(var_5832) = &input.network_acl_id {
        scope_5831.string(var_5832);
    }
    #[allow(unused_mut)]
    let mut scope_5833 = writer.prefix("PortRange");
    if let Some(var_5834) = &input.port_range {
        crate::query_ser::serialize_structure_crate_model_port_range(scope_5833, var_5834)?;
    }
    #[allow(unused_mut)]
    let mut scope_5835 = writer.prefix("Protocol");
    if let Some(var_5836) = &input.protocol {
        scope_5835.string(var_5836);
    }
    #[allow(unused_mut)]
    let mut scope_5837 = writer.prefix("RuleAction");
    if let Some(var_5838) = &input.rule_action {
        scope_5837.string(var_5838.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5839 = writer.prefix("RuleNumber");
    if let Some(var_5840) = &input.rule_number {
        scope_5839.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5840).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_replace_route(
    input: &crate::input::ReplaceRouteInput,
) -> 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, "ReplaceRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5841 = writer.prefix("DestinationCidrBlock");
    if let Some(var_5842) = &input.destination_cidr_block {
        scope_5841.string(var_5842);
    }
    #[allow(unused_mut)]
    let mut scope_5843 = writer.prefix("DestinationIpv6CidrBlock");
    if let Some(var_5844) = &input.destination_ipv6_cidr_block {
        scope_5843.string(var_5844);
    }
    #[allow(unused_mut)]
    let mut scope_5845 = writer.prefix("DestinationPrefixListId");
    if let Some(var_5846) = &input.destination_prefix_list_id {
        scope_5845.string(var_5846);
    }
    #[allow(unused_mut)]
    let mut scope_5847 = writer.prefix("DryRun");
    if let Some(var_5848) = &input.dry_run {
        scope_5847.boolean(*var_5848);
    }
    #[allow(unused_mut)]
    let mut scope_5849 = writer.prefix("VpcEndpointId");
    if let Some(var_5850) = &input.vpc_endpoint_id {
        scope_5849.string(var_5850);
    }
    #[allow(unused_mut)]
    let mut scope_5851 = writer.prefix("EgressOnlyInternetGatewayId");
    if let Some(var_5852) = &input.egress_only_internet_gateway_id {
        scope_5851.string(var_5852);
    }
    #[allow(unused_mut)]
    let mut scope_5853 = writer.prefix("GatewayId");
    if let Some(var_5854) = &input.gateway_id {
        scope_5853.string(var_5854);
    }
    #[allow(unused_mut)]
    let mut scope_5855 = writer.prefix("InstanceId");
    if let Some(var_5856) = &input.instance_id {
        scope_5855.string(var_5856);
    }
    #[allow(unused_mut)]
    let mut scope_5857 = writer.prefix("LocalTarget");
    if let Some(var_5858) = &input.local_target {
        scope_5857.boolean(*var_5858);
    }
    #[allow(unused_mut)]
    let mut scope_5859 = writer.prefix("NatGatewayId");
    if let Some(var_5860) = &input.nat_gateway_id {
        scope_5859.string(var_5860);
    }
    #[allow(unused_mut)]
    let mut scope_5861 = writer.prefix("TransitGatewayId");
    if let Some(var_5862) = &input.transit_gateway_id {
        scope_5861.string(var_5862);
    }
    #[allow(unused_mut)]
    let mut scope_5863 = writer.prefix("LocalGatewayId");
    if let Some(var_5864) = &input.local_gateway_id {
        scope_5863.string(var_5864);
    }
    #[allow(unused_mut)]
    let mut scope_5865 = writer.prefix("CarrierGatewayId");
    if let Some(var_5866) = &input.carrier_gateway_id {
        scope_5865.string(var_5866);
    }
    #[allow(unused_mut)]
    let mut scope_5867 = writer.prefix("NetworkInterfaceId");
    if let Some(var_5868) = &input.network_interface_id {
        scope_5867.string(var_5868);
    }
    #[allow(unused_mut)]
    let mut scope_5869 = writer.prefix("RouteTableId");
    if let Some(var_5870) = &input.route_table_id {
        scope_5869.string(var_5870);
    }
    #[allow(unused_mut)]
    let mut scope_5871 = writer.prefix("VpcPeeringConnectionId");
    if let Some(var_5872) = &input.vpc_peering_connection_id {
        scope_5871.string(var_5872);
    }
    #[allow(unused_mut)]
    let mut scope_5873 = writer.prefix("CoreNetworkArn");
    if let Some(var_5874) = &input.core_network_arn {
        scope_5873.string(var_5874);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_replace_route_table_association(
    input: &crate::input::ReplaceRouteTableAssociationInput,
) -> 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, "ReplaceRouteTableAssociation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5875 = writer.prefix("AssociationId");
    if let Some(var_5876) = &input.association_id {
        scope_5875.string(var_5876);
    }
    #[allow(unused_mut)]
    let mut scope_5877 = writer.prefix("DryRun");
    if let Some(var_5878) = &input.dry_run {
        scope_5877.boolean(*var_5878);
    }
    #[allow(unused_mut)]
    let mut scope_5879 = writer.prefix("RouteTableId");
    if let Some(var_5880) = &input.route_table_id {
        scope_5879.string(var_5880);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_replace_transit_gateway_route(
    input: &crate::input::ReplaceTransitGatewayRouteInput,
) -> 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, "ReplaceTransitGatewayRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5881 = writer.prefix("DestinationCidrBlock");
    if let Some(var_5882) = &input.destination_cidr_block {
        scope_5881.string(var_5882);
    }
    #[allow(unused_mut)]
    let mut scope_5883 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_5884) = &input.transit_gateway_route_table_id {
        scope_5883.string(var_5884);
    }
    #[allow(unused_mut)]
    let mut scope_5885 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_5886) = &input.transit_gateway_attachment_id {
        scope_5885.string(var_5886);
    }
    #[allow(unused_mut)]
    let mut scope_5887 = writer.prefix("Blackhole");
    if let Some(var_5888) = &input.blackhole {
        scope_5887.boolean(*var_5888);
    }
    #[allow(unused_mut)]
    let mut scope_5889 = writer.prefix("DryRun");
    if let Some(var_5890) = &input.dry_run {
        scope_5889.boolean(*var_5890);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_report_instance_status(
    input: &crate::input::ReportInstanceStatusInput,
) -> 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, "ReportInstanceStatus", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5891 = writer.prefix("Description");
    if let Some(var_5892) = &input.description {
        scope_5891.string(var_5892);
    }
    #[allow(unused_mut)]
    let mut scope_5893 = writer.prefix("DryRun");
    if let Some(var_5894) = &input.dry_run {
        scope_5893.boolean(*var_5894);
    }
    #[allow(unused_mut)]
    let mut scope_5895 = writer.prefix("EndTime");
    if let Some(var_5896) = &input.end_time {
        scope_5895.date_time(var_5896, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_5897 = writer.prefix("InstanceId");
    if let Some(var_5898) = &input.instances {
        let mut list_5900 = scope_5897.start_list(true, Some("InstanceId"));
        for item_5899 in var_5898 {
            #[allow(unused_mut)]
            let mut entry_5901 = list_5900.entry();
            entry_5901.string(item_5899);
        }
        list_5900.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5902 = writer.prefix("ReasonCode");
    if let Some(var_5903) = &input.reason_codes {
        let mut list_5905 = scope_5902.start_list(true, Some("item"));
        for item_5904 in var_5903 {
            #[allow(unused_mut)]
            let mut entry_5906 = list_5905.entry();
            entry_5906.string(item_5904.as_str());
        }
        list_5905.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5907 = writer.prefix("StartTime");
    if let Some(var_5908) = &input.start_time {
        scope_5907.date_time(var_5908, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_5909 = writer.prefix("Status");
    if let Some(var_5910) = &input.status {
        scope_5909.string(var_5910.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_request_spot_fleet(
    input: &crate::input::RequestSpotFleetInput,
) -> 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, "RequestSpotFleet", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5911 = writer.prefix("DryRun");
    if let Some(var_5912) = &input.dry_run {
        scope_5911.boolean(*var_5912);
    }
    #[allow(unused_mut)]
    let mut scope_5913 = writer.prefix("SpotFleetRequestConfig");
    if let Some(var_5914) = &input.spot_fleet_request_config {
        crate::query_ser::serialize_structure_crate_model_spot_fleet_request_config_data(
            scope_5913, var_5914,
        )?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_request_spot_instances(
    input: &crate::input::RequestSpotInstancesInput,
) -> 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, "RequestSpotInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5915 = writer.prefix("AvailabilityZoneGroup");
    if let Some(var_5916) = &input.availability_zone_group {
        scope_5915.string(var_5916);
    }
    #[allow(unused_mut)]
    let mut scope_5917 = writer.prefix("BlockDurationMinutes");
    if let Some(var_5918) = &input.block_duration_minutes {
        scope_5917.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5918).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5919 = writer.prefix("ClientToken");
    if let Some(var_5920) = &input.client_token {
        scope_5919.string(var_5920);
    }
    #[allow(unused_mut)]
    let mut scope_5921 = writer.prefix("DryRun");
    if let Some(var_5922) = &input.dry_run {
        scope_5921.boolean(*var_5922);
    }
    #[allow(unused_mut)]
    let mut scope_5923 = writer.prefix("InstanceCount");
    if let Some(var_5924) = &input.instance_count {
        scope_5923.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5924).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5925 = writer.prefix("LaunchGroup");
    if let Some(var_5926) = &input.launch_group {
        scope_5925.string(var_5926);
    }
    #[allow(unused_mut)]
    let mut scope_5927 = writer.prefix("LaunchSpecification");
    if let Some(var_5928) = &input.launch_specification {
        crate::query_ser::serialize_structure_crate_model_request_spot_launch_specification(
            scope_5927, var_5928,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_5929 = writer.prefix("SpotPrice");
    if let Some(var_5930) = &input.spot_price {
        scope_5929.string(var_5930);
    }
    #[allow(unused_mut)]
    let mut scope_5931 = writer.prefix("Type");
    if let Some(var_5932) = &input.r#type {
        scope_5931.string(var_5932.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5933 = writer.prefix("ValidFrom");
    if let Some(var_5934) = &input.valid_from {
        scope_5933.date_time(var_5934, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_5935 = writer.prefix("ValidUntil");
    if let Some(var_5936) = &input.valid_until {
        scope_5935.date_time(var_5936, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_5937 = writer.prefix("TagSpecification");
    if let Some(var_5938) = &input.tag_specifications {
        let mut list_5940 = scope_5937.start_list(true, Some("item"));
        for item_5939 in var_5938 {
            #[allow(unused_mut)]
            let mut entry_5941 = list_5940.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_5941, item_5939,
            )?;
        }
        list_5940.finish();
    }
    #[allow(unused_mut)]
    let mut scope_5942 = writer.prefix("InstanceInterruptionBehavior");
    if let Some(var_5943) = &input.instance_interruption_behavior {
        scope_5942.string(var_5943.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reset_address_attribute(
    input: &crate::input::ResetAddressAttributeInput,
) -> 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, "ResetAddressAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5944 = writer.prefix("AllocationId");
    if let Some(var_5945) = &input.allocation_id {
        scope_5944.string(var_5945);
    }
    #[allow(unused_mut)]
    let mut scope_5946 = writer.prefix("Attribute");
    if let Some(var_5947) = &input.attribute {
        scope_5946.string(var_5947.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5948 = writer.prefix("DryRun");
    if let Some(var_5949) = &input.dry_run {
        scope_5948.boolean(*var_5949);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

pub fn serialize_operation_crate_operation_reset_fpga_image_attribute(
    input: &crate::input::ResetFpgaImageAttributeInput,
) -> 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, "ResetFpgaImageAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5952 = writer.prefix("DryRun");
    if let Some(var_5953) = &input.dry_run {
        scope_5952.boolean(*var_5953);
    }
    #[allow(unused_mut)]
    let mut scope_5954 = writer.prefix("FpgaImageId");
    if let Some(var_5955) = &input.fpga_image_id {
        scope_5954.string(var_5955);
    }
    #[allow(unused_mut)]
    let mut scope_5956 = writer.prefix("Attribute");
    if let Some(var_5957) = &input.attribute {
        scope_5956.string(var_5957.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reset_image_attribute(
    input: &crate::input::ResetImageAttributeInput,
) -> 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, "ResetImageAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5958 = writer.prefix("Attribute");
    if let Some(var_5959) = &input.attribute {
        scope_5958.string(var_5959.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5960 = writer.prefix("ImageId");
    if let Some(var_5961) = &input.image_id {
        scope_5960.string(var_5961);
    }
    #[allow(unused_mut)]
    let mut scope_5962 = writer.prefix("DryRun");
    if let Some(var_5963) = &input.dry_run {
        scope_5962.boolean(*var_5963);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reset_instance_attribute(
    input: &crate::input::ResetInstanceAttributeInput,
) -> 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, "ResetInstanceAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5964 = writer.prefix("Attribute");
    if let Some(var_5965) = &input.attribute {
        scope_5964.string(var_5965.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5966 = writer.prefix("DryRun");
    if let Some(var_5967) = &input.dry_run {
        scope_5966.boolean(*var_5967);
    }
    #[allow(unused_mut)]
    let mut scope_5968 = writer.prefix("InstanceId");
    if let Some(var_5969) = &input.instance_id {
        scope_5968.string(var_5969);
    }
    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 InstanceAttributeName

fn as_ref(&self) -> &str

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

impl Clone for InstanceAttributeName

fn clone(&self) -> InstanceAttributeName

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InstanceAttributeName

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

Formats the value using the given formatter.

impl From<&str> for InstanceAttributeName

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for InstanceAttributeName

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 InstanceAttributeName

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 InstanceAttributeName

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

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

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

impl StructuralEq for InstanceAttributeName

impl StructuralPartialEq for InstanceAttributeName