Enum aws_sdk_ec2::model::InstanceType

source ·

#[non_exhaustive]
pub enum InstanceType {
Show 570 variants    A12xlarge,
    A14xlarge,
    A1Large,
    A1Medium,
    A1Metal,
    A1Xlarge,
    C1Medium,
    C1Xlarge,
    C32xlarge,
    C34xlarge,
    C38xlarge,
    C3Large,
    C3Xlarge,
    C42xlarge,
    C44xlarge,
    C48xlarge,
    C4Large,
    C4Xlarge,
    C512xlarge,
    C518xlarge,
    C524xlarge,
    C52xlarge,
    C54xlarge,
    C59xlarge,
    C5Large,
    C5Metal,
    C5Xlarge,
    C5a12xlarge,
    C5a16xlarge,
    C5a24xlarge,
    C5a2xlarge,
    C5a4xlarge,
    C5a8xlarge,
    C5aLarge,
    C5aXlarge,
    C5ad12xlarge,
    C5ad16xlarge,
    C5ad24xlarge,
    C5ad2xlarge,
    C5ad4xlarge,
    C5ad8xlarge,
    C5adLarge,
    C5adXlarge,
    C5d12xlarge,
    C5d18xlarge,
    C5d24xlarge,
    C5d2xlarge,
    C5d4xlarge,
    C5d9xlarge,
    C5dLarge,
    C5dMetal,
    C5dXlarge,
    C5n18xlarge,
    C5n2xlarge,
    C5n4xlarge,
    C5n9xlarge,
    C5nLarge,
    C5nMetal,
    C5nXlarge,
    C6a12xlarge,
    C6a16xlarge,
    C6a24xlarge,
    C6a2xlarge,
    C6a32xlarge,
    C6a48xlarge,
    C6a4xlarge,
    C6a8xlarge,
    C6aLarge,
    C6aMetal,
    C6aXlarge,
    C6g12xlarge,
    C6g16xlarge,
    C6g2xlarge,
    C6g4xlarge,
    C6g8xlarge,
    C6gLarge,
    C6gMedium,
    C6gMetal,
    C6gXlarge,
    C6gd12xlarge,
    C6gd16xlarge,
    C6gd2xlarge,
    C6gd4xlarge,
    C6gd8xlarge,
    C6gdLarge,
    C6gdMedium,
    C6gdMetal,
    C6gdXlarge,
    C6gn12xlarge,
    C6gn16xlarge,
    C6gn2xlarge,
    C6gn4xlarge,
    C6gn8xlarge,
    C6gnLarge,
    C6gnMedium,
    C6gnXlarge,
    C6i12xlarge,
    C6i16xlarge,
    C6i24xlarge,
    C6i2xlarge,
    C6i32xlarge,
    C6i4xlarge,
    C6i8xlarge,
    C6iLarge,
    C6iMetal,
    C6iXlarge,
    C6id12xlarge,
    C6id16xlarge,
    C6id24xlarge,
    C6id2xlarge,
    C6id32xlarge,
    C6id4xlarge,
    C6id8xlarge,
    C6idLarge,
    C6idMetal,
    C6idXlarge,
    C7g12xlarge,
    C7g16xlarge,
    C7g2xlarge,
    C7g4xlarge,
    C7g8xlarge,
    C7gLarge,
    C7gMedium,
    C7gXlarge,
    Cc14xlarge,
    Cc28xlarge,
    Cg14xlarge,
    Cr18xlarge,
    D22xlarge,
    D24xlarge,
    D28xlarge,
    D2Xlarge,
    D32xlarge,
    D34xlarge,
    D38xlarge,
    D3Xlarge,
    D3en12xlarge,
    D3en2xlarge,
    D3en4xlarge,
    D3en6xlarge,
    D3en8xlarge,
    D3enXlarge,
    Dl124xlarge,
    F116xlarge,
    F12xlarge,
    F14xlarge,
    G22xlarge,
    G28xlarge,
    G316xlarge,
    G34xlarge,
    G38xlarge,
    G3sXlarge,
    G4ad16xlarge,
    G4ad2xlarge,
    G4ad4xlarge,
    G4ad8xlarge,
    G4adXlarge,
    G4dn12xlarge,
    G4dn16xlarge,
    G4dn2xlarge,
    G4dn4xlarge,
    G4dn8xlarge,
    G4dnMetal,
    G4dnXlarge,
    G512xlarge,
    G516xlarge,
    G524xlarge,
    G52xlarge,
    G548xlarge,
    G54xlarge,
    G58xlarge,
    G5Xlarge,
    G5g16xlarge,
    G5g2xlarge,
    G5g4xlarge,
    G5g8xlarge,
    G5gMetal,
    G5gXlarge,
    H116xlarge,
    H12xlarge,
    H14xlarge,
    H18xlarge,
    Hi14xlarge,
    Hpc6a48xlarge,
    Hs18xlarge,
    I22xlarge,
    I24xlarge,
    I28xlarge,
    I2Xlarge,
    I316xlarge,
    I32xlarge,
    I34xlarge,
    I38xlarge,
    I3Large,
    I3Metal,
    I3Xlarge,
    I3en12xlarge,
    I3en24xlarge,
    I3en2xlarge,
    I3en3xlarge,
    I3en6xlarge,
    I3enLarge,
    I3enMetal,
    I3enXlarge,
    I4i16xlarge,
    I4i2xlarge,
    I4i32xlarge,
    I4i4xlarge,
    I4i8xlarge,
    I4iLarge,
    I4iMetal,
    I4iXlarge,
    Im4gn16xlarge,
    Im4gn2xlarge,
    Im4gn4xlarge,
    Im4gn8xlarge,
    Im4gnLarge,
    Im4gnXlarge,
    Inf124xlarge,
    Inf12xlarge,
    Inf16xlarge,
    Inf1Xlarge,
    Is4gen2xlarge,
    Is4gen4xlarge,
    Is4gen8xlarge,
    Is4genLarge,
    Is4genMedium,
    Is4genXlarge,
    M1Large,
    M1Medium,
    M1Small,
    M1Xlarge,
    M22xlarge,
    M24xlarge,
    M2Xlarge,
    M32xlarge,
    M3Large,
    M3Medium,
    M3Xlarge,
    M410xlarge,
    M416xlarge,
    M42xlarge,
    M44xlarge,
    M4Large,
    M4Xlarge,
    M512xlarge,
    M516xlarge,
    M524xlarge,
    M52xlarge,
    M54xlarge,
    M58xlarge,
    M5Large,
    M5Metal,
    M5Xlarge,
    M5a12xlarge,
    M5a16xlarge,
    M5a24xlarge,
    M5a2xlarge,
    M5a4xlarge,
    M5a8xlarge,
    M5aLarge,
    M5aXlarge,
    M5ad12xlarge,
    M5ad16xlarge,
    M5ad24xlarge,
    M5ad2xlarge,
    M5ad4xlarge,
    M5ad8xlarge,
    M5adLarge,
    M5adXlarge,
    M5d12xlarge,
    M5d16xlarge,
    M5d24xlarge,
    M5d2xlarge,
    M5d4xlarge,
    M5d8xlarge,
    M5dLarge,
    M5dMetal,
    M5dXlarge,
    M5dn12xlarge,
    M5dn16xlarge,
    M5dn24xlarge,
    M5dn2xlarge,
    M5dn4xlarge,
    M5dn8xlarge,
    M5dnLarge,
    M5dnMetal,
    M5dnXlarge,
    M5n12xlarge,
    M5n16xlarge,
    M5n24xlarge,
    M5n2xlarge,
    M5n4xlarge,
    M5n8xlarge,
    M5nLarge,
    M5nMetal,
    M5nXlarge,
    M5zn12xlarge,
    M5zn2xlarge,
    M5zn3xlarge,
    M5zn6xlarge,
    M5znLarge,
    M5znMetal,
    M5znXlarge,
    M6a12xlarge,
    M6a16xlarge,
    M6a24xlarge,
    M6a2xlarge,
    M6a32xlarge,
    M6a48xlarge,
    M6a4xlarge,
    M6a8xlarge,
    M6aLarge,
    M6aMetal,
    M6aXlarge,
    M6g12xlarge,
    M6g16xlarge,
    M6g2xlarge,
    M6g4xlarge,
    M6g8xlarge,
    M6gLarge,
    M6gMedium,
    M6gMetal,
    M6gXlarge,
    M6gd12xlarge,
    M6gd16xlarge,
    M6gd2xlarge,
    M6gd4xlarge,
    M6gd8xlarge,
    M6gdLarge,
    M6gdMedium,
    M6gdMetal,
    M6gdXlarge,
    M6i12xlarge,
    M6i16xlarge,
    M6i24xlarge,
    M6i2xlarge,
    M6i32xlarge,
    M6i4xlarge,
    M6i8xlarge,
    M6iLarge,
    M6iMetal,
    M6iXlarge,
    M6id12xlarge,
    M6id16xlarge,
    M6id24xlarge,
    M6id2xlarge,
    M6id32xlarge,
    M6id4xlarge,
    M6id8xlarge,
    M6idLarge,
    M6idMetal,
    M6idXlarge,
    Mac1Metal,
    Mac2Metal,
    P216xlarge,
    P28xlarge,
    P2Xlarge,
    P316xlarge,
    P32xlarge,
    P38xlarge,
    P3dn24xlarge,
    P4d24xlarge,
    P4de24xlarge,
    R32xlarge,
    R34xlarge,
    R38xlarge,
    R3Large,
    R3Xlarge,
    R416xlarge,
    R42xlarge,
    R44xlarge,
    R48xlarge,
    R4Large,
    R4Xlarge,
    R512xlarge,
    R516xlarge,
    R524xlarge,
    R52xlarge,
    R54xlarge,
    R58xlarge,
    R5Large,
    R5Metal,
    R5Xlarge,
    R5a12xlarge,
    R5a16xlarge,
    R5a24xlarge,
    R5a2xlarge,
    R5a4xlarge,
    R5a8xlarge,
    R5aLarge,
    R5aXlarge,
    R5ad12xlarge,
    R5ad16xlarge,
    R5ad24xlarge,
    R5ad2xlarge,
    R5ad4xlarge,
    R5ad8xlarge,
    R5adLarge,
    R5adXlarge,
    R5b12xlarge,
    R5b16xlarge,
    R5b24xlarge,
    R5b2xlarge,
    R5b4xlarge,
    R5b8xlarge,
    R5bLarge,
    R5bMetal,
    R5bXlarge,
    R5d12xlarge,
    R5d16xlarge,
    R5d24xlarge,
    R5d2xlarge,
    R5d4xlarge,
    R5d8xlarge,
    R5dLarge,
    R5dMetal,
    R5dXlarge,
    R5dn12xlarge,
    R5dn16xlarge,
    R5dn24xlarge,
    R5dn2xlarge,
    R5dn4xlarge,
    R5dn8xlarge,
    R5dnLarge,
    R5dnMetal,
    R5dnXlarge,
    R5n12xlarge,
    R5n16xlarge,
    R5n24xlarge,
    R5n2xlarge,
    R5n4xlarge,
    R5n8xlarge,
    R5nLarge,
    R5nMetal,
    R5nXlarge,
    R6a12xlarge,
    R6a16xlarge,
    R6a24xlarge,
    R6a2xlarge,
    R6a32xlarge,
    R6a48xlarge,
    R6a4xlarge,
    R6a8xlarge,
    R6aLarge,
    R6aMetal,
    R6aXlarge,
    R6g12xlarge,
    R6g16xlarge,
    R6g2xlarge,
    R6g4xlarge,
    R6g8xlarge,
    R6gLarge,
    R6gMedium,
    R6gMetal,
    R6gXlarge,
    R6gd12xlarge,
    R6gd16xlarge,
    R6gd2xlarge,
    R6gd4xlarge,
    R6gd8xlarge,
    R6gdLarge,
    R6gdMedium,
    R6gdMetal,
    R6gdXlarge,
    R6i12xlarge,
    R6i16xlarge,
    R6i24xlarge,
    R6i2xlarge,
    R6i32xlarge,
    R6i4xlarge,
    R6i8xlarge,
    R6iLarge,
    R6iMetal,
    R6iXlarge,
    R6id12xlarge,
    R6id16xlarge,
    R6id24xlarge,
    R6id2xlarge,
    R6id32xlarge,
    R6id4xlarge,
    R6id8xlarge,
    R6idLarge,
    R6idMetal,
    R6idXlarge,
    T1Micro,
    T22xlarge,
    T2Large,
    T2Medium,
    T2Micro,
    T2Nano,
    T2Small,
    T2Xlarge,
    T32xlarge,
    T3Large,
    T3Medium,
    T3Micro,
    T3Nano,
    T3Small,
    T3Xlarge,
    T3a2xlarge,
    T3aLarge,
    T3aMedium,
    T3aMicro,
    T3aNano,
    T3aSmall,
    T3aXlarge,
    T4g2xlarge,
    T4gLarge,
    T4gMedium,
    T4gMicro,
    T4gNano,
    T4gSmall,
    T4gXlarge,
    U12tb1112xlarge,
    U12tb1Metal,
    U18tb1Metal,
    U24tb1Metal,
    U3tb156xlarge,
    U6tb1112xlarge,
    U6tb156xlarge,
    U6tb1Metal,
    U9tb1112xlarge,
    U9tb1Metal,
    Vt124xlarge,
    Vt13xlarge,
    Vt16xlarge,
    X116xlarge,
    X132xlarge,
    X1e16xlarge,
    X1e2xlarge,
    X1e32xlarge,
    X1e4xlarge,
    X1e8xlarge,
    X1eXlarge,
    X2gd12xlarge,
    X2gd16xlarge,
    X2gd2xlarge,
    X2gd4xlarge,
    X2gd8xlarge,
    X2gdLarge,
    X2gdMedium,
    X2gdMetal,
    X2gdXlarge,
    X2idn16xlarge,
    X2idn24xlarge,
    X2idn32xlarge,
    X2idnMetal,
    X2iedn16xlarge,
    X2iedn24xlarge,
    X2iedn2xlarge,
    X2iedn32xlarge,
    X2iedn4xlarge,
    X2iedn8xlarge,
    X2iednMetal,
    X2iednXlarge,
    X2iezn12xlarge,
    X2iezn2xlarge,
    X2iezn4xlarge,
    X2iezn6xlarge,
    X2iezn8xlarge,
    X2ieznMetal,
    Z1d12xlarge,
    Z1d2xlarge,
    Z1d3xlarge,
    Z1d6xlarge,
    Z1dLarge,
    Z1dMetal,
    Z1dXlarge,
    Unknown(UnknownVariantValue),
}

