operation_ser.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_operation_crate_operation_add_client_id_to_open_id_connect_provider(
    input: &crate::input::AddClientIdToOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "AddClientIDToOpenIDConnectProvider",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_1 = writer.prefix("OpenIDConnectProviderArn");
    if let Some(var_2) = &input.open_id_connect_provider_arn {
        scope_1.string(var_2);
    }
    #[allow(unused_mut)]
    let mut scope_3 = writer.prefix("ClientID");
    if let Some(var_4) = &input.client_id {
        scope_3.string(var_4);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_add_role_to_instance_profile(
    input: &crate::input::AddRoleToInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "AddRoleToInstanceProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_5 = writer.prefix("InstanceProfileName");
    if let Some(var_6) = &input.instance_profile_name {
        scope_5.string(var_6);
    }
    #[allow(unused_mut)]
    let mut scope_7 = writer.prefix("RoleName");
    if let Some(var_8) = &input.role_name {
        scope_7.string(var_8);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_add_user_to_group(
    input: &crate::input::AddUserToGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AddUserToGroup", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_9 = writer.prefix("GroupName");
    if let Some(var_10) = &input.group_name {
        scope_9.string(var_10);
    }
    #[allow(unused_mut)]
    let mut scope_11 = writer.prefix("UserName");
    if let Some(var_12) = &input.user_name {
        scope_11.string(var_12);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_attach_group_policy(
    input: &crate::input::AttachGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "AttachGroupPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_13 = writer.prefix("GroupName");
    if let Some(var_14) = &input.group_name {
        scope_13.string(var_14);
    }
    #[allow(unused_mut)]
    let mut scope_15 = writer.prefix("PolicyArn");
    if let Some(var_16) = &input.policy_arn {
        scope_15.string(var_16);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_attach_role_policy(
    input: &crate::input::AttachRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AttachRolePolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_17 = writer.prefix("RoleName");
    if let Some(var_18) = &input.role_name {
        scope_17.string(var_18);
    }
    #[allow(unused_mut)]
    let mut scope_19 = writer.prefix("PolicyArn");
    if let Some(var_20) = &input.policy_arn {
        scope_19.string(var_20);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_attach_user_policy(
    input: &crate::input::AttachUserPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AttachUserPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_21 = writer.prefix("UserName");
    if let Some(var_22) = &input.user_name {
        scope_21.string(var_22);
    }
    #[allow(unused_mut)]
    let mut scope_23 = writer.prefix("PolicyArn");
    if let Some(var_24) = &input.policy_arn {
        scope_23.string(var_24);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_change_password(
    input: &crate::input::ChangePasswordInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ChangePassword", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_25 = writer.prefix("OldPassword");
    if let Some(var_26) = &input.old_password {
        scope_25.string(var_26);
    }
    #[allow(unused_mut)]
    let mut scope_27 = writer.prefix("NewPassword");
    if let Some(var_28) = &input.new_password {
        scope_27.string(var_28);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_access_key(
    input: &crate::input::CreateAccessKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateAccessKey", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_29 = writer.prefix("UserName");
    if let Some(var_30) = &input.user_name {
        scope_29.string(var_30);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_account_alias(
    input: &crate::input::CreateAccountAliasInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "CreateAccountAlias", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_31 = writer.prefix("AccountAlias");
    if let Some(var_32) = &input.account_alias {
        scope_31.string(var_32);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_group(
    input: &crate::input::CreateGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateGroup", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_33 = writer.prefix("Path");
    if let Some(var_34) = &input.path {
        scope_33.string(var_34);
    }
    #[allow(unused_mut)]
    let mut scope_35 = writer.prefix("GroupName");
    if let Some(var_36) = &input.group_name {
        scope_35.string(var_36);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_instance_profile(
    input: &crate::input::CreateInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "CreateInstanceProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_37 = writer.prefix("InstanceProfileName");
    if let Some(var_38) = &input.instance_profile_name {
        scope_37.string(var_38);
    }
    #[allow(unused_mut)]
    let mut scope_39 = writer.prefix("Path");
    if let Some(var_40) = &input.path {
        scope_39.string(var_40);
    }
    #[allow(unused_mut)]
    let mut scope_41 = writer.prefix("Tags");
    if let Some(var_42) = &input.tags {
        let mut list_44 = scope_41.start_list(false, None);
        for item_43 in var_42 {
            #[allow(unused_mut)]
            let mut entry_45 = list_44.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_45, item_43)?;
        }
        list_44.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_login_profile(
    input: &crate::input::CreateLoginProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "CreateLoginProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_46 = writer.prefix("UserName");
    if let Some(var_47) = &input.user_name {
        scope_46.string(var_47);
    }
    #[allow(unused_mut)]
    let mut scope_48 = writer.prefix("Password");
    if let Some(var_49) = &input.password {
        scope_48.string(var_49);
    }
    #[allow(unused_mut)]
    let mut scope_50 = writer.prefix("PasswordResetRequired");
    if input.password_reset_required {
        scope_50.boolean(input.password_reset_required);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_open_id_connect_provider(
    input: &crate::input::CreateOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "CreateOpenIDConnectProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_51 = writer.prefix("Url");
    if let Some(var_52) = &input.url {
        scope_51.string(var_52);
    }
    #[allow(unused_mut)]
    let mut scope_53 = writer.prefix("ClientIDList");
    if let Some(var_54) = &input.client_id_list {
        let mut list_56 = scope_53.start_list(false, None);
        for item_55 in var_54 {
            #[allow(unused_mut)]
            let mut entry_57 = list_56.entry();
            entry_57.string(item_55);
        }
        list_56.finish();
    }
    #[allow(unused_mut)]
    let mut scope_58 = writer.prefix("ThumbprintList");
    if let Some(var_59) = &input.thumbprint_list {
        let mut list_61 = scope_58.start_list(false, None);
        for item_60 in var_59 {
            #[allow(unused_mut)]
            let mut entry_62 = list_61.entry();
            entry_62.string(item_60);
        }
        list_61.finish();
    }
    #[allow(unused_mut)]
    let mut scope_63 = writer.prefix("Tags");
    if let Some(var_64) = &input.tags {
        let mut list_66 = scope_63.start_list(false, None);
        for item_65 in var_64 {
            #[allow(unused_mut)]
            let mut entry_67 = list_66.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_67, item_65)?;
        }
        list_66.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_policy(
    input: &crate::input::CreatePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreatePolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_68 = writer.prefix("PolicyName");
    if let Some(var_69) = &input.policy_name {
        scope_68.string(var_69);
    }
    #[allow(unused_mut)]
    let mut scope_70 = writer.prefix("Path");
    if let Some(var_71) = &input.path {
        scope_70.string(var_71);
    }
    #[allow(unused_mut)]
    let mut scope_72 = writer.prefix("PolicyDocument");
    if let Some(var_73) = &input.policy_document {
        scope_72.string(var_73);
    }
    #[allow(unused_mut)]
    let mut scope_74 = writer.prefix("Description");
    if let Some(var_75) = &input.description {
        scope_74.string(var_75);
    }
    #[allow(unused_mut)]
    let mut scope_76 = writer.prefix("Tags");
    if let Some(var_77) = &input.tags {
        let mut list_79 = scope_76.start_list(false, None);
        for item_78 in var_77 {
            #[allow(unused_mut)]
            let mut entry_80 = list_79.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_80, item_78)?;
        }
        list_79.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_policy_version(
    input: &crate::input::CreatePolicyVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "CreatePolicyVersion", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_81 = writer.prefix("PolicyArn");
    if let Some(var_82) = &input.policy_arn {
        scope_81.string(var_82);
    }
    #[allow(unused_mut)]
    let mut scope_83 = writer.prefix("PolicyDocument");
    if let Some(var_84) = &input.policy_document {
        scope_83.string(var_84);
    }
    #[allow(unused_mut)]
    let mut scope_85 = writer.prefix("SetAsDefault");
    if input.set_as_default {
        scope_85.boolean(input.set_as_default);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_role(
    input: &crate::input::CreateRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateRole", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_86 = writer.prefix("Path");
    if let Some(var_87) = &input.path {
        scope_86.string(var_87);
    }
    #[allow(unused_mut)]
    let mut scope_88 = writer.prefix("RoleName");
    if let Some(var_89) = &input.role_name {
        scope_88.string(var_89);
    }
    #[allow(unused_mut)]
    let mut scope_90 = writer.prefix("AssumeRolePolicyDocument");
    if let Some(var_91) = &input.assume_role_policy_document {
        scope_90.string(var_91);
    }
    #[allow(unused_mut)]
    let mut scope_92 = writer.prefix("Description");
    if let Some(var_93) = &input.description {
        scope_92.string(var_93);
    }
    #[allow(unused_mut)]
    let mut scope_94 = writer.prefix("MaxSessionDuration");
    if let Some(var_95) = &input.max_session_duration {
        scope_94.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_95).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_96 = writer.prefix("PermissionsBoundary");
    if let Some(var_97) = &input.permissions_boundary {
        scope_96.string(var_97);
    }
    #[allow(unused_mut)]
    let mut scope_98 = writer.prefix("Tags");
    if let Some(var_99) = &input.tags {
        let mut list_101 = scope_98.start_list(false, None);
        for item_100 in var_99 {
            #[allow(unused_mut)]
            let mut entry_102 = list_101.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_102, item_100)?;
        }
        list_101.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_saml_provider(
    input: &crate::input::CreateSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "CreateSAMLProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_103 = writer.prefix("SAMLMetadataDocument");
    if let Some(var_104) = &input.saml_metadata_document {
        scope_103.string(var_104);
    }
    #[allow(unused_mut)]
    let mut scope_105 = writer.prefix("Name");
    if let Some(var_106) = &input.name {
        scope_105.string(var_106);
    }
    #[allow(unused_mut)]
    let mut scope_107 = writer.prefix("Tags");
    if let Some(var_108) = &input.tags {
        let mut list_110 = scope_107.start_list(false, None);
        for item_109 in var_108 {
            #[allow(unused_mut)]
            let mut entry_111 = list_110.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_111, item_109)?;
        }
        list_110.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_service_linked_role(
    input: &crate::input::CreateServiceLinkedRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "CreateServiceLinkedRole", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_112 = writer.prefix("AWSServiceName");
    if let Some(var_113) = &input.aws_service_name {
        scope_112.string(var_113);
    }
    #[allow(unused_mut)]
    let mut scope_114 = writer.prefix("Description");
    if let Some(var_115) = &input.description {
        scope_114.string(var_115);
    }
    #[allow(unused_mut)]
    let mut scope_116 = writer.prefix("CustomSuffix");
    if let Some(var_117) = &input.custom_suffix {
        scope_116.string(var_117);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_service_specific_credential(
    input: &crate::input::CreateServiceSpecificCredentialInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "CreateServiceSpecificCredential",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_118 = writer.prefix("UserName");
    if let Some(var_119) = &input.user_name {
        scope_118.string(var_119);
    }
    #[allow(unused_mut)]
    let mut scope_120 = writer.prefix("ServiceName");
    if let Some(var_121) = &input.service_name {
        scope_120.string(var_121);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_user(
    input: &crate::input::CreateUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateUser", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_122 = writer.prefix("Path");
    if let Some(var_123) = &input.path {
        scope_122.string(var_123);
    }
    #[allow(unused_mut)]
    let mut scope_124 = writer.prefix("UserName");
    if let Some(var_125) = &input.user_name {
        scope_124.string(var_125);
    }
    #[allow(unused_mut)]
    let mut scope_126 = writer.prefix("PermissionsBoundary");
    if let Some(var_127) = &input.permissions_boundary {
        scope_126.string(var_127);
    }
    #[allow(unused_mut)]
    let mut scope_128 = writer.prefix("Tags");
    if let Some(var_129) = &input.tags {
        let mut list_131 = scope_128.start_list(false, None);
        for item_130 in var_129 {
            #[allow(unused_mut)]
            let mut entry_132 = list_131.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_132, item_130)?;
        }
        list_131.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_create_virtual_mfa_device(
    input: &crate::input::CreateVirtualMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "CreateVirtualMFADevice", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_133 = writer.prefix("Path");
    if let Some(var_134) = &input.path {
        scope_133.string(var_134);
    }
    #[allow(unused_mut)]
    let mut scope_135 = writer.prefix("VirtualMFADeviceName");
    if let Some(var_136) = &input.virtual_mfa_device_name {
        scope_135.string(var_136);
    }
    #[allow(unused_mut)]
    let mut scope_137 = writer.prefix("Tags");
    if let Some(var_138) = &input.tags {
        let mut list_140 = scope_137.start_list(false, None);
        for item_139 in var_138 {
            #[allow(unused_mut)]
            let mut entry_141 = list_140.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_141, item_139)?;
        }
        list_140.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_deactivate_mfa_device(
    input: &crate::input::DeactivateMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeactivateMFADevice", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_142 = writer.prefix("UserName");
    if let Some(var_143) = &input.user_name {
        scope_142.string(var_143);
    }
    #[allow(unused_mut)]
    let mut scope_144 = writer.prefix("SerialNumber");
    if let Some(var_145) = &input.serial_number {
        scope_144.string(var_145);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_access_key(
    input: &crate::input::DeleteAccessKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteAccessKey", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_146 = writer.prefix("UserName");
    if let Some(var_147) = &input.user_name {
        scope_146.string(var_147);
    }
    #[allow(unused_mut)]
    let mut scope_148 = writer.prefix("AccessKeyId");
    if let Some(var_149) = &input.access_key_id {
        scope_148.string(var_149);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_account_alias(
    input: &crate::input::DeleteAccountAliasInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteAccountAlias", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_150 = writer.prefix("AccountAlias");
    if let Some(var_151) = &input.account_alias {
        scope_150.string(var_151);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_account_password_policy(
    input: &crate::input::DeleteAccountPasswordPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let _ = input;
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteAccountPasswordPolicy", "2010-05-08");
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_group(
    input: &crate::input::DeleteGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteGroup", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_152 = writer.prefix("GroupName");
    if let Some(var_153) = &input.group_name {
        scope_152.string(var_153);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_group_policy(
    input: &crate::input::DeleteGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteGroupPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_154 = writer.prefix("GroupName");
    if let Some(var_155) = &input.group_name {
        scope_154.string(var_155);
    }
    #[allow(unused_mut)]
    let mut scope_156 = writer.prefix("PolicyName");
    if let Some(var_157) = &input.policy_name {
        scope_156.string(var_157);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_instance_profile(
    input: &crate::input::DeleteInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteInstanceProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_158 = writer.prefix("InstanceProfileName");
    if let Some(var_159) = &input.instance_profile_name {
        scope_158.string(var_159);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_login_profile(
    input: &crate::input::DeleteLoginProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteLoginProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_160 = writer.prefix("UserName");
    if let Some(var_161) = &input.user_name {
        scope_160.string(var_161);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_open_id_connect_provider(
    input: &crate::input::DeleteOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteOpenIDConnectProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_162 = writer.prefix("OpenIDConnectProviderArn");
    if let Some(var_163) = &input.open_id_connect_provider_arn {
        scope_162.string(var_163);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_policy(
    input: &crate::input::DeletePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeletePolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_164 = writer.prefix("PolicyArn");
    if let Some(var_165) = &input.policy_arn {
        scope_164.string(var_165);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_policy_version(
    input: &crate::input::DeletePolicyVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeletePolicyVersion", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_166 = writer.prefix("PolicyArn");
    if let Some(var_167) = &input.policy_arn {
        scope_166.string(var_167);
    }
    #[allow(unused_mut)]
    let mut scope_168 = writer.prefix("VersionId");
    if let Some(var_169) = &input.version_id {
        scope_168.string(var_169);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_role(
    input: &crate::input::DeleteRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteRole", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_170 = writer.prefix("RoleName");
    if let Some(var_171) = &input.role_name {
        scope_170.string(var_171);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_role_permissions_boundary(
    input: &crate::input::DeleteRolePermissionsBoundaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteRolePermissionsBoundary", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_172 = writer.prefix("RoleName");
    if let Some(var_173) = &input.role_name {
        scope_172.string(var_173);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_role_policy(
    input: &crate::input::DeleteRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteRolePolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_174 = writer.prefix("RoleName");
    if let Some(var_175) = &input.role_name {
        scope_174.string(var_175);
    }
    #[allow(unused_mut)]
    let mut scope_176 = writer.prefix("PolicyName");
    if let Some(var_177) = &input.policy_name {
        scope_176.string(var_177);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_saml_provider(
    input: &crate::input::DeleteSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteSAMLProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_178 = writer.prefix("SAMLProviderArn");
    if let Some(var_179) = &input.saml_provider_arn {
        scope_178.string(var_179);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_server_certificate(
    input: &crate::input::DeleteServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteServerCertificate", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_180 = writer.prefix("ServerCertificateName");
    if let Some(var_181) = &input.server_certificate_name {
        scope_180.string(var_181);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_service_linked_role(
    input: &crate::input::DeleteServiceLinkedRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteServiceLinkedRole", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_182 = writer.prefix("RoleName");
    if let Some(var_183) = &input.role_name {
        scope_182.string(var_183);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_service_specific_credential(
    input: &crate::input::DeleteServiceSpecificCredentialInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "DeleteServiceSpecificCredential",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_184 = writer.prefix("UserName");
    if let Some(var_185) = &input.user_name {
        scope_184.string(var_185);
    }
    #[allow(unused_mut)]
    let mut scope_186 = writer.prefix("ServiceSpecificCredentialId");
    if let Some(var_187) = &input.service_specific_credential_id {
        scope_186.string(var_187);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_signing_certificate(
    input: &crate::input::DeleteSigningCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteSigningCertificate", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_188 = writer.prefix("UserName");
    if let Some(var_189) = &input.user_name {
        scope_188.string(var_189);
    }
    #[allow(unused_mut)]
    let mut scope_190 = writer.prefix("CertificateId");
    if let Some(var_191) = &input.certificate_id {
        scope_190.string(var_191);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_ssh_public_key(
    input: &crate::input::DeleteSshPublicKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteSSHPublicKey", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_192 = writer.prefix("UserName");
    if let Some(var_193) = &input.user_name {
        scope_192.string(var_193);
    }
    #[allow(unused_mut)]
    let mut scope_194 = writer.prefix("SSHPublicKeyId");
    if let Some(var_195) = &input.ssh_public_key_id {
        scope_194.string(var_195);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_user(
    input: &crate::input::DeleteUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteUser", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_196 = writer.prefix("UserName");
    if let Some(var_197) = &input.user_name {
        scope_196.string(var_197);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_user_permissions_boundary(
    input: &crate::input::DeleteUserPermissionsBoundaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteUserPermissionsBoundary", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_198 = writer.prefix("UserName");
    if let Some(var_199) = &input.user_name {
        scope_198.string(var_199);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_user_policy(
    input: &crate::input::DeleteUserPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteUserPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_200 = writer.prefix("UserName");
    if let Some(var_201) = &input.user_name {
        scope_200.string(var_201);
    }
    #[allow(unused_mut)]
    let mut scope_202 = writer.prefix("PolicyName");
    if let Some(var_203) = &input.policy_name {
        scope_202.string(var_203);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_delete_virtual_mfa_device(
    input: &crate::input::DeleteVirtualMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DeleteVirtualMFADevice", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_204 = writer.prefix("SerialNumber");
    if let Some(var_205) = &input.serial_number {
        scope_204.string(var_205);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_detach_group_policy(
    input: &crate::input::DetachGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "DetachGroupPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_206 = writer.prefix("GroupName");
    if let Some(var_207) = &input.group_name {
        scope_206.string(var_207);
    }
    #[allow(unused_mut)]
    let mut scope_208 = writer.prefix("PolicyArn");
    if let Some(var_209) = &input.policy_arn {
        scope_208.string(var_209);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_detach_role_policy(
    input: &crate::input::DetachRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DetachRolePolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_210 = writer.prefix("RoleName");
    if let Some(var_211) = &input.role_name {
        scope_210.string(var_211);
    }
    #[allow(unused_mut)]
    let mut scope_212 = writer.prefix("PolicyArn");
    if let Some(var_213) = &input.policy_arn {
        scope_212.string(var_213);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_detach_user_policy(
    input: &crate::input::DetachUserPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DetachUserPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_214 = writer.prefix("UserName");
    if let Some(var_215) = &input.user_name {
        scope_214.string(var_215);
    }
    #[allow(unused_mut)]
    let mut scope_216 = writer.prefix("PolicyArn");
    if let Some(var_217) = &input.policy_arn {
        scope_216.string(var_217);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_enable_mfa_device(
    input: &crate::input::EnableMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "EnableMFADevice", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_218 = writer.prefix("UserName");
    if let Some(var_219) = &input.user_name {
        scope_218.string(var_219);
    }
    #[allow(unused_mut)]
    let mut scope_220 = writer.prefix("SerialNumber");
    if let Some(var_221) = &input.serial_number {
        scope_220.string(var_221);
    }
    #[allow(unused_mut)]
    let mut scope_222 = writer.prefix("AuthenticationCode1");
    if let Some(var_223) = &input.authentication_code1 {
        scope_222.string(var_223);
    }
    #[allow(unused_mut)]
    let mut scope_224 = writer.prefix("AuthenticationCode2");
    if let Some(var_225) = &input.authentication_code2 {
        scope_224.string(var_225);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_generate_credential_report(
    input: &crate::input::GenerateCredentialReportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let _ = input;
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GenerateCredentialReport", "2010-05-08");
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_generate_organizations_access_report(
    input: &crate::input::GenerateOrganizationsAccessReportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "GenerateOrganizationsAccessReport",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_226 = writer.prefix("EntityPath");
    if let Some(var_227) = &input.entity_path {
        scope_226.string(var_227);
    }
    #[allow(unused_mut)]
    let mut scope_228 = writer.prefix("OrganizationsPolicyId");
    if let Some(var_229) = &input.organizations_policy_id {
        scope_228.string(var_229);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_generate_service_last_accessed_details(
    input: &crate::input::GenerateServiceLastAccessedDetailsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "GenerateServiceLastAccessedDetails",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_230 = writer.prefix("Arn");
    if let Some(var_231) = &input.arn {
        scope_230.string(var_231);
    }
    #[allow(unused_mut)]
    let mut scope_232 = writer.prefix("Granularity");
    if let Some(var_233) = &input.granularity {
        scope_232.string(var_233.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_access_key_last_used(
    input: &crate::input::GetAccessKeyLastUsedInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GetAccessKeyLastUsed", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_234 = writer.prefix("AccessKeyId");
    if let Some(var_235) = &input.access_key_id {
        scope_234.string(var_235);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_account_authorization_details(
    input: &crate::input::GetAccountAuthorizationDetailsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "GetAccountAuthorizationDetails",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_236 = writer.prefix("Filter");
    if let Some(var_237) = &input.filter {
        let mut list_239 = scope_236.start_list(false, None);
        for item_238 in var_237 {
            #[allow(unused_mut)]
            let mut entry_240 = list_239.entry();
            entry_240.string(item_238.as_str());
        }
        list_239.finish();
    }
    #[allow(unused_mut)]
    let mut scope_241 = writer.prefix("MaxItems");
    if let Some(var_242) = &input.max_items {
        scope_241.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_242).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_243 = writer.prefix("Marker");
    if let Some(var_244) = &input.marker {
        scope_243.string(var_244);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_account_password_policy(
    input: &crate::input::GetAccountPasswordPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let _ = input;
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GetAccountPasswordPolicy", "2010-05-08");
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_account_summary(
    input: &crate::input::GetAccountSummaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let _ = input;
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GetAccountSummary", "2010-05-08");
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_context_keys_for_custom_policy(
    input: &crate::input::GetContextKeysForCustomPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GetContextKeysForCustomPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_245 = writer.prefix("PolicyInputList");
    if let Some(var_246) = &input.policy_input_list {
        let mut list_248 = scope_245.start_list(false, None);
        for item_247 in var_246 {
            #[allow(unused_mut)]
            let mut entry_249 = list_248.entry();
            entry_249.string(item_247);
        }
        list_248.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_context_keys_for_principal_policy(
    input: &crate::input::GetContextKeysForPrincipalPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "GetContextKeysForPrincipalPolicy",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_250 = writer.prefix("PolicySourceArn");
    if let Some(var_251) = &input.policy_source_arn {
        scope_250.string(var_251);
    }
    #[allow(unused_mut)]
    let mut scope_252 = writer.prefix("PolicyInputList");
    if let Some(var_253) = &input.policy_input_list {
        let mut list_255 = scope_252.start_list(false, None);
        for item_254 in var_253 {
            #[allow(unused_mut)]
            let mut entry_256 = list_255.entry();
            entry_256.string(item_254);
        }
        list_255.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_credential_report(
    input: &crate::input::GetCredentialReportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let _ = input;
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GetCredentialReport", "2010-05-08");
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_group(
    input: &crate::input::GetGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetGroup", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_257 = writer.prefix("GroupName");
    if let Some(var_258) = &input.group_name {
        scope_257.string(var_258);
    }
    #[allow(unused_mut)]
    let mut scope_259 = writer.prefix("Marker");
    if let Some(var_260) = &input.marker {
        scope_259.string(var_260);
    }
    #[allow(unused_mut)]
    let mut scope_261 = writer.prefix("MaxItems");
    if let Some(var_262) = &input.max_items {
        scope_261.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_262).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_group_policy(
    input: &crate::input::GetGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetGroupPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_263 = writer.prefix("GroupName");
    if let Some(var_264) = &input.group_name {
        scope_263.string(var_264);
    }
    #[allow(unused_mut)]
    let mut scope_265 = writer.prefix("PolicyName");
    if let Some(var_266) = &input.policy_name {
        scope_265.string(var_266);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_instance_profile(
    input: &crate::input::GetInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GetInstanceProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_267 = writer.prefix("InstanceProfileName");
    if let Some(var_268) = &input.instance_profile_name {
        scope_267.string(var_268);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_login_profile(
    input: &crate::input::GetLoginProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetLoginProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_269 = writer.prefix("UserName");
    if let Some(var_270) = &input.user_name {
        scope_269.string(var_270);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_open_id_connect_provider(
    input: &crate::input::GetOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GetOpenIDConnectProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_271 = writer.prefix("OpenIDConnectProviderArn");
    if let Some(var_272) = &input.open_id_connect_provider_arn {
        scope_271.string(var_272);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_organizations_access_report(
    input: &crate::input::GetOrganizationsAccessReportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GetOrganizationsAccessReport", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_273 = writer.prefix("JobId");
    if let Some(var_274) = &input.job_id {
        scope_273.string(var_274);
    }
    #[allow(unused_mut)]
    let mut scope_275 = writer.prefix("MaxItems");
    if let Some(var_276) = &input.max_items {
        scope_275.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_276).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_277 = writer.prefix("Marker");
    if let Some(var_278) = &input.marker {
        scope_277.string(var_278);
    }
    #[allow(unused_mut)]
    let mut scope_279 = writer.prefix("SortKey");
    if let Some(var_280) = &input.sort_key {
        scope_279.string(var_280.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_policy(
    input: &crate::input::GetPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_281 = writer.prefix("PolicyArn");
    if let Some(var_282) = &input.policy_arn {
        scope_281.string(var_282);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_policy_version(
    input: &crate::input::GetPolicyVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetPolicyVersion", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_283 = writer.prefix("PolicyArn");
    if let Some(var_284) = &input.policy_arn {
        scope_283.string(var_284);
    }
    #[allow(unused_mut)]
    let mut scope_285 = writer.prefix("VersionId");
    if let Some(var_286) = &input.version_id {
        scope_285.string(var_286);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_role(
    input: &crate::input::GetRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetRole", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_287 = writer.prefix("RoleName");
    if let Some(var_288) = &input.role_name {
        scope_287.string(var_288);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_role_policy(
    input: &crate::input::GetRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetRolePolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_289 = writer.prefix("RoleName");
    if let Some(var_290) = &input.role_name {
        scope_289.string(var_290);
    }
    #[allow(unused_mut)]
    let mut scope_291 = writer.prefix("PolicyName");
    if let Some(var_292) = &input.policy_name {
        scope_291.string(var_292);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_saml_provider(
    input: &crate::input::GetSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetSAMLProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_293 = writer.prefix("SAMLProviderArn");
    if let Some(var_294) = &input.saml_provider_arn {
        scope_293.string(var_294);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_server_certificate(
    input: &crate::input::GetServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GetServerCertificate", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_295 = writer.prefix("ServerCertificateName");
    if let Some(var_296) = &input.server_certificate_name {
        scope_295.string(var_296);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_service_last_accessed_details(
    input: &crate::input::GetServiceLastAccessedDetailsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "GetServiceLastAccessedDetails", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_297 = writer.prefix("JobId");
    if let Some(var_298) = &input.job_id {
        scope_297.string(var_298);
    }
    #[allow(unused_mut)]
    let mut scope_299 = writer.prefix("MaxItems");
    if let Some(var_300) = &input.max_items {
        scope_299.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_300).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_301 = writer.prefix("Marker");
    if let Some(var_302) = &input.marker {
        scope_301.string(var_302);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_service_last_accessed_details_with_entities(
    input: &crate::input::GetServiceLastAccessedDetailsWithEntitiesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "GetServiceLastAccessedDetailsWithEntities",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_303 = writer.prefix("JobId");
    if let Some(var_304) = &input.job_id {
        scope_303.string(var_304);
    }
    #[allow(unused_mut)]
    let mut scope_305 = writer.prefix("ServiceNamespace");
    if let Some(var_306) = &input.service_namespace {
        scope_305.string(var_306);
    }
    #[allow(unused_mut)]
    let mut scope_307 = writer.prefix("MaxItems");
    if let Some(var_308) = &input.max_items {
        scope_307.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_308).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_309 = writer.prefix("Marker");
    if let Some(var_310) = &input.marker {
        scope_309.string(var_310);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_service_linked_role_deletion_status(
    input: &crate::input::GetServiceLinkedRoleDeletionStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "GetServiceLinkedRoleDeletionStatus",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_311 = writer.prefix("DeletionTaskId");
    if let Some(var_312) = &input.deletion_task_id {
        scope_311.string(var_312);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_ssh_public_key(
    input: &crate::input::GetSshPublicKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetSSHPublicKey", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_313 = writer.prefix("UserName");
    if let Some(var_314) = &input.user_name {
        scope_313.string(var_314);
    }
    #[allow(unused_mut)]
    let mut scope_315 = writer.prefix("SSHPublicKeyId");
    if let Some(var_316) = &input.ssh_public_key_id {
        scope_315.string(var_316);
    }
    #[allow(unused_mut)]
    let mut scope_317 = writer.prefix("Encoding");
    if let Some(var_318) = &input.encoding {
        scope_317.string(var_318.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_user(
    input: &crate::input::GetUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetUser", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_319 = writer.prefix("UserName");
    if let Some(var_320) = &input.user_name {
        scope_319.string(var_320);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_get_user_policy(
    input: &crate::input::GetUserPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetUserPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_321 = writer.prefix("UserName");
    if let Some(var_322) = &input.user_name {
        scope_321.string(var_322);
    }
    #[allow(unused_mut)]
    let mut scope_323 = writer.prefix("PolicyName");
    if let Some(var_324) = &input.policy_name {
        scope_323.string(var_324);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_access_keys(
    input: &crate::input::ListAccessKeysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListAccessKeys", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_325 = writer.prefix("UserName");
    if let Some(var_326) = &input.user_name {
        scope_325.string(var_326);
    }
    #[allow(unused_mut)]
    let mut scope_327 = writer.prefix("Marker");
    if let Some(var_328) = &input.marker {
        scope_327.string(var_328);
    }
    #[allow(unused_mut)]
    let mut scope_329 = writer.prefix("MaxItems");
    if let Some(var_330) = &input.max_items {
        scope_329.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_330).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_account_aliases(
    input: &crate::input::ListAccountAliasesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListAccountAliases", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_331 = writer.prefix("Marker");
    if let Some(var_332) = &input.marker {
        scope_331.string(var_332);
    }
    #[allow(unused_mut)]
    let mut scope_333 = writer.prefix("MaxItems");
    if let Some(var_334) = &input.max_items {
        scope_333.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_334).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_attached_group_policies(
    input: &crate::input::ListAttachedGroupPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListAttachedGroupPolicies", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_335 = writer.prefix("GroupName");
    if let Some(var_336) = &input.group_name {
        scope_335.string(var_336);
    }
    #[allow(unused_mut)]
    let mut scope_337 = writer.prefix("PathPrefix");
    if let Some(var_338) = &input.path_prefix {
        scope_337.string(var_338);
    }
    #[allow(unused_mut)]
    let mut scope_339 = writer.prefix("Marker");
    if let Some(var_340) = &input.marker {
        scope_339.string(var_340);
    }
    #[allow(unused_mut)]
    let mut scope_341 = writer.prefix("MaxItems");
    if let Some(var_342) = &input.max_items {
        scope_341.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_342).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_attached_role_policies(
    input: &crate::input::ListAttachedRolePoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListAttachedRolePolicies", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_343 = writer.prefix("RoleName");
    if let Some(var_344) = &input.role_name {
        scope_343.string(var_344);
    }
    #[allow(unused_mut)]
    let mut scope_345 = writer.prefix("PathPrefix");
    if let Some(var_346) = &input.path_prefix {
        scope_345.string(var_346);
    }
    #[allow(unused_mut)]
    let mut scope_347 = writer.prefix("Marker");
    if let Some(var_348) = &input.marker {
        scope_347.string(var_348);
    }
    #[allow(unused_mut)]
    let mut scope_349 = writer.prefix("MaxItems");
    if let Some(var_350) = &input.max_items {
        scope_349.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_350).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_attached_user_policies(
    input: &crate::input::ListAttachedUserPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListAttachedUserPolicies", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_351 = writer.prefix("UserName");
    if let Some(var_352) = &input.user_name {
        scope_351.string(var_352);
    }
    #[allow(unused_mut)]
    let mut scope_353 = writer.prefix("PathPrefix");
    if let Some(var_354) = &input.path_prefix {
        scope_353.string(var_354);
    }
    #[allow(unused_mut)]
    let mut scope_355 = writer.prefix("Marker");
    if let Some(var_356) = &input.marker {
        scope_355.string(var_356);
    }
    #[allow(unused_mut)]
    let mut scope_357 = writer.prefix("MaxItems");
    if let Some(var_358) = &input.max_items {
        scope_357.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_358).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_entities_for_policy(
    input: &crate::input::ListEntitiesForPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListEntitiesForPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_359 = writer.prefix("PolicyArn");
    if let Some(var_360) = &input.policy_arn {
        scope_359.string(var_360);
    }
    #[allow(unused_mut)]
    let mut scope_361 = writer.prefix("EntityFilter");
    if let Some(var_362) = &input.entity_filter {
        scope_361.string(var_362.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_363 = writer.prefix("PathPrefix");
    if let Some(var_364) = &input.path_prefix {
        scope_363.string(var_364);
    }
    #[allow(unused_mut)]
    let mut scope_365 = writer.prefix("PolicyUsageFilter");
    if let Some(var_366) = &input.policy_usage_filter {
        scope_365.string(var_366.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_367 = writer.prefix("Marker");
    if let Some(var_368) = &input.marker {
        scope_367.string(var_368);
    }
    #[allow(unused_mut)]
    let mut scope_369 = writer.prefix("MaxItems");
    if let Some(var_370) = &input.max_items {
        scope_369.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_370).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_group_policies(
    input: &crate::input::ListGroupPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListGroupPolicies", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_371 = writer.prefix("GroupName");
    if let Some(var_372) = &input.group_name {
        scope_371.string(var_372);
    }
    #[allow(unused_mut)]
    let mut scope_373 = writer.prefix("Marker");
    if let Some(var_374) = &input.marker {
        scope_373.string(var_374);
    }
    #[allow(unused_mut)]
    let mut scope_375 = writer.prefix("MaxItems");
    if let Some(var_376) = &input.max_items {
        scope_375.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_376).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_groups(
    input: &crate::input::ListGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListGroups", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_377 = writer.prefix("PathPrefix");
    if let Some(var_378) = &input.path_prefix {
        scope_377.string(var_378);
    }
    #[allow(unused_mut)]
    let mut scope_379 = writer.prefix("Marker");
    if let Some(var_380) = &input.marker {
        scope_379.string(var_380);
    }
    #[allow(unused_mut)]
    let mut scope_381 = writer.prefix("MaxItems");
    if let Some(var_382) = &input.max_items {
        scope_381.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_382).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_groups_for_user(
    input: &crate::input::ListGroupsForUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListGroupsForUser", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_383 = writer.prefix("UserName");
    if let Some(var_384) = &input.user_name {
        scope_383.string(var_384);
    }
    #[allow(unused_mut)]
    let mut scope_385 = writer.prefix("Marker");
    if let Some(var_386) = &input.marker {
        scope_385.string(var_386);
    }
    #[allow(unused_mut)]
    let mut scope_387 = writer.prefix("MaxItems");
    if let Some(var_388) = &input.max_items {
        scope_387.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_388).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_instance_profiles(
    input: &crate::input::ListInstanceProfilesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListInstanceProfiles", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_389 = writer.prefix("PathPrefix");
    if let Some(var_390) = &input.path_prefix {
        scope_389.string(var_390);
    }
    #[allow(unused_mut)]
    let mut scope_391 = writer.prefix("Marker");
    if let Some(var_392) = &input.marker {
        scope_391.string(var_392);
    }
    #[allow(unused_mut)]
    let mut scope_393 = writer.prefix("MaxItems");
    if let Some(var_394) = &input.max_items {
        scope_393.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_394).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_instance_profiles_for_role(
    input: &crate::input::ListInstanceProfilesForRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListInstanceProfilesForRole", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_395 = writer.prefix("RoleName");
    if let Some(var_396) = &input.role_name {
        scope_395.string(var_396);
    }
    #[allow(unused_mut)]
    let mut scope_397 = writer.prefix("Marker");
    if let Some(var_398) = &input.marker {
        scope_397.string(var_398);
    }
    #[allow(unused_mut)]
    let mut scope_399 = writer.prefix("MaxItems");
    if let Some(var_400) = &input.max_items {
        scope_399.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_400).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_instance_profile_tags(
    input: &crate::input::ListInstanceProfileTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListInstanceProfileTags", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_401 = writer.prefix("InstanceProfileName");
    if let Some(var_402) = &input.instance_profile_name {
        scope_401.string(var_402);
    }
    #[allow(unused_mut)]
    let mut scope_403 = writer.prefix("Marker");
    if let Some(var_404) = &input.marker {
        scope_403.string(var_404);
    }
    #[allow(unused_mut)]
    let mut scope_405 = writer.prefix("MaxItems");
    if let Some(var_406) = &input.max_items {
        scope_405.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_406).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_mfa_devices(
    input: &crate::input::ListMfaDevicesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListMFADevices", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_407 = writer.prefix("UserName");
    if let Some(var_408) = &input.user_name {
        scope_407.string(var_408);
    }
    #[allow(unused_mut)]
    let mut scope_409 = writer.prefix("Marker");
    if let Some(var_410) = &input.marker {
        scope_409.string(var_410);
    }
    #[allow(unused_mut)]
    let mut scope_411 = writer.prefix("MaxItems");
    if let Some(var_412) = &input.max_items {
        scope_411.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_412).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_mfa_device_tags(
    input: &crate::input::ListMfaDeviceTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListMFADeviceTags", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_413 = writer.prefix("SerialNumber");
    if let Some(var_414) = &input.serial_number {
        scope_413.string(var_414);
    }
    #[allow(unused_mut)]
    let mut scope_415 = writer.prefix("Marker");
    if let Some(var_416) = &input.marker {
        scope_415.string(var_416);
    }
    #[allow(unused_mut)]
    let mut scope_417 = writer.prefix("MaxItems");
    if let Some(var_418) = &input.max_items {
        scope_417.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_418).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_open_id_connect_providers(
    input: &crate::input::ListOpenIdConnectProvidersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let _ = input;
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListOpenIDConnectProviders", "2010-05-08");
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_open_id_connect_provider_tags(
    input: &crate::input::ListOpenIdConnectProviderTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListOpenIDConnectProviderTags", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_419 = writer.prefix("OpenIDConnectProviderArn");
    if let Some(var_420) = &input.open_id_connect_provider_arn {
        scope_419.string(var_420);
    }
    #[allow(unused_mut)]
    let mut scope_421 = writer.prefix("Marker");
    if let Some(var_422) = &input.marker {
        scope_421.string(var_422);
    }
    #[allow(unused_mut)]
    let mut scope_423 = writer.prefix("MaxItems");
    if let Some(var_424) = &input.max_items {
        scope_423.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_424).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_policies(
    input: &crate::input::ListPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListPolicies", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_425 = writer.prefix("Scope");
    if let Some(var_426) = &input.scope {
        scope_425.string(var_426.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_427 = writer.prefix("OnlyAttached");
    if input.only_attached {
        scope_427.boolean(input.only_attached);
    }
    #[allow(unused_mut)]
    let mut scope_428 = writer.prefix("PathPrefix");
    if let Some(var_429) = &input.path_prefix {
        scope_428.string(var_429);
    }
    #[allow(unused_mut)]
    let mut scope_430 = writer.prefix("PolicyUsageFilter");
    if let Some(var_431) = &input.policy_usage_filter {
        scope_430.string(var_431.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_432 = writer.prefix("Marker");
    if let Some(var_433) = &input.marker {
        scope_432.string(var_433);
    }
    #[allow(unused_mut)]
    let mut scope_434 = writer.prefix("MaxItems");
    if let Some(var_435) = &input.max_items {
        scope_434.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_435).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_policies_granting_service_access(
    input: &crate::input::ListPoliciesGrantingServiceAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ListPoliciesGrantingServiceAccess",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_436 = writer.prefix("Marker");
    if let Some(var_437) = &input.marker {
        scope_436.string(var_437);
    }
    #[allow(unused_mut)]
    let mut scope_438 = writer.prefix("Arn");
    if let Some(var_439) = &input.arn {
        scope_438.string(var_439);
    }
    #[allow(unused_mut)]
    let mut scope_440 = writer.prefix("ServiceNamespaces");
    if let Some(var_441) = &input.service_namespaces {
        let mut list_443 = scope_440.start_list(false, None);
        for item_442 in var_441 {
            #[allow(unused_mut)]
            let mut entry_444 = list_443.entry();
            entry_444.string(item_442);
        }
        list_443.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_policy_tags(
    input: &crate::input::ListPolicyTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListPolicyTags", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_445 = writer.prefix("PolicyArn");
    if let Some(var_446) = &input.policy_arn {
        scope_445.string(var_446);
    }
    #[allow(unused_mut)]
    let mut scope_447 = writer.prefix("Marker");
    if let Some(var_448) = &input.marker {
        scope_447.string(var_448);
    }
    #[allow(unused_mut)]
    let mut scope_449 = writer.prefix("MaxItems");
    if let Some(var_450) = &input.max_items {
        scope_449.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_450).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_policy_versions(
    input: &crate::input::ListPolicyVersionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListPolicyVersions", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_451 = writer.prefix("PolicyArn");
    if let Some(var_452) = &input.policy_arn {
        scope_451.string(var_452);
    }
    #[allow(unused_mut)]
    let mut scope_453 = writer.prefix("Marker");
    if let Some(var_454) = &input.marker {
        scope_453.string(var_454);
    }
    #[allow(unused_mut)]
    let mut scope_455 = writer.prefix("MaxItems");
    if let Some(var_456) = &input.max_items {
        scope_455.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_456).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_role_policies(
    input: &crate::input::ListRolePoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListRolePolicies", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_457 = writer.prefix("RoleName");
    if let Some(var_458) = &input.role_name {
        scope_457.string(var_458);
    }
    #[allow(unused_mut)]
    let mut scope_459 = writer.prefix("Marker");
    if let Some(var_460) = &input.marker {
        scope_459.string(var_460);
    }
    #[allow(unused_mut)]
    let mut scope_461 = writer.prefix("MaxItems");
    if let Some(var_462) = &input.max_items {
        scope_461.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_462).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_roles(
    input: &crate::input::ListRolesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListRoles", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_463 = writer.prefix("PathPrefix");
    if let Some(var_464) = &input.path_prefix {
        scope_463.string(var_464);
    }
    #[allow(unused_mut)]
    let mut scope_465 = writer.prefix("Marker");
    if let Some(var_466) = &input.marker {
        scope_465.string(var_466);
    }
    #[allow(unused_mut)]
    let mut scope_467 = writer.prefix("MaxItems");
    if let Some(var_468) = &input.max_items {
        scope_467.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_468).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_role_tags(
    input: &crate::input::ListRoleTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListRoleTags", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_469 = writer.prefix("RoleName");
    if let Some(var_470) = &input.role_name {
        scope_469.string(var_470);
    }
    #[allow(unused_mut)]
    let mut scope_471 = writer.prefix("Marker");
    if let Some(var_472) = &input.marker {
        scope_471.string(var_472);
    }
    #[allow(unused_mut)]
    let mut scope_473 = writer.prefix("MaxItems");
    if let Some(var_474) = &input.max_items {
        scope_473.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_474).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_saml_providers(
    input: &crate::input::ListSamlProvidersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let _ = input;
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListSAMLProviders", "2010-05-08");
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_saml_provider_tags(
    input: &crate::input::ListSamlProviderTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListSAMLProviderTags", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_475 = writer.prefix("SAMLProviderArn");
    if let Some(var_476) = &input.saml_provider_arn {
        scope_475.string(var_476);
    }
    #[allow(unused_mut)]
    let mut scope_477 = writer.prefix("Marker");
    if let Some(var_478) = &input.marker {
        scope_477.string(var_478);
    }
    #[allow(unused_mut)]
    let mut scope_479 = writer.prefix("MaxItems");
    if let Some(var_480) = &input.max_items {
        scope_479.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_480).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_server_certificates(
    input: &crate::input::ListServerCertificatesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListServerCertificates", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_481 = writer.prefix("PathPrefix");
    if let Some(var_482) = &input.path_prefix {
        scope_481.string(var_482);
    }
    #[allow(unused_mut)]
    let mut scope_483 = writer.prefix("Marker");
    if let Some(var_484) = &input.marker {
        scope_483.string(var_484);
    }
    #[allow(unused_mut)]
    let mut scope_485 = writer.prefix("MaxItems");
    if let Some(var_486) = &input.max_items {
        scope_485.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_486).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_server_certificate_tags(
    input: &crate::input::ListServerCertificateTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListServerCertificateTags", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_487 = writer.prefix("ServerCertificateName");
    if let Some(var_488) = &input.server_certificate_name {
        scope_487.string(var_488);
    }
    #[allow(unused_mut)]
    let mut scope_489 = writer.prefix("Marker");
    if let Some(var_490) = &input.marker {
        scope_489.string(var_490);
    }
    #[allow(unused_mut)]
    let mut scope_491 = writer.prefix("MaxItems");
    if let Some(var_492) = &input.max_items {
        scope_491.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_492).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_service_specific_credentials(
    input: &crate::input::ListServiceSpecificCredentialsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ListServiceSpecificCredentials",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_493 = writer.prefix("UserName");
    if let Some(var_494) = &input.user_name {
        scope_493.string(var_494);
    }
    #[allow(unused_mut)]
    let mut scope_495 = writer.prefix("ServiceName");
    if let Some(var_496) = &input.service_name {
        scope_495.string(var_496);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_signing_certificates(
    input: &crate::input::ListSigningCertificatesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListSigningCertificates", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_497 = writer.prefix("UserName");
    if let Some(var_498) = &input.user_name {
        scope_497.string(var_498);
    }
    #[allow(unused_mut)]
    let mut scope_499 = writer.prefix("Marker");
    if let Some(var_500) = &input.marker {
        scope_499.string(var_500);
    }
    #[allow(unused_mut)]
    let mut scope_501 = writer.prefix("MaxItems");
    if let Some(var_502) = &input.max_items {
        scope_501.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_502).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_ssh_public_keys(
    input: &crate::input::ListSshPublicKeysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListSSHPublicKeys", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_503 = writer.prefix("UserName");
    if let Some(var_504) = &input.user_name {
        scope_503.string(var_504);
    }
    #[allow(unused_mut)]
    let mut scope_505 = writer.prefix("Marker");
    if let Some(var_506) = &input.marker {
        scope_505.string(var_506);
    }
    #[allow(unused_mut)]
    let mut scope_507 = writer.prefix("MaxItems");
    if let Some(var_508) = &input.max_items {
        scope_507.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_508).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_user_policies(
    input: &crate::input::ListUserPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListUserPolicies", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_509 = writer.prefix("UserName");
    if let Some(var_510) = &input.user_name {
        scope_509.string(var_510);
    }
    #[allow(unused_mut)]
    let mut scope_511 = writer.prefix("Marker");
    if let Some(var_512) = &input.marker {
        scope_511.string(var_512);
    }
    #[allow(unused_mut)]
    let mut scope_513 = writer.prefix("MaxItems");
    if let Some(var_514) = &input.max_items {
        scope_513.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_514).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_users(
    input: &crate::input::ListUsersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListUsers", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_515 = writer.prefix("PathPrefix");
    if let Some(var_516) = &input.path_prefix {
        scope_515.string(var_516);
    }
    #[allow(unused_mut)]
    let mut scope_517 = writer.prefix("Marker");
    if let Some(var_518) = &input.marker {
        scope_517.string(var_518);
    }
    #[allow(unused_mut)]
    let mut scope_519 = writer.prefix("MaxItems");
    if let Some(var_520) = &input.max_items {
        scope_519.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_520).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_user_tags(
    input: &crate::input::ListUserTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListUserTags", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_521 = writer.prefix("UserName");
    if let Some(var_522) = &input.user_name {
        scope_521.string(var_522);
    }
    #[allow(unused_mut)]
    let mut scope_523 = writer.prefix("Marker");
    if let Some(var_524) = &input.marker {
        scope_523.string(var_524);
    }
    #[allow(unused_mut)]
    let mut scope_525 = writer.prefix("MaxItems");
    if let Some(var_526) = &input.max_items {
        scope_525.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_526).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_list_virtual_mfa_devices(
    input: &crate::input::ListVirtualMfaDevicesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "ListVirtualMFADevices", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_527 = writer.prefix("AssignmentStatus");
    if let Some(var_528) = &input.assignment_status {
        scope_527.string(var_528.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_529 = writer.prefix("Marker");
    if let Some(var_530) = &input.marker {
        scope_529.string(var_530);
    }
    #[allow(unused_mut)]
    let mut scope_531 = writer.prefix("MaxItems");
    if let Some(var_532) = &input.max_items {
        scope_531.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_532).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_put_group_policy(
    input: &crate::input::PutGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutGroupPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_533 = writer.prefix("GroupName");
    if let Some(var_534) = &input.group_name {
        scope_533.string(var_534);
    }
    #[allow(unused_mut)]
    let mut scope_535 = writer.prefix("PolicyName");
    if let Some(var_536) = &input.policy_name {
        scope_535.string(var_536);
    }
    #[allow(unused_mut)]
    let mut scope_537 = writer.prefix("PolicyDocument");
    if let Some(var_538) = &input.policy_document {
        scope_537.string(var_538);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_put_role_permissions_boundary(
    input: &crate::input::PutRolePermissionsBoundaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "PutRolePermissionsBoundary", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_539 = writer.prefix("RoleName");
    if let Some(var_540) = &input.role_name {
        scope_539.string(var_540);
    }
    #[allow(unused_mut)]
    let mut scope_541 = writer.prefix("PermissionsBoundary");
    if let Some(var_542) = &input.permissions_boundary {
        scope_541.string(var_542);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_put_role_policy(
    input: &crate::input::PutRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutRolePolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_543 = writer.prefix("RoleName");
    if let Some(var_544) = &input.role_name {
        scope_543.string(var_544);
    }
    #[allow(unused_mut)]
    let mut scope_545 = writer.prefix("PolicyName");
    if let Some(var_546) = &input.policy_name {
        scope_545.string(var_546);
    }
    #[allow(unused_mut)]
    let mut scope_547 = writer.prefix("PolicyDocument");
    if let Some(var_548) = &input.policy_document {
        scope_547.string(var_548);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_put_user_permissions_boundary(
    input: &crate::input::PutUserPermissionsBoundaryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "PutUserPermissionsBoundary", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_549 = writer.prefix("UserName");
    if let Some(var_550) = &input.user_name {
        scope_549.string(var_550);
    }
    #[allow(unused_mut)]
    let mut scope_551 = writer.prefix("PermissionsBoundary");
    if let Some(var_552) = &input.permissions_boundary {
        scope_551.string(var_552);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_put_user_policy(
    input: &crate::input::PutUserPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutUserPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_553 = writer.prefix("UserName");
    if let Some(var_554) = &input.user_name {
        scope_553.string(var_554);
    }
    #[allow(unused_mut)]
    let mut scope_555 = writer.prefix("PolicyName");
    if let Some(var_556) = &input.policy_name {
        scope_555.string(var_556);
    }
    #[allow(unused_mut)]
    let mut scope_557 = writer.prefix("PolicyDocument");
    if let Some(var_558) = &input.policy_document {
        scope_557.string(var_558);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_remove_client_id_from_open_id_connect_provider(
    input: &crate::input::RemoveClientIdFromOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "RemoveClientIDFromOpenIDConnectProvider",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_559 = writer.prefix("OpenIDConnectProviderArn");
    if let Some(var_560) = &input.open_id_connect_provider_arn {
        scope_559.string(var_560);
    }
    #[allow(unused_mut)]
    let mut scope_561 = writer.prefix("ClientID");
    if let Some(var_562) = &input.client_id {
        scope_561.string(var_562);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_remove_role_from_instance_profile(
    input: &crate::input::RemoveRoleFromInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "RemoveRoleFromInstanceProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_563 = writer.prefix("InstanceProfileName");
    if let Some(var_564) = &input.instance_profile_name {
        scope_563.string(var_564);
    }
    #[allow(unused_mut)]
    let mut scope_565 = writer.prefix("RoleName");
    if let Some(var_566) = &input.role_name {
        scope_565.string(var_566);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_remove_user_from_group(
    input: &crate::input::RemoveUserFromGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "RemoveUserFromGroup", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_567 = writer.prefix("GroupName");
    if let Some(var_568) = &input.group_name {
        scope_567.string(var_568);
    }
    #[allow(unused_mut)]
    let mut scope_569 = writer.prefix("UserName");
    if let Some(var_570) = &input.user_name {
        scope_569.string(var_570);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_reset_service_specific_credential(
    input: &crate::input::ResetServiceSpecificCredentialInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "ResetServiceSpecificCredential",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_571 = writer.prefix("UserName");
    if let Some(var_572) = &input.user_name {
        scope_571.string(var_572);
    }
    #[allow(unused_mut)]
    let mut scope_573 = writer.prefix("ServiceSpecificCredentialId");
    if let Some(var_574) = &input.service_specific_credential_id {
        scope_573.string(var_574);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_resync_mfa_device(
    input: &crate::input::ResyncMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ResyncMFADevice", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_575 = writer.prefix("UserName");
    if let Some(var_576) = &input.user_name {
        scope_575.string(var_576);
    }
    #[allow(unused_mut)]
    let mut scope_577 = writer.prefix("SerialNumber");
    if let Some(var_578) = &input.serial_number {
        scope_577.string(var_578);
    }
    #[allow(unused_mut)]
    let mut scope_579 = writer.prefix("AuthenticationCode1");
    if let Some(var_580) = &input.authentication_code1 {
        scope_579.string(var_580);
    }
    #[allow(unused_mut)]
    let mut scope_581 = writer.prefix("AuthenticationCode2");
    if let Some(var_582) = &input.authentication_code2 {
        scope_581.string(var_582);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_set_default_policy_version(
    input: &crate::input::SetDefaultPolicyVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "SetDefaultPolicyVersion", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_583 = writer.prefix("PolicyArn");
    if let Some(var_584) = &input.policy_arn {
        scope_583.string(var_584);
    }
    #[allow(unused_mut)]
    let mut scope_585 = writer.prefix("VersionId");
    if let Some(var_586) = &input.version_id {
        scope_585.string(var_586);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_set_security_token_service_preferences(
    input: &crate::input::SetSecurityTokenServicePreferencesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "SetSecurityTokenServicePreferences",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_587 = writer.prefix("GlobalEndpointTokenVersion");
    if let Some(var_588) = &input.global_endpoint_token_version {
        scope_587.string(var_588.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_simulate_custom_policy(
    input: &crate::input::SimulateCustomPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "SimulateCustomPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_589 = writer.prefix("PolicyInputList");
    if let Some(var_590) = &input.policy_input_list {
        let mut list_592 = scope_589.start_list(false, None);
        for item_591 in var_590 {
            #[allow(unused_mut)]
            let mut entry_593 = list_592.entry();
            entry_593.string(item_591);
        }
        list_592.finish();
    }
    #[allow(unused_mut)]
    let mut scope_594 = writer.prefix("PermissionsBoundaryPolicyInputList");
    if let Some(var_595) = &input.permissions_boundary_policy_input_list {
        let mut list_597 = scope_594.start_list(false, None);
        for item_596 in var_595 {
            #[allow(unused_mut)]
            let mut entry_598 = list_597.entry();
            entry_598.string(item_596);
        }
        list_597.finish();
    }
    #[allow(unused_mut)]
    let mut scope_599 = writer.prefix("ActionNames");
    if let Some(var_600) = &input.action_names {
        let mut list_602 = scope_599.start_list(false, None);
        for item_601 in var_600 {
            #[allow(unused_mut)]
            let mut entry_603 = list_602.entry();
            entry_603.string(item_601);
        }
        list_602.finish();
    }
    #[allow(unused_mut)]
    let mut scope_604 = writer.prefix("ResourceArns");
    if let Some(var_605) = &input.resource_arns {
        let mut list_607 = scope_604.start_list(false, None);
        for item_606 in var_605 {
            #[allow(unused_mut)]
            let mut entry_608 = list_607.entry();
            entry_608.string(item_606);
        }
        list_607.finish();
    }
    #[allow(unused_mut)]
    let mut scope_609 = writer.prefix("ResourcePolicy");
    if let Some(var_610) = &input.resource_policy {
        scope_609.string(var_610);
    }
    #[allow(unused_mut)]
    let mut scope_611 = writer.prefix("ResourceOwner");
    if let Some(var_612) = &input.resource_owner {
        scope_611.string(var_612);
    }
    #[allow(unused_mut)]
    let mut scope_613 = writer.prefix("CallerArn");
    if let Some(var_614) = &input.caller_arn {
        scope_613.string(var_614);
    }
    #[allow(unused_mut)]
    let mut scope_615 = writer.prefix("ContextEntries");
    if let Some(var_616) = &input.context_entries {
        let mut list_618 = scope_615.start_list(false, None);
        for item_617 in var_616 {
            #[allow(unused_mut)]
            let mut entry_619 = list_618.entry();
            crate::query_ser::serialize_structure_crate_model_context_entry(entry_619, item_617)?;
        }
        list_618.finish();
    }
    #[allow(unused_mut)]
    let mut scope_620 = writer.prefix("ResourceHandlingOption");
    if let Some(var_621) = &input.resource_handling_option {
        scope_620.string(var_621);
    }
    #[allow(unused_mut)]
    let mut scope_622 = writer.prefix("MaxItems");
    if let Some(var_623) = &input.max_items {
        scope_622.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_623).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_624 = writer.prefix("Marker");
    if let Some(var_625) = &input.marker {
        scope_624.string(var_625);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_simulate_principal_policy(
    input: &crate::input::SimulatePrincipalPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "SimulatePrincipalPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_626 = writer.prefix("PolicySourceArn");
    if let Some(var_627) = &input.policy_source_arn {
        scope_626.string(var_627);
    }
    #[allow(unused_mut)]
    let mut scope_628 = writer.prefix("PolicyInputList");
    if let Some(var_629) = &input.policy_input_list {
        let mut list_631 = scope_628.start_list(false, None);
        for item_630 in var_629 {
            #[allow(unused_mut)]
            let mut entry_632 = list_631.entry();
            entry_632.string(item_630);
        }
        list_631.finish();
    }
    #[allow(unused_mut)]
    let mut scope_633 = writer.prefix("PermissionsBoundaryPolicyInputList");
    if let Some(var_634) = &input.permissions_boundary_policy_input_list {
        let mut list_636 = scope_633.start_list(false, None);
        for item_635 in var_634 {
            #[allow(unused_mut)]
            let mut entry_637 = list_636.entry();
            entry_637.string(item_635);
        }
        list_636.finish();
    }
    #[allow(unused_mut)]
    let mut scope_638 = writer.prefix("ActionNames");
    if let Some(var_639) = &input.action_names {
        let mut list_641 = scope_638.start_list(false, None);
        for item_640 in var_639 {
            #[allow(unused_mut)]
            let mut entry_642 = list_641.entry();
            entry_642.string(item_640);
        }
        list_641.finish();
    }
    #[allow(unused_mut)]
    let mut scope_643 = writer.prefix("ResourceArns");
    if let Some(var_644) = &input.resource_arns {
        let mut list_646 = scope_643.start_list(false, None);
        for item_645 in var_644 {
            #[allow(unused_mut)]
            let mut entry_647 = list_646.entry();
            entry_647.string(item_645);
        }
        list_646.finish();
    }
    #[allow(unused_mut)]
    let mut scope_648 = writer.prefix("ResourcePolicy");
    if let Some(var_649) = &input.resource_policy {
        scope_648.string(var_649);
    }
    #[allow(unused_mut)]
    let mut scope_650 = writer.prefix("ResourceOwner");
    if let Some(var_651) = &input.resource_owner {
        scope_650.string(var_651);
    }
    #[allow(unused_mut)]
    let mut scope_652 = writer.prefix("CallerArn");
    if let Some(var_653) = &input.caller_arn {
        scope_652.string(var_653);
    }
    #[allow(unused_mut)]
    let mut scope_654 = writer.prefix("ContextEntries");
    if let Some(var_655) = &input.context_entries {
        let mut list_657 = scope_654.start_list(false, None);
        for item_656 in var_655 {
            #[allow(unused_mut)]
            let mut entry_658 = list_657.entry();
            crate::query_ser::serialize_structure_crate_model_context_entry(entry_658, item_656)?;
        }
        list_657.finish();
    }
    #[allow(unused_mut)]
    let mut scope_659 = writer.prefix("ResourceHandlingOption");
    if let Some(var_660) = &input.resource_handling_option {
        scope_659.string(var_660);
    }
    #[allow(unused_mut)]
    let mut scope_661 = writer.prefix("MaxItems");
    if let Some(var_662) = &input.max_items {
        scope_661.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_662).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_663 = writer.prefix("Marker");
    if let Some(var_664) = &input.marker {
        scope_663.string(var_664);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_tag_instance_profile(
    input: &crate::input::TagInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "TagInstanceProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_665 = writer.prefix("InstanceProfileName");
    if let Some(var_666) = &input.instance_profile_name {
        scope_665.string(var_666);
    }
    #[allow(unused_mut)]
    let mut scope_667 = writer.prefix("Tags");
    if let Some(var_668) = &input.tags {
        let mut list_670 = scope_667.start_list(false, None);
        for item_669 in var_668 {
            #[allow(unused_mut)]
            let mut entry_671 = list_670.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_671, item_669)?;
        }
        list_670.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_tag_mfa_device(
    input: &crate::input::TagMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagMFADevice", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_672 = writer.prefix("SerialNumber");
    if let Some(var_673) = &input.serial_number {
        scope_672.string(var_673);
    }
    #[allow(unused_mut)]
    let mut scope_674 = writer.prefix("Tags");
    if let Some(var_675) = &input.tags {
        let mut list_677 = scope_674.start_list(false, None);
        for item_676 in var_675 {
            #[allow(unused_mut)]
            let mut entry_678 = list_677.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_678, item_676)?;
        }
        list_677.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_tag_open_id_connect_provider(
    input: &crate::input::TagOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "TagOpenIDConnectProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_679 = writer.prefix("OpenIDConnectProviderArn");
    if let Some(var_680) = &input.open_id_connect_provider_arn {
        scope_679.string(var_680);
    }
    #[allow(unused_mut)]
    let mut scope_681 = writer.prefix("Tags");
    if let Some(var_682) = &input.tags {
        let mut list_684 = scope_681.start_list(false, None);
        for item_683 in var_682 {
            #[allow(unused_mut)]
            let mut entry_685 = list_684.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_685, item_683)?;
        }
        list_684.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_tag_policy(
    input: &crate::input::TagPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_686 = writer.prefix("PolicyArn");
    if let Some(var_687) = &input.policy_arn {
        scope_686.string(var_687);
    }
    #[allow(unused_mut)]
    let mut scope_688 = writer.prefix("Tags");
    if let Some(var_689) = &input.tags {
        let mut list_691 = scope_688.start_list(false, None);
        for item_690 in var_689 {
            #[allow(unused_mut)]
            let mut entry_692 = list_691.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_692, item_690)?;
        }
        list_691.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_tag_role(
    input: &crate::input::TagRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagRole", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_693 = writer.prefix("RoleName");
    if let Some(var_694) = &input.role_name {
        scope_693.string(var_694);
    }
    #[allow(unused_mut)]
    let mut scope_695 = writer.prefix("Tags");
    if let Some(var_696) = &input.tags {
        let mut list_698 = scope_695.start_list(false, None);
        for item_697 in var_696 {
            #[allow(unused_mut)]
            let mut entry_699 = list_698.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_699, item_697)?;
        }
        list_698.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_tag_saml_provider(
    input: &crate::input::TagSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagSAMLProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_700 = writer.prefix("SAMLProviderArn");
    if let Some(var_701) = &input.saml_provider_arn {
        scope_700.string(var_701);
    }
    #[allow(unused_mut)]
    let mut scope_702 = writer.prefix("Tags");
    if let Some(var_703) = &input.tags {
        let mut list_705 = scope_702.start_list(false, None);
        for item_704 in var_703 {
            #[allow(unused_mut)]
            let mut entry_706 = list_705.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_706, item_704)?;
        }
        list_705.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_tag_server_certificate(
    input: &crate::input::TagServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "TagServerCertificate", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_707 = writer.prefix("ServerCertificateName");
    if let Some(var_708) = &input.server_certificate_name {
        scope_707.string(var_708);
    }
    #[allow(unused_mut)]
    let mut scope_709 = writer.prefix("Tags");
    if let Some(var_710) = &input.tags {
        let mut list_712 = scope_709.start_list(false, None);
        for item_711 in var_710 {
            #[allow(unused_mut)]
            let mut entry_713 = list_712.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_713, item_711)?;
        }
        list_712.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_tag_user(
    input: &crate::input::TagUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagUser", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_714 = writer.prefix("UserName");
    if let Some(var_715) = &input.user_name {
        scope_714.string(var_715);
    }
    #[allow(unused_mut)]
    let mut scope_716 = writer.prefix("Tags");
    if let Some(var_717) = &input.tags {
        let mut list_719 = scope_716.start_list(false, None);
        for item_718 in var_717 {
            #[allow(unused_mut)]
            let mut entry_720 = list_719.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_720, item_718)?;
        }
        list_719.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_untag_instance_profile(
    input: &crate::input::UntagInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UntagInstanceProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_721 = writer.prefix("InstanceProfileName");
    if let Some(var_722) = &input.instance_profile_name {
        scope_721.string(var_722);
    }
    #[allow(unused_mut)]
    let mut scope_723 = writer.prefix("TagKeys");
    if let Some(var_724) = &input.tag_keys {
        let mut list_726 = scope_723.start_list(false, None);
        for item_725 in var_724 {
            #[allow(unused_mut)]
            let mut entry_727 = list_726.entry();
            entry_727.string(item_725);
        }
        list_726.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_untag_mfa_device(
    input: &crate::input::UntagMfaDeviceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UntagMFADevice", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_728 = writer.prefix("SerialNumber");
    if let Some(var_729) = &input.serial_number {
        scope_728.string(var_729);
    }
    #[allow(unused_mut)]
    let mut scope_730 = writer.prefix("TagKeys");
    if let Some(var_731) = &input.tag_keys {
        let mut list_733 = scope_730.start_list(false, None);
        for item_732 in var_731 {
            #[allow(unused_mut)]
            let mut entry_734 = list_733.entry();
            entry_734.string(item_732);
        }
        list_733.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_untag_open_id_connect_provider(
    input: &crate::input::UntagOpenIdConnectProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UntagOpenIDConnectProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_735 = writer.prefix("OpenIDConnectProviderArn");
    if let Some(var_736) = &input.open_id_connect_provider_arn {
        scope_735.string(var_736);
    }
    #[allow(unused_mut)]
    let mut scope_737 = writer.prefix("TagKeys");
    if let Some(var_738) = &input.tag_keys {
        let mut list_740 = scope_737.start_list(false, None);
        for item_739 in var_738 {
            #[allow(unused_mut)]
            let mut entry_741 = list_740.entry();
            entry_741.string(item_739);
        }
        list_740.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_untag_policy(
    input: &crate::input::UntagPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UntagPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_742 = writer.prefix("PolicyArn");
    if let Some(var_743) = &input.policy_arn {
        scope_742.string(var_743);
    }
    #[allow(unused_mut)]
    let mut scope_744 = writer.prefix("TagKeys");
    if let Some(var_745) = &input.tag_keys {
        let mut list_747 = scope_744.start_list(false, None);
        for item_746 in var_745 {
            #[allow(unused_mut)]
            let mut entry_748 = list_747.entry();
            entry_748.string(item_746);
        }
        list_747.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_untag_role(
    input: &crate::input::UntagRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UntagRole", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_749 = writer.prefix("RoleName");
    if let Some(var_750) = &input.role_name {
        scope_749.string(var_750);
    }
    #[allow(unused_mut)]
    let mut scope_751 = writer.prefix("TagKeys");
    if let Some(var_752) = &input.tag_keys {
        let mut list_754 = scope_751.start_list(false, None);
        for item_753 in var_752 {
            #[allow(unused_mut)]
            let mut entry_755 = list_754.entry();
            entry_755.string(item_753);
        }
        list_754.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_untag_saml_provider(
    input: &crate::input::UntagSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UntagSAMLProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_756 = writer.prefix("SAMLProviderArn");
    if let Some(var_757) = &input.saml_provider_arn {
        scope_756.string(var_757);
    }
    #[allow(unused_mut)]
    let mut scope_758 = writer.prefix("TagKeys");
    if let Some(var_759) = &input.tag_keys {
        let mut list_761 = scope_758.start_list(false, None);
        for item_760 in var_759 {
            #[allow(unused_mut)]
            let mut entry_762 = list_761.entry();
            entry_762.string(item_760);
        }
        list_761.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_untag_server_certificate(
    input: &crate::input::UntagServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UntagServerCertificate", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_763 = writer.prefix("ServerCertificateName");
    if let Some(var_764) = &input.server_certificate_name {
        scope_763.string(var_764);
    }
    #[allow(unused_mut)]
    let mut scope_765 = writer.prefix("TagKeys");
    if let Some(var_766) = &input.tag_keys {
        let mut list_768 = scope_765.start_list(false, None);
        for item_767 in var_766 {
            #[allow(unused_mut)]
            let mut entry_769 = list_768.entry();
            entry_769.string(item_767);
        }
        list_768.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_untag_user(
    input: &crate::input::UntagUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UntagUser", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_770 = writer.prefix("UserName");
    if let Some(var_771) = &input.user_name {
        scope_770.string(var_771);
    }
    #[allow(unused_mut)]
    let mut scope_772 = writer.prefix("TagKeys");
    if let Some(var_773) = &input.tag_keys {
        let mut list_775 = scope_772.start_list(false, None);
        for item_774 in var_773 {
            #[allow(unused_mut)]
            let mut entry_776 = list_775.entry();
            entry_776.string(item_774);
        }
        list_775.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_access_key(
    input: &crate::input::UpdateAccessKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateAccessKey", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_777 = writer.prefix("UserName");
    if let Some(var_778) = &input.user_name {
        scope_777.string(var_778);
    }
    #[allow(unused_mut)]
    let mut scope_779 = writer.prefix("AccessKeyId");
    if let Some(var_780) = &input.access_key_id {
        scope_779.string(var_780);
    }
    #[allow(unused_mut)]
    let mut scope_781 = writer.prefix("Status");
    if let Some(var_782) = &input.status {
        scope_781.string(var_782.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_account_password_policy(
    input: &crate::input::UpdateAccountPasswordPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UpdateAccountPasswordPolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_783 = writer.prefix("MinimumPasswordLength");
    if let Some(var_784) = &input.minimum_password_length {
        scope_783.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_784).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_785 = writer.prefix("RequireSymbols");
    if input.require_symbols {
        scope_785.boolean(input.require_symbols);
    }
    #[allow(unused_mut)]
    let mut scope_786 = writer.prefix("RequireNumbers");
    if input.require_numbers {
        scope_786.boolean(input.require_numbers);
    }
    #[allow(unused_mut)]
    let mut scope_787 = writer.prefix("RequireUppercaseCharacters");
    if input.require_uppercase_characters {
        scope_787.boolean(input.require_uppercase_characters);
    }
    #[allow(unused_mut)]
    let mut scope_788 = writer.prefix("RequireLowercaseCharacters");
    if input.require_lowercase_characters {
        scope_788.boolean(input.require_lowercase_characters);
    }
    #[allow(unused_mut)]
    let mut scope_789 = writer.prefix("AllowUsersToChangePassword");
    if input.allow_users_to_change_password {
        scope_789.boolean(input.allow_users_to_change_password);
    }
    #[allow(unused_mut)]
    let mut scope_790 = writer.prefix("MaxPasswordAge");
    if let Some(var_791) = &input.max_password_age {
        scope_790.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_791).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_792 = writer.prefix("PasswordReusePrevention");
    if let Some(var_793) = &input.password_reuse_prevention {
        scope_792.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_793).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_794 = writer.prefix("HardExpiry");
    if let Some(var_795) = &input.hard_expiry {
        scope_794.boolean(*var_795);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_assume_role_policy(
    input: &crate::input::UpdateAssumeRolePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UpdateAssumeRolePolicy", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_796 = writer.prefix("RoleName");
    if let Some(var_797) = &input.role_name {
        scope_796.string(var_797);
    }
    #[allow(unused_mut)]
    let mut scope_798 = writer.prefix("PolicyDocument");
    if let Some(var_799) = &input.policy_document {
        scope_798.string(var_799);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_group(
    input: &crate::input::UpdateGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateGroup", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_800 = writer.prefix("GroupName");
    if let Some(var_801) = &input.group_name {
        scope_800.string(var_801);
    }
    #[allow(unused_mut)]
    let mut scope_802 = writer.prefix("NewPath");
    if let Some(var_803) = &input.new_path {
        scope_802.string(var_803);
    }
    #[allow(unused_mut)]
    let mut scope_804 = writer.prefix("NewGroupName");
    if let Some(var_805) = &input.new_group_name {
        scope_804.string(var_805);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_login_profile(
    input: &crate::input::UpdateLoginProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UpdateLoginProfile", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_806 = writer.prefix("UserName");
    if let Some(var_807) = &input.user_name {
        scope_806.string(var_807);
    }
    #[allow(unused_mut)]
    let mut scope_808 = writer.prefix("Password");
    if let Some(var_809) = &input.password {
        scope_808.string(var_809);
    }
    #[allow(unused_mut)]
    let mut scope_810 = writer.prefix("PasswordResetRequired");
    if let Some(var_811) = &input.password_reset_required {
        scope_810.boolean(*var_811);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_open_id_connect_provider_thumbprint(
    input: &crate::input::UpdateOpenIdConnectProviderThumbprintInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "UpdateOpenIDConnectProviderThumbprint",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_812 = writer.prefix("OpenIDConnectProviderArn");
    if let Some(var_813) = &input.open_id_connect_provider_arn {
        scope_812.string(var_813);
    }
    #[allow(unused_mut)]
    let mut scope_814 = writer.prefix("ThumbprintList");
    if let Some(var_815) = &input.thumbprint_list {
        let mut list_817 = scope_814.start_list(false, None);
        for item_816 in var_815 {
            #[allow(unused_mut)]
            let mut entry_818 = list_817.entry();
            entry_818.string(item_816);
        }
        list_817.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_role(
    input: &crate::input::UpdateRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateRole", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_819 = writer.prefix("RoleName");
    if let Some(var_820) = &input.role_name {
        scope_819.string(var_820);
    }
    #[allow(unused_mut)]
    let mut scope_821 = writer.prefix("Description");
    if let Some(var_822) = &input.description {
        scope_821.string(var_822);
    }
    #[allow(unused_mut)]
    let mut scope_823 = writer.prefix("MaxSessionDuration");
    if let Some(var_824) = &input.max_session_duration {
        scope_823.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_824).into()),
        );
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_role_description(
    input: &crate::input::UpdateRoleDescriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UpdateRoleDescription", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_825 = writer.prefix("RoleName");
    if let Some(var_826) = &input.role_name {
        scope_825.string(var_826);
    }
    #[allow(unused_mut)]
    let mut scope_827 = writer.prefix("Description");
    if let Some(var_828) = &input.description {
        scope_827.string(var_828);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_saml_provider(
    input: &crate::input::UpdateSamlProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UpdateSAMLProvider", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_829 = writer.prefix("SAMLMetadataDocument");
    if let Some(var_830) = &input.saml_metadata_document {
        scope_829.string(var_830);
    }
    #[allow(unused_mut)]
    let mut scope_831 = writer.prefix("SAMLProviderArn");
    if let Some(var_832) = &input.saml_provider_arn {
        scope_831.string(var_832);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_server_certificate(
    input: &crate::input::UpdateServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UpdateServerCertificate", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_833 = writer.prefix("ServerCertificateName");
    if let Some(var_834) = &input.server_certificate_name {
        scope_833.string(var_834);
    }
    #[allow(unused_mut)]
    let mut scope_835 = writer.prefix("NewPath");
    if let Some(var_836) = &input.new_path {
        scope_835.string(var_836);
    }
    #[allow(unused_mut)]
    let mut scope_837 = writer.prefix("NewServerCertificateName");
    if let Some(var_838) = &input.new_server_certificate_name {
        scope_837.string(var_838);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_service_specific_credential(
    input: &crate::input::UpdateServiceSpecificCredentialInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(
        &mut out,
        "UpdateServiceSpecificCredential",
        "2010-05-08",
    );
    #[allow(unused_mut)]
    let mut scope_839 = writer.prefix("UserName");
    if let Some(var_840) = &input.user_name {
        scope_839.string(var_840);
    }
    #[allow(unused_mut)]
    let mut scope_841 = writer.prefix("ServiceSpecificCredentialId");
    if let Some(var_842) = &input.service_specific_credential_id {
        scope_841.string(var_842);
    }
    #[allow(unused_mut)]
    let mut scope_843 = writer.prefix("Status");
    if let Some(var_844) = &input.status {
        scope_843.string(var_844.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_signing_certificate(
    input: &crate::input::UpdateSigningCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UpdateSigningCertificate", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_845 = writer.prefix("UserName");
    if let Some(var_846) = &input.user_name {
        scope_845.string(var_846);
    }
    #[allow(unused_mut)]
    let mut scope_847 = writer.prefix("CertificateId");
    if let Some(var_848) = &input.certificate_id {
        scope_847.string(var_848);
    }
    #[allow(unused_mut)]
    let mut scope_849 = writer.prefix("Status");
    if let Some(var_850) = &input.status {
        scope_849.string(var_850.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_ssh_public_key(
    input: &crate::input::UpdateSshPublicKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UpdateSSHPublicKey", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_851 = writer.prefix("UserName");
    if let Some(var_852) = &input.user_name {
        scope_851.string(var_852);
    }
    #[allow(unused_mut)]
    let mut scope_853 = writer.prefix("SSHPublicKeyId");
    if let Some(var_854) = &input.ssh_public_key_id {
        scope_853.string(var_854);
    }
    #[allow(unused_mut)]
    let mut scope_855 = writer.prefix("Status");
    if let Some(var_856) = &input.status {
        scope_855.string(var_856.as_str());
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_update_user(
    input: &crate::input::UpdateUserInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateUser", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_857 = writer.prefix("UserName");
    if let Some(var_858) = &input.user_name {
        scope_857.string(var_858);
    }
    #[allow(unused_mut)]
    let mut scope_859 = writer.prefix("NewPath");
    if let Some(var_860) = &input.new_path {
        scope_859.string(var_860);
    }
    #[allow(unused_mut)]
    let mut scope_861 = writer.prefix("NewUserName");
    if let Some(var_862) = &input.new_user_name {
        scope_861.string(var_862);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_upload_server_certificate(
    input: &crate::input::UploadServerCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UploadServerCertificate", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_863 = writer.prefix("Path");
    if let Some(var_864) = &input.path {
        scope_863.string(var_864);
    }
    #[allow(unused_mut)]
    let mut scope_865 = writer.prefix("ServerCertificateName");
    if let Some(var_866) = &input.server_certificate_name {
        scope_865.string(var_866);
    }
    #[allow(unused_mut)]
    let mut scope_867 = writer.prefix("CertificateBody");
    if let Some(var_868) = &input.certificate_body {
        scope_867.string(var_868);
    }
    #[allow(unused_mut)]
    let mut scope_869 = writer.prefix("PrivateKey");
    if let Some(var_870) = &input.private_key {
        scope_869.string(var_870);
    }
    #[allow(unused_mut)]
    let mut scope_871 = writer.prefix("CertificateChain");
    if let Some(var_872) = &input.certificate_chain {
        scope_871.string(var_872);
    }
    #[allow(unused_mut)]
    let mut scope_873 = writer.prefix("Tags");
    if let Some(var_874) = &input.tags {
        let mut list_876 = scope_873.start_list(false, None);
        for item_875 in var_874 {
            #[allow(unused_mut)]
            let mut entry_877 = list_876.entry();
            crate::query_ser::serialize_structure_crate_model_tag(entry_877, item_875)?;
        }
        list_876.finish();
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_upload_signing_certificate(
    input: &crate::input::UploadSigningCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UploadSigningCertificate", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_878 = writer.prefix("UserName");
    if let Some(var_879) = &input.user_name {
        scope_878.string(var_879);
    }
    #[allow(unused_mut)]
    let mut scope_880 = writer.prefix("CertificateBody");
    if let Some(var_881) = &input.certificate_body {
        scope_880.string(var_881);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_upload_ssh_public_key(
    input: &crate::input::UploadSshPublicKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        aws_smithy_query::QueryWriter::new(&mut out, "UploadSSHPublicKey", "2010-05-08");
    #[allow(unused_mut)]
    let mut scope_882 = writer.prefix("UserName");
    if let Some(var_883) = &input.user_name {
        scope_882.string(var_883);
    }
    #[allow(unused_mut)]
    let mut scope_884 = writer.prefix("SSHPublicKeyBody");
    if let Some(var_885) = &input.ssh_public_key_body {
        scope_884.string(var_885);
    }
    writer.finish();
    Ok(aws_smithy_http::body::SdkBody::from(out))
}