Enum aws_sdk_ec2::model::VolumeType

#[non_exhaustive]
pub enum VolumeType {
    Gp2,
    Gp3,
    Io1,
    Io2,
    Sc1,
    St1,
    Standard,
    Unknown(UnknownVariantValue),
}

When writing a match expression against VolumeType, 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 volumetype = unimplemented!();
match volumetype {
    VolumeType::Gp2 => { /* ... */ },
    VolumeType::Gp3 => { /* ... */ },
    VolumeType::Io1 => { /* ... */ },
    VolumeType::Io2 => { /* ... */ },
    VolumeType::Sc1 => { /* ... */ },
    VolumeType::St1 => { /* ... */ },
    VolumeType::Standard => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

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

Gp2

Gp3

Io1

Io2

Sc1

St1

Standard

Unknown(UnknownVariantValue)

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

Implementations

impl VolumeType

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 21400)

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

src/query_ser.rs (line 4058)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_launch_template_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::FleetLaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1449 = writer.prefix("LaunchTemplateId");
    if let Some(var_1450) = &input.launch_template_id {
        scope_1449.string(var_1450);
    }
    #[allow(unused_mut)]
    let mut scope_1451 = writer.prefix("LaunchTemplateName");
    if let Some(var_1452) = &input.launch_template_name {
        scope_1451.string(var_1452);
    }
    #[allow(unused_mut)]
    let mut scope_1453 = writer.prefix("Version");
    if let Some(var_1454) = &input.version {
        scope_1453.string(var_1454);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_overrides(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_1455 = writer.prefix("InstanceType");
    if let Some(var_1456) = &input.instance_type {
        scope_1455.string(var_1456.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_1457 = writer.prefix("SpotPrice");
    if let Some(var_1458) = &input.spot_price {
        scope_1457.string(var_1458);
    }
    #[allow(unused_mut)]
    let mut scope_1459 = writer.prefix("SubnetId");
    if let Some(var_1460) = &input.subnet_id {
        scope_1459.string(var_1460);
    }
    #[allow(unused_mut)]
    let mut scope_1461 = writer.prefix("AvailabilityZone");
    if let Some(var_1462) = &input.availability_zone {
        scope_1461.string(var_1462);
    }
    #[allow(unused_mut)]
    let mut scope_1463 = writer.prefix("WeightedCapacity");
    if let Some(var_1464) = &input.weighted_capacity {
        scope_1463.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1464).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1465 = writer.prefix("Priority");
    if let Some(var_1466) = &input.priority {
        scope_1465.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_1466).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_1467 = writer.prefix("InstanceRequirements");
    if let Some(var_1468) = &input.instance_requirements {
        crate::query_ser::serialize_structure_crate_model_instance_requirements(
            scope_1467, var_1468,
        )?;
    }
    Ok(())
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/operation_ser.rs (line 5381)

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

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

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

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

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

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

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

pub fn serialize_operation_crate_operation_create_vpn_connection_route(
    input: &crate::input::CreateVpnConnectionRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "CreateVpnConnectionRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1720 = writer.prefix("DestinationCidrBlock");
    if let Some(var_1721) = &input.destination_cidr_block {
        scope_1720.string(var_1721);
    }
    #[allow(unused_mut)]
    let mut scope_1722 = writer.prefix("VpnConnectionId");
    if let Some(var_1723) = &input.vpn_connection_id {
        scope_1722.string(var_1723);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

pub fn serialize_operation_crate_operation_delete_carrier_gateway(
    input: &crate::input::DeleteCarrierGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteCarrierGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1737 = writer.prefix("CarrierGatewayId");
    if let Some(var_1738) = &input.carrier_gateway_id {
        scope_1737.string(var_1738);
    }
    #[allow(unused_mut)]
    let mut scope_1739 = writer.prefix("DryRun");
    if let Some(var_1740) = &input.dry_run {
        scope_1739.boolean(*var_1740);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_client_vpn_endpoint(
    input: &crate::input::DeleteClientVpnEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteClientVpnEndpoint", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1741 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_1742) = &input.client_vpn_endpoint_id {
        scope_1741.string(var_1742);
    }
    #[allow(unused_mut)]
    let mut scope_1743 = writer.prefix("DryRun");
    if let Some(var_1744) = &input.dry_run {
        scope_1743.boolean(*var_1744);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_client_vpn_route(
    input: &crate::input::DeleteClientVpnRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteClientVpnRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1745 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_1746) = &input.client_vpn_endpoint_id {
        scope_1745.string(var_1746);
    }
    #[allow(unused_mut)]
    let mut scope_1747 = writer.prefix("TargetVpcSubnetId");
    if let Some(var_1748) = &input.target_vpc_subnet_id {
        scope_1747.string(var_1748);
    }
    #[allow(unused_mut)]
    let mut scope_1749 = writer.prefix("DestinationCidrBlock");
    if let Some(var_1750) = &input.destination_cidr_block {
        scope_1749.string(var_1750);
    }
    #[allow(unused_mut)]
    let mut scope_1751 = writer.prefix("DryRun");
    if let Some(var_1752) = &input.dry_run {
        scope_1751.boolean(*var_1752);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_coip_cidr(
    input: &crate::input::DeleteCoipCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteCoipCidr", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1753 = writer.prefix("Cidr");
    if let Some(var_1754) = &input.cidr {
        scope_1753.string(var_1754);
    }
    #[allow(unused_mut)]
    let mut scope_1755 = writer.prefix("CoipPoolId");
    if let Some(var_1756) = &input.coip_pool_id {
        scope_1755.string(var_1756);
    }
    #[allow(unused_mut)]
    let mut scope_1757 = writer.prefix("DryRun");
    if let Some(var_1758) = &input.dry_run {
        scope_1757.boolean(*var_1758);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_coip_pool(
    input: &crate::input::DeleteCoipPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteCoipPool", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1759 = writer.prefix("CoipPoolId");
    if let Some(var_1760) = &input.coip_pool_id {
        scope_1759.string(var_1760);
    }
    #[allow(unused_mut)]
    let mut scope_1761 = writer.prefix("DryRun");
    if let Some(var_1762) = &input.dry_run {
        scope_1761.boolean(*var_1762);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_customer_gateway(
    input: &crate::input::DeleteCustomerGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteCustomerGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1763 = writer.prefix("CustomerGatewayId");
    if let Some(var_1764) = &input.customer_gateway_id {
        scope_1763.string(var_1764);
    }
    #[allow(unused_mut)]
    let mut scope_1765 = writer.prefix("DryRun");
    if let Some(var_1766) = &input.dry_run {
        scope_1765.boolean(*var_1766);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_dhcp_options(
    input: &crate::input::DeleteDhcpOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteDhcpOptions", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1767 = writer.prefix("DhcpOptionsId");
    if let Some(var_1768) = &input.dhcp_options_id {
        scope_1767.string(var_1768);
    }
    #[allow(unused_mut)]
    let mut scope_1769 = writer.prefix("DryRun");
    if let Some(var_1770) = &input.dry_run {
        scope_1769.boolean(*var_1770);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_egress_only_internet_gateway(
    input: &crate::input::DeleteEgressOnlyInternetGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteEgressOnlyInternetGateway",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1771 = writer.prefix("DryRun");
    if let Some(var_1772) = &input.dry_run {
        scope_1771.boolean(*var_1772);
    }
    #[allow(unused_mut)]
    let mut scope_1773 = writer.prefix("EgressOnlyInternetGatewayId");
    if let Some(var_1774) = &input.egress_only_internet_gateway_id {
        scope_1773.string(var_1774);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_fleets(
    input: &crate::input::DeleteFleetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteFleets", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1775 = writer.prefix("DryRun");
    if let Some(var_1776) = &input.dry_run {
        scope_1775.boolean(*var_1776);
    }
    #[allow(unused_mut)]
    let mut scope_1777 = writer.prefix("FleetId");
    if let Some(var_1778) = &input.fleet_ids {
        let mut list_1780 = scope_1777.start_list(true, None);
        for item_1779 in var_1778 {
            #[allow(unused_mut)]
            let mut entry_1781 = list_1780.entry();
            entry_1781.string(item_1779);
        }
        list_1780.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1782 = writer.prefix("TerminateInstances");
    if let Some(var_1783) = &input.terminate_instances {
        scope_1782.boolean(*var_1783);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_flow_logs(
    input: &crate::input::DeleteFlowLogsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteFlowLogs", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1784 = writer.prefix("DryRun");
    if let Some(var_1785) = &input.dry_run {
        scope_1784.boolean(*var_1785);
    }
    #[allow(unused_mut)]
    let mut scope_1786 = writer.prefix("FlowLogId");
    if let Some(var_1787) = &input.flow_log_ids {
        let mut list_1789 = scope_1786.start_list(true, Some("item"));
        for item_1788 in var_1787 {
            #[allow(unused_mut)]
            let mut entry_1790 = list_1789.entry();
            entry_1790.string(item_1788);
        }
        list_1789.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_fpga_image(
    input: &crate::input::DeleteFpgaImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteFpgaImage", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1791 = writer.prefix("DryRun");
    if let Some(var_1792) = &input.dry_run {
        scope_1791.boolean(*var_1792);
    }
    #[allow(unused_mut)]
    let mut scope_1793 = writer.prefix("FpgaImageId");
    if let Some(var_1794) = &input.fpga_image_id {
        scope_1793.string(var_1794);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_instance_event_window(
    input: &crate::input::DeleteInstanceEventWindowInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteInstanceEventWindow", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1795 = writer.prefix("DryRun");
    if let Some(var_1796) = &input.dry_run {
        scope_1795.boolean(*var_1796);
    }
    #[allow(unused_mut)]
    let mut scope_1797 = writer.prefix("ForceDelete");
    if let Some(var_1798) = &input.force_delete {
        scope_1797.boolean(*var_1798);
    }
    #[allow(unused_mut)]
    let mut scope_1799 = writer.prefix("InstanceEventWindowId");
    if let Some(var_1800) = &input.instance_event_window_id {
        scope_1799.string(var_1800);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_internet_gateway(
    input: &crate::input::DeleteInternetGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteInternetGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1801 = writer.prefix("DryRun");
    if let Some(var_1802) = &input.dry_run {
        scope_1801.boolean(*var_1802);
    }
    #[allow(unused_mut)]
    let mut scope_1803 = writer.prefix("InternetGatewayId");
    if let Some(var_1804) = &input.internet_gateway_id {
        scope_1803.string(var_1804);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_ipam(
    input: &crate::input::DeleteIpamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteIpam", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1805 = writer.prefix("DryRun");
    if let Some(var_1806) = &input.dry_run {
        scope_1805.boolean(*var_1806);
    }
    #[allow(unused_mut)]
    let mut scope_1807 = writer.prefix("IpamId");
    if let Some(var_1808) = &input.ipam_id {
        scope_1807.string(var_1808);
    }
    #[allow(unused_mut)]
    let mut scope_1809 = writer.prefix("Cascade");
    if let Some(var_1810) = &input.cascade {
        scope_1809.boolean(*var_1810);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_ipam_pool(
    input: &crate::input::DeleteIpamPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteIpamPool", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1811 = writer.prefix("DryRun");
    if let Some(var_1812) = &input.dry_run {
        scope_1811.boolean(*var_1812);
    }
    #[allow(unused_mut)]
    let mut scope_1813 = writer.prefix("IpamPoolId");
    if let Some(var_1814) = &input.ipam_pool_id {
        scope_1813.string(var_1814);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_ipam_scope(
    input: &crate::input::DeleteIpamScopeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteIpamScope", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1815 = writer.prefix("DryRun");
    if let Some(var_1816) = &input.dry_run {
        scope_1815.boolean(*var_1816);
    }
    #[allow(unused_mut)]
    let mut scope_1817 = writer.prefix("IpamScopeId");
    if let Some(var_1818) = &input.ipam_scope_id {
        scope_1817.string(var_1818);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_key_pair(
    input: &crate::input::DeleteKeyPairInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteKeyPair", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1819 = writer.prefix("KeyName");
    if let Some(var_1820) = &input.key_name {
        scope_1819.string(var_1820);
    }
    #[allow(unused_mut)]
    let mut scope_1821 = writer.prefix("KeyPairId");
    if let Some(var_1822) = &input.key_pair_id {
        scope_1821.string(var_1822);
    }
    #[allow(unused_mut)]
    let mut scope_1823 = writer.prefix("DryRun");
    if let Some(var_1824) = &input.dry_run {
        scope_1823.boolean(*var_1824);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_launch_template(
    input: &crate::input::DeleteLaunchTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteLaunchTemplate", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1825 = writer.prefix("DryRun");
    if let Some(var_1826) = &input.dry_run {
        scope_1825.boolean(*var_1826);
    }
    #[allow(unused_mut)]
    let mut scope_1827 = writer.prefix("LaunchTemplateId");
    if let Some(var_1828) = &input.launch_template_id {
        scope_1827.string(var_1828);
    }
    #[allow(unused_mut)]
    let mut scope_1829 = writer.prefix("LaunchTemplateName");
    if let Some(var_1830) = &input.launch_template_name {
        scope_1829.string(var_1830);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_launch_template_versions(
    input: &crate::input::DeleteLaunchTemplateVersionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteLaunchTemplateVersions", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1831 = writer.prefix("DryRun");
    if let Some(var_1832) = &input.dry_run {
        scope_1831.boolean(*var_1832);
    }
    #[allow(unused_mut)]
    let mut scope_1833 = writer.prefix("LaunchTemplateId");
    if let Some(var_1834) = &input.launch_template_id {
        scope_1833.string(var_1834);
    }
    #[allow(unused_mut)]
    let mut scope_1835 = writer.prefix("LaunchTemplateName");
    if let Some(var_1836) = &input.launch_template_name {
        scope_1835.string(var_1836);
    }
    #[allow(unused_mut)]
    let mut scope_1837 = writer.prefix("LaunchTemplateVersion");
    if let Some(var_1838) = &input.versions {
        let mut list_1840 = scope_1837.start_list(true, Some("item"));
        for item_1839 in var_1838 {
            #[allow(unused_mut)]
            let mut entry_1841 = list_1840.entry();
            entry_1841.string(item_1839);
        }
        list_1840.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_local_gateway_route(
    input: &crate::input::DeleteLocalGatewayRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteLocalGatewayRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1842 = writer.prefix("DestinationCidrBlock");
    if let Some(var_1843) = &input.destination_cidr_block {
        scope_1842.string(var_1843);
    }
    #[allow(unused_mut)]
    let mut scope_1844 = writer.prefix("LocalGatewayRouteTableId");
    if let Some(var_1845) = &input.local_gateway_route_table_id {
        scope_1844.string(var_1845);
    }
    #[allow(unused_mut)]
    let mut scope_1846 = writer.prefix("DryRun");
    if let Some(var_1847) = &input.dry_run {
        scope_1846.boolean(*var_1847);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_local_gateway_route_table(
    input: &crate::input::DeleteLocalGatewayRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteLocalGatewayRouteTable", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1848 = writer.prefix("LocalGatewayRouteTableId");
    if let Some(var_1849) = &input.local_gateway_route_table_id {
        scope_1848.string(var_1849);
    }
    #[allow(unused_mut)]
    let mut scope_1850 = writer.prefix("DryRun");
    if let Some(var_1851) = &input.dry_run {
        scope_1850.boolean(*var_1851);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_local_gateway_route_table_virtual_interface_group_association(
    input: &crate::input::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1852 = writer.prefix("LocalGatewayRouteTableVirtualInterfaceGroupAssociationId");
    if let Some(var_1853) = &input.local_gateway_route_table_virtual_interface_group_association_id
    {
        scope_1852.string(var_1853);
    }
    #[allow(unused_mut)]
    let mut scope_1854 = writer.prefix("DryRun");
    if let Some(var_1855) = &input.dry_run {
        scope_1854.boolean(*var_1855);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_local_gateway_route_table_vpc_association(
    input: &crate::input::DeleteLocalGatewayRouteTableVpcAssociationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteLocalGatewayRouteTableVpcAssociation",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1856 = writer.prefix("LocalGatewayRouteTableVpcAssociationId");
    if let Some(var_1857) = &input.local_gateway_route_table_vpc_association_id {
        scope_1856.string(var_1857);
    }
    #[allow(unused_mut)]
    let mut scope_1858 = writer.prefix("DryRun");
    if let Some(var_1859) = &input.dry_run {
        scope_1858.boolean(*var_1859);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_managed_prefix_list(
    input: &crate::input::DeleteManagedPrefixListInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteManagedPrefixList", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1860 = writer.prefix("DryRun");
    if let Some(var_1861) = &input.dry_run {
        scope_1860.boolean(*var_1861);
    }
    #[allow(unused_mut)]
    let mut scope_1862 = writer.prefix("PrefixListId");
    if let Some(var_1863) = &input.prefix_list_id {
        scope_1862.string(var_1863);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_nat_gateway(
    input: &crate::input::DeleteNatGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteNatGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1864 = writer.prefix("DryRun");
    if let Some(var_1865) = &input.dry_run {
        scope_1864.boolean(*var_1865);
    }
    #[allow(unused_mut)]
    let mut scope_1866 = writer.prefix("NatGatewayId");
    if let Some(var_1867) = &input.nat_gateway_id {
        scope_1866.string(var_1867);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_network_acl(
    input: &crate::input::DeleteNetworkAclInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteNetworkAcl", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1868 = writer.prefix("DryRun");
    if let Some(var_1869) = &input.dry_run {
        scope_1868.boolean(*var_1869);
    }
    #[allow(unused_mut)]
    let mut scope_1870 = writer.prefix("NetworkAclId");
    if let Some(var_1871) = &input.network_acl_id {
        scope_1870.string(var_1871);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_network_acl_entry(
    input: &crate::input::DeleteNetworkAclEntryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteNetworkAclEntry", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1872 = writer.prefix("DryRun");
    if let Some(var_1873) = &input.dry_run {
        scope_1872.boolean(*var_1873);
    }
    #[allow(unused_mut)]
    let mut scope_1874 = writer.prefix("Egress");
    if let Some(var_1875) = &input.egress {
        scope_1874.boolean(*var_1875);
    }
    #[allow(unused_mut)]
    let mut scope_1876 = writer.prefix("NetworkAclId");
    if let Some(var_1877) = &input.network_acl_id {
        scope_1876.string(var_1877);
    }
    #[allow(unused_mut)]
    let mut scope_1878 = writer.prefix("RuleNumber");
    if let Some(var_1879) = &input.rule_number {
        scope_1878.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_1879).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_network_insights_access_scope(
    input: &crate::input::DeleteNetworkInsightsAccessScopeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteNetworkInsightsAccessScope",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1880 = writer.prefix("DryRun");
    if let Some(var_1881) = &input.dry_run {
        scope_1880.boolean(*var_1881);
    }
    #[allow(unused_mut)]
    let mut scope_1882 = writer.prefix("NetworkInsightsAccessScopeId");
    if let Some(var_1883) = &input.network_insights_access_scope_id {
        scope_1882.string(var_1883);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_network_insights_access_scope_analysis(
    input: &crate::input::DeleteNetworkInsightsAccessScopeAnalysisInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteNetworkInsightsAccessScopeAnalysis",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1884 = writer.prefix("NetworkInsightsAccessScopeAnalysisId");
    if let Some(var_1885) = &input.network_insights_access_scope_analysis_id {
        scope_1884.string(var_1885);
    }
    #[allow(unused_mut)]
    let mut scope_1886 = writer.prefix("DryRun");
    if let Some(var_1887) = &input.dry_run {
        scope_1886.boolean(*var_1887);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_network_insights_analysis(
    input: &crate::input::DeleteNetworkInsightsAnalysisInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteNetworkInsightsAnalysis", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1888 = writer.prefix("DryRun");
    if let Some(var_1889) = &input.dry_run {
        scope_1888.boolean(*var_1889);
    }
    #[allow(unused_mut)]
    let mut scope_1890 = writer.prefix("NetworkInsightsAnalysisId");
    if let Some(var_1891) = &input.network_insights_analysis_id {
        scope_1890.string(var_1891);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_network_insights_path(
    input: &crate::input::DeleteNetworkInsightsPathInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteNetworkInsightsPath", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1892 = writer.prefix("DryRun");
    if let Some(var_1893) = &input.dry_run {
        scope_1892.boolean(*var_1893);
    }
    #[allow(unused_mut)]
    let mut scope_1894 = writer.prefix("NetworkInsightsPathId");
    if let Some(var_1895) = &input.network_insights_path_id {
        scope_1894.string(var_1895);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_network_interface(
    input: &crate::input::DeleteNetworkInterfaceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteNetworkInterface", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1896 = writer.prefix("DryRun");
    if let Some(var_1897) = &input.dry_run {
        scope_1896.boolean(*var_1897);
    }
    #[allow(unused_mut)]
    let mut scope_1898 = writer.prefix("NetworkInterfaceId");
    if let Some(var_1899) = &input.network_interface_id {
        scope_1898.string(var_1899);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_network_interface_permission(
    input: &crate::input::DeleteNetworkInterfacePermissionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteNetworkInterfacePermission",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1900 = writer.prefix("NetworkInterfacePermissionId");
    if let Some(var_1901) = &input.network_interface_permission_id {
        scope_1900.string(var_1901);
    }
    #[allow(unused_mut)]
    let mut scope_1902 = writer.prefix("Force");
    if let Some(var_1903) = &input.force {
        scope_1902.boolean(*var_1903);
    }
    #[allow(unused_mut)]
    let mut scope_1904 = writer.prefix("DryRun");
    if let Some(var_1905) = &input.dry_run {
        scope_1904.boolean(*var_1905);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_placement_group(
    input: &crate::input::DeletePlacementGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeletePlacementGroup", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1906 = writer.prefix("DryRun");
    if let Some(var_1907) = &input.dry_run {
        scope_1906.boolean(*var_1907);
    }
    #[allow(unused_mut)]
    let mut scope_1908 = writer.prefix("GroupName");
    if let Some(var_1909) = &input.group_name {
        scope_1908.string(var_1909);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_public_ipv4_pool(
    input: &crate::input::DeletePublicIpv4PoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeletePublicIpv4Pool", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1910 = writer.prefix("DryRun");
    if let Some(var_1911) = &input.dry_run {
        scope_1910.boolean(*var_1911);
    }
    #[allow(unused_mut)]
    let mut scope_1912 = writer.prefix("PoolId");
    if let Some(var_1913) = &input.pool_id {
        scope_1912.string(var_1913);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_queued_reserved_instances(
    input: &crate::input::DeleteQueuedReservedInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteQueuedReservedInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1914 = writer.prefix("DryRun");
    if let Some(var_1915) = &input.dry_run {
        scope_1914.boolean(*var_1915);
    }
    #[allow(unused_mut)]
    let mut scope_1916 = writer.prefix("ReservedInstancesId");
    if let Some(var_1917) = &input.reserved_instances_ids {
        let mut list_1919 = scope_1916.start_list(true, Some("item"));
        for item_1918 in var_1917 {
            #[allow(unused_mut)]
            let mut entry_1920 = list_1919.entry();
            entry_1920.string(item_1918);
        }
        list_1919.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_route(
    input: &crate::input::DeleteRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1921 = writer.prefix("DestinationCidrBlock");
    if let Some(var_1922) = &input.destination_cidr_block {
        scope_1921.string(var_1922);
    }
    #[allow(unused_mut)]
    let mut scope_1923 = writer.prefix("DestinationIpv6CidrBlock");
    if let Some(var_1924) = &input.destination_ipv6_cidr_block {
        scope_1923.string(var_1924);
    }
    #[allow(unused_mut)]
    let mut scope_1925 = writer.prefix("DestinationPrefixListId");
    if let Some(var_1926) = &input.destination_prefix_list_id {
        scope_1925.string(var_1926);
    }
    #[allow(unused_mut)]
    let mut scope_1927 = writer.prefix("DryRun");
    if let Some(var_1928) = &input.dry_run {
        scope_1927.boolean(*var_1928);
    }
    #[allow(unused_mut)]
    let mut scope_1929 = writer.prefix("RouteTableId");
    if let Some(var_1930) = &input.route_table_id {
        scope_1929.string(var_1930);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_route_table(
    input: &crate::input::DeleteRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteRouteTable", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1931 = writer.prefix("DryRun");
    if let Some(var_1932) = &input.dry_run {
        scope_1931.boolean(*var_1932);
    }
    #[allow(unused_mut)]
    let mut scope_1933 = writer.prefix("RouteTableId");
    if let Some(var_1934) = &input.route_table_id {
        scope_1933.string(var_1934);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_security_group(
    input: &crate::input::DeleteSecurityGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteSecurityGroup", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1935 = writer.prefix("GroupId");
    if let Some(var_1936) = &input.group_id {
        scope_1935.string(var_1936);
    }
    #[allow(unused_mut)]
    let mut scope_1937 = writer.prefix("GroupName");
    if let Some(var_1938) = &input.group_name {
        scope_1937.string(var_1938);
    }
    #[allow(unused_mut)]
    let mut scope_1939 = writer.prefix("DryRun");
    if let Some(var_1940) = &input.dry_run {
        scope_1939.boolean(*var_1940);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_snapshot(
    input: &crate::input::DeleteSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteSnapshot", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1941 = writer.prefix("SnapshotId");
    if let Some(var_1942) = &input.snapshot_id {
        scope_1941.string(var_1942);
    }
    #[allow(unused_mut)]
    let mut scope_1943 = writer.prefix("DryRun");
    if let Some(var_1944) = &input.dry_run {
        scope_1943.boolean(*var_1944);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_spot_datafeed_subscription(
    input: &crate::input::DeleteSpotDatafeedSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteSpotDatafeedSubscription",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1945 = writer.prefix("DryRun");
    if let Some(var_1946) = &input.dry_run {
        scope_1945.boolean(*var_1946);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_subnet(
    input: &crate::input::DeleteSubnetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteSubnet", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1947 = writer.prefix("SubnetId");
    if let Some(var_1948) = &input.subnet_id {
        scope_1947.string(var_1948);
    }
    #[allow(unused_mut)]
    let mut scope_1949 = writer.prefix("DryRun");
    if let Some(var_1950) = &input.dry_run {
        scope_1949.boolean(*var_1950);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_subnet_cidr_reservation(
    input: &crate::input::DeleteSubnetCidrReservationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteSubnetCidrReservation", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1951 = writer.prefix("SubnetCidrReservationId");
    if let Some(var_1952) = &input.subnet_cidr_reservation_id {
        scope_1951.string(var_1952);
    }
    #[allow(unused_mut)]
    let mut scope_1953 = writer.prefix("DryRun");
    if let Some(var_1954) = &input.dry_run {
        scope_1953.boolean(*var_1954);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_tags(
    input: &crate::input::DeleteTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteTags", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1955 = writer.prefix("DryRun");
    if let Some(var_1956) = &input.dry_run {
        scope_1955.boolean(*var_1956);
    }
    #[allow(unused_mut)]
    let mut scope_1957 = writer.prefix("ResourceId");
    if let Some(var_1958) = &input.resources {
        let mut list_1960 = scope_1957.start_list(true, None);
        for item_1959 in var_1958 {
            #[allow(unused_mut)]
            let mut entry_1961 = list_1960.entry();
            entry_1961.string(item_1959);
        }
        list_1960.finish();
    }
    #[allow(unused_mut)]
    let mut scope_1962 = writer.prefix("Tag");
    if let Some(var_1963) = &input.tags {
        let mut list_1965 = scope_1962.start_list(true, Some("item"));
        for item_1964 in var_1963 {
            #[allow(unused_mut)]
            let mut entry_1966 = list_1965.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_1966, item_1964)?;
        }
        list_1965.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_traffic_mirror_filter(
    input: &crate::input::DeleteTrafficMirrorFilterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteTrafficMirrorFilter", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1967 = writer.prefix("TrafficMirrorFilterId");
    if let Some(var_1968) = &input.traffic_mirror_filter_id {
        scope_1967.string(var_1968);
    }
    #[allow(unused_mut)]
    let mut scope_1969 = writer.prefix("DryRun");
    if let Some(var_1970) = &input.dry_run {
        scope_1969.boolean(*var_1970);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_traffic_mirror_filter_rule(
    input: &crate::input::DeleteTrafficMirrorFilterRuleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteTrafficMirrorFilterRule", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1971 = writer.prefix("TrafficMirrorFilterRuleId");
    if let Some(var_1972) = &input.traffic_mirror_filter_rule_id {
        scope_1971.string(var_1972);
    }
    #[allow(unused_mut)]
    let mut scope_1973 = writer.prefix("DryRun");
    if let Some(var_1974) = &input.dry_run {
        scope_1973.boolean(*var_1974);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_traffic_mirror_session(
    input: &crate::input::DeleteTrafficMirrorSessionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteTrafficMirrorSession", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1975 = writer.prefix("TrafficMirrorSessionId");
    if let Some(var_1976) = &input.traffic_mirror_session_id {
        scope_1975.string(var_1976);
    }
    #[allow(unused_mut)]
    let mut scope_1977 = writer.prefix("DryRun");
    if let Some(var_1978) = &input.dry_run {
        scope_1977.boolean(*var_1978);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_traffic_mirror_target(
    input: &crate::input::DeleteTrafficMirrorTargetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteTrafficMirrorTarget", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1979 = writer.prefix("TrafficMirrorTargetId");
    if let Some(var_1980) = &input.traffic_mirror_target_id {
        scope_1979.string(var_1980);
    }
    #[allow(unused_mut)]
    let mut scope_1981 = writer.prefix("DryRun");
    if let Some(var_1982) = &input.dry_run {
        scope_1981.boolean(*var_1982);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway(
    input: &crate::input::DeleteTransitGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteTransitGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1983 = writer.prefix("TransitGatewayId");
    if let Some(var_1984) = &input.transit_gateway_id {
        scope_1983.string(var_1984);
    }
    #[allow(unused_mut)]
    let mut scope_1985 = writer.prefix("DryRun");
    if let Some(var_1986) = &input.dry_run {
        scope_1985.boolean(*var_1986);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway_connect(
    input: &crate::input::DeleteTransitGatewayConnectInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteTransitGatewayConnect", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_1987 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_1988) = &input.transit_gateway_attachment_id {
        scope_1987.string(var_1988);
    }
    #[allow(unused_mut)]
    let mut scope_1989 = writer.prefix("DryRun");
    if let Some(var_1990) = &input.dry_run {
        scope_1989.boolean(*var_1990);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway_connect_peer(
    input: &crate::input::DeleteTransitGatewayConnectPeerInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteTransitGatewayConnectPeer",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1991 = writer.prefix("TransitGatewayConnectPeerId");
    if let Some(var_1992) = &input.transit_gateway_connect_peer_id {
        scope_1991.string(var_1992);
    }
    #[allow(unused_mut)]
    let mut scope_1993 = writer.prefix("DryRun");
    if let Some(var_1994) = &input.dry_run {
        scope_1993.boolean(*var_1994);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway_multicast_domain(
    input: &crate::input::DeleteTransitGatewayMulticastDomainInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteTransitGatewayMulticastDomain",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1995 = writer.prefix("TransitGatewayMulticastDomainId");
    if let Some(var_1996) = &input.transit_gateway_multicast_domain_id {
        scope_1995.string(var_1996);
    }
    #[allow(unused_mut)]
    let mut scope_1997 = writer.prefix("DryRun");
    if let Some(var_1998) = &input.dry_run {
        scope_1997.boolean(*var_1998);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway_peering_attachment(
    input: &crate::input::DeleteTransitGatewayPeeringAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteTransitGatewayPeeringAttachment",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_1999 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_2000) = &input.transit_gateway_attachment_id {
        scope_1999.string(var_2000);
    }
    #[allow(unused_mut)]
    let mut scope_2001 = writer.prefix("DryRun");
    if let Some(var_2002) = &input.dry_run {
        scope_2001.boolean(*var_2002);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway_policy_table(
    input: &crate::input::DeleteTransitGatewayPolicyTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteTransitGatewayPolicyTable",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2003 = writer.prefix("TransitGatewayPolicyTableId");
    if let Some(var_2004) = &input.transit_gateway_policy_table_id {
        scope_2003.string(var_2004);
    }
    #[allow(unused_mut)]
    let mut scope_2005 = writer.prefix("DryRun");
    if let Some(var_2006) = &input.dry_run {
        scope_2005.boolean(*var_2006);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway_prefix_list_reference(
    input: &crate::input::DeleteTransitGatewayPrefixListReferenceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteTransitGatewayPrefixListReference",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2007 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_2008) = &input.transit_gateway_route_table_id {
        scope_2007.string(var_2008);
    }
    #[allow(unused_mut)]
    let mut scope_2009 = writer.prefix("PrefixListId");
    if let Some(var_2010) = &input.prefix_list_id {
        scope_2009.string(var_2010);
    }
    #[allow(unused_mut)]
    let mut scope_2011 = writer.prefix("DryRun");
    if let Some(var_2012) = &input.dry_run {
        scope_2011.boolean(*var_2012);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway_route(
    input: &crate::input::DeleteTransitGatewayRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteTransitGatewayRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2013 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_2014) = &input.transit_gateway_route_table_id {
        scope_2013.string(var_2014);
    }
    #[allow(unused_mut)]
    let mut scope_2015 = writer.prefix("DestinationCidrBlock");
    if let Some(var_2016) = &input.destination_cidr_block {
        scope_2015.string(var_2016);
    }
    #[allow(unused_mut)]
    let mut scope_2017 = writer.prefix("DryRun");
    if let Some(var_2018) = &input.dry_run {
        scope_2017.boolean(*var_2018);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway_route_table(
    input: &crate::input::DeleteTransitGatewayRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteTransitGatewayRouteTable",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2019 = writer.prefix("TransitGatewayRouteTableId");
    if let Some(var_2020) = &input.transit_gateway_route_table_id {
        scope_2019.string(var_2020);
    }
    #[allow(unused_mut)]
    let mut scope_2021 = writer.prefix("DryRun");
    if let Some(var_2022) = &input.dry_run {
        scope_2021.boolean(*var_2022);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway_route_table_announcement(
    input: &crate::input::DeleteTransitGatewayRouteTableAnnouncementInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteTransitGatewayRouteTableAnnouncement",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2023 = writer.prefix("TransitGatewayRouteTableAnnouncementId");
    if let Some(var_2024) = &input.transit_gateway_route_table_announcement_id {
        scope_2023.string(var_2024);
    }
    #[allow(unused_mut)]
    let mut scope_2025 = writer.prefix("DryRun");
    if let Some(var_2026) = &input.dry_run {
        scope_2025.boolean(*var_2026);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_transit_gateway_vpc_attachment(
    input: &crate::input::DeleteTransitGatewayVpcAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteTransitGatewayVpcAttachment",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2027 = writer.prefix("TransitGatewayAttachmentId");
    if let Some(var_2028) = &input.transit_gateway_attachment_id {
        scope_2027.string(var_2028);
    }
    #[allow(unused_mut)]
    let mut scope_2029 = writer.prefix("DryRun");
    if let Some(var_2030) = &input.dry_run {
        scope_2029.boolean(*var_2030);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_volume(
    input: &crate::input::DeleteVolumeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteVolume", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2031 = writer.prefix("VolumeId");
    if let Some(var_2032) = &input.volume_id {
        scope_2031.string(var_2032);
    }
    #[allow(unused_mut)]
    let mut scope_2033 = writer.prefix("DryRun");
    if let Some(var_2034) = &input.dry_run {
        scope_2033.boolean(*var_2034);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_vpc(
    input: &crate::input::DeleteVpcInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpc", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2035 = writer.prefix("VpcId");
    if let Some(var_2036) = &input.vpc_id {
        scope_2035.string(var_2036);
    }
    #[allow(unused_mut)]
    let mut scope_2037 = writer.prefix("DryRun");
    if let Some(var_2038) = &input.dry_run {
        scope_2037.boolean(*var_2038);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_vpc_endpoint_connection_notifications(
    input: &crate::input::DeleteVpcEndpointConnectionNotificationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteVpcEndpointConnectionNotifications",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2039 = writer.prefix("DryRun");
    if let Some(var_2040) = &input.dry_run {
        scope_2039.boolean(*var_2040);
    }
    #[allow(unused_mut)]
    let mut scope_2041 = writer.prefix("ConnectionNotificationId");
    if let Some(var_2042) = &input.connection_notification_ids {
        let mut list_2044 = scope_2041.start_list(true, Some("item"));
        for item_2043 in var_2042 {
            #[allow(unused_mut)]
            let mut entry_2045 = list_2044.entry();
            entry_2045.string(item_2043);
        }
        list_2044.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_vpc_endpoints(
    input: &crate::input::DeleteVpcEndpointsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpcEndpoints", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2046 = writer.prefix("DryRun");
    if let Some(var_2047) = &input.dry_run {
        scope_2046.boolean(*var_2047);
    }
    #[allow(unused_mut)]
    let mut scope_2048 = writer.prefix("VpcEndpointId");
    if let Some(var_2049) = &input.vpc_endpoint_ids {
        let mut list_2051 = scope_2048.start_list(true, Some("item"));
        for item_2050 in var_2049 {
            #[allow(unused_mut)]
            let mut entry_2052 = list_2051.entry();
            entry_2052.string(item_2050);
        }
        list_2051.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_vpc_endpoint_service_configurations(
    input: &crate::input::DeleteVpcEndpointServiceConfigurationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteVpcEndpointServiceConfigurations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2053 = writer.prefix("DryRun");
    if let Some(var_2054) = &input.dry_run {
        scope_2053.boolean(*var_2054);
    }
    #[allow(unused_mut)]
    let mut scope_2055 = writer.prefix("ServiceId");
    if let Some(var_2056) = &input.service_ids {
        let mut list_2058 = scope_2055.start_list(true, Some("item"));
        for item_2057 in var_2056 {
            #[allow(unused_mut)]
            let mut entry_2059 = list_2058.entry();
            entry_2059.string(item_2057);
        }
        list_2058.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_vpc_peering_connection(
    input: &crate::input::DeleteVpcPeeringConnectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpcPeeringConnection", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2060 = writer.prefix("DryRun");
    if let Some(var_2061) = &input.dry_run {
        scope_2060.boolean(*var_2061);
    }
    #[allow(unused_mut)]
    let mut scope_2062 = writer.prefix("VpcPeeringConnectionId");
    if let Some(var_2063) = &input.vpc_peering_connection_id {
        scope_2062.string(var_2063);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_vpn_connection(
    input: &crate::input::DeleteVpnConnectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpnConnection", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2064 = writer.prefix("VpnConnectionId");
    if let Some(var_2065) = &input.vpn_connection_id {
        scope_2064.string(var_2065);
    }
    #[allow(unused_mut)]
    let mut scope_2066 = writer.prefix("DryRun");
    if let Some(var_2067) = &input.dry_run {
        scope_2066.boolean(*var_2067);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_vpn_connection_route(
    input: &crate::input::DeleteVpnConnectionRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpnConnectionRoute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2068 = writer.prefix("DestinationCidrBlock");
    if let Some(var_2069) = &input.destination_cidr_block {
        scope_2068.string(var_2069);
    }
    #[allow(unused_mut)]
    let mut scope_2070 = writer.prefix("VpnConnectionId");
    if let Some(var_2071) = &input.vpn_connection_id {
        scope_2070.string(var_2071);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_vpn_gateway(
    input: &crate::input::DeleteVpnGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpnGateway", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2072 = writer.prefix("VpnGatewayId");
    if let Some(var_2073) = &input.vpn_gateway_id {
        scope_2072.string(var_2073);
    }
    #[allow(unused_mut)]
    let mut scope_2074 = writer.prefix("DryRun");
    if let Some(var_2075) = &input.dry_run {
        scope_2074.boolean(*var_2075);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_deprovision_byoip_cidr(
    input: &crate::input::DeprovisionByoipCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeprovisionByoipCidr", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2076 = writer.prefix("Cidr");
    if let Some(var_2077) = &input.cidr {
        scope_2076.string(var_2077);
    }
    #[allow(unused_mut)]
    let mut scope_2078 = writer.prefix("DryRun");
    if let Some(var_2079) = &input.dry_run {
        scope_2078.boolean(*var_2079);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_deprovision_ipam_pool_cidr(
    input: &crate::input::DeprovisionIpamPoolCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeprovisionIpamPoolCidr", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2080 = writer.prefix("DryRun");
    if let Some(var_2081) = &input.dry_run {
        scope_2080.boolean(*var_2081);
    }
    #[allow(unused_mut)]
    let mut scope_2082 = writer.prefix("IpamPoolId");
    if let Some(var_2083) = &input.ipam_pool_id {
        scope_2082.string(var_2083);
    }
    #[allow(unused_mut)]
    let mut scope_2084 = writer.prefix("Cidr");
    if let Some(var_2085) = &input.cidr {
        scope_2084.string(var_2085);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_deprovision_public_ipv4_pool_cidr(
    input: &crate::input::DeprovisionPublicIpv4PoolCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeprovisionPublicIpv4PoolCidr", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2086 = writer.prefix("DryRun");
    if let Some(var_2087) = &input.dry_run {
        scope_2086.boolean(*var_2087);
    }
    #[allow(unused_mut)]
    let mut scope_2088 = writer.prefix("PoolId");
    if let Some(var_2089) = &input.pool_id {
        scope_2088.string(var_2089);
    }
    #[allow(unused_mut)]
    let mut scope_2090 = writer.prefix("Cidr");
    if let Some(var_2091) = &input.cidr {
        scope_2090.string(var_2091);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_deregister_image(
    input: &crate::input::DeregisterImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeregisterImage", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2092 = writer.prefix("ImageId");
    if let Some(var_2093) = &input.image_id {
        scope_2092.string(var_2093);
    }
    #[allow(unused_mut)]
    let mut scope_2094 = writer.prefix("DryRun");
    if let Some(var_2095) = &input.dry_run {
        scope_2094.boolean(*var_2095);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_deregister_instance_event_notification_attributes(
    input: &crate::input::DeregisterInstanceEventNotificationAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeregisterInstanceEventNotificationAttributes",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2096 = writer.prefix("DryRun");
    if let Some(var_2097) = &input.dry_run {
        scope_2096.boolean(*var_2097);
    }
    #[allow(unused_mut)]
    let mut scope_2098 = writer.prefix("InstanceTagAttribute");
    if let Some(var_2099) = &input.instance_tag_attribute {
        crate::query_ser::serialize_structure_crate_model_deregister_instance_tag_attribute_request(scope_2098, var_2099)?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_deregister_transit_gateway_multicast_group_members(
    input: &crate::input::DeregisterTransitGatewayMulticastGroupMembersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeregisterTransitGatewayMulticastGroupMembers",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2100 = writer.prefix("TransitGatewayMulticastDomainId");
    if let Some(var_2101) = &input.transit_gateway_multicast_domain_id {
        scope_2100.string(var_2101);
    }
    #[allow(unused_mut)]
    let mut scope_2102 = writer.prefix("GroupIpAddress");
    if let Some(var_2103) = &input.group_ip_address {
        scope_2102.string(var_2103);
    }
    #[allow(unused_mut)]
    let mut scope_2104 = writer.prefix("NetworkInterfaceIds");
    if let Some(var_2105) = &input.network_interface_ids {
        let mut list_2107 = scope_2104.start_list(true, Some("item"));
        for item_2106 in var_2105 {
            #[allow(unused_mut)]
            let mut entry_2108 = list_2107.entry();
            entry_2108.string(item_2106);
        }
        list_2107.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2109 = writer.prefix("DryRun");
    if let Some(var_2110) = &input.dry_run {
        scope_2109.boolean(*var_2110);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_deregister_transit_gateway_multicast_group_sources(
    input: &crate::input::DeregisterTransitGatewayMulticastGroupSourcesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeregisterTransitGatewayMulticastGroupSources",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2111 = writer.prefix("TransitGatewayMulticastDomainId");
    if let Some(var_2112) = &input.transit_gateway_multicast_domain_id {
        scope_2111.string(var_2112);
    }
    #[allow(unused_mut)]
    let mut scope_2113 = writer.prefix("GroupIpAddress");
    if let Some(var_2114) = &input.group_ip_address {
        scope_2113.string(var_2114);
    }
    #[allow(unused_mut)]
    let mut scope_2115 = writer.prefix("NetworkInterfaceIds");
    if let Some(var_2116) = &input.network_interface_ids {
        let mut list_2118 = scope_2115.start_list(true, Some("item"));
        for item_2117 in var_2116 {
            #[allow(unused_mut)]
            let mut entry_2119 = list_2118.entry();
            entry_2119.string(item_2117);
        }
        list_2118.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2120 = writer.prefix("DryRun");
    if let Some(var_2121) = &input.dry_run {
        scope_2120.boolean(*var_2121);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_account_attributes(
    input: &crate::input::DescribeAccountAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeAccountAttributes", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2122 = writer.prefix("AttributeName");
    if let Some(var_2123) = &input.attribute_names {
        let mut list_2125 = scope_2122.start_list(true, Some("attributeName"));
        for item_2124 in var_2123 {
            #[allow(unused_mut)]
            let mut entry_2126 = list_2125.entry();
            entry_2126.string(item_2124.as_str());
        }
        list_2125.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2127 = writer.prefix("DryRun");
    if let Some(var_2128) = &input.dry_run {
        scope_2127.boolean(*var_2128);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_addresses(
    input: &crate::input::DescribeAddressesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeAddresses", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2129 = writer.prefix("Filter");
    if let Some(var_2130) = &input.filters {
        let mut list_2132 = scope_2129.start_list(true, Some("Filter"));
        for item_2131 in var_2130 {
            #[allow(unused_mut)]
            let mut entry_2133 = list_2132.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2133, item_2131)?;
        }
        list_2132.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2134 = writer.prefix("PublicIp");
    if let Some(var_2135) = &input.public_ips {
        let mut list_2137 = scope_2134.start_list(true, Some("PublicIp"));
        for item_2136 in var_2135 {
            #[allow(unused_mut)]
            let mut entry_2138 = list_2137.entry();
            entry_2138.string(item_2136);
        }
        list_2137.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2139 = writer.prefix("AllocationId");
    if let Some(var_2140) = &input.allocation_ids {
        let mut list_2142 = scope_2139.start_list(true, Some("AllocationId"));
        for item_2141 in var_2140 {
            #[allow(unused_mut)]
            let mut entry_2143 = list_2142.entry();
            entry_2143.string(item_2141);
        }
        list_2142.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2144 = writer.prefix("DryRun");
    if let Some(var_2145) = &input.dry_run {
        scope_2144.boolean(*var_2145);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_addresses_attribute(
    input: &crate::input::DescribeAddressesAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeAddressesAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2146 = writer.prefix("AllocationId");
    if let Some(var_2147) = &input.allocation_ids {
        let mut list_2149 = scope_2146.start_list(true, Some("item"));
        for item_2148 in var_2147 {
            #[allow(unused_mut)]
            let mut entry_2150 = list_2149.entry();
            entry_2150.string(item_2148);
        }
        list_2149.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2151 = writer.prefix("Attribute");
    if let Some(var_2152) = &input.attribute {
        scope_2151.string(var_2152.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_2153 = writer.prefix("NextToken");
    if let Some(var_2154) = &input.next_token {
        scope_2153.string(var_2154);
    }
    #[allow(unused_mut)]
    let mut scope_2155 = writer.prefix("MaxResults");
    if let Some(var_2156) = &input.max_results {
        scope_2155.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2156).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2157 = writer.prefix("DryRun");
    if let Some(var_2158) = &input.dry_run {
        scope_2157.boolean(*var_2158);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_aggregate_id_format(
    input: &crate::input::DescribeAggregateIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeAggregateIdFormat", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2159 = writer.prefix("DryRun");
    if let Some(var_2160) = &input.dry_run {
        scope_2159.boolean(*var_2160);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_availability_zones(
    input: &crate::input::DescribeAvailabilityZonesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeAvailabilityZones", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2161 = writer.prefix("Filter");
    if let Some(var_2162) = &input.filters {
        let mut list_2164 = scope_2161.start_list(true, Some("Filter"));
        for item_2163 in var_2162 {
            #[allow(unused_mut)]
            let mut entry_2165 = list_2164.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2165, item_2163)?;
        }
        list_2164.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2166 = writer.prefix("ZoneName");
    if let Some(var_2167) = &input.zone_names {
        let mut list_2169 = scope_2166.start_list(true, Some("ZoneName"));
        for item_2168 in var_2167 {
            #[allow(unused_mut)]
            let mut entry_2170 = list_2169.entry();
            entry_2170.string(item_2168);
        }
        list_2169.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2171 = writer.prefix("ZoneId");
    if let Some(var_2172) = &input.zone_ids {
        let mut list_2174 = scope_2171.start_list(true, Some("ZoneId"));
        for item_2173 in var_2172 {
            #[allow(unused_mut)]
            let mut entry_2175 = list_2174.entry();
            entry_2175.string(item_2173);
        }
        list_2174.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2176 = writer.prefix("AllAvailabilityZones");
    if let Some(var_2177) = &input.all_availability_zones {
        scope_2176.boolean(*var_2177);
    }
    #[allow(unused_mut)]
    let mut scope_2178 = writer.prefix("DryRun");
    if let Some(var_2179) = &input.dry_run {
        scope_2178.boolean(*var_2179);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_bundle_tasks(
    input: &crate::input::DescribeBundleTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeBundleTasks", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2180 = writer.prefix("BundleId");
    if let Some(var_2181) = &input.bundle_ids {
        let mut list_2183 = scope_2180.start_list(true, Some("BundleId"));
        for item_2182 in var_2181 {
            #[allow(unused_mut)]
            let mut entry_2184 = list_2183.entry();
            entry_2184.string(item_2182);
        }
        list_2183.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2185 = writer.prefix("Filter");
    if let Some(var_2186) = &input.filters {
        let mut list_2188 = scope_2185.start_list(true, Some("Filter"));
        for item_2187 in var_2186 {
            #[allow(unused_mut)]
            let mut entry_2189 = list_2188.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2189, item_2187)?;
        }
        list_2188.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2190 = writer.prefix("DryRun");
    if let Some(var_2191) = &input.dry_run {
        scope_2190.boolean(*var_2191);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_byoip_cidrs(
    input: &crate::input::DescribeByoipCidrsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeByoipCidrs", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2192 = writer.prefix("DryRun");
    if let Some(var_2193) = &input.dry_run {
        scope_2192.boolean(*var_2193);
    }
    #[allow(unused_mut)]
    let mut scope_2194 = writer.prefix("MaxResults");
    if let Some(var_2195) = &input.max_results {
        scope_2194.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2195).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2196 = writer.prefix("NextToken");
    if let Some(var_2197) = &input.next_token {
        scope_2196.string(var_2197);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_capacity_reservation_fleets(
    input: &crate::input::DescribeCapacityReservationFleetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DescribeCapacityReservationFleets",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2198 = writer.prefix("CapacityReservationFleetId");
    if let Some(var_2199) = &input.capacity_reservation_fleet_ids {
        let mut list_2201 = scope_2198.start_list(true, Some("item"));
        for item_2200 in var_2199 {
            #[allow(unused_mut)]
            let mut entry_2202 = list_2201.entry();
            entry_2202.string(item_2200);
        }
        list_2201.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2203 = writer.prefix("NextToken");
    if let Some(var_2204) = &input.next_token {
        scope_2203.string(var_2204);
    }
    #[allow(unused_mut)]
    let mut scope_2205 = writer.prefix("MaxResults");
    if let Some(var_2206) = &input.max_results {
        scope_2205.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2206).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2207 = writer.prefix("Filter");
    if let Some(var_2208) = &input.filters {
        let mut list_2210 = scope_2207.start_list(true, Some("Filter"));
        for item_2209 in var_2208 {
            #[allow(unused_mut)]
            let mut entry_2211 = list_2210.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2211, item_2209)?;
        }
        list_2210.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2212 = writer.prefix("DryRun");
    if let Some(var_2213) = &input.dry_run {
        scope_2212.boolean(*var_2213);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_capacity_reservations(
    input: &crate::input::DescribeCapacityReservationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeCapacityReservations", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2214 = writer.prefix("CapacityReservationId");
    if let Some(var_2215) = &input.capacity_reservation_ids {
        let mut list_2217 = scope_2214.start_list(true, Some("item"));
        for item_2216 in var_2215 {
            #[allow(unused_mut)]
            let mut entry_2218 = list_2217.entry();
            entry_2218.string(item_2216);
        }
        list_2217.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2219 = writer.prefix("NextToken");
    if let Some(var_2220) = &input.next_token {
        scope_2219.string(var_2220);
    }
    #[allow(unused_mut)]
    let mut scope_2221 = writer.prefix("MaxResults");
    if let Some(var_2222) = &input.max_results {
        scope_2221.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2222).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2223 = writer.prefix("Filter");
    if let Some(var_2224) = &input.filters {
        let mut list_2226 = scope_2223.start_list(true, Some("Filter"));
        for item_2225 in var_2224 {
            #[allow(unused_mut)]
            let mut entry_2227 = list_2226.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2227, item_2225)?;
        }
        list_2226.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2228 = writer.prefix("DryRun");
    if let Some(var_2229) = &input.dry_run {
        scope_2228.boolean(*var_2229);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_carrier_gateways(
    input: &crate::input::DescribeCarrierGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeCarrierGateways", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2230 = writer.prefix("CarrierGatewayId");
    if let Some(var_2231) = &input.carrier_gateway_ids {
        let mut list_2233 = scope_2230.start_list(true, None);
        for item_2232 in var_2231 {
            #[allow(unused_mut)]
            let mut entry_2234 = list_2233.entry();
            entry_2234.string(item_2232);
        }
        list_2233.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2235 = writer.prefix("Filter");
    if let Some(var_2236) = &input.filters {
        let mut list_2238 = scope_2235.start_list(true, Some("Filter"));
        for item_2237 in var_2236 {
            #[allow(unused_mut)]
            let mut entry_2239 = list_2238.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2239, item_2237)?;
        }
        list_2238.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2240 = writer.prefix("MaxResults");
    if let Some(var_2241) = &input.max_results {
        scope_2240.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2241).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2242 = writer.prefix("NextToken");
    if let Some(var_2243) = &input.next_token {
        scope_2242.string(var_2243);
    }
    #[allow(unused_mut)]
    let mut scope_2244 = writer.prefix("DryRun");
    if let Some(var_2245) = &input.dry_run {
        scope_2244.boolean(*var_2245);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_classic_link_instances(
    input: &crate::input::DescribeClassicLinkInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeClassicLinkInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2246 = writer.prefix("Filter");
    if let Some(var_2247) = &input.filters {
        let mut list_2249 = scope_2246.start_list(true, Some("Filter"));
        for item_2248 in var_2247 {
            #[allow(unused_mut)]
            let mut entry_2250 = list_2249.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2250, item_2248)?;
        }
        list_2249.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2251 = writer.prefix("DryRun");
    if let Some(var_2252) = &input.dry_run {
        scope_2251.boolean(*var_2252);
    }
    #[allow(unused_mut)]
    let mut scope_2253 = writer.prefix("InstanceId");
    if let Some(var_2254) = &input.instance_ids {
        let mut list_2256 = scope_2253.start_list(true, Some("InstanceId"));
        for item_2255 in var_2254 {
            #[allow(unused_mut)]
            let mut entry_2257 = list_2256.entry();
            entry_2257.string(item_2255);
        }
        list_2256.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2258 = writer.prefix("MaxResults");
    if let Some(var_2259) = &input.max_results {
        scope_2258.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2259).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2260 = writer.prefix("NextToken");
    if let Some(var_2261) = &input.next_token {
        scope_2260.string(var_2261);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_client_vpn_authorization_rules(
    input: &crate::input::DescribeClientVpnAuthorizationRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DescribeClientVpnAuthorizationRules",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2262 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_2263) = &input.client_vpn_endpoint_id {
        scope_2262.string(var_2263);
    }
    #[allow(unused_mut)]
    let mut scope_2264 = writer.prefix("DryRun");
    if let Some(var_2265) = &input.dry_run {
        scope_2264.boolean(*var_2265);
    }
    #[allow(unused_mut)]
    let mut scope_2266 = writer.prefix("NextToken");
    if let Some(var_2267) = &input.next_token {
        scope_2266.string(var_2267);
    }
    #[allow(unused_mut)]
    let mut scope_2268 = writer.prefix("Filter");
    if let Some(var_2269) = &input.filters {
        let mut list_2271 = scope_2268.start_list(true, Some("Filter"));
        for item_2270 in var_2269 {
            #[allow(unused_mut)]
            let mut entry_2272 = list_2271.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2272, item_2270)?;
        }
        list_2271.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2273 = writer.prefix("MaxResults");
    if let Some(var_2274) = &input.max_results {
        scope_2273.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2274).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_client_vpn_connections(
    input: &crate::input::DescribeClientVpnConnectionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeClientVpnConnections", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2275 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_2276) = &input.client_vpn_endpoint_id {
        scope_2275.string(var_2276);
    }
    #[allow(unused_mut)]
    let mut scope_2277 = writer.prefix("Filter");
    if let Some(var_2278) = &input.filters {
        let mut list_2280 = scope_2277.start_list(true, Some("Filter"));
        for item_2279 in var_2278 {
            #[allow(unused_mut)]
            let mut entry_2281 = list_2280.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2281, item_2279)?;
        }
        list_2280.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2282 = writer.prefix("NextToken");
    if let Some(var_2283) = &input.next_token {
        scope_2282.string(var_2283);
    }
    #[allow(unused_mut)]
    let mut scope_2284 = writer.prefix("MaxResults");
    if let Some(var_2285) = &input.max_results {
        scope_2284.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2285).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2286 = writer.prefix("DryRun");
    if let Some(var_2287) = &input.dry_run {
        scope_2286.boolean(*var_2287);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_client_vpn_endpoints(
    input: &crate::input::DescribeClientVpnEndpointsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeClientVpnEndpoints", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2288 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_2289) = &input.client_vpn_endpoint_ids {
        let mut list_2291 = scope_2288.start_list(true, Some("item"));
        for item_2290 in var_2289 {
            #[allow(unused_mut)]
            let mut entry_2292 = list_2291.entry();
            entry_2292.string(item_2290);
        }
        list_2291.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2293 = writer.prefix("MaxResults");
    if let Some(var_2294) = &input.max_results {
        scope_2293.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2294).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2295 = writer.prefix("NextToken");
    if let Some(var_2296) = &input.next_token {
        scope_2295.string(var_2296);
    }
    #[allow(unused_mut)]
    let mut scope_2297 = writer.prefix("Filter");
    if let Some(var_2298) = &input.filters {
        let mut list_2300 = scope_2297.start_list(true, Some("Filter"));
        for item_2299 in var_2298 {
            #[allow(unused_mut)]
            let mut entry_2301 = list_2300.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2301, item_2299)?;
        }
        list_2300.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2302 = writer.prefix("DryRun");
    if let Some(var_2303) = &input.dry_run {
        scope_2302.boolean(*var_2303);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_client_vpn_routes(
    input: &crate::input::DescribeClientVpnRoutesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeClientVpnRoutes", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2304 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_2305) = &input.client_vpn_endpoint_id {
        scope_2304.string(var_2305);
    }
    #[allow(unused_mut)]
    let mut scope_2306 = writer.prefix("Filter");
    if let Some(var_2307) = &input.filters {
        let mut list_2309 = scope_2306.start_list(true, Some("Filter"));
        for item_2308 in var_2307 {
            #[allow(unused_mut)]
            let mut entry_2310 = list_2309.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2310, item_2308)?;
        }
        list_2309.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2311 = writer.prefix("MaxResults");
    if let Some(var_2312) = &input.max_results {
        scope_2311.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2312).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2313 = writer.prefix("NextToken");
    if let Some(var_2314) = &input.next_token {
        scope_2313.string(var_2314);
    }
    #[allow(unused_mut)]
    let mut scope_2315 = writer.prefix("DryRun");
    if let Some(var_2316) = &input.dry_run {
        scope_2315.boolean(*var_2316);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_client_vpn_target_networks(
    input: &crate::input::DescribeClientVpnTargetNetworksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DescribeClientVpnTargetNetworks",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2317 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_2318) = &input.client_vpn_endpoint_id {
        scope_2317.string(var_2318);
    }
    #[allow(unused_mut)]
    let mut scope_2319 = writer.prefix("AssociationIds");
    if let Some(var_2320) = &input.association_ids {
        let mut list_2322 = scope_2319.start_list(true, Some("item"));
        for item_2321 in var_2320 {
            #[allow(unused_mut)]
            let mut entry_2323 = list_2322.entry();
            entry_2323.string(item_2321);
        }
        list_2322.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2324 = writer.prefix("MaxResults");
    if let Some(var_2325) = &input.max_results {
        scope_2324.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2325).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2326 = writer.prefix("NextToken");
    if let Some(var_2327) = &input.next_token {
        scope_2326.string(var_2327);
    }
    #[allow(unused_mut)]
    let mut scope_2328 = writer.prefix("Filter");
    if let Some(var_2329) = &input.filters {
        let mut list_2331 = scope_2328.start_list(true, Some("Filter"));
        for item_2330 in var_2329 {
            #[allow(unused_mut)]
            let mut entry_2332 = list_2331.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2332, item_2330)?;
        }
        list_2331.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2333 = writer.prefix("DryRun");
    if let Some(var_2334) = &input.dry_run {
        scope_2333.boolean(*var_2334);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_coip_pools(
    input: &crate::input::DescribeCoipPoolsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeCoipPools", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2335 = writer.prefix("PoolId");
    if let Some(var_2336) = &input.pool_ids {
        let mut list_2338 = scope_2335.start_list(true, Some("item"));
        for item_2337 in var_2336 {
            #[allow(unused_mut)]
            let mut entry_2339 = list_2338.entry();
            entry_2339.string(item_2337);
        }
        list_2338.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2340 = writer.prefix("Filter");
    if let Some(var_2341) = &input.filters {
        let mut list_2343 = scope_2340.start_list(true, Some("Filter"));
        for item_2342 in var_2341 {
            #[allow(unused_mut)]
            let mut entry_2344 = list_2343.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2344, item_2342)?;
        }
        list_2343.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2345 = writer.prefix("MaxResults");
    if let Some(var_2346) = &input.max_results {
        scope_2345.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2346).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2347 = writer.prefix("NextToken");
    if let Some(var_2348) = &input.next_token {
        scope_2347.string(var_2348);
    }
    #[allow(unused_mut)]
    let mut scope_2349 = writer.prefix("DryRun");
    if let Some(var_2350) = &input.dry_run {
        scope_2349.boolean(*var_2350);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_conversion_tasks(
    input: &crate::input::DescribeConversionTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeConversionTasks", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2351 = writer.prefix("ConversionTaskId");
    if let Some(var_2352) = &input.conversion_task_ids {
        let mut list_2354 = scope_2351.start_list(true, Some("item"));
        for item_2353 in var_2352 {
            #[allow(unused_mut)]
            let mut entry_2355 = list_2354.entry();
            entry_2355.string(item_2353);
        }
        list_2354.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2356 = writer.prefix("DryRun");
    if let Some(var_2357) = &input.dry_run {
        scope_2356.boolean(*var_2357);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_customer_gateways(
    input: &crate::input::DescribeCustomerGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeCustomerGateways", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2358 = writer.prefix("CustomerGatewayId");
    if let Some(var_2359) = &input.customer_gateway_ids {
        let mut list_2361 = scope_2358.start_list(true, Some("CustomerGatewayId"));
        for item_2360 in var_2359 {
            #[allow(unused_mut)]
            let mut entry_2362 = list_2361.entry();
            entry_2362.string(item_2360);
        }
        list_2361.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2363 = writer.prefix("Filter");
    if let Some(var_2364) = &input.filters {
        let mut list_2366 = scope_2363.start_list(true, Some("Filter"));
        for item_2365 in var_2364 {
            #[allow(unused_mut)]
            let mut entry_2367 = list_2366.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2367, item_2365)?;
        }
        list_2366.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2368 = writer.prefix("DryRun");
    if let Some(var_2369) = &input.dry_run {
        scope_2368.boolean(*var_2369);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_dhcp_options(
    input: &crate::input::DescribeDhcpOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeDhcpOptions", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2370 = writer.prefix("DhcpOptionsId");
    if let Some(var_2371) = &input.dhcp_options_ids {
        let mut list_2373 = scope_2370.start_list(true, Some("DhcpOptionsId"));
        for item_2372 in var_2371 {
            #[allow(unused_mut)]
            let mut entry_2374 = list_2373.entry();
            entry_2374.string(item_2372);
        }
        list_2373.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2375 = writer.prefix("Filter");
    if let Some(var_2376) = &input.filters {
        let mut list_2378 = scope_2375.start_list(true, Some("Filter"));
        for item_2377 in var_2376 {
            #[allow(unused_mut)]
            let mut entry_2379 = list_2378.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2379, item_2377)?;
        }
        list_2378.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2380 = writer.prefix("DryRun");
    if let Some(var_2381) = &input.dry_run {
        scope_2380.boolean(*var_2381);
    }
    #[allow(unused_mut)]
    let mut scope_2382 = writer.prefix("NextToken");
    if let Some(var_2383) = &input.next_token {
        scope_2382.string(var_2383);
    }
    #[allow(unused_mut)]
    let mut scope_2384 = writer.prefix("MaxResults");
    if let Some(var_2385) = &input.max_results {
        scope_2384.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2385).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_egress_only_internet_gateways(
    input: &crate::input::DescribeEgressOnlyInternetGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DescribeEgressOnlyInternetGateways",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2386 = writer.prefix("DryRun");
    if let Some(var_2387) = &input.dry_run {
        scope_2386.boolean(*var_2387);
    }
    #[allow(unused_mut)]
    let mut scope_2388 = writer.prefix("EgressOnlyInternetGatewayId");
    if let Some(var_2389) = &input.egress_only_internet_gateway_ids {
        let mut list_2391 = scope_2388.start_list(true, Some("item"));
        for item_2390 in var_2389 {
            #[allow(unused_mut)]
            let mut entry_2392 = list_2391.entry();
            entry_2392.string(item_2390);
        }
        list_2391.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2393 = writer.prefix("MaxResults");
    if let Some(var_2394) = &input.max_results {
        scope_2393.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2394).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2395 = writer.prefix("NextToken");
    if let Some(var_2396) = &input.next_token {
        scope_2395.string(var_2396);
    }
    #[allow(unused_mut)]
    let mut scope_2397 = writer.prefix("Filter");
    if let Some(var_2398) = &input.filters {
        let mut list_2400 = scope_2397.start_list(true, Some("Filter"));
        for item_2399 in var_2398 {
            #[allow(unused_mut)]
            let mut entry_2401 = list_2400.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2401, item_2399)?;
        }
        list_2400.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_elastic_gpus(
    input: &crate::input::DescribeElasticGpusInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeElasticGpus", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2402 = writer.prefix("ElasticGpuId");
    if let Some(var_2403) = &input.elastic_gpu_ids {
        let mut list_2405 = scope_2402.start_list(true, Some("item"));
        for item_2404 in var_2403 {
            #[allow(unused_mut)]
            let mut entry_2406 = list_2405.entry();
            entry_2406.string(item_2404);
        }
        list_2405.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2407 = writer.prefix("DryRun");
    if let Some(var_2408) = &input.dry_run {
        scope_2407.boolean(*var_2408);
    }
    #[allow(unused_mut)]
    let mut scope_2409 = writer.prefix("Filter");
    if let Some(var_2410) = &input.filters {
        let mut list_2412 = scope_2409.start_list(true, Some("Filter"));
        for item_2411 in var_2410 {
            #[allow(unused_mut)]
            let mut entry_2413 = list_2412.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2413, item_2411)?;
        }
        list_2412.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2414 = writer.prefix("MaxResults");
    if let Some(var_2415) = &input.max_results {
        scope_2414.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2415).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2416 = writer.prefix("NextToken");
    if let Some(var_2417) = &input.next_token {
        scope_2416.string(var_2417);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_export_image_tasks(
    input: &crate::input::DescribeExportImageTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeExportImageTasks", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2418 = writer.prefix("DryRun");
    if let Some(var_2419) = &input.dry_run {
        scope_2418.boolean(*var_2419);
    }
    #[allow(unused_mut)]
    let mut scope_2420 = writer.prefix("Filter");
    if let Some(var_2421) = &input.filters {
        let mut list_2423 = scope_2420.start_list(true, Some("Filter"));
        for item_2422 in var_2421 {
            #[allow(unused_mut)]
            let mut entry_2424 = list_2423.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2424, item_2422)?;
        }
        list_2423.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2425 = writer.prefix("ExportImageTaskId");
    if let Some(var_2426) = &input.export_image_task_ids {
        let mut list_2428 = scope_2425.start_list(true, Some("ExportImageTaskId"));
        for item_2427 in var_2426 {
            #[allow(unused_mut)]
            let mut entry_2429 = list_2428.entry();
            entry_2429.string(item_2427);
        }
        list_2428.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2430 = writer.prefix("MaxResults");
    if let Some(var_2431) = &input.max_results {
        scope_2430.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2431).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2432 = writer.prefix("NextToken");
    if let Some(var_2433) = &input.next_token {
        scope_2432.string(var_2433);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_export_tasks(
    input: &crate::input::DescribeExportTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeExportTasks", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2434 = writer.prefix("ExportTaskId");
    if let Some(var_2435) = &input.export_task_ids {
        let mut list_2437 = scope_2434.start_list(true, Some("ExportTaskId"));
        for item_2436 in var_2435 {
            #[allow(unused_mut)]
            let mut entry_2438 = list_2437.entry();
            entry_2438.string(item_2436);
        }
        list_2437.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2439 = writer.prefix("Filter");
    if let Some(var_2440) = &input.filters {
        let mut list_2442 = scope_2439.start_list(true, Some("Filter"));
        for item_2441 in var_2440 {
            #[allow(unused_mut)]
            let mut entry_2443 = list_2442.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2443, item_2441)?;
        }
        list_2442.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_fast_launch_images(
    input: &crate::input::DescribeFastLaunchImagesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeFastLaunchImages", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2444 = writer.prefix("ImageId");
    if let Some(var_2445) = &input.image_ids {
        let mut list_2447 = scope_2444.start_list(true, Some("ImageId"));
        for item_2446 in var_2445 {
            #[allow(unused_mut)]
            let mut entry_2448 = list_2447.entry();
            entry_2448.string(item_2446);
        }
        list_2447.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2449 = writer.prefix("Filter");
    if let Some(var_2450) = &input.filters {
        let mut list_2452 = scope_2449.start_list(true, Some("Filter"));
        for item_2451 in var_2450 {
            #[allow(unused_mut)]
            let mut entry_2453 = list_2452.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2453, item_2451)?;
        }
        list_2452.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2454 = writer.prefix("MaxResults");
    if let Some(var_2455) = &input.max_results {
        scope_2454.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2455).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2456 = writer.prefix("NextToken");
    if let Some(var_2457) = &input.next_token {
        scope_2456.string(var_2457);
    }
    #[allow(unused_mut)]
    let mut scope_2458 = writer.prefix("DryRun");
    if let Some(var_2459) = &input.dry_run {
        scope_2458.boolean(*var_2459);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_fast_snapshot_restores(
    input: &crate::input::DescribeFastSnapshotRestoresInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeFastSnapshotRestores", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2460 = writer.prefix("Filter");
    if let Some(var_2461) = &input.filters {
        let mut list_2463 = scope_2460.start_list(true, Some("Filter"));
        for item_2462 in var_2461 {
            #[allow(unused_mut)]
            let mut entry_2464 = list_2463.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2464, item_2462)?;
        }
        list_2463.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2465 = writer.prefix("MaxResults");
    if let Some(var_2466) = &input.max_results {
        scope_2465.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2466).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2467 = writer.prefix("NextToken");
    if let Some(var_2468) = &input.next_token {
        scope_2467.string(var_2468);
    }
    #[allow(unused_mut)]
    let mut scope_2469 = writer.prefix("DryRun");
    if let Some(var_2470) = &input.dry_run {
        scope_2469.boolean(*var_2470);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_fleet_history(
    input: &crate::input::DescribeFleetHistoryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeFleetHistory", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2471 = writer.prefix("DryRun");
    if let Some(var_2472) = &input.dry_run {
        scope_2471.boolean(*var_2472);
    }
    #[allow(unused_mut)]
    let mut scope_2473 = writer.prefix("EventType");
    if let Some(var_2474) = &input.event_type {
        scope_2473.string(var_2474.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_2475 = writer.prefix("MaxResults");
    if let Some(var_2476) = &input.max_results {
        scope_2475.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2476).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2477 = writer.prefix("NextToken");
    if let Some(var_2478) = &input.next_token {
        scope_2477.string(var_2478);
    }
    #[allow(unused_mut)]
    let mut scope_2479 = writer.prefix("FleetId");
    if let Some(var_2480) = &input.fleet_id {
        scope_2479.string(var_2480);
    }
    #[allow(unused_mut)]
    let mut scope_2481 = writer.prefix("StartTime");
    if let Some(var_2482) = &input.start_time {
        scope_2481.date_time(var_2482, aws_smithy_types::date_time::Format::DateTime)?;
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_fleet_instances(
    input: &crate::input::DescribeFleetInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeFleetInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2483 = writer.prefix("DryRun");
    if let Some(var_2484) = &input.dry_run {
        scope_2483.boolean(*var_2484);
    }
    #[allow(unused_mut)]
    let mut scope_2485 = writer.prefix("MaxResults");
    if let Some(var_2486) = &input.max_results {
        scope_2485.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2486).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2487 = writer.prefix("NextToken");
    if let Some(var_2488) = &input.next_token {
        scope_2487.string(var_2488);
    }
    #[allow(unused_mut)]
    let mut scope_2489 = writer.prefix("FleetId");
    if let Some(var_2490) = &input.fleet_id {
        scope_2489.string(var_2490);
    }
    #[allow(unused_mut)]
    let mut scope_2491 = writer.prefix("Filter");
    if let Some(var_2492) = &input.filters {
        let mut list_2494 = scope_2491.start_list(true, Some("Filter"));
        for item_2493 in var_2492 {
            #[allow(unused_mut)]
            let mut entry_2495 = list_2494.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2495, item_2493)?;
        }
        list_2494.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_fleets(
    input: &crate::input::DescribeFleetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeFleets", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2496 = writer.prefix("DryRun");
    if let Some(var_2497) = &input.dry_run {
        scope_2496.boolean(*var_2497);
    }
    #[allow(unused_mut)]
    let mut scope_2498 = writer.prefix("MaxResults");
    if let Some(var_2499) = &input.max_results {
        scope_2498.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2499).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2500 = writer.prefix("NextToken");
    if let Some(var_2501) = &input.next_token {
        scope_2500.string(var_2501);
    }
    #[allow(unused_mut)]
    let mut scope_2502 = writer.prefix("FleetId");
    if let Some(var_2503) = &input.fleet_ids {
        let mut list_2505 = scope_2502.start_list(true, None);
        for item_2504 in var_2503 {
            #[allow(unused_mut)]
            let mut entry_2506 = list_2505.entry();
            entry_2506.string(item_2504);
        }
        list_2505.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2507 = writer.prefix("Filter");
    if let Some(var_2508) = &input.filters {
        let mut list_2510 = scope_2507.start_list(true, Some("Filter"));
        for item_2509 in var_2508 {
            #[allow(unused_mut)]
            let mut entry_2511 = list_2510.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2511, item_2509)?;
        }
        list_2510.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_flow_logs(
    input: &crate::input::DescribeFlowLogsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeFlowLogs", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2512 = writer.prefix("DryRun");
    if let Some(var_2513) = &input.dry_run {
        scope_2512.boolean(*var_2513);
    }
    #[allow(unused_mut)]
    let mut scope_2514 = writer.prefix("Filter");
    if let Some(var_2515) = &input.filter {
        let mut list_2517 = scope_2514.start_list(true, Some("Filter"));
        for item_2516 in var_2515 {
            #[allow(unused_mut)]
            let mut entry_2518 = list_2517.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2518, item_2516)?;
        }
        list_2517.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2519 = writer.prefix("FlowLogId");
    if let Some(var_2520) = &input.flow_log_ids {
        let mut list_2522 = scope_2519.start_list(true, Some("item"));
        for item_2521 in var_2520 {
            #[allow(unused_mut)]
            let mut entry_2523 = list_2522.entry();
            entry_2523.string(item_2521);
        }
        list_2522.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2524 = writer.prefix("MaxResults");
    if let Some(var_2525) = &input.max_results {
        scope_2524.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2525).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2526 = writer.prefix("NextToken");
    if let Some(var_2527) = &input.next_token {
        scope_2526.string(var_2527);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_fpga_image_attribute(
    input: &crate::input::DescribeFpgaImageAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeFpgaImageAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2528 = writer.prefix("DryRun");
    if let Some(var_2529) = &input.dry_run {
        scope_2528.boolean(*var_2529);
    }
    #[allow(unused_mut)]
    let mut scope_2530 = writer.prefix("FpgaImageId");
    if let Some(var_2531) = &input.fpga_image_id {
        scope_2530.string(var_2531);
    }
    #[allow(unused_mut)]
    let mut scope_2532 = writer.prefix("Attribute");
    if let Some(var_2533) = &input.attribute {
        scope_2532.string(var_2533.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_fpga_images(
    input: &crate::input::DescribeFpgaImagesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeFpgaImages", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2534 = writer.prefix("DryRun");
    if let Some(var_2535) = &input.dry_run {
        scope_2534.boolean(*var_2535);
    }
    #[allow(unused_mut)]
    let mut scope_2536 = writer.prefix("FpgaImageId");
    if let Some(var_2537) = &input.fpga_image_ids {
        let mut list_2539 = scope_2536.start_list(true, Some("item"));
        for item_2538 in var_2537 {
            #[allow(unused_mut)]
            let mut entry_2540 = list_2539.entry();
            entry_2540.string(item_2538);
        }
        list_2539.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2541 = writer.prefix("Owner");
    if let Some(var_2542) = &input.owners {
        let mut list_2544 = scope_2541.start_list(true, Some("Owner"));
        for item_2543 in var_2542 {
            #[allow(unused_mut)]
            let mut entry_2545 = list_2544.entry();
            entry_2545.string(item_2543);
        }
        list_2544.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2546 = writer.prefix("Filter");
    if let Some(var_2547) = &input.filters {
        let mut list_2549 = scope_2546.start_list(true, Some("Filter"));
        for item_2548 in var_2547 {
            #[allow(unused_mut)]
            let mut entry_2550 = list_2549.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2550, item_2548)?;
        }
        list_2549.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2551 = writer.prefix("NextToken");
    if let Some(var_2552) = &input.next_token {
        scope_2551.string(var_2552);
    }
    #[allow(unused_mut)]
    let mut scope_2553 = writer.prefix("MaxResults");
    if let Some(var_2554) = &input.max_results {
        scope_2553.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2554).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_host_reservation_offerings(
    input: &crate::input::DescribeHostReservationOfferingsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DescribeHostReservationOfferings",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2555 = writer.prefix("Filter");
    if let Some(var_2556) = &input.filter {
        let mut list_2558 = scope_2555.start_list(true, Some("Filter"));
        for item_2557 in var_2556 {
            #[allow(unused_mut)]
            let mut entry_2559 = list_2558.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2559, item_2557)?;
        }
        list_2558.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2560 = writer.prefix("MaxDuration");
    if let Some(var_2561) = &input.max_duration {
        scope_2560.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2561).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2562 = writer.prefix("MaxResults");
    if let Some(var_2563) = &input.max_results {
        scope_2562.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2563).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2564 = writer.prefix("MinDuration");
    if let Some(var_2565) = &input.min_duration {
        scope_2564.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2565).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2566 = writer.prefix("NextToken");
    if let Some(var_2567) = &input.next_token {
        scope_2566.string(var_2567);
    }
    #[allow(unused_mut)]
    let mut scope_2568 = writer.prefix("OfferingId");
    if let Some(var_2569) = &input.offering_id {
        scope_2568.string(var_2569);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_host_reservations(
    input: &crate::input::DescribeHostReservationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeHostReservations", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2570 = writer.prefix("Filter");
    if let Some(var_2571) = &input.filter {
        let mut list_2573 = scope_2570.start_list(true, Some("Filter"));
        for item_2572 in var_2571 {
            #[allow(unused_mut)]
            let mut entry_2574 = list_2573.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2574, item_2572)?;
        }
        list_2573.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2575 = writer.prefix("HostReservationIdSet");
    if let Some(var_2576) = &input.host_reservation_id_set {
        let mut list_2578 = scope_2575.start_list(true, Some("item"));
        for item_2577 in var_2576 {
            #[allow(unused_mut)]
            let mut entry_2579 = list_2578.entry();
            entry_2579.string(item_2577);
        }
        list_2578.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2580 = writer.prefix("MaxResults");
    if let Some(var_2581) = &input.max_results {
        scope_2580.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2581).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2582 = writer.prefix("NextToken");
    if let Some(var_2583) = &input.next_token {
        scope_2582.string(var_2583);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_hosts(
    input: &crate::input::DescribeHostsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeHosts", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2584 = writer.prefix("Filter");
    if let Some(var_2585) = &input.filter {
        let mut list_2587 = scope_2584.start_list(true, Some("Filter"));
        for item_2586 in var_2585 {
            #[allow(unused_mut)]
            let mut entry_2588 = list_2587.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2588, item_2586)?;
        }
        list_2587.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2589 = writer.prefix("HostId");
    if let Some(var_2590) = &input.host_ids {
        let mut list_2592 = scope_2589.start_list(true, Some("item"));
        for item_2591 in var_2590 {
            #[allow(unused_mut)]
            let mut entry_2593 = list_2592.entry();
            entry_2593.string(item_2591);
        }
        list_2592.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2594 = writer.prefix("MaxResults");
    if let Some(var_2595) = &input.max_results {
        scope_2594.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2595).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2596 = writer.prefix("NextToken");
    if let Some(var_2597) = &input.next_token {
        scope_2596.string(var_2597);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_iam_instance_profile_associations(
    input: &crate::input::DescribeIamInstanceProfileAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DescribeIamInstanceProfileAssociations",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_2598 = writer.prefix("AssociationId");
    if let Some(var_2599) = &input.association_ids {
        let mut list_2601 = scope_2598.start_list(true, Some("AssociationId"));
        for item_2600 in var_2599 {
            #[allow(unused_mut)]
            let mut entry_2602 = list_2601.entry();
            entry_2602.string(item_2600);
        }
        list_2601.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2603 = writer.prefix("Filter");
    if let Some(var_2604) = &input.filters {
        let mut list_2606 = scope_2603.start_list(true, Some("Filter"));
        for item_2605 in var_2604 {
            #[allow(unused_mut)]
            let mut entry_2607 = list_2606.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2607, item_2605)?;
        }
        list_2606.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2608 = writer.prefix("MaxResults");
    if let Some(var_2609) = &input.max_results {
        scope_2608.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2609).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2610 = writer.prefix("NextToken");
    if let Some(var_2611) = &input.next_token {
        scope_2610.string(var_2611);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_identity_id_format(
    input: &crate::input::DescribeIdentityIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeIdentityIdFormat", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2612 = writer.prefix("PrincipalArn");
    if let Some(var_2613) = &input.principal_arn {
        scope_2612.string(var_2613);
    }
    #[allow(unused_mut)]
    let mut scope_2614 = writer.prefix("Resource");
    if let Some(var_2615) = &input.resource {
        scope_2614.string(var_2615);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_id_format(
    input: &crate::input::DescribeIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeIdFormat", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2616 = writer.prefix("Resource");
    if let Some(var_2617) = &input.resource {
        scope_2616.string(var_2617);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_image_attribute(
    input: &crate::input::DescribeImageAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeImageAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2618 = writer.prefix("Attribute");
    if let Some(var_2619) = &input.attribute {
        scope_2618.string(var_2619.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_2620 = writer.prefix("ImageId");
    if let Some(var_2621) = &input.image_id {
        scope_2620.string(var_2621);
    }
    #[allow(unused_mut)]
    let mut scope_2622 = writer.prefix("DryRun");
    if let Some(var_2623) = &input.dry_run {
        scope_2622.boolean(*var_2623);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_images(
    input: &crate::input::DescribeImagesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeImages", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2624 = writer.prefix("ExecutableBy");
    if let Some(var_2625) = &input.executable_users {
        let mut list_2627 = scope_2624.start_list(true, Some("ExecutableBy"));
        for item_2626 in var_2625 {
            #[allow(unused_mut)]
            let mut entry_2628 = list_2627.entry();
            entry_2628.string(item_2626);
        }
        list_2627.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2629 = writer.prefix("Filter");
    if let Some(var_2630) = &input.filters {
        let mut list_2632 = scope_2629.start_list(true, Some("Filter"));
        for item_2631 in var_2630 {
            #[allow(unused_mut)]
            let mut entry_2633 = list_2632.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2633, item_2631)?;
        }
        list_2632.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2634 = writer.prefix("ImageId");
    if let Some(var_2635) = &input.image_ids {
        let mut list_2637 = scope_2634.start_list(true, Some("ImageId"));
        for item_2636 in var_2635 {
            #[allow(unused_mut)]
            let mut entry_2638 = list_2637.entry();
            entry_2638.string(item_2636);
        }
        list_2637.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2639 = writer.prefix("Owner");
    if let Some(var_2640) = &input.owners {
        let mut list_2642 = scope_2639.start_list(true, Some("Owner"));
        for item_2641 in var_2640 {
            #[allow(unused_mut)]
            let mut entry_2643 = list_2642.entry();
            entry_2643.string(item_2641);
        }
        list_2642.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2644 = writer.prefix("IncludeDeprecated");
    if let Some(var_2645) = &input.include_deprecated {
        scope_2644.boolean(*var_2645);
    }
    #[allow(unused_mut)]
    let mut scope_2646 = writer.prefix("DryRun");
    if let Some(var_2647) = &input.dry_run {
        scope_2646.boolean(*var_2647);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_import_image_tasks(
    input: &crate::input::DescribeImportImageTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeImportImageTasks", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2648 = writer.prefix("DryRun");
    if let Some(var_2649) = &input.dry_run {
        scope_2648.boolean(*var_2649);
    }
    #[allow(unused_mut)]
    let mut scope_2650 = writer.prefix("Filters");
    if let Some(var_2651) = &input.filters {
        let mut list_2653 = scope_2650.start_list(true, Some("Filter"));
        for item_2652 in var_2651 {
            #[allow(unused_mut)]
            let mut entry_2654 = list_2653.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2654, item_2652)?;
        }
        list_2653.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2655 = writer.prefix("ImportTaskId");
    if let Some(var_2656) = &input.import_task_ids {
        let mut list_2658 = scope_2655.start_list(true, Some("ImportTaskId"));
        for item_2657 in var_2656 {
            #[allow(unused_mut)]
            let mut entry_2659 = list_2658.entry();
            entry_2659.string(item_2657);
        }
        list_2658.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2660 = writer.prefix("MaxResults");
    if let Some(var_2661) = &input.max_results {
        scope_2660.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2661).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2662 = writer.prefix("NextToken");
    if let Some(var_2663) = &input.next_token {
        scope_2662.string(var_2663);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_import_snapshot_tasks(
    input: &crate::input::DescribeImportSnapshotTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DescribeImportSnapshotTasks", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2664 = writer.prefix("DryRun");
    if let Some(var_2665) = &input.dry_run {
        scope_2664.boolean(*var_2665);
    }
    #[allow(unused_mut)]
    let mut scope_2666 = writer.prefix("Filters");
    if let Some(var_2667) = &input.filters {
        let mut list_2669 = scope_2666.start_list(true, Some("Filter"));
        for item_2668 in var_2667 {
            #[allow(unused_mut)]
            let mut entry_2670 = list_2669.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2670, item_2668)?;
        }
        list_2669.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2671 = writer.prefix("ImportTaskId");
    if let Some(var_2672) = &input.import_task_ids {
        let mut list_2674 = scope_2671.start_list(true, Some("ImportTaskId"));
        for item_2673 in var_2672 {
            #[allow(unused_mut)]
            let mut entry_2675 = list_2674.entry();
            entry_2675.string(item_2673);
        }
        list_2674.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2676 = writer.prefix("MaxResults");
    if let Some(var_2677) = &input.max_results {
        scope_2676.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_2677).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_2678 = writer.prefix("NextToken");
    if let Some(var_2679) = &input.next_token {
        scope_2678.string(var_2679);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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 const fn values() -> &'static [&'static str]

Returns all the &str values of the enum members.

Trait Implementations

impl AsRef<str> for VolumeType

fn as_ref(&self) -> &str

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

impl Clone for VolumeType

fn clone(&self) -> VolumeType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VolumeType

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

Formats the value using the given formatter.

impl From<&str> for VolumeType

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for VolumeType

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 VolumeType

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 VolumeType

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

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

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

impl StructuralEq for VolumeType

impl StructuralPartialEq for VolumeType