Expand description

When writing a match expression against InstanceType, 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 instancetype = unimplemented!();
match instancetype {
    InstanceType::A12xlarge => { /* ... */ },
    InstanceType::A14xlarge => { /* ... */ },
    InstanceType::A1Large => { /* ... */ },
    InstanceType::A1Medium => { /* ... */ },
    InstanceType::A1Metal => { /* ... */ },
    InstanceType::A1Xlarge => { /* ... */ },
    InstanceType::C1Medium => { /* ... */ },
    InstanceType::C1Xlarge => { /* ... */ },
    InstanceType::C32xlarge => { /* ... */ },
    InstanceType::C34xlarge => { /* ... */ },
    InstanceType::C38xlarge => { /* ... */ },
    InstanceType::C3Large => { /* ... */ },
    InstanceType::C3Xlarge => { /* ... */ },
    InstanceType::C42xlarge => { /* ... */ },
    InstanceType::C44xlarge => { /* ... */ },
    InstanceType::C48xlarge => { /* ... */ },
    InstanceType::C4Large => { /* ... */ },
    InstanceType::C4Xlarge => { /* ... */ },
    InstanceType::C512xlarge => { /* ... */ },
    InstanceType::C518xlarge => { /* ... */ },
    InstanceType::C524xlarge => { /* ... */ },
    InstanceType::C52xlarge => { /* ... */ },
    InstanceType::C54xlarge => { /* ... */ },
    InstanceType::C59xlarge => { /* ... */ },
    InstanceType::C5Large => { /* ... */ },
    InstanceType::C5Metal => { /* ... */ },
    InstanceType::C5Xlarge => { /* ... */ },
    InstanceType::C5a12xlarge => { /* ... */ },
    InstanceType::C5a16xlarge => { /* ... */ },
    InstanceType::C5a24xlarge => { /* ... */ },
    InstanceType::C5a2xlarge => { /* ... */ },
    InstanceType::C5a4xlarge => { /* ... */ },
    InstanceType::C5a8xlarge => { /* ... */ },
    InstanceType::C5aLarge => { /* ... */ },
    InstanceType::C5aXlarge => { /* ... */ },
    InstanceType::C5ad12xlarge => { /* ... */ },
    InstanceType::C5ad16xlarge => { /* ... */ },
    InstanceType::C5ad24xlarge => { /* ... */ },
    InstanceType::C5ad2xlarge => { /* ... */ },
    InstanceType::C5ad4xlarge => { /* ... */ },
    InstanceType::C5ad8xlarge => { /* ... */ },
    InstanceType::C5adLarge => { /* ... */ },
    InstanceType::C5adXlarge => { /* ... */ },
    InstanceType::C5d12xlarge => { /* ... */ },
    InstanceType::C5d18xlarge => { /* ... */ },
    InstanceType::C5d24xlarge => { /* ... */ },
    InstanceType::C5d2xlarge => { /* ... */ },
    InstanceType::C5d4xlarge => { /* ... */ },
    InstanceType::C5d9xlarge => { /* ... */ },
    InstanceType::C5dLarge => { /* ... */ },
    InstanceType::C5dMetal => { /* ... */ },
    InstanceType::C5dXlarge => { /* ... */ },
    InstanceType::C5n18xlarge => { /* ... */ },
    InstanceType::C5n2xlarge => { /* ... */ },
    InstanceType::C5n4xlarge => { /* ... */ },
    InstanceType::C5n9xlarge => { /* ... */ },
    InstanceType::C5nLarge => { /* ... */ },
    InstanceType::C5nMetal => { /* ... */ },
    InstanceType::C5nXlarge => { /* ... */ },
    InstanceType::C6a12xlarge => { /* ... */ },
    InstanceType::C6a16xlarge => { /* ... */ },
    InstanceType::C6a24xlarge => { /* ... */ },
    InstanceType::C6a2xlarge => { /* ... */ },
    InstanceType::C6a32xlarge => { /* ... */ },
    InstanceType::C6a48xlarge => { /* ... */ },
    InstanceType::C6a4xlarge => { /* ... */ },
    InstanceType::C6a8xlarge => { /* ... */ },
    InstanceType::C6aLarge => { /* ... */ },
    InstanceType::C6aMetal => { /* ... */ },
    InstanceType::C6aXlarge => { /* ... */ },
    InstanceType::C6g12xlarge => { /* ... */ },
    InstanceType::C6g16xlarge => { /* ... */ },
    InstanceType::C6g2xlarge => { /* ... */ },
    InstanceType::C6g4xlarge => { /* ... */ },
    InstanceType::C6g8xlarge => { /* ... */ },
    InstanceType::C6gLarge => { /* ... */ },
    InstanceType::C6gMedium => { /* ... */ },
    InstanceType::C6gMetal => { /* ... */ },
    InstanceType::C6gXlarge => { /* ... */ },
    InstanceType::C6gd12xlarge => { /* ... */ },
    InstanceType::C6gd16xlarge => { /* ... */ },
    InstanceType::C6gd2xlarge => { /* ... */ },
    InstanceType::C6gd4xlarge => { /* ... */ },
    InstanceType::C6gd8xlarge => { /* ... */ },
    InstanceType::C6gdLarge => { /* ... */ },
    InstanceType::C6gdMedium => { /* ... */ },
    InstanceType::C6gdMetal => { /* ... */ },
    InstanceType::C6gdXlarge => { /* ... */ },
    InstanceType::C6gn12xlarge => { /* ... */ },
    InstanceType::C6gn16xlarge => { /* ... */ },
    InstanceType::C6gn2xlarge => { /* ... */ },
    InstanceType::C6gn4xlarge => { /* ... */ },
    InstanceType::C6gn8xlarge => { /* ... */ },
    InstanceType::C6gnLarge => { /* ... */ },
    InstanceType::C6gnMedium => { /* ... */ },
    InstanceType::C6gnXlarge => { /* ... */ },
    InstanceType::C6i12xlarge => { /* ... */ },
    InstanceType::C6i16xlarge => { /* ... */ },
    InstanceType::C6i24xlarge => { /* ... */ },
    InstanceType::C6i2xlarge => { /* ... */ },
    InstanceType::C6i32xlarge => { /* ... */ },
    InstanceType::C6i4xlarge => { /* ... */ },
    InstanceType::C6i8xlarge => { /* ... */ },
    InstanceType::C6iLarge => { /* ... */ },
    InstanceType::C6iMetal => { /* ... */ },
    InstanceType::C6iXlarge => { /* ... */ },
    InstanceType::C6id12xlarge => { /* ... */ },
    InstanceType::C6id16xlarge => { /* ... */ },
    InstanceType::C6id24xlarge => { /* ... */ },
    InstanceType::C6id2xlarge => { /* ... */ },
    InstanceType::C6id32xlarge => { /* ... */ },
    InstanceType::C6id4xlarge => { /* ... */ },
    InstanceType::C6id8xlarge => { /* ... */ },
    InstanceType::C6idLarge => { /* ... */ },
    InstanceType::C6idMetal => { /* ... */ },
    InstanceType::C6idXlarge => { /* ... */ },
    InstanceType::C7g12xlarge => { /* ... */ },
    InstanceType::C7g16xlarge => { /* ... */ },
    InstanceType::C7g2xlarge => { /* ... */ },
    InstanceType::C7g4xlarge => { /* ... */ },
    InstanceType::C7g8xlarge => { /* ... */ },
    InstanceType::C7gLarge => { /* ... */ },
    InstanceType::C7gMedium => { /* ... */ },
    InstanceType::C7gXlarge => { /* ... */ },
    InstanceType::Cc14xlarge => { /* ... */ },
    InstanceType::Cc28xlarge => { /* ... */ },
    InstanceType::Cg14xlarge => { /* ... */ },
    InstanceType::Cr18xlarge => { /* ... */ },
    InstanceType::D22xlarge => { /* ... */ },
    InstanceType::D24xlarge => { /* ... */ },
    InstanceType::D28xlarge => { /* ... */ },
    InstanceType::D2Xlarge => { /* ... */ },
    InstanceType::D32xlarge => { /* ... */ },
    InstanceType::D34xlarge => { /* ... */ },
    InstanceType::D38xlarge => { /* ... */ },
    InstanceType::D3Xlarge => { /* ... */ },
    InstanceType::D3en12xlarge => { /* ... */ },
    InstanceType::D3en2xlarge => { /* ... */ },
    InstanceType::D3en4xlarge => { /* ... */ },
    InstanceType::D3en6xlarge => { /* ... */ },
    InstanceType::D3en8xlarge => { /* ... */ },
    InstanceType::D3enXlarge => { /* ... */ },
    InstanceType::Dl124xlarge => { /* ... */ },
    InstanceType::F116xlarge => { /* ... */ },
    InstanceType::F12xlarge => { /* ... */ },
    InstanceType::F14xlarge => { /* ... */ },
    InstanceType::G22xlarge => { /* ... */ },
    InstanceType::G28xlarge => { /* ... */ },
    InstanceType::G316xlarge => { /* ... */ },
    InstanceType::G34xlarge => { /* ... */ },
    InstanceType::G38xlarge => { /* ... */ },
    InstanceType::G3sXlarge => { /* ... */ },
    InstanceType::G4ad16xlarge => { /* ... */ },
    InstanceType::G4ad2xlarge => { /* ... */ },
    InstanceType::G4ad4xlarge => { /* ... */ },
    InstanceType::G4ad8xlarge => { /* ... */ },
    InstanceType::G4adXlarge => { /* ... */ },
    InstanceType::G4dn12xlarge => { /* ... */ },
    InstanceType::G4dn16xlarge => { /* ... */ },
    InstanceType::G4dn2xlarge => { /* ... */ },
    InstanceType::G4dn4xlarge => { /* ... */ },
    InstanceType::G4dn8xlarge => { /* ... */ },
    InstanceType::G4dnMetal => { /* ... */ },
    InstanceType::G4dnXlarge => { /* ... */ },
    InstanceType::G512xlarge => { /* ... */ },
    InstanceType::G516xlarge => { /* ... */ },
    InstanceType::G524xlarge => { /* ... */ },
    InstanceType::G52xlarge => { /* ... */ },
    InstanceType::G548xlarge => { /* ... */ },
    InstanceType::G54xlarge => { /* ... */ },
    InstanceType::G58xlarge => { /* ... */ },
    InstanceType::G5Xlarge => { /* ... */ },
    InstanceType::G5g16xlarge => { /* ... */ },
    InstanceType::G5g2xlarge => { /* ... */ },
    InstanceType::G5g4xlarge => { /* ... */ },
    InstanceType::G5g8xlarge => { /* ... */ },
    InstanceType::G5gMetal => { /* ... */ },
    InstanceType::G5gXlarge => { /* ... */ },
    InstanceType::H116xlarge => { /* ... */ },
    InstanceType::H12xlarge => { /* ... */ },
    InstanceType::H14xlarge => { /* ... */ },
    InstanceType::H18xlarge => { /* ... */ },
    InstanceType::Hi14xlarge => { /* ... */ },
    InstanceType::Hpc6a48xlarge => { /* ... */ },
    InstanceType::Hs18xlarge => { /* ... */ },
    InstanceType::I22xlarge => { /* ... */ },
    InstanceType::I24xlarge => { /* ... */ },
    InstanceType::I28xlarge => { /* ... */ },
    InstanceType::I2Xlarge => { /* ... */ },
    InstanceType::I316xlarge => { /* ... */ },
    InstanceType::I32xlarge => { /* ... */ },
    InstanceType::I34xlarge => { /* ... */ },
    InstanceType::I38xlarge => { /* ... */ },
    InstanceType::I3Large => { /* ... */ },
    InstanceType::I3Metal => { /* ... */ },
    InstanceType::I3Xlarge => { /* ... */ },
    InstanceType::I3en12xlarge => { /* ... */ },
    InstanceType::I3en24xlarge => { /* ... */ },
    InstanceType::I3en2xlarge => { /* ... */ },
    InstanceType::I3en3xlarge => { /* ... */ },
    InstanceType::I3en6xlarge => { /* ... */ },
    InstanceType::I3enLarge => { /* ... */ },
    InstanceType::I3enMetal => { /* ... */ },
    InstanceType::I3enXlarge => { /* ... */ },
    InstanceType::I4i16xlarge => { /* ... */ },
    InstanceType::I4i2xlarge => { /* ... */ },
    InstanceType::I4i32xlarge => { /* ... */ },
    InstanceType::I4i4xlarge => { /* ... */ },
    InstanceType::I4i8xlarge => { /* ... */ },
    InstanceType::I4iLarge => { /* ... */ },
    InstanceType::I4iMetal => { /* ... */ },
    InstanceType::I4iXlarge => { /* ... */ },
    InstanceType::Im4gn16xlarge => { /* ... */ },
    InstanceType::Im4gn2xlarge => { /* ... */ },
    InstanceType::Im4gn4xlarge => { /* ... */ },
    InstanceType::Im4gn8xlarge => { /* ... */ },
    InstanceType::Im4gnLarge => { /* ... */ },
    InstanceType::Im4gnXlarge => { /* ... */ },
    InstanceType::Inf124xlarge => { /* ... */ },
    InstanceType::Inf12xlarge => { /* ... */ },
    InstanceType::Inf16xlarge => { /* ... */ },
    InstanceType::Inf1Xlarge => { /* ... */ },
    InstanceType::Is4gen2xlarge => { /* ... */ },
    InstanceType::Is4gen4xlarge => { /* ... */ },
    InstanceType::Is4gen8xlarge => { /* ... */ },
    InstanceType::Is4genLarge => { /* ... */ },
    InstanceType::Is4genMedium => { /* ... */ },
    InstanceType::Is4genXlarge => { /* ... */ },
    InstanceType::M1Large => { /* ... */ },
    InstanceType::M1Medium => { /* ... */ },
    InstanceType::M1Small => { /* ... */ },
    InstanceType::M1Xlarge => { /* ... */ },
    InstanceType::M22xlarge => { /* ... */ },
    InstanceType::M24xlarge => { /* ... */ },
    InstanceType::M2Xlarge => { /* ... */ },
    InstanceType::M32xlarge => { /* ... */ },
    InstanceType::M3Large => { /* ... */ },
    InstanceType::M3Medium => { /* ... */ },
    InstanceType::M3Xlarge => { /* ... */ },
    InstanceType::M410xlarge => { /* ... */ },
    InstanceType::M416xlarge => { /* ... */ },
    InstanceType::M42xlarge => { /* ... */ },
    InstanceType::M44xlarge => { /* ... */ },
    InstanceType::M4Large => { /* ... */ },
    InstanceType::M4Xlarge => { /* ... */ },
    InstanceType::M512xlarge => { /* ... */ },
    InstanceType::M516xlarge => { /* ... */ },
    InstanceType::M524xlarge => { /* ... */ },
    InstanceType::M52xlarge => { /* ... */ },
    InstanceType::M54xlarge => { /* ... */ },
    InstanceType::M58xlarge => { /* ... */ },
    InstanceType::M5Large => { /* ... */ },
    InstanceType::M5Metal => { /* ... */ },
    InstanceType::M5Xlarge => { /* ... */ },
    InstanceType::M5a12xlarge => { /* ... */ },
    InstanceType::M5a16xlarge => { /* ... */ },
    InstanceType::M5a24xlarge => { /* ... */ },
    InstanceType::M5a2xlarge => { /* ... */ },
    InstanceType::M5a4xlarge => { /* ... */ },
    InstanceType::M5a8xlarge => { /* ... */ },
    InstanceType::M5aLarge => { /* ... */ },
    InstanceType::M5aXlarge => { /* ... */ },
    InstanceType::M5ad12xlarge => { /* ... */ },
    InstanceType::M5ad16xlarge => { /* ... */ },
    InstanceType::M5ad24xlarge => { /* ... */ },
    InstanceType::M5ad2xlarge => { /* ... */ },
    InstanceType::M5ad4xlarge => { /* ... */ },
    InstanceType::M5ad8xlarge => { /* ... */ },
    InstanceType::M5adLarge => { /* ... */ },
    InstanceType::M5adXlarge => { /* ... */ },
    InstanceType::M5d12xlarge => { /* ... */ },
    InstanceType::M5d16xlarge => { /* ... */ },
    InstanceType::M5d24xlarge => { /* ... */ },
    InstanceType::M5d2xlarge => { /* ... */ },
    InstanceType::M5d4xlarge => { /* ... */ },
    InstanceType::M5d8xlarge => { /* ... */ },
    InstanceType::M5dLarge => { /* ... */ },
    InstanceType::M5dMetal => { /* ... */ },
    InstanceType::M5dXlarge => { /* ... */ },
    InstanceType::M5dn12xlarge => { /* ... */ },
    InstanceType::M5dn16xlarge => { /* ... */ },
    InstanceType::M5dn24xlarge => { /* ... */ },
    InstanceType::M5dn2xlarge => { /* ... */ },
    InstanceType::M5dn4xlarge => { /* ... */ },
    InstanceType::M5dn8xlarge => { /* ... */ },
    InstanceType::M5dnLarge => { /* ... */ },
    InstanceType::M5dnMetal => { /* ... */ },
    InstanceType::M5dnXlarge => { /* ... */ },
    InstanceType::M5n12xlarge => { /* ... */ },
    InstanceType::M5n16xlarge => { /* ... */ },
    InstanceType::M5n24xlarge => { /* ... */ },
    InstanceType::M5n2xlarge => { /* ... */ },
    InstanceType::M5n4xlarge => { /* ... */ },
    InstanceType::M5n8xlarge => { /* ... */ },
    InstanceType::M5nLarge => { /* ... */ },
    InstanceType::M5nMetal => { /* ... */ },
    InstanceType::M5nXlarge => { /* ... */ },
    InstanceType::M5zn12xlarge => { /* ... */ },
    InstanceType::M5zn2xlarge => { /* ... */ },
    InstanceType::M5zn3xlarge => { /* ... */ },
    InstanceType::M5zn6xlarge => { /* ... */ },
    InstanceType::M5znLarge => { /* ... */ },
    InstanceType::M5znMetal => { /* ... */ },
    InstanceType::M5znXlarge => { /* ... */ },
    InstanceType::M6a12xlarge => { /* ... */ },
    InstanceType::M6a16xlarge => { /* ... */ },
    InstanceType::M6a24xlarge => { /* ... */ },
    InstanceType::M6a2xlarge => { /* ... */ },
    InstanceType::M6a32xlarge => { /* ... */ },
    InstanceType::M6a48xlarge => { /* ... */ },
    InstanceType::M6a4xlarge => { /* ... */ },
    InstanceType::M6a8xlarge => { /* ... */ },
    InstanceType::M6aLarge => { /* ... */ },
    InstanceType::M6aMetal => { /* ... */ },
    InstanceType::M6aXlarge => { /* ... */ },
    InstanceType::M6g12xlarge => { /* ... */ },
    InstanceType::M6g16xlarge => { /* ... */ },
    InstanceType::M6g2xlarge => { /* ... */ },
    InstanceType::M6g4xlarge => { /* ... */ },
    InstanceType::M6g8xlarge => { /* ... */ },
    InstanceType::M6gLarge => { /* ... */ },
    InstanceType::M6gMedium => { /* ... */ },
    InstanceType::M6gMetal => { /* ... */ },
    InstanceType::M6gXlarge => { /* ... */ },
    InstanceType::M6gd12xlarge => { /* ... */ },
    InstanceType::M6gd16xlarge => { /* ... */ },
    InstanceType::M6gd2xlarge => { /* ... */ },
    InstanceType::M6gd4xlarge => { /* ... */ },
    InstanceType::M6gd8xlarge => { /* ... */ },
    InstanceType::M6gdLarge => { /* ... */ },
    InstanceType::M6gdMedium => { /* ... */ },
    InstanceType::M6gdMetal => { /* ... */ },
    InstanceType::M6gdXlarge => { /* ... */ },
    InstanceType::M6i12xlarge => { /* ... */ },
    InstanceType::M6i16xlarge => { /* ... */ },
    InstanceType::M6i24xlarge => { /* ... */ },
    InstanceType::M6i2xlarge => { /* ... */ },
    InstanceType::M6i32xlarge => { /* ... */ },
    InstanceType::M6i4xlarge => { /* ... */ },
    InstanceType::M6i8xlarge => { /* ... */ },
    InstanceType::M6iLarge => { /* ... */ },
    InstanceType::M6iMetal => { /* ... */ },
    InstanceType::M6iXlarge => { /* ... */ },
    InstanceType::M6id12xlarge => { /* ... */ },
    InstanceType::M6id16xlarge => { /* ... */ },
    InstanceType::M6id24xlarge => { /* ... */ },
    InstanceType::M6id2xlarge => { /* ... */ },
    InstanceType::M6id32xlarge => { /* ... */ },
    InstanceType::M6id4xlarge => { /* ... */ },
    InstanceType::M6id8xlarge => { /* ... */ },
    InstanceType::M6idLarge => { /* ... */ },
    InstanceType::M6idMetal => { /* ... */ },
    InstanceType::M6idXlarge => { /* ... */ },
    InstanceType::Mac1Metal => { /* ... */ },
    InstanceType::Mac2Metal => { /* ... */ },
    InstanceType::P216xlarge => { /* ... */ },
    InstanceType::P28xlarge => { /* ... */ },
    InstanceType::P2Xlarge => { /* ... */ },
    InstanceType::P316xlarge => { /* ... */ },
    InstanceType::P32xlarge => { /* ... */ },
    InstanceType::P38xlarge => { /* ... */ },
    InstanceType::P3dn24xlarge => { /* ... */ },
    InstanceType::P4d24xlarge => { /* ... */ },
    InstanceType::P4de24xlarge => { /* ... */ },
    InstanceType::R32xlarge => { /* ... */ },
    InstanceType::R34xlarge => { /* ... */ },
    InstanceType::R38xlarge => { /* ... */ },
    InstanceType::R3Large => { /* ... */ },
    InstanceType::R3Xlarge => { /* ... */ },
    InstanceType::R416xlarge => { /* ... */ },
    InstanceType::R42xlarge => { /* ... */ },
    InstanceType::R44xlarge => { /* ... */ },
    InstanceType::R48xlarge => { /* ... */ },
    InstanceType::R4Large => { /* ... */ },
    InstanceType::R4Xlarge => { /* ... */ },
    InstanceType::R512xlarge => { /* ... */ },
    InstanceType::R516xlarge => { /* ... */ },
    InstanceType::R524xlarge => { /* ... */ },
    InstanceType::R52xlarge => { /* ... */ },
    InstanceType::R54xlarge => { /* ... */ },
    InstanceType::R58xlarge => { /* ... */ },
    InstanceType::R5Large => { /* ... */ },
    InstanceType::R5Metal => { /* ... */ },
    InstanceType::R5Xlarge => { /* ... */ },
    InstanceType::R5a12xlarge => { /* ... */ },
    InstanceType::R5a16xlarge => { /* ... */ },
    InstanceType::R5a24xlarge => { /* ... */ },
    InstanceType::R5a2xlarge => { /* ... */ },
    InstanceType::R5a4xlarge => { /* ... */ },
    InstanceType::R5a8xlarge => { /* ... */ },
    InstanceType::R5aLarge => { /* ... */ },
    InstanceType::R5aXlarge => { /* ... */ },
    InstanceType::R5ad12xlarge => { /* ... */ },
    InstanceType::R5ad16xlarge => { /* ... */ },
    InstanceType::R5ad24xlarge => { /* ... */ },
    InstanceType::R5ad2xlarge => { /* ... */ },
    InstanceType::R5ad4xlarge => { /* ... */ },
    InstanceType::R5ad8xlarge => { /* ... */ },
    InstanceType::R5adLarge => { /* ... */ },
    InstanceType::R5adXlarge => { /* ... */ },
    InstanceType::R5b12xlarge => { /* ... */ },
    InstanceType::R5b16xlarge => { /* ... */ },
    InstanceType::R5b24xlarge => { /* ... */ },
    InstanceType::R5b2xlarge => { /* ... */ },
    InstanceType::R5b4xlarge => { /* ... */ },
    InstanceType::R5b8xlarge => { /* ... */ },
    InstanceType::R5bLarge => { /* ... */ },
    InstanceType::R5bMetal => { /* ... */ },
    InstanceType::R5bXlarge => { /* ... */ },
    InstanceType::R5d12xlarge => { /* ... */ },
    InstanceType::R5d16xlarge => { /* ... */ },
    InstanceType::R5d24xlarge => { /* ... */ },
    InstanceType::R5d2xlarge => { /* ... */ },
    InstanceType::R5d4xlarge => { /* ... */ },
    InstanceType::R5d8xlarge => { /* ... */ },
    InstanceType::R5dLarge => { /* ... */ },
    InstanceType::R5dMetal => { /* ... */ },
    InstanceType::R5dXlarge => { /* ... */ },
    InstanceType::R5dn12xlarge => { /* ... */ },
    InstanceType::R5dn16xlarge => { /* ... */ },
    InstanceType::R5dn24xlarge => { /* ... */ },
    InstanceType::R5dn2xlarge => { /* ... */ },
    InstanceType::R5dn4xlarge => { /* ... */ },
    InstanceType::R5dn8xlarge => { /* ... */ },
    InstanceType::R5dnLarge => { /* ... */ },
    InstanceType::R5dnMetal => { /* ... */ },
    InstanceType::R5dnXlarge => { /* ... */ },
    InstanceType::R5n12xlarge => { /* ... */ },
    InstanceType::R5n16xlarge => { /* ... */ },
    InstanceType::R5n24xlarge => { /* ... */ },
    InstanceType::R5n2xlarge => { /* ... */ },
    InstanceType::R5n4xlarge => { /* ... */ },
    InstanceType::R5n8xlarge => { /* ... */ },
    InstanceType::R5nLarge => { /* ... */ },
    InstanceType::R5nMetal => { /* ... */ },
    InstanceType::R5nXlarge => { /* ... */ },
    InstanceType::R6a12xlarge => { /* ... */ },
    InstanceType::R6a16xlarge => { /* ... */ },
    InstanceType::R6a24xlarge => { /* ... */ },
    InstanceType::R6a2xlarge => { /* ... */ },
    InstanceType::R6a32xlarge => { /* ... */ },
    InstanceType::R6a48xlarge => { /* ... */ },
    InstanceType::R6a4xlarge => { /* ... */ },
    InstanceType::R6a8xlarge => { /* ... */ },
    InstanceType::R6aLarge => { /* ... */ },
    InstanceType::R6aMetal => { /* ... */ },
    InstanceType::R6aXlarge => { /* ... */ },
    InstanceType::R6g12xlarge => { /* ... */ },
    InstanceType::R6g16xlarge => { /* ... */ },
    InstanceType::R6g2xlarge => { /* ... */ },
    InstanceType::R6g4xlarge => { /* ... */ },
    InstanceType::R6g8xlarge => { /* ... */ },
    InstanceType::R6gLarge => { /* ... */ },
    InstanceType::R6gMedium => { /* ... */ },
    InstanceType::R6gMetal => { /* ... */ },
    InstanceType::R6gXlarge => { /* ... */ },
    InstanceType::R6gd12xlarge => { /* ... */ },
    InstanceType::R6gd16xlarge => { /* ... */ },
    InstanceType::R6gd2xlarge => { /* ... */ },
    InstanceType::R6gd4xlarge => { /* ... */ },
    InstanceType::R6gd8xlarge => { /* ... */ },
    InstanceType::R6gdLarge => { /* ... */ },
    InstanceType::R6gdMedium => { /* ... */ },
    InstanceType::R6gdMetal => { /* ... */ },
    InstanceType::R6gdXlarge => { /* ... */ },
    InstanceType::R6i12xlarge => { /* ... */ },
    InstanceType::R6i16xlarge => { /* ... */ },
    InstanceType::R6i24xlarge => { /* ... */ },
    InstanceType::R6i2xlarge => { /* ... */ },
    InstanceType::R6i32xlarge => { /* ... */ },
    InstanceType::R6i4xlarge => { /* ... */ },
    InstanceType::R6i8xlarge => { /* ... */ },
    InstanceType::R6iLarge => { /* ... */ },
    InstanceType::R6iMetal => { /* ... */ },
    InstanceType::R6iXlarge => { /* ... */ },
    InstanceType::R6id12xlarge => { /* ... */ },
    InstanceType::R6id16xlarge => { /* ... */ },
    InstanceType::R6id24xlarge => { /* ... */ },
    InstanceType::R6id2xlarge => { /* ... */ },
    InstanceType::R6id32xlarge => { /* ... */ },
    InstanceType::R6id4xlarge => { /* ... */ },
    InstanceType::R6id8xlarge => { /* ... */ },
    InstanceType::R6idLarge => { /* ... */ },
    InstanceType::R6idMetal => { /* ... */ },
    InstanceType::R6idXlarge => { /* ... */ },
    InstanceType::T1Micro => { /* ... */ },
    InstanceType::T22xlarge => { /* ... */ },
    InstanceType::T2Large => { /* ... */ },
    InstanceType::T2Medium => { /* ... */ },
    InstanceType::T2Micro => { /* ... */ },
    InstanceType::T2Nano => { /* ... */ },
    InstanceType::T2Small => { /* ... */ },
    InstanceType::T2Xlarge => { /* ... */ },
    InstanceType::T32xlarge => { /* ... */ },
    InstanceType::T3Large => { /* ... */ },
    InstanceType::T3Medium => { /* ... */ },
    InstanceType::T3Micro => { /* ... */ },
    InstanceType::T3Nano => { /* ... */ },
    InstanceType::T3Small => { /* ... */ },
    InstanceType::T3Xlarge => { /* ... */ },
    InstanceType::T3a2xlarge => { /* ... */ },
    InstanceType::T3aLarge => { /* ... */ },
    InstanceType::T3aMedium => { /* ... */ },
    InstanceType::T3aMicro => { /* ... */ },
    InstanceType::T3aNano => { /* ... */ },
    InstanceType::T3aSmall => { /* ... */ },
    InstanceType::T3aXlarge => { /* ... */ },
    InstanceType::T4g2xlarge => { /* ... */ },
    InstanceType::T4gLarge => { /* ... */ },
    InstanceType::T4gMedium => { /* ... */ },
    InstanceType::T4gMicro => { /* ... */ },
    InstanceType::T4gNano => { /* ... */ },
    InstanceType::T4gSmall => { /* ... */ },
    InstanceType::T4gXlarge => { /* ... */ },
    InstanceType::U12tb1112xlarge => { /* ... */ },
    InstanceType::U12tb1Metal => { /* ... */ },
    InstanceType::U18tb1Metal => { /* ... */ },
    InstanceType::U24tb1Metal => { /* ... */ },
    InstanceType::U3tb156xlarge => { /* ... */ },
    InstanceType::U6tb1112xlarge => { /* ... */ },
    InstanceType::U6tb156xlarge => { /* ... */ },
    InstanceType::U6tb1Metal => { /* ... */ },
    InstanceType::U9tb1112xlarge => { /* ... */ },
    InstanceType::U9tb1Metal => { /* ... */ },
    InstanceType::Vt124xlarge => { /* ... */ },
    InstanceType::Vt13xlarge => { /* ... */ },
    InstanceType::Vt16xlarge => { /* ... */ },
    InstanceType::X116xlarge => { /* ... */ },
    InstanceType::X132xlarge => { /* ... */ },
    InstanceType::X1e16xlarge => { /* ... */ },
    InstanceType::X1e2xlarge => { /* ... */ },
    InstanceType::X1e32xlarge => { /* ... */ },
    InstanceType::X1e4xlarge => { /* ... */ },
    InstanceType::X1e8xlarge => { /* ... */ },
    InstanceType::X1eXlarge => { /* ... */ },
    InstanceType::X2gd12xlarge => { /* ... */ },
    InstanceType::X2gd16xlarge => { /* ... */ },
    InstanceType::X2gd2xlarge => { /* ... */ },
    InstanceType::X2gd4xlarge => { /* ... */ },
    InstanceType::X2gd8xlarge => { /* ... */ },
    InstanceType::X2gdLarge => { /* ... */ },
    InstanceType::X2gdMedium => { /* ... */ },
    InstanceType::X2gdMetal => { /* ... */ },
    InstanceType::X2gdXlarge => { /* ... */ },
    InstanceType::X2idn16xlarge => { /* ... */ },
    InstanceType::X2idn24xlarge => { /* ... */ },
    InstanceType::X2idn32xlarge => { /* ... */ },
    InstanceType::X2idnMetal => { /* ... */ },
    InstanceType::X2iedn16xlarge => { /* ... */ },
    InstanceType::X2iedn24xlarge => { /* ... */ },
    InstanceType::X2iedn2xlarge => { /* ... */ },
    InstanceType::X2iedn32xlarge => { /* ... */ },
    InstanceType::X2iedn4xlarge => { /* ... */ },
    InstanceType::X2iedn8xlarge => { /* ... */ },
    InstanceType::X2iednMetal => { /* ... */ },
    InstanceType::X2iednXlarge => { /* ... */ },
    InstanceType::X2iezn12xlarge => { /* ... */ },
    InstanceType::X2iezn2xlarge => { /* ... */ },
    InstanceType::X2iezn4xlarge => { /* ... */ },
    InstanceType::X2iezn6xlarge => { /* ... */ },
    InstanceType::X2iezn8xlarge => { /* ... */ },
    InstanceType::X2ieznMetal => { /* ... */ },
    InstanceType::Z1d12xlarge => { /* ... */ },
    InstanceType::Z1d2xlarge => { /* ... */ },
    InstanceType::Z1d3xlarge => { /* ... */ },
    InstanceType::Z1d6xlarge => { /* ... */ },
    InstanceType::Z1dLarge => { /* ... */ },
    InstanceType::Z1dMetal => { /* ... */ },
    InstanceType::Z1dXlarge => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

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

This enum is marked as 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.

§

Unknown(UnknownVariantValue)

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

Implementations§

source §

impl InstanceType

source

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository ?

src/model.rs (line 18499)

18498
18499
18500

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

More examples

Hide additional examples

src/query_ser.rs (line 202)

pub fn serialize_structure_crate_model_reservation_fleet_instance_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ReservationFleetInstanceSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_59 = writer.prefix("InstanceType");
    if let Some(var_60) = &input.instance_type {
        scope_59.string(var_60.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_61 = writer.prefix("InstancePlatform");
    if let Some(var_62) = &input.instance_platform {
        scope_61.string(var_62.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_63 = writer.prefix("Weight");
    if let Some(var_64) = &input.weight {
        scope_63.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_64).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_65 = writer.prefix("AvailabilityZone");
    if let Some(var_66) = &input.availability_zone {
        scope_65.string(var_66);
    }
    #[allow(unused_mut)]
    let mut scope_67 = writer.prefix("AvailabilityZoneId");
    if let Some(var_68) = &input.availability_zone_id {
        scope_67.string(var_68);
    }
    #[allow(unused_mut)]
    let mut scope_69 = writer.prefix("EbsOptimized");
    if let Some(var_70) = &input.ebs_optimized {
        scope_69.boolean(*var_70);
    }
    #[allow(unused_mut)]
    let mut scope_71 = writer.prefix("Priority");
    if let Some(var_72) = &input.priority {
        scope_71.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_72).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_client_vpn_authentication_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ClientVpnAuthenticationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_73 = writer.prefix("Type");
    if let Some(var_74) = &input.r#type {
        scope_73.string(var_74.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_75 = writer.prefix("ActiveDirectory");
    if let Some(var_76) = &input.active_directory {
        crate::query_ser::serialize_structure_crate_model_directory_service_authentication_request(
            scope_75, var_76,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_77 = writer.prefix("MutualAuthentication");
    if let Some(var_78) = &input.mutual_authentication {
        crate::query_ser::serialize_structure_crate_model_certificate_authentication_request(
            scope_77, var_78,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_79 = writer.prefix("FederatedAuthentication");
    if let Some(var_80) = &input.federated_authentication {
        crate::query_ser::serialize_structure_crate_model_federated_authentication_request(
            scope_79, var_80,
        )?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_connection_log_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ConnectionLogOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_81 = writer.prefix("Enabled");
    if let Some(var_82) = &input.enabled {
        scope_81.boolean(*var_82);
    }
    #[allow(unused_mut)]
    let mut scope_83 = writer.prefix("CloudwatchLogGroup");
    if let Some(var_84) = &input.cloudwatch_log_group {
        scope_83.string(var_84);
    }
    #[allow(unused_mut)]
    let mut scope_85 = writer.prefix("CloudwatchLogStream");
    if let Some(var_86) = &input.cloudwatch_log_stream {
        scope_85.string(var_86);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_client_connect_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ClientConnectOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_87 = writer.prefix("Enabled");
    if let Some(var_88) = &input.enabled {
        scope_87.boolean(*var_88);
    }
    #[allow(unused_mut)]
    let mut scope_89 = writer.prefix("LambdaFunctionArn");
    if let Some(var_90) = &input.lambda_function_arn {
        scope_89.string(var_90);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_client_login_banner_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ClientLoginBannerOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_91 = writer.prefix("Enabled");
    if let Some(var_92) = &input.enabled {
        scope_91.boolean(*var_92);
    }
    #[allow(unused_mut)]
    let mut scope_93 = writer.prefix("BannerText");
    if let Some(var_94) = &input.banner_text {
        scope_93.string(var_94);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_new_dhcp_configuration(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::NewDhcpConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_95 = writer.prefix("Key");
    if let Some(var_96) = &input.key {
        scope_95.string(var_96);
    }
    #[allow(unused_mut)]
    let mut scope_97 = writer.prefix("Value");
    if let Some(var_98) = &input.values {
        let mut list_100 = scope_97.start_list(true, Some("item"));
        for item_99 in var_98 {
            #[allow(unused_mut)]
            let mut entry_101 = list_100.entry();
            entry_101.string(item_99);
        }
        list_100.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SpotOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_102 = writer.prefix("AllocationStrategy");
    if let Some(var_103) = &input.allocation_strategy {
        scope_102.string(var_103.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_104 = writer.prefix("MaintenanceStrategies");
    if let Some(var_105) = &input.maintenance_strategies {
        crate::query_ser::serialize_structure_crate_model_fleet_spot_maintenance_strategies_request(scope_104, var_105)?;
    }
    #[allow(unused_mut)]
    let mut scope_106 = writer.prefix("InstanceInterruptionBehavior");
    if let Some(var_107) = &input.instance_interruption_behavior {
        scope_106.string(var_107.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_108 = writer.prefix("InstancePoolsToUseCount");
    if let Some(var_109) = &input.instance_pools_to_use_count {
        scope_108.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_109).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_110 = writer.prefix("SingleInstanceType");
    if let Some(var_111) = &input.single_instance_type {
        scope_110.boolean(*var_111);
    }
    #[allow(unused_mut)]
    let mut scope_112 = writer.prefix("SingleAvailabilityZone");
    if let Some(var_113) = &input.single_availability_zone {
        scope_112.boolean(*var_113);
    }
    #[allow(unused_mut)]
    let mut scope_114 = writer.prefix("MinTargetCapacity");
    if let Some(var_115) = &input.min_target_capacity {
        scope_114.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_115).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_116 = writer.prefix("MaxTotalPrice");
    if let Some(var_117) = &input.max_total_price {
        scope_116.string(var_117);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_on_demand_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::OnDemandOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_118 = writer.prefix("AllocationStrategy");
    if let Some(var_119) = &input.allocation_strategy {
        scope_118.string(var_119.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_120 = writer.prefix("CapacityReservationOptions");
    if let Some(var_121) = &input.capacity_reservation_options {
        crate::query_ser::serialize_structure_crate_model_capacity_reservation_options_request(
            scope_120, var_121,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_122 = writer.prefix("SingleInstanceType");
    if let Some(var_123) = &input.single_instance_type {
        scope_122.boolean(*var_123);
    }
    #[allow(unused_mut)]
    let mut scope_124 = writer.prefix("SingleAvailabilityZone");
    if let Some(var_125) = &input.single_availability_zone {
        scope_124.boolean(*var_125);
    }
    #[allow(unused_mut)]
    let mut scope_126 = writer.prefix("MinTargetCapacity");
    if let Some(var_127) = &input.min_target_capacity {
        scope_126.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_127).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_128 = writer.prefix("MaxTotalPrice");
    if let Some(var_129) = &input.max_total_price {
        scope_128.string(var_129);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_launch_template_config_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::FleetLaunchTemplateConfigRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_130 = writer.prefix("LaunchTemplateSpecification");
    if let Some(var_131) = &input.launch_template_specification {
        crate::query_ser::serialize_structure_crate_model_fleet_launch_template_specification_request(scope_130, var_131)?;
    }
    #[allow(unused_mut)]
    let mut scope_132 = writer.prefix("Overrides");
    if let Some(var_133) = &input.overrides {
        let mut list_135 = scope_132.start_list(true, Some("item"));
        for item_134 in var_133 {
            #[allow(unused_mut)]
            let mut entry_136 = list_135.entry();
            crate::query_ser::serialize_structure_crate_model_fleet_launch_template_overrides_request(entry_136, item_134)?;
        }
        list_135.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_capacity_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::TargetCapacitySpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_137 = writer.prefix("TotalTargetCapacity");
    if let Some(var_138) = &input.total_target_capacity {
        scope_137.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_138).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_139 = writer.prefix("OnDemandTargetCapacity");
    if let Some(var_140) = &input.on_demand_target_capacity {
        scope_139.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_140).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_141 = writer.prefix("SpotTargetCapacity");
    if let Some(var_142) = &input.spot_target_capacity {
        scope_141.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_142).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_143 = writer.prefix("DefaultTargetCapacityType");
    if let Some(var_144) = &input.default_target_capacity_type {
        scope_143.string(var_144.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_145 = writer.prefix("TargetCapacityUnitType");
    if let Some(var_146) = &input.target_capacity_unit_type {
        scope_145.string(var_146.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_destination_options_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::DestinationOptionsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_147 = writer.prefix("FileFormat");
    if let Some(var_148) = &input.file_format {
        scope_147.string(var_148.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_149 = writer.prefix("HiveCompatiblePartitions");
    if let Some(var_150) = &input.hive_compatible_partitions {
        scope_149.boolean(*var_150);
    }
    #[allow(unused_mut)]
    let mut scope_151 = writer.prefix("PerHourPartition");
    if let Some(var_152) = &input.per_hour_partition {
        scope_151.boolean(*var_152);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_storage_location(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::StorageLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_153 = writer.prefix("Bucket");
    if let Some(var_154) = &input.bucket {
        scope_153.string(var_154);
    }
    #[allow(unused_mut)]
    let mut scope_155 = writer.prefix("Key");
    if let Some(var_156) = &input.key {
        scope_155.string(var_156);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_block_device_mapping(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::BlockDeviceMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_157 = writer.prefix("DeviceName");
    if let Some(var_158) = &input.device_name {
        scope_157.string(var_158);
    }
    #[allow(unused_mut)]
    let mut scope_159 = writer.prefix("VirtualName");
    if let Some(var_160) = &input.virtual_name {
        scope_159.string(var_160);
    }
    #[allow(unused_mut)]
    let mut scope_161 = writer.prefix("Ebs");
    if let Some(var_162) = &input.ebs {
        crate::query_ser::serialize_structure_crate_model_ebs_block_device(scope_161, var_162)?;
    }
    #[allow(unused_mut)]
    let mut scope_163 = writer.prefix("NoDevice");
    if let Some(var_164) = &input.no_device {
        scope_163.string(var_164);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_event_window_time_range_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceEventWindowTimeRangeRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_165 = writer.prefix("StartWeekDay");
    if let Some(var_166) = &input.start_week_day {
        scope_165.string(var_166.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_167 = writer.prefix("StartHour");
    if let Some(var_168) = &input.start_hour {
        scope_167.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_168).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_169 = writer.prefix("EndWeekDay");
    if let Some(var_170) = &input.end_week_day {
        scope_169.string(var_170.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_171 = writer.prefix("EndHour");
    if let Some(var_172) = &input.end_hour {
        scope_171.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_172).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_export_to_s3_task_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ExportToS3TaskSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_173 = writer.prefix("ContainerFormat");
    if let Some(var_174) = &input.container_format {
        scope_173.string(var_174.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_175 = writer.prefix("DiskImageFormat");
    if let Some(var_176) = &input.disk_image_format {
        scope_175.string(var_176.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_177 = writer.prefix("S3Bucket");
    if let Some(var_178) = &input.s3_bucket {
        scope_177.string(var_178);
    }
    #[allow(unused_mut)]
    let mut scope_179 = writer.prefix("S3Prefix");
    if let Some(var_180) = &input.s3_prefix {
        scope_179.string(var_180);
    }
    Ok(())
}

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

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_request_ipam_resource_tag(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::RequestIpamResourceTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_183 = writer.prefix("Key");
    if let Some(var_184) = &input.key {
        scope_183.string(var_184);
    }
    #[allow(unused_mut)]
    let mut scope_185 = writer.prefix("Value");
    if let Some(var_186) = &input.value {
        scope_185.string(var_186);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_request_launch_template_data(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::RequestLaunchTemplateData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_187 = writer.prefix("KernelId");
    if let Some(var_188) = &input.kernel_id {
        scope_187.string(var_188);
    }
    #[allow(unused_mut)]
    let mut scope_189 = writer.prefix("EbsOptimized");
    if let Some(var_190) = &input.ebs_optimized {
        scope_189.boolean(*var_190);
    }
    #[allow(unused_mut)]
    let mut scope_191 = writer.prefix("IamInstanceProfile");
    if let Some(var_192) = &input.iam_instance_profile {
        crate::query_ser::serialize_structure_crate_model_launch_template_iam_instance_profile_specification_request(scope_191, var_192)?;
    }
    #[allow(unused_mut)]
    let mut scope_193 = writer.prefix("BlockDeviceMapping");
    if let Some(var_194) = &input.block_device_mappings {
        let mut list_196 = scope_193.start_list(true, Some("BlockDeviceMapping"));
        for item_195 in var_194 {
            #[allow(unused_mut)]
            let mut entry_197 = list_196.entry();
            crate::query_ser::serialize_structure_crate_model_launch_template_block_device_mapping_request(entry_197, item_195)?;
        }
        list_196.finish();
    }
    #[allow(unused_mut)]
    let mut scope_198 = writer.prefix("NetworkInterface");
    if let Some(var_199) = &input.network_interfaces {
        let mut list_201 =
            scope_198.start_list(true, Some("InstanceNetworkInterfaceSpecification"));
        for item_200 in var_199 {
            #[allow(unused_mut)]
            let mut entry_202 = list_201.entry();
            crate::query_ser::serialize_structure_crate_model_launch_template_instance_network_interface_specification_request(entry_202, item_200)?;
        }
        list_201.finish();
    }
    #[allow(unused_mut)]
    let mut scope_203 = writer.prefix("ImageId");
    if let Some(var_204) = &input.image_id {
        scope_203.string(var_204);
    }
    #[allow(unused_mut)]
    let mut scope_205 = writer.prefix("InstanceType");
    if let Some(var_206) = &input.instance_type {
        scope_205.string(var_206.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_207 = writer.prefix("KeyName");
    if let Some(var_208) = &input.key_name {
        scope_207.string(var_208);
    }
    #[allow(unused_mut)]
    let mut scope_209 = writer.prefix("Monitoring");
    if let Some(var_210) = &input.monitoring {
        crate::query_ser::serialize_structure_crate_model_launch_templates_monitoring_request(
            scope_209, var_210,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_211 = writer.prefix("Placement");
    if let Some(var_212) = &input.placement {
        crate::query_ser::serialize_structure_crate_model_launch_template_placement_request(
            scope_211, var_212,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_213 = writer.prefix("RamDiskId");
    if let Some(var_214) = &input.ram_disk_id {
        scope_213.string(var_214);
    }
    #[allow(unused_mut)]
    let mut scope_215 = writer.prefix("DisableApiTermination");
    if let Some(var_216) = &input.disable_api_termination {
        scope_215.boolean(*var_216);
    }
    #[allow(unused_mut)]
    let mut scope_217 = writer.prefix("InstanceInitiatedShutdownBehavior");
    if let Some(var_218) = &input.instance_initiated_shutdown_behavior {
        scope_217.string(var_218.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_219 = writer.prefix("UserData");
    if let Some(var_220) = &input.user_data {
        scope_219.string(var_220);
    }
    #[allow(unused_mut)]
    let mut scope_221 = writer.prefix("TagSpecification");
    if let Some(var_222) = &input.tag_specifications {
        let mut list_224 =
            scope_221.start_list(true, Some("LaunchTemplateTagSpecificationRequest"));
        for item_223 in var_222 {
            #[allow(unused_mut)]
            let mut entry_225 = list_224.entry();
            crate::query_ser::serialize_structure_crate_model_launch_template_tag_specification_request(entry_225, item_223)?;
        }
        list_224.finish();
    }
    #[allow(unused_mut)]
    let mut scope_226 = writer.prefix("ElasticGpuSpecification");
    if let Some(var_227) = &input.elastic_gpu_specifications {
        let mut list_229 = scope_226.start_list(true, Some("ElasticGpuSpecification"));
        for item_228 in var_227 {
            #[allow(unused_mut)]
            let mut entry_230 = list_229.entry();
            crate::query_ser::serialize_structure_crate_model_elastic_gpu_specification(
                entry_230, item_228,
            )?;
        }
        list_229.finish();
    }
    #[allow(unused_mut)]
    let mut scope_231 = writer.prefix("ElasticInferenceAccelerator");
    if let Some(var_232) = &input.elastic_inference_accelerators {
        let mut list_234 = scope_231.start_list(true, Some("item"));
        for item_233 in var_232 {
            #[allow(unused_mut)]
            let mut entry_235 = list_234.entry();
            crate::query_ser::serialize_structure_crate_model_launch_template_elastic_inference_accelerator(entry_235, item_233)?;
        }
        list_234.finish();
    }
    #[allow(unused_mut)]
    let mut scope_236 = writer.prefix("SecurityGroupId");
    if let Some(var_237) = &input.security_group_ids {
        let mut list_239 = scope_236.start_list(true, Some("SecurityGroupId"));
        for item_238 in var_237 {
            #[allow(unused_mut)]
            let mut entry_240 = list_239.entry();
            entry_240.string(item_238);
        }
        list_239.finish();
    }
    #[allow(unused_mut)]
    let mut scope_241 = writer.prefix("SecurityGroup");
    if let Some(var_242) = &input.security_groups {
        let mut list_244 = scope_241.start_list(true, Some("SecurityGroup"));
        for item_243 in var_242 {
            #[allow(unused_mut)]
            let mut entry_245 = list_244.entry();
            entry_245.string(item_243);
        }
        list_244.finish();
    }
    #[allow(unused_mut)]
    let mut scope_246 = writer.prefix("InstanceMarketOptions");
    if let Some(var_247) = &input.instance_market_options {
        crate::query_ser::serialize_structure_crate_model_launch_template_instance_market_options_request(scope_246, var_247)?;
    }
    #[allow(unused_mut)]
    let mut scope_248 = writer.prefix("CreditSpecification");
    if let Some(var_249) = &input.credit_specification {
        crate::query_ser::serialize_structure_crate_model_credit_specification_request(
            scope_248, var_249,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_250 = writer.prefix("CpuOptions");
    if let Some(var_251) = &input.cpu_options {
        crate::query_ser::serialize_structure_crate_model_launch_template_cpu_options_request(
            scope_250, var_251,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_252 = writer.prefix("CapacityReservationSpecification");
    if let Some(var_253) = &input.capacity_reservation_specification {
        crate::query_ser::serialize_structure_crate_model_launch_template_capacity_reservation_specification_request(scope_252, var_253)?;
    }
    #[allow(unused_mut)]
    let mut scope_254 = writer.prefix("LicenseSpecification");
    if let Some(var_255) = &input.license_specifications {
        let mut list_257 = scope_254.start_list(true, Some("item"));
        for item_256 in var_255 {
            #[allow(unused_mut)]
            let mut entry_258 = list_257.entry();
            crate::query_ser::serialize_structure_crate_model_launch_template_license_configuration_request(entry_258, item_256)?;
        }
        list_257.finish();
    }
    #[allow(unused_mut)]
    let mut scope_259 = writer.prefix("HibernationOptions");
    if let Some(var_260) = &input.hibernation_options {
        crate::query_ser::serialize_structure_crate_model_launch_template_hibernation_options_request(scope_259, var_260)?;
    }
    #[allow(unused_mut)]
    let mut scope_261 = writer.prefix("MetadataOptions");
    if let Some(var_262) = &input.metadata_options {
        crate::query_ser::serialize_structure_crate_model_launch_template_instance_metadata_options_request(scope_261, var_262)?;
    }
    #[allow(unused_mut)]
    let mut scope_263 = writer.prefix("EnclaveOptions");
    if let Some(var_264) = &input.enclave_options {
        crate::query_ser::serialize_structure_crate_model_launch_template_enclave_options_request(
            scope_263, var_264,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_265 = writer.prefix("InstanceRequirements");
    if let Some(var_266) = &input.instance_requirements {
        crate::query_ser::serialize_structure_crate_model_instance_requirements_request(
            scope_265, var_266,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_267 = writer.prefix("PrivateDnsNameOptions");
    if let Some(var_268) = &input.private_dns_name_options {
        crate::query_ser::serialize_structure_crate_model_launch_template_private_dns_name_options_request(scope_267, var_268)?;
    }
    #[allow(unused_mut)]
    let mut scope_269 = writer.prefix("MaintenanceOptions");
    if let Some(var_270) = &input.maintenance_options {
        crate::query_ser::serialize_structure_crate_model_launch_template_instance_maintenance_options_request(scope_269, var_270)?;
    }
    #[allow(unused_mut)]
    let mut scope_271 = writer.prefix("DisableApiStop");
    if let Some(var_272) = &input.disable_api_stop {
        scope_271.boolean(*var_272);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_add_prefix_list_entry(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AddPrefixListEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_273 = writer.prefix("Cidr");
    if let Some(var_274) = &input.cidr {
        scope_273.string(var_274);
    }
    #[allow(unused_mut)]
    let mut scope_275 = writer.prefix("Description");
    if let Some(var_276) = &input.description {
        scope_275.string(var_276);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_icmp_type_code(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::IcmpTypeCode,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_277 = writer.prefix("Code");
    if let Some(var_278) = &input.code {
        scope_277.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_278).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_279 = writer.prefix("Type");
    if let Some(var_280) = &input.r#type {
        scope_279.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_280).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_port_range(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PortRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_281 = writer.prefix("From");
    if let Some(var_282) = &input.from {
        scope_281.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_282).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_283 = writer.prefix("To");
    if let Some(var_284) = &input.to {
        scope_283.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_284).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_access_scope_path_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::AccessScopePathRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_285 = writer.prefix("Source");
    if let Some(var_286) = &input.source {
        crate::query_ser::serialize_structure_crate_model_path_statement_request(
            scope_285, var_286,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_287 = writer.prefix("Destination");
    if let Some(var_288) = &input.destination {
        crate::query_ser::serialize_structure_crate_model_path_statement_request(
            scope_287, var_288,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_289 = writer.prefix("ThroughResource");
    if let Some(var_290) = &input.through_resources {
        let mut list_292 = scope_289.start_list(true, Some("item"));
        for item_291 in var_290 {
            #[allow(unused_mut)]
            let mut entry_293 = list_292.entry();
            crate::query_ser::serialize_structure_crate_model_through_resources_statement_request(
                entry_293, item_291,
            )?;
        }
        list_292.finish();
    }
    Ok(())
}

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

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_private_ip_address_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PrivateIpAddressSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_296 = writer.prefix("Primary");
    if let Some(var_297) = &input.primary {
        scope_296.boolean(*var_297);
    }
    #[allow(unused_mut)]
    let mut scope_298 = writer.prefix("PrivateIpAddress");
    if let Some(var_299) = &input.private_ip_address {
        scope_298.string(var_299);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ipv4_prefix_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Ipv4PrefixSpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_300 = writer.prefix("Ipv4Prefix");
    if let Some(var_301) = &input.ipv4_prefix {
        scope_300.string(var_301);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ipv6_prefix_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Ipv6PrefixSpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_302 = writer.prefix("Ipv6Prefix");
    if let Some(var_303) = &input.ipv6_prefix {
        scope_302.string(var_303);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_price_schedule_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::PriceScheduleSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_304 = writer.prefix("CurrencyCode");
    if let Some(var_305) = &input.currency_code {
        scope_304.string(var_305.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_306 = writer.prefix("Price");
    if let Some(var_307) = &input.price {
        scope_306.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_307).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_308 = writer.prefix("Term");
    if let Some(var_309) = &input.term {
        scope_308.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_309).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_310 = writer.prefix("InstanceId");
    if let Some(var_311) = &input.instance_id {
        scope_310.string(var_311);
    }
    #[allow(unused_mut)]
    let mut scope_312 = writer.prefix("ExcludeBootVolume");
    if let Some(var_313) = &input.exclude_boot_volume {
        scope_312.boolean(*var_313);
    }
    #[allow(unused_mut)]
    let mut scope_314 = writer.prefix("ExcludeDataVolumeId");
    if let Some(var_315) = &input.exclude_data_volume_ids {
        let mut list_317 = scope_314.start_list(true, Some("VolumeId"));
        for item_316 in var_315 {
            #[allow(unused_mut)]
            let mut entry_318 = list_317.entry();
            entry_318.string(item_316);
        }
        list_317.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_s3_object_tag(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::S3ObjectTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_319 = writer.prefix("Key");
    if let Some(var_320) = &input.key {
        scope_319.string(var_320);
    }
    #[allow(unused_mut)]
    let mut scope_321 = writer.prefix("Value");
    if let Some(var_322) = &input.value {
        scope_321.string(var_322);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_tag(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_323 = writer.prefix("Key");
    if let Some(var_324) = &input.key {
        scope_323.string(var_324);
    }
    #[allow(unused_mut)]
    let mut scope_325 = writer.prefix("Value");
    if let Some(var_326) = &input.value {
        scope_325.string(var_326);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_traffic_mirror_port_range_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::TrafficMirrorPortRangeRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_327 = writer.prefix("FromPort");
    if let Some(var_328) = &input.from_port {
        scope_327.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_328).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_329 = writer.prefix("ToPort");
    if let Some(var_330) = &input.to_port {
        scope_329.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_330).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_transit_gateway_request_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::TransitGatewayRequestOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_331 = writer.prefix("AmazonSideAsn");
    if let Some(var_332) = &input.amazon_side_asn {
        scope_331.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_332).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_333 = writer.prefix("AutoAcceptSharedAttachments");
    if let Some(var_334) = &input.auto_accept_shared_attachments {
        scope_333.string(var_334.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_335 = writer.prefix("DefaultRouteTableAssociation");
    if let Some(var_336) = &input.default_route_table_association {
        scope_335.string(var_336.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_337 = writer.prefix("DefaultRouteTablePropagation");
    if let Some(var_338) = &input.default_route_table_propagation {
        scope_337.string(var_338.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_339 = writer.prefix("VpnEcmpSupport");
    if let Some(var_340) = &input.vpn_ecmp_support {
        scope_339.string(var_340.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_341 = writer.prefix("DnsSupport");
    if let Some(var_342) = &input.dns_support {
        scope_341.string(var_342.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_343 = writer.prefix("MulticastSupport");
    if let Some(var_344) = &input.multicast_support {
        scope_343.string(var_344.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_345 = writer.prefix("TransitGatewayCidrBlocks");
    if let Some(var_346) = &input.transit_gateway_cidr_blocks {
        let mut list_348 = scope_345.start_list(true, Some("item"));
        for item_347 in var_346 {
            #[allow(unused_mut)]
            let mut entry_349 = list_348.entry();
            entry_349.string(item_347);
        }
        list_348.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_transit_gateway_connect_request_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CreateTransitGatewayConnectRequestOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_350 = writer.prefix("Protocol");
    if let Some(var_351) = &input.protocol {
        scope_350.string(var_351.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_transit_gateway_connect_request_bgp_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::TransitGatewayConnectRequestBgpOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_352 = writer.prefix("PeerAsn");
    if let Some(var_353) = &input.peer_asn {
        scope_352.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_353).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_transit_gateway_multicast_domain_request_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CreateTransitGatewayMulticastDomainRequestOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_354 = writer.prefix("Igmpv2Support");
    if let Some(var_355) = &input.igmpv2_support {
        scope_354.string(var_355.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_356 = writer.prefix("StaticSourcesSupport");
    if let Some(var_357) = &input.static_sources_support {
        scope_356.string(var_357.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_358 = writer.prefix("AutoAcceptSharedAssociations");
    if let Some(var_359) = &input.auto_accept_shared_associations {
        scope_358.string(var_359.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_transit_gateway_peering_attachment_request_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CreateTransitGatewayPeeringAttachmentRequestOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_360 = writer.prefix("DynamicRouting");
    if let Some(var_361) = &input.dynamic_routing {
        scope_360.string(var_361.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_transit_gateway_vpc_attachment_request_options(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::CreateTransitGatewayVpcAttachmentRequestOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_362 = writer.prefix("DnsSupport");
    if let Some(var_363) = &input.dns_support {
        scope_362.string(var_363.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_364 = writer.prefix("Ipv6Support");
    if let Some(var_365) = &input.ipv6_support {
        scope_364.string(var_365.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_366 = writer.prefix("ApplianceModeSupport");
    if let Some(var_367) = &input.appliance_mode_support {
        scope_366.string(var_367.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_dns_options_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::DnsOptionsSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_368 = writer.prefix("DnsRecordIpType");
    if let Some(var_369) = &input.dns_record_ip_type {
        scope_368.string(var_369.as_str());
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_vpn_connection_options_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::VpnConnectionOptionsSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_370 = writer.prefix("EnableAcceleration");
    if let Some(var_371) = &input.enable_acceleration {
        scope_370.boolean(*var_371);
    }
    #[allow(unused_mut)]
    let mut scope_372 = writer.prefix("StaticRoutesOnly");
    if let Some(var_373) = &input.static_routes_only {
        scope_372.boolean(*var_373);
    }
    #[allow(unused_mut)]
    let mut scope_374 = writer.prefix("TunnelInsideIpVersion");
    if let Some(var_375) = &input.tunnel_inside_ip_version {
        scope_374.string(var_375.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_376 = writer.prefix("TunnelOptions");
    if let Some(var_377) = &input.tunnel_options {
        let mut list_379 = scope_376.start_list(true, None);
        for item_378 in var_377 {
            #[allow(unused_mut)]
            let mut entry_380 = list_379.entry();
            crate::query_ser::serialize_structure_crate_model_vpn_tunnel_options_specification(
                entry_380, item_378,
            )?;
        }
        list_379.finish();
    }
    #[allow(unused_mut)]
    let mut scope_381 = writer.prefix("LocalIpv4NetworkCidr");
    if let Some(var_382) = &input.local_ipv4_network_cidr {
        scope_381.string(var_382);
    }
    #[allow(unused_mut)]
    let mut scope_383 = writer.prefix("RemoteIpv4NetworkCidr");
    if let Some(var_384) = &input.remote_ipv4_network_cidr {
        scope_383.string(var_384);
    }
    #[allow(unused_mut)]
    let mut scope_385 = writer.prefix("LocalIpv6NetworkCidr");
    if let Some(var_386) = &input.local_ipv6_network_cidr {
        scope_385.string(var_386);
    }
    #[allow(unused_mut)]
    let mut scope_387 = writer.prefix("RemoteIpv6NetworkCidr");
    if let Some(var_388) = &input.remote_ipv6_network_cidr {
        scope_387.string(var_388);
    }
    #[allow(unused_mut)]
    let mut scope_389 = writer.prefix("OutsideIpAddressType");
    if let Some(var_390) = &input.outside_ip_address_type {
        scope_389.string(var_390);
    }
    #[allow(unused_mut)]
    let mut scope_391 = writer.prefix("TransportTransitGatewayAttachmentId");
    if let Some(var_392) = &input.transport_transit_gateway_attachment_id {
        scope_391.string(var_392);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_deregister_instance_tag_attribute_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::DeregisterInstanceTagAttributeRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_393 = writer.prefix("IncludeAllTagsOfInstance");
    if let Some(var_394) = &input.include_all_tags_of_instance {
        scope_393.boolean(*var_394);
    }
    #[allow(unused_mut)]
    let mut scope_395 = writer.prefix("InstanceTagKey");
    if let Some(var_396) = &input.instance_tag_keys {
        let mut list_398 = scope_395.start_list(true, Some("item"));
        for item_397 in var_396 {
            #[allow(unused_mut)]
            let mut entry_399 = list_398.entry();
            entry_399.string(item_397);
        }
        list_398.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_filter(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_400 = writer.prefix("Name");
    if let Some(var_401) = &input.name {
        scope_400.string(var_401);
    }
    #[allow(unused_mut)]
    let mut scope_402 = writer.prefix("Value");
    if let Some(var_403) = &input.values {
        let mut list_405 = scope_402.start_list(true, Some("item"));
        for item_404 in var_403 {
            #[allow(unused_mut)]
            let mut entry_406 = list_405.entry();
            entry_406.string(item_404);
        }
        list_405.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_slot_date_time_range_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SlotDateTimeRangeRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_407 = writer.prefix("EarliestTime");
    if let Some(var_408) = &input.earliest_time {
        scope_407.date_time(var_408, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_409 = writer.prefix("LatestTime");
    if let Some(var_410) = &input.latest_time {
        scope_409.date_time(var_410, aws_smithy_types::date_time::Format::DateTime)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instance_recurrence_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ScheduledInstanceRecurrenceRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_411 = writer.prefix("Frequency");
    if let Some(var_412) = &input.frequency {
        scope_411.string(var_412);
    }
    #[allow(unused_mut)]
    let mut scope_413 = writer.prefix("Interval");
    if let Some(var_414) = &input.interval {
        scope_413.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_414).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_415 = writer.prefix("OccurrenceDay");
    if let Some(var_416) = &input.occurrence_days {
        let mut list_418 = scope_415.start_list(true, Some("OccurenceDay"));
        for item_417 in var_416 {
            #[allow(unused_mut)]
            let mut entry_419 = list_418.entry();
            entry_419.number(
                #[allow(clippy::useless_conversion)]
                aws_smithy_types::Number::NegInt((*item_417).into()),
            );
        }
        list_418.finish();
    }
    #[allow(unused_mut)]
    let mut scope_420 = writer.prefix("OccurrenceRelativeToEnd");
    if let Some(var_421) = &input.occurrence_relative_to_end {
        scope_420.boolean(*var_421);
    }
    #[allow(unused_mut)]
    let mut scope_422 = writer.prefix("OccurrenceUnit");
    if let Some(var_423) = &input.occurrence_unit {
        scope_422.string(var_423);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_slot_start_time_range_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::SlotStartTimeRangeRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_424 = writer.prefix("EarliestTime");
    if let Some(var_425) = &input.earliest_time {
        scope_424.date_time(var_425, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_426 = writer.prefix("LatestTime");
    if let Some(var_427) = &input.latest_time {
        scope_426.date_time(var_427, aws_smithy_types::date_time::Format::DateTime)?;
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_event_window_disassociation_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::InstanceEventWindowDisassociationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_428 = writer.prefix("InstanceId");
    if let Some(var_429) = &input.instance_ids {
        let mut list_431 = scope_428.start_list(true, Some("item"));
        for item_430 in var_429 {
            #[allow(unused_mut)]
            let mut entry_432 = list_431.entry();
            entry_432.string(item_430);
        }
        list_431.finish();
    }
    #[allow(unused_mut)]
    let mut scope_433 = writer.prefix("InstanceTag");
    if let Some(var_434) = &input.instance_tags {
        let mut list_436 = scope_433.start_list(true, Some("item"));
        for item_435 in var_434 {
            #[allow(unused_mut)]
            let mut entry_437 = list_436.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_437, item_435)?;
        }
        list_436.finish();
    }
    #[allow(unused_mut)]
    let mut scope_438 = writer.prefix("DedicatedHostId");
    if let Some(var_439) = &input.dedicated_host_ids {
        let mut list_441 = scope_438.start_list(true, Some("item"));
        for item_440 in var_439 {
            #[allow(unused_mut)]
            let mut entry_442 = list_441.entry();
            entry_442.string(item_440);
        }
        list_441.finish();
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fast_launch_snapshot_configuration_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::FastLaunchSnapshotConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_443 = writer.prefix("TargetResourceCount");
    if let Some(var_444) = &input.target_resource_count {
        scope_443.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_444).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fast_launch_launch_template_specification_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::FastLaunchLaunchTemplateSpecificationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_445 = writer.prefix("LaunchTemplateId");
    if let Some(var_446) = &input.launch_template_id {
        scope_445.string(var_446);
    }
    #[allow(unused_mut)]
    let mut scope_447 = writer.prefix("LaunchTemplateName");
    if let Some(var_448) = &input.launch_template_name {
        scope_447.string(var_448);
    }
    #[allow(unused_mut)]
    let mut scope_449 = writer.prefix("Version");
    if let Some(var_450) = &input.version {
        scope_449.string(var_450);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_export_task_s3_location_request(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::ExportTaskS3LocationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_451 = writer.prefix("S3Bucket");
    if let Some(var_452) = &input.s3_bucket {
        scope_451.string(var_452);
    }
    #[allow(unused_mut)]
    let mut scope_453 = writer.prefix("S3Prefix");
    if let Some(var_454) = &input.s3_prefix {
        scope_453.string(var_454);
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_integrate_services(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::IntegrateServices,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_455 = writer.prefix("AthenaIntegration");
    if let Some(var_456) = &input.athena_integrations {
        let mut list_458 = scope_455.start_list(true, Some("item"));
        for item_457 in var_456 {
            #[allow(unused_mut)]
            let mut entry_459 = list_458.entry();
            crate::query_ser::serialize_structure_crate_model_athena_integration(
                entry_459, item_457,
            )?;
        }
        list_458.finish();
    }
    Ok(())
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_specification(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::LaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_997 = writer.prefix("LaunchTemplateId");
    if let Some(var_998) = &input.launch_template_id {
        scope_997.string(var_998);
    }
    #[allow(unused_mut)]
    let mut scope_999 = writer.prefix("LaunchTemplateName");
    if let Some(var_1000) = &input.launch_template_name {
        scope_999.string(var_1000);
    }
    #[allow(unused_mut)]
    let mut scope_1001 = writer.prefix("Version");
    if let Some(var_1002) = &input.version {
        scope_1001.string(var_1002);
    }
    Ok(())
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/operation_ser.rs (line 9913)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn serialize_operation_crate_operation_disable_vpc_classic_link_dns_support(
    input: &crate::input::DisableVpcClassicLinkDnsSupportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DisableVpcClassicLinkDnsSupport",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4155 = writer.prefix("VpcId");
    if let Some(var_4156) = &input.vpc_id {
        scope_4155.string(var_4156);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

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

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

pub fn serialize_operation_crate_operation_disassociate_iam_instance_profile(
    input: &crate::input::DisassociateIamInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DisassociateIamInstanceProfile",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4175 = writer.prefix("AssociationId");
    if let Some(var_4176) = &input.association_id {
        scope_4175.string(var_4176);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

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

pub fn serialize_operation_crate_operation_disassociate_subnet_cidr_block(
    input: &crate::input::DisassociateSubnetCidrBlockInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DisassociateSubnetCidrBlock", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4187 = writer.prefix("AssociationId");
    if let Some(var_4188) = &input.association_id {
        scope_4187.string(var_4188);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

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

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

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

pub fn serialize_operation_crate_operation_disassociate_vpc_cidr_block(
    input: &crate::input::DisassociateVpcCidrBlockInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DisassociateVpcCidrBlock", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_4218 = writer.prefix("AssociationId");
    if let Some(var_4219) = &input.association_id {
        scope_4218.string(var_4219);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

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

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

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

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

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

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

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

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

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

pub fn serialize_operation_crate_operation_enable_vpc_classic_link_dns_support(
    input: &crate::input::EnableVpcClassicLinkDnsSupportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "EnableVpcClassicLinkDnsSupport",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_4280 = writer.prefix("VpcId");
    if let Some(var_4281) = &input.vpc_id {
        scope_4280.string(var_4281);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn serialize_operation_crate_operation_reset_instance_attribute(
    input: &crate::input::ResetInstanceAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ResetInstanceAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5964 = writer.prefix("Attribute");
    if let Some(var_5965) = &input.attribute {
        scope_5964.string(var_5965.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5966 = writer.prefix("DryRun");
    if let Some(var_5967) = &input.dry_run {
        scope_5966.boolean(*var_5967);
    }
    #[allow(unused_mut)]
    let mut scope_5968 = writer.prefix("InstanceId");
    if let Some(var_5969) = &input.instance_id {
        scope_5968.string(var_5969);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reset_network_interface_attribute(
    input: &crate::input::ResetNetworkInterfaceAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ResetNetworkInterfaceAttribute",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5970 = writer.prefix("DryRun");
    if let Some(var_5971) = &input.dry_run {
        scope_5970.boolean(*var_5971);
    }
    #[allow(unused_mut)]
    let mut scope_5972 = writer.prefix("NetworkInterfaceId");
    if let Some(var_5973) = &input.network_interface_id {
        scope_5972.string(var_5973);
    }
    #[allow(unused_mut)]
    let mut scope_5974 = writer.prefix("SourceDestCheck");
    if let Some(var_5975) = &input.source_dest_check {
        scope_5974.string(var_5975);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reset_snapshot_attribute(
    input: &crate::input::ResetSnapshotAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ResetSnapshotAttribute", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5976 = writer.prefix("Attribute");
    if let Some(var_5977) = &input.attribute {
        scope_5976.string(var_5977.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_5978 = writer.prefix("SnapshotId");
    if let Some(var_5979) = &input.snapshot_id {
        scope_5978.string(var_5979);
    }
    #[allow(unused_mut)]
    let mut scope_5980 = writer.prefix("DryRun");
    if let Some(var_5981) = &input.dry_run {
        scope_5980.boolean(*var_5981);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_restore_address_to_classic(
    input: &crate::input::RestoreAddressToClassicInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "RestoreAddressToClassic", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5982 = writer.prefix("DryRun");
    if let Some(var_5983) = &input.dry_run {
        scope_5982.boolean(*var_5983);
    }
    #[allow(unused_mut)]
    let mut scope_5984 = writer.prefix("PublicIp");
    if let Some(var_5985) = &input.public_ip {
        scope_5984.string(var_5985);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_restore_image_from_recycle_bin(
    input: &crate::input::RestoreImageFromRecycleBinInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "RestoreImageFromRecycleBin", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5986 = writer.prefix("ImageId");
    if let Some(var_5987) = &input.image_id {
        scope_5986.string(var_5987);
    }
    #[allow(unused_mut)]
    let mut scope_5988 = writer.prefix("DryRun");
    if let Some(var_5989) = &input.dry_run {
        scope_5988.boolean(*var_5989);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_restore_managed_prefix_list_version(
    input: &crate::input::RestoreManagedPrefixListVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "RestoreManagedPrefixListVersion",
        "2016-11-15",
    );
    #[allow(unused_mut)]
    let mut scope_5990 = writer.prefix("DryRun");
    if let Some(var_5991) = &input.dry_run {
        scope_5990.boolean(*var_5991);
    }
    #[allow(unused_mut)]
    let mut scope_5992 = writer.prefix("PrefixListId");
    if let Some(var_5993) = &input.prefix_list_id {
        scope_5992.string(var_5993);
    }
    #[allow(unused_mut)]
    let mut scope_5994 = writer.prefix("PreviousVersion");
    if let Some(var_5995) = &input.previous_version {
        scope_5994.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5995).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_5996 = writer.prefix("CurrentVersion");
    if let Some(var_5997) = &input.current_version {
        scope_5996.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_5997).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_restore_snapshot_from_recycle_bin(
    input: &crate::input::RestoreSnapshotFromRecycleBinInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "RestoreSnapshotFromRecycleBin", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_5998 = writer.prefix("SnapshotId");
    if let Some(var_5999) = &input.snapshot_id {
        scope_5998.string(var_5999);
    }
    #[allow(unused_mut)]
    let mut scope_6000 = writer.prefix("DryRun");
    if let Some(var_6001) = &input.dry_run {
        scope_6000.boolean(*var_6001);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_restore_snapshot_tier(
    input: &crate::input::RestoreSnapshotTierInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "RestoreSnapshotTier", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_6002 = writer.prefix("SnapshotId");
    if let Some(var_6003) = &input.snapshot_id {
        scope_6002.string(var_6003);
    }
    #[allow(unused_mut)]
    let mut scope_6004 = writer.prefix("TemporaryRestoreDays");
    if let Some(var_6005) = &input.temporary_restore_days {
        scope_6004.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_6005).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_6006 = writer.prefix("PermanentRestore");
    if let Some(var_6007) = &input.permanent_restore {
        scope_6006.boolean(*var_6007);
    }
    #[allow(unused_mut)]
    let mut scope_6008 = writer.prefix("DryRun");
    if let Some(var_6009) = &input.dry_run {
        scope_6008.boolean(*var_6009);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_revoke_client_vpn_ingress(
    input: &crate::input::RevokeClientVpnIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "RevokeClientVpnIngress", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_6010 = writer.prefix("ClientVpnEndpointId");
    if let Some(var_6011) = &input.client_vpn_endpoint_id {
        scope_6010.string(var_6011);
    }
    #[allow(unused_mut)]
    let mut scope_6012 = writer.prefix("TargetNetworkCidr");
    if let Some(var_6013) = &input.target_network_cidr {
        scope_6012.string(var_6013);
    }
    #[allow(unused_mut)]
    let mut scope_6014 = writer.prefix("AccessGroupId");
    if let Some(var_6015) = &input.access_group_id {
        scope_6014.string(var_6015);
    }
    #[allow(unused_mut)]
    let mut scope_6016 = writer.prefix("RevokeAllGroups");
    if let Some(var_6017) = &input.revoke_all_groups {
        scope_6016.boolean(*var_6017);
    }
    #[allow(unused_mut)]
    let mut scope_6018 = writer.prefix("DryRun");
    if let Some(var_6019) = &input.dry_run {
        scope_6018.boolean(*var_6019);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_revoke_security_group_egress(
    input: &crate::input::RevokeSecurityGroupEgressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "RevokeSecurityGroupEgress", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_6020 = writer.prefix("DryRun");
    if let Some(var_6021) = &input.dry_run {
        scope_6020.boolean(*var_6021);
    }
    #[allow(unused_mut)]
    let mut scope_6022 = writer.prefix("GroupId");
    if let Some(var_6023) = &input.group_id {
        scope_6022.string(var_6023);
    }
    #[allow(unused_mut)]
    let mut scope_6024 = writer.prefix("IpPermissions");
    if let Some(var_6025) = &input.ip_permissions {
        let mut list_6027 = scope_6024.start_list(true, Some("item"));
        for item_6026 in var_6025 {
            #[allow(unused_mut)]
            let mut entry_6028 = list_6027.entry();
            crate::query_ser::serialize_structure_crate_model_ip_permission(entry_6028, item_6026)?;
        }
        list_6027.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6029 = writer.prefix("SecurityGroupRuleId");
    if let Some(var_6030) = &input.security_group_rule_ids {
        let mut list_6032 = scope_6029.start_list(true, Some("item"));
        for item_6031 in var_6030 {
            #[allow(unused_mut)]
            let mut entry_6033 = list_6032.entry();
            entry_6033.string(item_6031);
        }
        list_6032.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6034 = writer.prefix("CidrIp");
    if let Some(var_6035) = &input.cidr_ip {
        scope_6034.string(var_6035);
    }
    #[allow(unused_mut)]
    let mut scope_6036 = writer.prefix("FromPort");
    if let Some(var_6037) = &input.from_port {
        scope_6036.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_6037).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_6038 = writer.prefix("IpProtocol");
    if let Some(var_6039) = &input.ip_protocol {
        scope_6038.string(var_6039);
    }
    #[allow(unused_mut)]
    let mut scope_6040 = writer.prefix("ToPort");
    if let Some(var_6041) = &input.to_port {
        scope_6040.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_6041).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_6042 = writer.prefix("SourceSecurityGroupName");
    if let Some(var_6043) = &input.source_security_group_name {
        scope_6042.string(var_6043);
    }
    #[allow(unused_mut)]
    let mut scope_6044 = writer.prefix("SourceSecurityGroupOwnerId");
    if let Some(var_6045) = &input.source_security_group_owner_id {
        scope_6044.string(var_6045);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_revoke_security_group_ingress(
    input: &crate::input::RevokeSecurityGroupIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "RevokeSecurityGroupIngress", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_6046 = writer.prefix("CidrIp");
    if let Some(var_6047) = &input.cidr_ip {
        scope_6046.string(var_6047);
    }
    #[allow(unused_mut)]
    let mut scope_6048 = writer.prefix("FromPort");
    if let Some(var_6049) = &input.from_port {
        scope_6048.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_6049).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_6050 = writer.prefix("GroupId");
    if let Some(var_6051) = &input.group_id {
        scope_6050.string(var_6051);
    }
    #[allow(unused_mut)]
    let mut scope_6052 = writer.prefix("GroupName");
    if let Some(var_6053) = &input.group_name {
        scope_6052.string(var_6053);
    }
    #[allow(unused_mut)]
    let mut scope_6054 = writer.prefix("IpPermissions");
    if let Some(var_6055) = &input.ip_permissions {
        let mut list_6057 = scope_6054.start_list(true, Some("item"));
        for item_6056 in var_6055 {
            #[allow(unused_mut)]
            let mut entry_6058 = list_6057.entry();
            crate::query_ser::serialize_structure_crate_model_ip_permission(entry_6058, item_6056)?;
        }
        list_6057.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6059 = writer.prefix("IpProtocol");
    if let Some(var_6060) = &input.ip_protocol {
        scope_6059.string(var_6060);
    }
    #[allow(unused_mut)]
    let mut scope_6061 = writer.prefix("SourceSecurityGroupName");
    if let Some(var_6062) = &input.source_security_group_name {
        scope_6061.string(var_6062);
    }
    #[allow(unused_mut)]
    let mut scope_6063 = writer.prefix("SourceSecurityGroupOwnerId");
    if let Some(var_6064) = &input.source_security_group_owner_id {
        scope_6063.string(var_6064);
    }
    #[allow(unused_mut)]
    let mut scope_6065 = writer.prefix("ToPort");
    if let Some(var_6066) = &input.to_port {
        scope_6065.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_6066).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_6067 = writer.prefix("DryRun");
    if let Some(var_6068) = &input.dry_run {
        scope_6067.boolean(*var_6068);
    }
    #[allow(unused_mut)]
    let mut scope_6069 = writer.prefix("SecurityGroupRuleId");
    if let Some(var_6070) = &input.security_group_rule_ids {
        let mut list_6072 = scope_6069.start_list(true, Some("item"));
        for item_6071 in var_6070 {
            #[allow(unused_mut)]
            let mut entry_6073 = list_6072.entry();
            entry_6073.string(item_6071);
        }
        list_6072.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_run_instances(
    input: &crate::input::RunInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RunInstances", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_6074 = writer.prefix("BlockDeviceMapping");
    if let Some(var_6075) = &input.block_device_mappings {
        let mut list_6077 = scope_6074.start_list(true, Some("BlockDeviceMapping"));
        for item_6076 in var_6075 {
            #[allow(unused_mut)]
            let mut entry_6078 = list_6077.entry();
            crate::query_ser::serialize_structure_crate_model_block_device_mapping(
                entry_6078, item_6076,
            )?;
        }
        list_6077.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6079 = writer.prefix("ImageId");
    if let Some(var_6080) = &input.image_id {
        scope_6079.string(var_6080);
    }
    #[allow(unused_mut)]
    let mut scope_6081 = writer.prefix("InstanceType");
    if let Some(var_6082) = &input.instance_type {
        scope_6081.string(var_6082.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_6083 = writer.prefix("Ipv6AddressCount");
    if let Some(var_6084) = &input.ipv6_address_count {
        scope_6083.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_6084).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_6085 = writer.prefix("Ipv6Address");
    if let Some(var_6086) = &input.ipv6_addresses {
        let mut list_6088 = scope_6085.start_list(true, Some("item"));
        for item_6087 in var_6086 {
            #[allow(unused_mut)]
            let mut entry_6089 = list_6088.entry();
            crate::query_ser::serialize_structure_crate_model_instance_ipv6_address(
                entry_6089, item_6087,
            )?;
        }
        list_6088.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6090 = writer.prefix("KernelId");
    if let Some(var_6091) = &input.kernel_id {
        scope_6090.string(var_6091);
    }
    #[allow(unused_mut)]
    let mut scope_6092 = writer.prefix("KeyName");
    if let Some(var_6093) = &input.key_name {
        scope_6092.string(var_6093);
    }
    #[allow(unused_mut)]
    let mut scope_6094 = writer.prefix("MaxCount");
    if let Some(var_6095) = &input.max_count {
        scope_6094.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_6095).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_6096 = writer.prefix("MinCount");
    if let Some(var_6097) = &input.min_count {
        scope_6096.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_6097).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_6098 = writer.prefix("Monitoring");
    if let Some(var_6099) = &input.monitoring {
        crate::query_ser::serialize_structure_crate_model_run_instances_monitoring_enabled(
            scope_6098, var_6099,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6100 = writer.prefix("Placement");
    if let Some(var_6101) = &input.placement {
        crate::query_ser::serialize_structure_crate_model_placement(scope_6100, var_6101)?;
    }
    #[allow(unused_mut)]
    let mut scope_6102 = writer.prefix("RamdiskId");
    if let Some(var_6103) = &input.ramdisk_id {
        scope_6102.string(var_6103);
    }
    #[allow(unused_mut)]
    let mut scope_6104 = writer.prefix("SecurityGroupId");
    if let Some(var_6105) = &input.security_group_ids {
        let mut list_6107 = scope_6104.start_list(true, Some("SecurityGroupId"));
        for item_6106 in var_6105 {
            #[allow(unused_mut)]
            let mut entry_6108 = list_6107.entry();
            entry_6108.string(item_6106);
        }
        list_6107.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6109 = writer.prefix("SecurityGroup");
    if let Some(var_6110) = &input.security_groups {
        let mut list_6112 = scope_6109.start_list(true, Some("SecurityGroup"));
        for item_6111 in var_6110 {
            #[allow(unused_mut)]
            let mut entry_6113 = list_6112.entry();
            entry_6113.string(item_6111);
        }
        list_6112.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6114 = writer.prefix("SubnetId");
    if let Some(var_6115) = &input.subnet_id {
        scope_6114.string(var_6115);
    }
    #[allow(unused_mut)]
    let mut scope_6116 = writer.prefix("UserData");
    if let Some(var_6117) = &input.user_data {
        scope_6116.string(var_6117);
    }
    #[allow(unused_mut)]
    let mut scope_6118 = writer.prefix("AdditionalInfo");
    if let Some(var_6119) = &input.additional_info {
        scope_6118.string(var_6119);
    }
    #[allow(unused_mut)]
    let mut scope_6120 = writer.prefix("ClientToken");
    if let Some(var_6121) = &input.client_token {
        scope_6120.string(var_6121);
    }
    #[allow(unused_mut)]
    let mut scope_6122 = writer.prefix("DisableApiTermination");
    if let Some(var_6123) = &input.disable_api_termination {
        scope_6122.boolean(*var_6123);
    }
    #[allow(unused_mut)]
    let mut scope_6124 = writer.prefix("DryRun");
    if let Some(var_6125) = &input.dry_run {
        scope_6124.boolean(*var_6125);
    }
    #[allow(unused_mut)]
    let mut scope_6126 = writer.prefix("EbsOptimized");
    if let Some(var_6127) = &input.ebs_optimized {
        scope_6126.boolean(*var_6127);
    }
    #[allow(unused_mut)]
    let mut scope_6128 = writer.prefix("IamInstanceProfile");
    if let Some(var_6129) = &input.iam_instance_profile {
        crate::query_ser::serialize_structure_crate_model_iam_instance_profile_specification(
            scope_6128, var_6129,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6130 = writer.prefix("InstanceInitiatedShutdownBehavior");
    if let Some(var_6131) = &input.instance_initiated_shutdown_behavior {
        scope_6130.string(var_6131.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_6132 = writer.prefix("NetworkInterface");
    if let Some(var_6133) = &input.network_interfaces {
        let mut list_6135 = scope_6132.start_list(true, Some("item"));
        for item_6134 in var_6133 {
            #[allow(unused_mut)]
            let mut entry_6136 = list_6135.entry();
            crate::query_ser::serialize_structure_crate_model_instance_network_interface_specification(entry_6136, item_6134)?;
        }
        list_6135.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6137 = writer.prefix("PrivateIpAddress");
    if let Some(var_6138) = &input.private_ip_address {
        scope_6137.string(var_6138);
    }
    #[allow(unused_mut)]
    let mut scope_6139 = writer.prefix("ElasticGpuSpecification");
    if let Some(var_6140) = &input.elastic_gpu_specification {
        let mut list_6142 = scope_6139.start_list(true, Some("item"));
        for item_6141 in var_6140 {
            #[allow(unused_mut)]
            let mut entry_6143 = list_6142.entry();
            crate::query_ser::serialize_structure_crate_model_elastic_gpu_specification(
                entry_6143, item_6141,
            )?;
        }
        list_6142.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6144 = writer.prefix("ElasticInferenceAccelerator");
    if let Some(var_6145) = &input.elastic_inference_accelerators {
        let mut list_6147 = scope_6144.start_list(true, Some("item"));
        for item_6146 in var_6145 {
            #[allow(unused_mut)]
            let mut entry_6148 = list_6147.entry();
            crate::query_ser::serialize_structure_crate_model_elastic_inference_accelerator(
                entry_6148, item_6146,
            )?;
        }
        list_6147.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6149 = writer.prefix("TagSpecification");
    if let Some(var_6150) = &input.tag_specifications {
        let mut list_6152 = scope_6149.start_list(true, Some("item"));
        for item_6151 in var_6150 {
            #[allow(unused_mut)]
            let mut entry_6153 = list_6152.entry();
            crate::query_ser::serialize_structure_crate_model_tag_specification(
                entry_6153, item_6151,
            )?;
        }
        list_6152.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6154 = writer.prefix("LaunchTemplate");
    if let Some(var_6155) = &input.launch_template {
        crate::query_ser::serialize_structure_crate_model_launch_template_specification(
            scope_6154, var_6155,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6156 = writer.prefix("InstanceMarketOptions");
    if let Some(var_6157) = &input.instance_market_options {
        crate::query_ser::serialize_structure_crate_model_instance_market_options_request(
            scope_6156, var_6157,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6158 = writer.prefix("CreditSpecification");
    if let Some(var_6159) = &input.credit_specification {
        crate::query_ser::serialize_structure_crate_model_credit_specification_request(
            scope_6158, var_6159,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6160 = writer.prefix("CpuOptions");
    if let Some(var_6161) = &input.cpu_options {
        crate::query_ser::serialize_structure_crate_model_cpu_options_request(
            scope_6160, var_6161,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6162 = writer.prefix("CapacityReservationSpecification");
    if let Some(var_6163) = &input.capacity_reservation_specification {
        crate::query_ser::serialize_structure_crate_model_capacity_reservation_specification(
            scope_6162, var_6163,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6164 = writer.prefix("HibernationOptions");
    if let Some(var_6165) = &input.hibernation_options {
        crate::query_ser::serialize_structure_crate_model_hibernation_options_request(
            scope_6164, var_6165,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6166 = writer.prefix("LicenseSpecification");
    if let Some(var_6167) = &input.license_specifications {
        let mut list_6169 = scope_6166.start_list(true, Some("item"));
        for item_6168 in var_6167 {
            #[allow(unused_mut)]
            let mut entry_6170 = list_6169.entry();
            crate::query_ser::serialize_structure_crate_model_license_configuration_request(
                entry_6170, item_6168,
            )?;
        }
        list_6169.finish();
    }
    #[allow(unused_mut)]
    let mut scope_6171 = writer.prefix("MetadataOptions");
    if let Some(var_6172) = &input.metadata_options {
        crate::query_ser::serialize_structure_crate_model_instance_metadata_options_request(
            scope_6171, var_6172,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6173 = writer.prefix("EnclaveOptions");
    if let Some(var_6174) = &input.enclave_options {
        crate::query_ser::serialize_structure_crate_model_enclave_options_request(
            scope_6173, var_6174,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6175 = writer.prefix("PrivateDnsNameOptions");
    if let Some(var_6176) = &input.private_dns_name_options {
        crate::query_ser::serialize_structure_crate_model_private_dns_name_options_request(
            scope_6175, var_6176,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6177 = writer.prefix("MaintenanceOptions");
    if let Some(var_6178) = &input.maintenance_options {
        crate::query_ser::serialize_structure_crate_model_instance_maintenance_options_request(
            scope_6177, var_6178,
        )?;
    }
    #[allow(unused_mut)]
    let mut scope_6179 = writer.prefix("DisableApiStop");
    if let Some(var_6180) = &input.disable_api_stop {
        scope_6179.boolean(*var_6180);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}