Enum aws_sdk_ec2::model::HostnameType

#[non_exhaustive]
pub enum HostnameType {
    IpName,
    ResourceName,
    Unknown(UnknownVariantValue),
}

When writing a match expression against HostnameType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Here is an example of how you can make a match expression forward-compatible:

# let hostnametype = unimplemented!();
match hostnametype {
    HostnameType::IpName => { /* ... */ },
    HostnameType::ResourceName => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

The above code demonstrates that when hostnametype represents NewFeature, the execution path will lead to the second last match arm, even though the enum does not contain a variant HostnameType::NewFeature in the current version of SDK. The reason is that the variable other, created by the @ operator, is bound to HostnameType::Unknown(UnknownVariantValue("NewFeature".to_owned())) and calling as_str on it yields "NewFeature". This match expression is forward-compatible when executed with a newer version of SDK where the variant HostnameType::NewFeature is defined. Specifically, when hostnametype represents NewFeature, the execution path will hit the second last match arm as before by virtue of calling as_str on HostnameType::NewFeature also yielding "NewFeature".

Explicitly matching on the Unknown variant should be avoided for two reasons:

• The inner data UnknownVariantValue is opaque, and no further information can be extracted.
• It might inadvertently shadow other intended match arms.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

IpName

ResourceName

Unknown(UnknownVariantValue)

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

Implementations

impl HostnameType

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 10806)

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

src/query_ser.rs (line 3590)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/operation_ser.rs (line 18548)

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

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

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

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

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

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

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

pub const fn values() -> &'static [&'static str]

Returns all the &str values of the enum members.

Trait Implementations

impl AsRef<str> for HostnameType

fn as_ref(&self) -> &str

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

impl Clone for HostnameType

fn clone(&self) -> HostnameType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HostnameType

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

Formats the value using the given formatter.

impl From<&str> for HostnameType

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for HostnameType

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for HostnameType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for HostnameType

fn cmp(&self, other: &HostnameType) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<HostnameType> for HostnameType

fn eq(&self, other: &HostnameType) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<HostnameType> for HostnameType

fn partial_cmp(&self, other: &HostnameType) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for HostnameType

impl StructuralEq for HostnameType

impl StructuralPartialEq for HostnameType