#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_configuration_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetConfigurationRequest,
) {
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("InstanceCount");
if let Some(var_2) = &input.instance_count {
scope_1.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2).into()),
);
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("OfferingId");
if let Some(var_4) = &input.offering_id {
scope_3.string(var_4);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_tag_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TagSpecification,
) {
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("ResourceType");
if let Some(var_6) = &input.resource_type {
scope_5.string(var_6.as_str());
}
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("Tag");
if let Some(var_8) = &input.tags {
let mut list_10 = scope_7.start_list(true, Some("item"));
for item_9 in var_8 {
#[allow(unused_mut)]
let mut entry_11 = list_10.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_11, item_9);
}
list_10.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_iam_instance_profile_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::IamInstanceProfileSpecification,
) {
#[allow(unused_mut)]
let mut scope_12 = writer.prefix("Arn");
if let Some(var_13) = &input.arn {
scope_12.string(var_13);
}
#[allow(unused_mut)]
let mut scope_14 = writer.prefix("Name");
if let Some(var_15) = &input.name {
scope_14.string(var_15);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_event_window_association_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceEventWindowAssociationRequest,
) {
#[allow(unused_mut)]
let mut scope_16 = writer.prefix("InstanceId");
if let Some(var_17) = &input.instance_ids {
let mut list_19 = scope_16.start_list(true, Some("item"));
for item_18 in var_17 {
#[allow(unused_mut)]
let mut entry_20 = list_19.entry();
entry_20.string(item_18);
}
list_19.finish();
}
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("InstanceTag");
if let Some(var_22) = &input.instance_tags {
let mut list_24 = scope_21.start_list(true, Some("item"));
for item_23 in var_22 {
#[allow(unused_mut)]
let mut entry_25 = list_24.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_25, item_23);
}
list_24.finish();
}
#[allow(unused_mut)]
let mut scope_26 = writer.prefix("DedicatedHostId");
if let Some(var_27) = &input.dedicated_host_ids {
let mut list_29 = scope_26.start_list(true, Some("item"));
for item_28 in var_27 {
#[allow(unused_mut)]
let mut entry_30 = list_29.entry();
entry_30.string(item_28);
}
list_29.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ip_permission(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::IpPermission,
) {
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("FromPort");
if let Some(var_32) = &input.from_port {
scope_31.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_32).into()),
);
}
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("IpProtocol");
if let Some(var_34) = &input.ip_protocol {
scope_33.string(var_34);
}
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("IpRanges");
if let Some(var_36) = &input.ip_ranges {
let mut list_38 = scope_35.start_list(true, Some("item"));
for item_37 in var_36 {
#[allow(unused_mut)]
let mut entry_39 = list_38.entry();
crate::query_ser::serialize_structure_crate_model_ip_range(entry_39, item_37);
}
list_38.finish();
}
#[allow(unused_mut)]
let mut scope_40 = writer.prefix("Ipv6Ranges");
if let Some(var_41) = &input.ipv6_ranges {
let mut list_43 = scope_40.start_list(true, Some("item"));
for item_42 in var_41 {
#[allow(unused_mut)]
let mut entry_44 = list_43.entry();
crate::query_ser::serialize_structure_crate_model_ipv6_range(entry_44, item_42);
}
list_43.finish();
}
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("PrefixListIds");
if let Some(var_46) = &input.prefix_list_ids {
let mut list_48 = scope_45.start_list(true, Some("item"));
for item_47 in var_46 {
#[allow(unused_mut)]
let mut entry_49 = list_48.entry();
crate::query_ser::serialize_structure_crate_model_prefix_list_id(entry_49, item_47);
}
list_48.finish();
}
#[allow(unused_mut)]
let mut scope_50 = writer.prefix("ToPort");
if let Some(var_51) = &input.to_port {
scope_50.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_51).into()),
);
}
#[allow(unused_mut)]
let mut scope_52 = writer.prefix("Groups");
if let Some(var_53) = &input.user_id_group_pairs {
let mut list_55 = scope_52.start_list(true, Some("item"));
for item_54 in var_53 {
#[allow(unused_mut)]
let mut entry_56 = list_55.entry();
crate::query_ser::serialize_structure_crate_model_user_id_group_pair(entry_56, item_54);
}
list_55.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_storage(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Storage,
) {
#[allow(unused_mut)]
let mut scope_57 = writer.prefix("S3");
if let Some(var_58) = &input.s3 {
crate::query_ser::serialize_structure_crate_model_s3_storage(scope_57, var_58);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_reservation_fleet_instance_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ReservationFleetInstanceSpecification,
) {
#[allow(unused_mut)]
let mut scope_59 = writer.prefix("InstanceType");
if let Some(var_60) = &input.instance_type {
scope_59.string(var_60.as_str());
}
#[allow(unused_mut)]
let mut scope_61 = writer.prefix("InstancePlatform");
if let Some(var_62) = &input.instance_platform {
scope_61.string(var_62.as_str());
}
#[allow(unused_mut)]
let mut scope_63 = writer.prefix("Weight");
if let Some(var_64) = &input.weight {
scope_63.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_64).into()),
);
}
#[allow(unused_mut)]
let mut scope_65 = writer.prefix("AvailabilityZone");
if let Some(var_66) = &input.availability_zone {
scope_65.string(var_66);
}
#[allow(unused_mut)]
let mut scope_67 = writer.prefix("AvailabilityZoneId");
if let Some(var_68) = &input.availability_zone_id {
scope_67.string(var_68);
}
#[allow(unused_mut)]
let mut scope_69 = writer.prefix("EbsOptimized");
if let Some(var_70) = &input.ebs_optimized {
scope_69.boolean(*var_70);
}
#[allow(unused_mut)]
let mut scope_71 = writer.prefix("Priority");
if let Some(var_72) = &input.priority {
scope_71.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_client_vpn_authentication_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ClientVpnAuthenticationRequest,
) {
#[allow(unused_mut)]
let mut scope_73 = writer.prefix("Type");
if let Some(var_74) = &input.r#type {
scope_73.string(var_74.as_str());
}
#[allow(unused_mut)]
let mut scope_75 = writer.prefix("ActiveDirectory");
if let Some(var_76) = &input.active_directory {
crate::query_ser::serialize_structure_crate_model_directory_service_authentication_request(
scope_75, var_76,
);
}
#[allow(unused_mut)]
let mut scope_77 = writer.prefix("MutualAuthentication");
if let Some(var_78) = &input.mutual_authentication {
crate::query_ser::serialize_structure_crate_model_certificate_authentication_request(
scope_77, var_78,
);
}
#[allow(unused_mut)]
let mut scope_79 = writer.prefix("FederatedAuthentication");
if let Some(var_80) = &input.federated_authentication {
crate::query_ser::serialize_structure_crate_model_federated_authentication_request(
scope_79, var_80,
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_connection_log_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ConnectionLogOptions,
) {
#[allow(unused_mut)]
let mut scope_81 = writer.prefix("Enabled");
if let Some(var_82) = &input.enabled {
scope_81.boolean(*var_82);
}
#[allow(unused_mut)]
let mut scope_83 = writer.prefix("CloudwatchLogGroup");
if let Some(var_84) = &input.cloudwatch_log_group {
scope_83.string(var_84);
}
#[allow(unused_mut)]
let mut scope_85 = writer.prefix("CloudwatchLogStream");
if let Some(var_86) = &input.cloudwatch_log_stream {
scope_85.string(var_86);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_client_connect_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ClientConnectOptions,
) {
#[allow(unused_mut)]
let mut scope_87 = writer.prefix("Enabled");
if let Some(var_88) = &input.enabled {
scope_87.boolean(*var_88);
}
#[allow(unused_mut)]
let mut scope_89 = writer.prefix("LambdaFunctionArn");
if let Some(var_90) = &input.lambda_function_arn {
scope_89.string(var_90);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_new_dhcp_configuration(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::NewDhcpConfiguration,
) {
#[allow(unused_mut)]
let mut scope_91 = writer.prefix("Key");
if let Some(var_92) = &input.key {
scope_91.string(var_92);
}
#[allow(unused_mut)]
let mut scope_93 = writer.prefix("Value");
if let Some(var_94) = &input.values {
let mut list_96 = scope_93.start_list(true, Some("item"));
for item_95 in var_94 {
#[allow(unused_mut)]
let mut entry_97 = list_96.entry();
entry_97.string(item_95);
}
list_96.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SpotOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_98 = writer.prefix("AllocationStrategy");
if let Some(var_99) = &input.allocation_strategy {
scope_98.string(var_99.as_str());
}
#[allow(unused_mut)]
let mut scope_100 = writer.prefix("MaintenanceStrategies");
if let Some(var_101) = &input.maintenance_strategies {
crate::query_ser::serialize_structure_crate_model_fleet_spot_maintenance_strategies_request(
scope_100, var_101,
);
}
#[allow(unused_mut)]
let mut scope_102 = writer.prefix("InstanceInterruptionBehavior");
if let Some(var_103) = &input.instance_interruption_behavior {
scope_102.string(var_103.as_str());
}
#[allow(unused_mut)]
let mut scope_104 = writer.prefix("InstancePoolsToUseCount");
if let Some(var_105) = &input.instance_pools_to_use_count {
scope_104.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_105).into()),
);
}
#[allow(unused_mut)]
let mut scope_106 = writer.prefix("SingleInstanceType");
if let Some(var_107) = &input.single_instance_type {
scope_106.boolean(*var_107);
}
#[allow(unused_mut)]
let mut scope_108 = writer.prefix("SingleAvailabilityZone");
if let Some(var_109) = &input.single_availability_zone {
scope_108.boolean(*var_109);
}
#[allow(unused_mut)]
let mut scope_110 = writer.prefix("MinTargetCapacity");
if let Some(var_111) = &input.min_target_capacity {
scope_110.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_111).into()),
);
}
#[allow(unused_mut)]
let mut scope_112 = writer.prefix("MaxTotalPrice");
if let Some(var_113) = &input.max_total_price {
scope_112.string(var_113);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_on_demand_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::OnDemandOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_114 = writer.prefix("AllocationStrategy");
if let Some(var_115) = &input.allocation_strategy {
scope_114.string(var_115.as_str());
}
#[allow(unused_mut)]
let mut scope_116 = writer.prefix("CapacityReservationOptions");
if let Some(var_117) = &input.capacity_reservation_options {
crate::query_ser::serialize_structure_crate_model_capacity_reservation_options_request(
scope_116, var_117,
);
}
#[allow(unused_mut)]
let mut scope_118 = writer.prefix("SingleInstanceType");
if let Some(var_119) = &input.single_instance_type {
scope_118.boolean(*var_119);
}
#[allow(unused_mut)]
let mut scope_120 = writer.prefix("SingleAvailabilityZone");
if let Some(var_121) = &input.single_availability_zone {
scope_120.boolean(*var_121);
}
#[allow(unused_mut)]
let mut scope_122 = writer.prefix("MinTargetCapacity");
if let Some(var_123) = &input.min_target_capacity {
scope_122.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_123).into()),
);
}
#[allow(unused_mut)]
let mut scope_124 = writer.prefix("MaxTotalPrice");
if let Some(var_125) = &input.max_total_price {
scope_124.string(var_125);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_launch_template_config_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::FleetLaunchTemplateConfigRequest,
) {
#[allow(unused_mut)]
let mut scope_126 = writer.prefix("LaunchTemplateSpecification");
if let Some(var_127) = &input.launch_template_specification {
crate::query_ser::serialize_structure_crate_model_fleet_launch_template_specification_request(scope_126, var_127);
}
#[allow(unused_mut)]
let mut scope_128 = writer.prefix("Overrides");
if let Some(var_129) = &input.overrides {
let mut list_131 = scope_128.start_list(true, Some("item"));
for item_130 in var_129 {
#[allow(unused_mut)]
let mut entry_132 = list_131.entry();
crate::query_ser::serialize_structure_crate_model_fleet_launch_template_overrides_request(entry_132, item_130);
}
list_131.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_capacity_specification_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetCapacitySpecificationRequest,
) {
#[allow(unused_mut)]
let mut scope_133 = writer.prefix("TotalTargetCapacity");
if let Some(var_134) = &input.total_target_capacity {
scope_133.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_134).into()),
);
}
#[allow(unused_mut)]
let mut scope_135 = writer.prefix("OnDemandTargetCapacity");
if let Some(var_136) = &input.on_demand_target_capacity {
scope_135.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_136).into()),
);
}
#[allow(unused_mut)]
let mut scope_137 = writer.prefix("SpotTargetCapacity");
if let Some(var_138) = &input.spot_target_capacity {
scope_137.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_138).into()),
);
}
#[allow(unused_mut)]
let mut scope_139 = writer.prefix("DefaultTargetCapacityType");
if let Some(var_140) = &input.default_target_capacity_type {
scope_139.string(var_140.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_destination_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DestinationOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_141 = writer.prefix("FileFormat");
if let Some(var_142) = &input.file_format {
scope_141.string(var_142.as_str());
}
#[allow(unused_mut)]
let mut scope_143 = writer.prefix("HiveCompatiblePartitions");
if let Some(var_144) = &input.hive_compatible_partitions {
scope_143.boolean(*var_144);
}
#[allow(unused_mut)]
let mut scope_145 = writer.prefix("PerHourPartition");
if let Some(var_146) = &input.per_hour_partition {
scope_145.boolean(*var_146);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_storage_location(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::StorageLocation,
) {
#[allow(unused_mut)]
let mut scope_147 = writer.prefix("Bucket");
if let Some(var_148) = &input.bucket {
scope_147.string(var_148);
}
#[allow(unused_mut)]
let mut scope_149 = writer.prefix("Key");
if let Some(var_150) = &input.key {
scope_149.string(var_150);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_block_device_mapping(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::BlockDeviceMapping,
) {
#[allow(unused_mut)]
let mut scope_151 = writer.prefix("DeviceName");
if let Some(var_152) = &input.device_name {
scope_151.string(var_152);
}
#[allow(unused_mut)]
let mut scope_153 = writer.prefix("VirtualName");
if let Some(var_154) = &input.virtual_name {
scope_153.string(var_154);
}
#[allow(unused_mut)]
let mut scope_155 = writer.prefix("Ebs");
if let Some(var_156) = &input.ebs {
crate::query_ser::serialize_structure_crate_model_ebs_block_device(scope_155, var_156);
}
#[allow(unused_mut)]
let mut scope_157 = writer.prefix("NoDevice");
if let Some(var_158) = &input.no_device {
scope_157.string(var_158);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_event_window_time_range_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceEventWindowTimeRangeRequest,
) {
#[allow(unused_mut)]
let mut scope_159 = writer.prefix("StartWeekDay");
if let Some(var_160) = &input.start_week_day {
scope_159.string(var_160.as_str());
}
#[allow(unused_mut)]
let mut scope_161 = writer.prefix("StartHour");
if let Some(var_162) = &input.start_hour {
scope_161.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_162).into()),
);
}
#[allow(unused_mut)]
let mut scope_163 = writer.prefix("EndWeekDay");
if let Some(var_164) = &input.end_week_day {
scope_163.string(var_164.as_str());
}
#[allow(unused_mut)]
let mut scope_165 = writer.prefix("EndHour");
if let Some(var_166) = &input.end_hour {
scope_165.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_166).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_export_to_s3_task_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ExportToS3TaskSpecification,
) {
#[allow(unused_mut)]
let mut scope_167 = writer.prefix("ContainerFormat");
if let Some(var_168) = &input.container_format {
scope_167.string(var_168.as_str());
}
#[allow(unused_mut)]
let mut scope_169 = writer.prefix("DiskImageFormat");
if let Some(var_170) = &input.disk_image_format {
scope_169.string(var_170.as_str());
}
#[allow(unused_mut)]
let mut scope_171 = writer.prefix("S3Bucket");
if let Some(var_172) = &input.s3_bucket {
scope_171.string(var_172);
}
#[allow(unused_mut)]
let mut scope_173 = writer.prefix("S3Prefix");
if let Some(var_174) = &input.s3_prefix {
scope_173.string(var_174);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_request_launch_template_data(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RequestLaunchTemplateData,
) {
#[allow(unused_mut)]
let mut scope_175 = writer.prefix("KernelId");
if let Some(var_176) = &input.kernel_id {
scope_175.string(var_176);
}
#[allow(unused_mut)]
let mut scope_177 = writer.prefix("EbsOptimized");
if let Some(var_178) = &input.ebs_optimized {
scope_177.boolean(*var_178);
}
#[allow(unused_mut)]
let mut scope_179 = writer.prefix("IamInstanceProfile");
if let Some(var_180) = &input.iam_instance_profile {
crate::query_ser::serialize_structure_crate_model_launch_template_iam_instance_profile_specification_request(scope_179, var_180);
}
#[allow(unused_mut)]
let mut scope_181 = writer.prefix("BlockDeviceMapping");
if let Some(var_182) = &input.block_device_mappings {
let mut list_184 = scope_181.start_list(true, Some("BlockDeviceMapping"));
for item_183 in var_182 {
#[allow(unused_mut)]
let mut entry_185 = list_184.entry();
crate::query_ser::serialize_structure_crate_model_launch_template_block_device_mapping_request(entry_185, item_183);
}
list_184.finish();
}
#[allow(unused_mut)]
let mut scope_186 = writer.prefix("NetworkInterface");
if let Some(var_187) = &input.network_interfaces {
let mut list_189 =
scope_186.start_list(true, Some("InstanceNetworkInterfaceSpecification"));
for item_188 in var_187 {
#[allow(unused_mut)]
let mut entry_190 = list_189.entry();
crate::query_ser::serialize_structure_crate_model_launch_template_instance_network_interface_specification_request(entry_190, item_188);
}
list_189.finish();
}
#[allow(unused_mut)]
let mut scope_191 = writer.prefix("ImageId");
if let Some(var_192) = &input.image_id {
scope_191.string(var_192);
}
#[allow(unused_mut)]
let mut scope_193 = writer.prefix("InstanceType");
if let Some(var_194) = &input.instance_type {
scope_193.string(var_194.as_str());
}
#[allow(unused_mut)]
let mut scope_195 = writer.prefix("KeyName");
if let Some(var_196) = &input.key_name {
scope_195.string(var_196);
}
#[allow(unused_mut)]
let mut scope_197 = writer.prefix("Monitoring");
if let Some(var_198) = &input.monitoring {
crate::query_ser::serialize_structure_crate_model_launch_templates_monitoring_request(
scope_197, var_198,
);
}
#[allow(unused_mut)]
let mut scope_199 = writer.prefix("Placement");
if let Some(var_200) = &input.placement {
crate::query_ser::serialize_structure_crate_model_launch_template_placement_request(
scope_199, var_200,
);
}
#[allow(unused_mut)]
let mut scope_201 = writer.prefix("RamDiskId");
if let Some(var_202) = &input.ram_disk_id {
scope_201.string(var_202);
}
#[allow(unused_mut)]
let mut scope_203 = writer.prefix("DisableApiTermination");
if let Some(var_204) = &input.disable_api_termination {
scope_203.boolean(*var_204);
}
#[allow(unused_mut)]
let mut scope_205 = writer.prefix("InstanceInitiatedShutdownBehavior");
if let Some(var_206) = &input.instance_initiated_shutdown_behavior {
scope_205.string(var_206.as_str());
}
#[allow(unused_mut)]
let mut scope_207 = writer.prefix("UserData");
if let Some(var_208) = &input.user_data {
scope_207.string(var_208);
}
#[allow(unused_mut)]
let mut scope_209 = writer.prefix("TagSpecification");
if let Some(var_210) = &input.tag_specifications {
let mut list_212 =
scope_209.start_list(true, Some("LaunchTemplateTagSpecificationRequest"));
for item_211 in var_210 {
#[allow(unused_mut)]
let mut entry_213 = list_212.entry();
crate::query_ser::serialize_structure_crate_model_launch_template_tag_specification_request(entry_213, item_211);
}
list_212.finish();
}
#[allow(unused_mut)]
let mut scope_214 = writer.prefix("ElasticGpuSpecification");
if let Some(var_215) = &input.elastic_gpu_specifications {
let mut list_217 = scope_214.start_list(true, Some("ElasticGpuSpecification"));
for item_216 in var_215 {
#[allow(unused_mut)]
let mut entry_218 = list_217.entry();
crate::query_ser::serialize_structure_crate_model_elastic_gpu_specification(
entry_218, item_216,
);
}
list_217.finish();
}
#[allow(unused_mut)]
let mut scope_219 = writer.prefix("ElasticInferenceAccelerator");
if let Some(var_220) = &input.elastic_inference_accelerators {
let mut list_222 = scope_219.start_list(true, Some("item"));
for item_221 in var_220 {
#[allow(unused_mut)]
let mut entry_223 = list_222.entry();
crate::query_ser::serialize_structure_crate_model_launch_template_elastic_inference_accelerator(entry_223, item_221);
}
list_222.finish();
}
#[allow(unused_mut)]
let mut scope_224 = writer.prefix("SecurityGroupId");
if let Some(var_225) = &input.security_group_ids {
let mut list_227 = scope_224.start_list(true, Some("SecurityGroupId"));
for item_226 in var_225 {
#[allow(unused_mut)]
let mut entry_228 = list_227.entry();
entry_228.string(item_226);
}
list_227.finish();
}
#[allow(unused_mut)]
let mut scope_229 = writer.prefix("SecurityGroup");
if let Some(var_230) = &input.security_groups {
let mut list_232 = scope_229.start_list(true, Some("SecurityGroup"));
for item_231 in var_230 {
#[allow(unused_mut)]
let mut entry_233 = list_232.entry();
entry_233.string(item_231);
}
list_232.finish();
}
#[allow(unused_mut)]
let mut scope_234 = writer.prefix("InstanceMarketOptions");
if let Some(var_235) = &input.instance_market_options {
crate::query_ser::serialize_structure_crate_model_launch_template_instance_market_options_request(scope_234, var_235);
}
#[allow(unused_mut)]
let mut scope_236 = writer.prefix("CreditSpecification");
if let Some(var_237) = &input.credit_specification {
crate::query_ser::serialize_structure_crate_model_credit_specification_request(
scope_236, var_237,
);
}
#[allow(unused_mut)]
let mut scope_238 = writer.prefix("CpuOptions");
if let Some(var_239) = &input.cpu_options {
crate::query_ser::serialize_structure_crate_model_launch_template_cpu_options_request(
scope_238, var_239,
);
}
#[allow(unused_mut)]
let mut scope_240 = writer.prefix("CapacityReservationSpecification");
if let Some(var_241) = &input.capacity_reservation_specification {
crate::query_ser::serialize_structure_crate_model_launch_template_capacity_reservation_specification_request(scope_240, var_241);
}
#[allow(unused_mut)]
let mut scope_242 = writer.prefix("LicenseSpecification");
if let Some(var_243) = &input.license_specifications {
let mut list_245 = scope_242.start_list(true, Some("item"));
for item_244 in var_243 {
#[allow(unused_mut)]
let mut entry_246 = list_245.entry();
crate::query_ser::serialize_structure_crate_model_launch_template_license_configuration_request(entry_246, item_244);
}
list_245.finish();
}
#[allow(unused_mut)]
let mut scope_247 = writer.prefix("HibernationOptions");
if let Some(var_248) = &input.hibernation_options {
crate::query_ser::serialize_structure_crate_model_launch_template_hibernation_options_request(scope_247, var_248);
}
#[allow(unused_mut)]
let mut scope_249 = writer.prefix("MetadataOptions");
if let Some(var_250) = &input.metadata_options {
crate::query_ser::serialize_structure_crate_model_launch_template_instance_metadata_options_request(scope_249, var_250);
}
#[allow(unused_mut)]
let mut scope_251 = writer.prefix("EnclaveOptions");
if let Some(var_252) = &input.enclave_options {
crate::query_ser::serialize_structure_crate_model_launch_template_enclave_options_request(
scope_251, var_252,
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_add_prefix_list_entry(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AddPrefixListEntry,
) {
#[allow(unused_mut)]
let mut scope_253 = writer.prefix("Cidr");
if let Some(var_254) = &input.cidr {
scope_253.string(var_254);
}
#[allow(unused_mut)]
let mut scope_255 = writer.prefix("Description");
if let Some(var_256) = &input.description {
scope_255.string(var_256);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_icmp_type_code(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::IcmpTypeCode,
) {
#[allow(unused_mut)]
let mut scope_257 = writer.prefix("Code");
if let Some(var_258) = &input.code {
scope_257.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_258).into()),
);
}
#[allow(unused_mut)]
let mut scope_259 = writer.prefix("Type");
if let Some(var_260) = &input.r#type {
scope_259.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_260).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_port_range(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PortRange,
) {
#[allow(unused_mut)]
let mut scope_261 = writer.prefix("From");
if let Some(var_262) = &input.from {
scope_261.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_262).into()),
);
}
#[allow(unused_mut)]
let mut scope_263 = writer.prefix("To");
if let Some(var_264) = &input.to {
scope_263.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_264).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_ipv6_address(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceIpv6Address,
) {
#[allow(unused_mut)]
let mut scope_265 = writer.prefix("Ipv6Address");
if let Some(var_266) = &input.ipv6_address {
scope_265.string(var_266);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_private_ip_address_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PrivateIpAddressSpecification,
) {
#[allow(unused_mut)]
let mut scope_267 = writer.prefix("Primary");
if let Some(var_268) = &input.primary {
scope_267.boolean(*var_268);
}
#[allow(unused_mut)]
let mut scope_269 = writer.prefix("PrivateIpAddress");
if let Some(var_270) = &input.private_ip_address {
scope_269.string(var_270);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ipv4_prefix_specification_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Ipv4PrefixSpecificationRequest,
) {
#[allow(unused_mut)]
let mut scope_271 = writer.prefix("Ipv4Prefix");
if let Some(var_272) = &input.ipv4_prefix {
scope_271.string(var_272);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ipv6_prefix_specification_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Ipv6PrefixSpecificationRequest,
) {
#[allow(unused_mut)]
let mut scope_273 = writer.prefix("Ipv6Prefix");
if let Some(var_274) = &input.ipv6_prefix {
scope_273.string(var_274);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_price_schedule_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PriceScheduleSpecification,
) {
#[allow(unused_mut)]
let mut scope_275 = writer.prefix("CurrencyCode");
if let Some(var_276) = &input.currency_code {
scope_275.string(var_276.as_str());
}
#[allow(unused_mut)]
let mut scope_277 = writer.prefix("Price");
if let Some(var_278) = &input.price {
scope_277.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_278).into()),
);
}
#[allow(unused_mut)]
let mut scope_279 = writer.prefix("Term");
if let Some(var_280) = &input.term {
scope_279.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_280).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceSpecification,
) {
#[allow(unused_mut)]
let mut scope_281 = writer.prefix("InstanceId");
if let Some(var_282) = &input.instance_id {
scope_281.string(var_282);
}
#[allow(unused_mut)]
let mut scope_283 = writer.prefix("ExcludeBootVolume");
if let Some(var_284) = &input.exclude_boot_volume {
scope_283.boolean(*var_284);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_s3_object_tag(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::S3ObjectTag,
) {
#[allow(unused_mut)]
let mut scope_285 = writer.prefix("Key");
if let Some(var_286) = &input.key {
scope_285.string(var_286);
}
#[allow(unused_mut)]
let mut scope_287 = writer.prefix("Value");
if let Some(var_288) = &input.value {
scope_287.string(var_288);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_tag(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Tag,
) {
#[allow(unused_mut)]
let mut scope_289 = writer.prefix("Key");
if let Some(var_290) = &input.key {
scope_289.string(var_290);
}
#[allow(unused_mut)]
let mut scope_291 = writer.prefix("Value");
if let Some(var_292) = &input.value {
scope_291.string(var_292);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_traffic_mirror_port_range_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TrafficMirrorPortRangeRequest,
) {
#[allow(unused_mut)]
let mut scope_293 = writer.prefix("FromPort");
if let Some(var_294) = &input.from_port {
scope_293.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_294).into()),
);
}
#[allow(unused_mut)]
let mut scope_295 = writer.prefix("ToPort");
if let Some(var_296) = &input.to_port {
scope_295.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_296).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_transit_gateway_request_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TransitGatewayRequestOptions,
) {
#[allow(unused_mut)]
let mut scope_297 = writer.prefix("AmazonSideAsn");
if let Some(var_298) = &input.amazon_side_asn {
scope_297.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_298).into()),
);
}
#[allow(unused_mut)]
let mut scope_299 = writer.prefix("AutoAcceptSharedAttachments");
if let Some(var_300) = &input.auto_accept_shared_attachments {
scope_299.string(var_300.as_str());
}
#[allow(unused_mut)]
let mut scope_301 = writer.prefix("DefaultRouteTableAssociation");
if let Some(var_302) = &input.default_route_table_association {
scope_301.string(var_302.as_str());
}
#[allow(unused_mut)]
let mut scope_303 = writer.prefix("DefaultRouteTablePropagation");
if let Some(var_304) = &input.default_route_table_propagation {
scope_303.string(var_304.as_str());
}
#[allow(unused_mut)]
let mut scope_305 = writer.prefix("VpnEcmpSupport");
if let Some(var_306) = &input.vpn_ecmp_support {
scope_305.string(var_306.as_str());
}
#[allow(unused_mut)]
let mut scope_307 = writer.prefix("DnsSupport");
if let Some(var_308) = &input.dns_support {
scope_307.string(var_308.as_str());
}
#[allow(unused_mut)]
let mut scope_309 = writer.prefix("MulticastSupport");
if let Some(var_310) = &input.multicast_support {
scope_309.string(var_310.as_str());
}
#[allow(unused_mut)]
let mut scope_311 = writer.prefix("TransitGatewayCidrBlocks");
if let Some(var_312) = &input.transit_gateway_cidr_blocks {
let mut list_314 = scope_311.start_list(true, Some("item"));
for item_313 in var_312 {
#[allow(unused_mut)]
let mut entry_315 = list_314.entry();
entry_315.string(item_313);
}
list_314.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_transit_gateway_connect_request_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CreateTransitGatewayConnectRequestOptions,
) {
#[allow(unused_mut)]
let mut scope_316 = writer.prefix("Protocol");
if let Some(var_317) = &input.protocol {
scope_316.string(var_317.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_transit_gateway_connect_request_bgp_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TransitGatewayConnectRequestBgpOptions,
) {
#[allow(unused_mut)]
let mut scope_318 = writer.prefix("PeerAsn");
if let Some(var_319) = &input.peer_asn {
scope_318.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_319).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_transit_gateway_multicast_domain_request_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CreateTransitGatewayMulticastDomainRequestOptions,
) {
#[allow(unused_mut)]
let mut scope_320 = writer.prefix("Igmpv2Support");
if let Some(var_321) = &input.igmpv2_support {
scope_320.string(var_321.as_str());
}
#[allow(unused_mut)]
let mut scope_322 = writer.prefix("StaticSourcesSupport");
if let Some(var_323) = &input.static_sources_support {
scope_322.string(var_323.as_str());
}
#[allow(unused_mut)]
let mut scope_324 = writer.prefix("AutoAcceptSharedAssociations");
if let Some(var_325) = &input.auto_accept_shared_associations {
scope_324.string(var_325.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_transit_gateway_vpc_attachment_request_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CreateTransitGatewayVpcAttachmentRequestOptions,
) {
#[allow(unused_mut)]
let mut scope_326 = writer.prefix("DnsSupport");
if let Some(var_327) = &input.dns_support {
scope_326.string(var_327.as_str());
}
#[allow(unused_mut)]
let mut scope_328 = writer.prefix("Ipv6Support");
if let Some(var_329) = &input.ipv6_support {
scope_328.string(var_329.as_str());
}
#[allow(unused_mut)]
let mut scope_330 = writer.prefix("ApplianceModeSupport");
if let Some(var_331) = &input.appliance_mode_support {
scope_330.string(var_331.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_vpn_connection_options_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::VpnConnectionOptionsSpecification,
) {
#[allow(unused_mut)]
let mut scope_332 = writer.prefix("EnableAcceleration");
if let Some(var_333) = &input.enable_acceleration {
scope_332.boolean(*var_333);
}
#[allow(unused_mut)]
let mut scope_334 = writer.prefix("StaticRoutesOnly");
if let Some(var_335) = &input.static_routes_only {
scope_334.boolean(*var_335);
}
#[allow(unused_mut)]
let mut scope_336 = writer.prefix("TunnelInsideIpVersion");
if let Some(var_337) = &input.tunnel_inside_ip_version {
scope_336.string(var_337.as_str());
}
#[allow(unused_mut)]
let mut scope_338 = writer.prefix("TunnelOptions");
if let Some(var_339) = &input.tunnel_options {
let mut list_341 = scope_338.start_list(true, None);
for item_340 in var_339 {
#[allow(unused_mut)]
let mut entry_342 = list_341.entry();
crate::query_ser::serialize_structure_crate_model_vpn_tunnel_options_specification(
entry_342, item_340,
);
}
list_341.finish();
}
#[allow(unused_mut)]
let mut scope_343 = writer.prefix("LocalIpv4NetworkCidr");
if let Some(var_344) = &input.local_ipv4_network_cidr {
scope_343.string(var_344);
}
#[allow(unused_mut)]
let mut scope_345 = writer.prefix("RemoteIpv4NetworkCidr");
if let Some(var_346) = &input.remote_ipv4_network_cidr {
scope_345.string(var_346);
}
#[allow(unused_mut)]
let mut scope_347 = writer.prefix("LocalIpv6NetworkCidr");
if let Some(var_348) = &input.local_ipv6_network_cidr {
scope_347.string(var_348);
}
#[allow(unused_mut)]
let mut scope_349 = writer.prefix("RemoteIpv6NetworkCidr");
if let Some(var_350) = &input.remote_ipv6_network_cidr {
scope_349.string(var_350);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_deregister_instance_tag_attribute_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DeregisterInstanceTagAttributeRequest,
) {
#[allow(unused_mut)]
let mut scope_351 = writer.prefix("IncludeAllTagsOfInstance");
if let Some(var_352) = &input.include_all_tags_of_instance {
scope_351.boolean(*var_352);
}
#[allow(unused_mut)]
let mut scope_353 = writer.prefix("InstanceTagKey");
if let Some(var_354) = &input.instance_tag_keys {
let mut list_356 = scope_353.start_list(true, Some("item"));
for item_355 in var_354 {
#[allow(unused_mut)]
let mut entry_357 = list_356.entry();
entry_357.string(item_355);
}
list_356.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_filter(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Filter,
) {
#[allow(unused_mut)]
let mut scope_358 = writer.prefix("Name");
if let Some(var_359) = &input.name {
scope_358.string(var_359);
}
#[allow(unused_mut)]
let mut scope_360 = writer.prefix("Value");
if let Some(var_361) = &input.values {
let mut list_363 = scope_360.start_list(true, Some("item"));
for item_362 in var_361 {
#[allow(unused_mut)]
let mut entry_364 = list_363.entry();
entry_364.string(item_362);
}
list_363.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_slot_date_time_range_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SlotDateTimeRangeRequest,
) {
#[allow(unused_mut)]
let mut scope_365 = writer.prefix("EarliestTime");
if let Some(var_366) = &input.earliest_time {
scope_365.instant(var_366, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_367 = writer.prefix("LatestTime");
if let Some(var_368) = &input.latest_time {
scope_367.instant(var_368, aws_smithy_types::instant::Format::DateTime);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instance_recurrence_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledInstanceRecurrenceRequest,
) {
#[allow(unused_mut)]
let mut scope_369 = writer.prefix("Frequency");
if let Some(var_370) = &input.frequency {
scope_369.string(var_370);
}
#[allow(unused_mut)]
let mut scope_371 = writer.prefix("Interval");
if let Some(var_372) = &input.interval {
scope_371.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_372).into()),
);
}
#[allow(unused_mut)]
let mut scope_373 = writer.prefix("OccurrenceDay");
if let Some(var_374) = &input.occurrence_days {
let mut list_376 = scope_373.start_list(true, Some("OccurenceDay"));
for item_375 in var_374 {
#[allow(unused_mut)]
let mut entry_377 = list_376.entry();
entry_377.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_375).into()),
);
}
list_376.finish();
}
#[allow(unused_mut)]
let mut scope_378 = writer.prefix("OccurrenceRelativeToEnd");
if let Some(var_379) = &input.occurrence_relative_to_end {
scope_378.boolean(*var_379);
}
#[allow(unused_mut)]
let mut scope_380 = writer.prefix("OccurrenceUnit");
if let Some(var_381) = &input.occurrence_unit {
scope_380.string(var_381);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_slot_start_time_range_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SlotStartTimeRangeRequest,
) {
#[allow(unused_mut)]
let mut scope_382 = writer.prefix("EarliestTime");
if let Some(var_383) = &input.earliest_time {
scope_382.instant(var_383, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_384 = writer.prefix("LatestTime");
if let Some(var_385) = &input.latest_time {
scope_384.instant(var_385, aws_smithy_types::instant::Format::DateTime);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_event_window_disassociation_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceEventWindowDisassociationRequest,
) {
#[allow(unused_mut)]
let mut scope_386 = writer.prefix("InstanceId");
if let Some(var_387) = &input.instance_ids {
let mut list_389 = scope_386.start_list(true, Some("item"));
for item_388 in var_387 {
#[allow(unused_mut)]
let mut entry_390 = list_389.entry();
entry_390.string(item_388);
}
list_389.finish();
}
#[allow(unused_mut)]
let mut scope_391 = writer.prefix("InstanceTag");
if let Some(var_392) = &input.instance_tags {
let mut list_394 = scope_391.start_list(true, Some("item"));
for item_393 in var_392 {
#[allow(unused_mut)]
let mut entry_395 = list_394.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_395, item_393);
}
list_394.finish();
}
#[allow(unused_mut)]
let mut scope_396 = writer.prefix("DedicatedHostId");
if let Some(var_397) = &input.dedicated_host_ids {
let mut list_399 = scope_396.start_list(true, Some("item"));
for item_398 in var_397 {
#[allow(unused_mut)]
let mut entry_400 = list_399.entry();
entry_400.string(item_398);
}
list_399.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_export_task_s3_location_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ExportTaskS3LocationRequest,
) {
#[allow(unused_mut)]
let mut scope_401 = writer.prefix("S3Bucket");
if let Some(var_402) = &input.s3_bucket {
scope_401.string(var_402);
}
#[allow(unused_mut)]
let mut scope_403 = writer.prefix("S3Prefix");
if let Some(var_404) = &input.s3_prefix {
scope_403.string(var_404);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_integrate_services(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::IntegrateServices,
) {
#[allow(unused_mut)]
let mut scope_405 = writer.prefix("AthenaIntegration");
if let Some(var_406) = &input.athena_integrations {
let mut list_408 = scope_405.start_list(true, Some("item"));
for item_407 in var_406 {
#[allow(unused_mut)]
let mut entry_409 = list_408.entry();
crate::query_ser::serialize_structure_crate_model_athena_integration(
entry_409, item_407,
);
}
list_408.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_client_data(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ClientData,
) {
#[allow(unused_mut)]
let mut scope_410 = writer.prefix("Comment");
if let Some(var_411) = &input.comment {
scope_410.string(var_411);
}
#[allow(unused_mut)]
let mut scope_412 = writer.prefix("UploadEnd");
if let Some(var_413) = &input.upload_end {
scope_412.instant(var_413, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_414 = writer.prefix("UploadSize");
if let Some(var_415) = &input.upload_size {
scope_414.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_415).into()),
);
}
#[allow(unused_mut)]
let mut scope_416 = writer.prefix("UploadStart");
if let Some(var_417) = &input.upload_start {
scope_416.instant(var_417, aws_smithy_types::instant::Format::DateTime);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_image_disk_container(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ImageDiskContainer,
) {
#[allow(unused_mut)]
let mut scope_418 = writer.prefix("Description");
if let Some(var_419) = &input.description {
scope_418.string(var_419);
}
#[allow(unused_mut)]
let mut scope_420 = writer.prefix("DeviceName");
if let Some(var_421) = &input.device_name {
scope_420.string(var_421);
}
#[allow(unused_mut)]
let mut scope_422 = writer.prefix("Format");
if let Some(var_423) = &input.format {
scope_422.string(var_423);
}
#[allow(unused_mut)]
let mut scope_424 = writer.prefix("SnapshotId");
if let Some(var_425) = &input.snapshot_id {
scope_424.string(var_425);
}
#[allow(unused_mut)]
let mut scope_426 = writer.prefix("Url");
if let Some(var_427) = &input.url {
scope_426.string(var_427);
}
#[allow(unused_mut)]
let mut scope_428 = writer.prefix("UserBucket");
if let Some(var_429) = &input.user_bucket {
crate::query_ser::serialize_structure_crate_model_user_bucket(scope_428, var_429);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_import_image_license_configuration_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ImportImageLicenseConfigurationRequest,
) {
#[allow(unused_mut)]
let mut scope_430 = writer.prefix("LicenseConfigurationArn");
if let Some(var_431) = &input.license_configuration_arn {
scope_430.string(var_431);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_disk_image(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DiskImage,
) {
#[allow(unused_mut)]
let mut scope_432 = writer.prefix("Description");
if let Some(var_433) = &input.description {
scope_432.string(var_433);
}
#[allow(unused_mut)]
let mut scope_434 = writer.prefix("Image");
if let Some(var_435) = &input.image {
crate::query_ser::serialize_structure_crate_model_disk_image_detail(scope_434, var_435);
}
#[allow(unused_mut)]
let mut scope_436 = writer.prefix("Volume");
if let Some(var_437) = &input.volume {
crate::query_ser::serialize_structure_crate_model_volume_detail(scope_436, var_437);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_import_instance_launch_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ImportInstanceLaunchSpecification,
) {
#[allow(unused_mut)]
let mut scope_438 = writer.prefix("AdditionalInfo");
if let Some(var_439) = &input.additional_info {
scope_438.string(var_439);
}
#[allow(unused_mut)]
let mut scope_440 = writer.prefix("Architecture");
if let Some(var_441) = &input.architecture {
scope_440.string(var_441.as_str());
}
#[allow(unused_mut)]
let mut scope_442 = writer.prefix("GroupId");
if let Some(var_443) = &input.group_ids {
let mut list_445 = scope_442.start_list(true, Some("SecurityGroupId"));
for item_444 in var_443 {
#[allow(unused_mut)]
let mut entry_446 = list_445.entry();
entry_446.string(item_444);
}
list_445.finish();
}
#[allow(unused_mut)]
let mut scope_447 = writer.prefix("GroupName");
if let Some(var_448) = &input.group_names {
let mut list_450 = scope_447.start_list(true, Some("SecurityGroup"));
for item_449 in var_448 {
#[allow(unused_mut)]
let mut entry_451 = list_450.entry();
entry_451.string(item_449);
}
list_450.finish();
}
#[allow(unused_mut)]
let mut scope_452 = writer.prefix("InstanceInitiatedShutdownBehavior");
if let Some(var_453) = &input.instance_initiated_shutdown_behavior {
scope_452.string(var_453.as_str());
}
#[allow(unused_mut)]
let mut scope_454 = writer.prefix("InstanceType");
if let Some(var_455) = &input.instance_type {
scope_454.string(var_455.as_str());
}
#[allow(unused_mut)]
let mut scope_456 = writer.prefix("Monitoring");
if let Some(var_457) = &input.monitoring {
scope_456.boolean(*var_457);
}
#[allow(unused_mut)]
let mut scope_458 = writer.prefix("Placement");
if let Some(var_459) = &input.placement {
crate::query_ser::serialize_structure_crate_model_placement(scope_458, var_459);
}
#[allow(unused_mut)]
let mut scope_460 = writer.prefix("PrivateIpAddress");
if let Some(var_461) = &input.private_ip_address {
scope_460.string(var_461);
}
#[allow(unused_mut)]
let mut scope_462 = writer.prefix("SubnetId");
if let Some(var_463) = &input.subnet_id {
scope_462.string(var_463);
}
#[allow(unused_mut)]
let mut scope_464 = writer.prefix("UserData");
if let Some(var_465) = &input.user_data {
crate::query_ser::serialize_structure_crate_model_user_data(scope_464, var_465);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_snapshot_disk_container(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SnapshotDiskContainer,
) {
#[allow(unused_mut)]
let mut scope_466 = writer.prefix("Description");
if let Some(var_467) = &input.description {
scope_466.string(var_467);
}
#[allow(unused_mut)]
let mut scope_468 = writer.prefix("Format");
if let Some(var_469) = &input.format {
scope_468.string(var_469);
}
#[allow(unused_mut)]
let mut scope_470 = writer.prefix("Url");
if let Some(var_471) = &input.url {
scope_470.string(var_471);
}
#[allow(unused_mut)]
let mut scope_472 = writer.prefix("UserBucket");
if let Some(var_473) = &input.user_bucket {
crate::query_ser::serialize_structure_crate_model_user_bucket(scope_472, var_473);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_disk_image_detail(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DiskImageDetail,
) {
#[allow(unused_mut)]
let mut scope_474 = writer.prefix("Bytes");
if let Some(var_475) = &input.bytes {
scope_474.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_475).into()),
);
}
#[allow(unused_mut)]
let mut scope_476 = writer.prefix("Format");
if let Some(var_477) = &input.format {
scope_476.string(var_477.as_str());
}
#[allow(unused_mut)]
let mut scope_478 = writer.prefix("ImportManifestUrl");
if let Some(var_479) = &input.import_manifest_url {
scope_478.string(var_479);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_volume_detail(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::VolumeDetail,
) {
#[allow(unused_mut)]
let mut scope_480 = writer.prefix("Size");
if let Some(var_481) = &input.size {
scope_480.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_481).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_dns_servers_options_modify_structure(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DnsServersOptionsModifyStructure,
) {
#[allow(unused_mut)]
let mut scope_482 = writer.prefix("CustomDnsServers");
if let Some(var_483) = &input.custom_dns_servers {
let mut list_485 = scope_482.start_list(true, Some("item"));
for item_484 in var_483 {
#[allow(unused_mut)]
let mut entry_486 = list_485.entry();
entry_486.string(item_484);
}
list_485.finish();
}
#[allow(unused_mut)]
let mut scope_487 = writer.prefix("Enabled");
if let Some(var_488) = &input.enabled {
scope_487.boolean(*var_488);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_load_permission_modifications(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LoadPermissionModifications,
) {
#[allow(unused_mut)]
let mut scope_489 = writer.prefix("Add");
if let Some(var_490) = &input.add {
let mut list_492 = scope_489.start_list(true, Some("item"));
for item_491 in var_490 {
#[allow(unused_mut)]
let mut entry_493 = list_492.entry();
crate::query_ser::serialize_structure_crate_model_load_permission_request(
entry_493, item_491,
);
}
list_492.finish();
}
#[allow(unused_mut)]
let mut scope_494 = writer.prefix("Remove");
if let Some(var_495) = &input.remove {
let mut list_497 = scope_494.start_list(true, Some("item"));
for item_496 in var_495 {
#[allow(unused_mut)]
let mut entry_498 = list_497.entry();
crate::query_ser::serialize_structure_crate_model_load_permission_request(
entry_498, item_496,
);
}
list_497.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_attribute_value(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AttributeValue,
) {
#[allow(unused_mut)]
let mut scope_499 = writer.prefix("Value");
if let Some(var_500) = &input.value {
scope_499.string(var_500);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_permission_modifications(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchPermissionModifications,
) {
#[allow(unused_mut)]
let mut scope_501 = writer.prefix("Add");
if let Some(var_502) = &input.add {
let mut list_504 = scope_501.start_list(true, Some("item"));
for item_503 in var_502 {
#[allow(unused_mut)]
let mut entry_505 = list_504.entry();
crate::query_ser::serialize_structure_crate_model_launch_permission(
entry_505, item_503,
);
}
list_504.finish();
}
#[allow(unused_mut)]
let mut scope_506 = writer.prefix("Remove");
if let Some(var_507) = &input.remove {
let mut list_509 = scope_506.start_list(true, Some("item"));
for item_508 in var_507 {
#[allow(unused_mut)]
let mut entry_510 = list_509.entry();
crate::query_ser::serialize_structure_crate_model_launch_permission(
entry_510, item_508,
);
}
list_509.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_attribute_boolean_value(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AttributeBooleanValue,
) {
#[allow(unused_mut)]
let mut scope_511 = writer.prefix("Value");
if let Some(var_512) = &input.value {
scope_511.boolean(*var_512);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_block_device_mapping_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceBlockDeviceMappingSpecification,
) {
#[allow(unused_mut)]
let mut scope_513 = writer.prefix("DeviceName");
if let Some(var_514) = &input.device_name {
scope_513.string(var_514);
}
#[allow(unused_mut)]
let mut scope_515 = writer.prefix("Ebs");
if let Some(var_516) = &input.ebs {
crate::query_ser::serialize_structure_crate_model_ebs_instance_block_device_specification(
scope_515, var_516,
);
}
#[allow(unused_mut)]
let mut scope_517 = writer.prefix("NoDevice");
if let Some(var_518) = &input.no_device {
scope_517.string(var_518);
}
#[allow(unused_mut)]
let mut scope_519 = writer.prefix("VirtualName");
if let Some(var_520) = &input.virtual_name {
scope_519.string(var_520);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_blob_attribute_value(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::BlobAttributeValue,
) {
#[allow(unused_mut)]
let mut scope_521 = writer.prefix("Value");
if let Some(var_522) = &input.value {
scope_521.string(&aws_smithy_types::base64::encode(var_522));
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_capacity_reservation_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CapacityReservationSpecification,
) {
#[allow(unused_mut)]
let mut scope_523 = writer.prefix("CapacityReservationPreference");
if let Some(var_524) = &input.capacity_reservation_preference {
scope_523.string(var_524.as_str());
}
#[allow(unused_mut)]
let mut scope_525 = writer.prefix("CapacityReservationTarget");
if let Some(var_526) = &input.capacity_reservation_target {
crate::query_ser::serialize_structure_crate_model_capacity_reservation_target(
scope_525, var_526,
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_credit_specification_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceCreditSpecificationRequest,
) {
#[allow(unused_mut)]
let mut scope_527 = writer.prefix("InstanceId");
if let Some(var_528) = &input.instance_id {
scope_527.string(var_528);
}
#[allow(unused_mut)]
let mut scope_529 = writer.prefix("CpuCredits");
if let Some(var_530) = &input.cpu_credits {
scope_529.string(var_530);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_remove_prefix_list_entry(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RemovePrefixListEntry,
) {
#[allow(unused_mut)]
let mut scope_531 = writer.prefix("Cidr");
if let Some(var_532) = &input.cidr {
scope_531.string(var_532);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_network_interface_attachment_changes(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::NetworkInterfaceAttachmentChanges,
) {
#[allow(unused_mut)]
let mut scope_533 = writer.prefix("AttachmentId");
if let Some(var_534) = &input.attachment_id {
scope_533.string(var_534);
}
#[allow(unused_mut)]
let mut scope_535 = writer.prefix("DeleteOnTermination");
if let Some(var_536) = &input.delete_on_termination {
scope_535.boolean(*var_536);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_reserved_instances_configuration(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ReservedInstancesConfiguration,
) {
#[allow(unused_mut)]
let mut scope_537 = writer.prefix("AvailabilityZone");
if let Some(var_538) = &input.availability_zone {
scope_537.string(var_538);
}
#[allow(unused_mut)]
let mut scope_539 = writer.prefix("InstanceCount");
if let Some(var_540) = &input.instance_count {
scope_539.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_540).into()),
);
}
#[allow(unused_mut)]
let mut scope_541 = writer.prefix("InstanceType");
if let Some(var_542) = &input.instance_type {
scope_541.string(var_542.as_str());
}
#[allow(unused_mut)]
let mut scope_543 = writer.prefix("Platform");
if let Some(var_544) = &input.platform {
scope_543.string(var_544);
}
#[allow(unused_mut)]
let mut scope_545 = writer.prefix("Scope");
if let Some(var_546) = &input.scope {
scope_545.string(var_546.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_security_group_rule_update(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SecurityGroupRuleUpdate,
) {
#[allow(unused_mut)]
let mut scope_547 = writer.prefix("SecurityGroupRuleId");
if let Some(var_548) = &input.security_group_rule_id {
scope_547.string(var_548);
}
#[allow(unused_mut)]
let mut scope_549 = writer.prefix("SecurityGroupRule");
if let Some(var_550) = &input.security_group_rule {
crate::query_ser::serialize_structure_crate_model_security_group_rule_request(
scope_549, var_550,
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_volume_permission_modifications(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CreateVolumePermissionModifications,
) {
#[allow(unused_mut)]
let mut scope_551 = writer.prefix("Add");
if let Some(var_552) = &input.add {
let mut list_554 = scope_551.start_list(true, Some("item"));
for item_553 in var_552 {
#[allow(unused_mut)]
let mut entry_555 = list_554.entry();
crate::query_ser::serialize_structure_crate_model_create_volume_permission(
entry_555, item_553,
);
}
list_554.finish();
}
#[allow(unused_mut)]
let mut scope_556 = writer.prefix("Remove");
if let Some(var_557) = &input.remove {
let mut list_559 = scope_556.start_list(true, Some("item"));
for item_558 in var_557 {
#[allow(unused_mut)]
let mut entry_560 = list_559.entry();
crate::query_ser::serialize_structure_crate_model_create_volume_permission(
entry_560, item_558,
);
}
list_559.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateConfig,
) {
#[allow(unused_mut)]
let mut scope_561 = writer.prefix("LaunchTemplateSpecification");
if let Some(var_562) = &input.launch_template_specification {
crate::query_ser::serialize_structure_crate_model_fleet_launch_template_specification(
scope_561, var_562,
);
}
#[allow(unused_mut)]
let mut scope_563 = writer.prefix("Overrides");
if let Some(var_564) = &input.overrides {
let mut list_566 = scope_563.start_list(true, Some("item"));
for item_565 in var_564 {
#[allow(unused_mut)]
let mut entry_567 = list_566.entry();
crate::query_ser::serialize_structure_crate_model_launch_template_overrides(
entry_567, item_565,
);
}
list_566.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_modify_transit_gateway_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ModifyTransitGatewayOptions,
) {
#[allow(unused_mut)]
let mut scope_568 = writer.prefix("AddTransitGatewayCidrBlocks");
if let Some(var_569) = &input.add_transit_gateway_cidr_blocks {
let mut list_571 = scope_568.start_list(true, Some("item"));
for item_570 in var_569 {
#[allow(unused_mut)]
let mut entry_572 = list_571.entry();
entry_572.string(item_570);
}
list_571.finish();
}
#[allow(unused_mut)]
let mut scope_573 = writer.prefix("RemoveTransitGatewayCidrBlocks");
if let Some(var_574) = &input.remove_transit_gateway_cidr_blocks {
let mut list_576 = scope_573.start_list(true, Some("item"));
for item_575 in var_574 {
#[allow(unused_mut)]
let mut entry_577 = list_576.entry();
entry_577.string(item_575);
}
list_576.finish();
}
#[allow(unused_mut)]
let mut scope_578 = writer.prefix("VpnEcmpSupport");
if let Some(var_579) = &input.vpn_ecmp_support {
scope_578.string(var_579.as_str());
}
#[allow(unused_mut)]
let mut scope_580 = writer.prefix("DnsSupport");
if let Some(var_581) = &input.dns_support {
scope_580.string(var_581.as_str());
}
#[allow(unused_mut)]
let mut scope_582 = writer.prefix("AutoAcceptSharedAttachments");
if let Some(var_583) = &input.auto_accept_shared_attachments {
scope_582.string(var_583.as_str());
}
#[allow(unused_mut)]
let mut scope_584 = writer.prefix("DefaultRouteTableAssociation");
if let Some(var_585) = &input.default_route_table_association {
scope_584.string(var_585.as_str());
}
#[allow(unused_mut)]
let mut scope_586 = writer.prefix("AssociationDefaultRouteTableId");
if let Some(var_587) = &input.association_default_route_table_id {
scope_586.string(var_587);
}
#[allow(unused_mut)]
let mut scope_588 = writer.prefix("DefaultRouteTablePropagation");
if let Some(var_589) = &input.default_route_table_propagation {
scope_588.string(var_589.as_str());
}
#[allow(unused_mut)]
let mut scope_590 = writer.prefix("PropagationDefaultRouteTableId");
if let Some(var_591) = &input.propagation_default_route_table_id {
scope_590.string(var_591);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_modify_transit_gateway_vpc_attachment_request_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ModifyTransitGatewayVpcAttachmentRequestOptions,
) {
#[allow(unused_mut)]
let mut scope_592 = writer.prefix("DnsSupport");
if let Some(var_593) = &input.dns_support {
scope_592.string(var_593.as_str());
}
#[allow(unused_mut)]
let mut scope_594 = writer.prefix("Ipv6Support");
if let Some(var_595) = &input.ipv6_support {
scope_594.string(var_595.as_str());
}
#[allow(unused_mut)]
let mut scope_596 = writer.prefix("ApplianceModeSupport");
if let Some(var_597) = &input.appliance_mode_support {
scope_596.string(var_597.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_peering_connection_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PeeringConnectionOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_598 = writer.prefix("AllowDnsResolutionFromRemoteVpc");
if let Some(var_599) = &input.allow_dns_resolution_from_remote_vpc {
scope_598.boolean(*var_599);
}
#[allow(unused_mut)]
let mut scope_600 = writer.prefix("AllowEgressFromLocalClassicLinkToRemoteVpc");
if let Some(var_601) = &input.allow_egress_from_local_classic_link_to_remote_vpc {
scope_600.boolean(*var_601);
}
#[allow(unused_mut)]
let mut scope_602 = writer.prefix("AllowEgressFromLocalVpcToRemoteClassicLink");
if let Some(var_603) = &input.allow_egress_from_local_vpc_to_remote_classic_link {
scope_602.boolean(*var_603);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_modify_vpn_tunnel_options_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ModifyVpnTunnelOptionsSpecification,
) {
#[allow(unused_mut)]
let mut scope_604 = writer.prefix("TunnelInsideCidr");
if let Some(var_605) = &input.tunnel_inside_cidr {
scope_604.string(var_605);
}
#[allow(unused_mut)]
let mut scope_606 = writer.prefix("TunnelInsideIpv6Cidr");
if let Some(var_607) = &input.tunnel_inside_ipv6_cidr {
scope_606.string(var_607);
}
#[allow(unused_mut)]
let mut scope_608 = writer.prefix("PreSharedKey");
if let Some(var_609) = &input.pre_shared_key {
scope_608.string(var_609);
}
#[allow(unused_mut)]
let mut scope_610 = writer.prefix("Phase1LifetimeSeconds");
if let Some(var_611) = &input.phase1_lifetime_seconds {
scope_610.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_611).into()),
);
}
#[allow(unused_mut)]
let mut scope_612 = writer.prefix("Phase2LifetimeSeconds");
if let Some(var_613) = &input.phase2_lifetime_seconds {
scope_612.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_613).into()),
);
}
#[allow(unused_mut)]
let mut scope_614 = writer.prefix("RekeyMarginTimeSeconds");
if let Some(var_615) = &input.rekey_margin_time_seconds {
scope_614.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_615).into()),
);
}
#[allow(unused_mut)]
let mut scope_616 = writer.prefix("RekeyFuzzPercentage");
if let Some(var_617) = &input.rekey_fuzz_percentage {
scope_616.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_617).into()),
);
}
#[allow(unused_mut)]
let mut scope_618 = writer.prefix("ReplayWindowSize");
if let Some(var_619) = &input.replay_window_size {
scope_618.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_619).into()),
);
}
#[allow(unused_mut)]
let mut scope_620 = writer.prefix("DPDTimeoutSeconds");
if let Some(var_621) = &input.dpd_timeout_seconds {
scope_620.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_621).into()),
);
}
#[allow(unused_mut)]
let mut scope_622 = writer.prefix("DPDTimeoutAction");
if let Some(var_623) = &input.dpd_timeout_action {
scope_622.string(var_623);
}
#[allow(unused_mut)]
let mut scope_624 = writer.prefix("Phase1EncryptionAlgorithm");
if let Some(var_625) = &input.phase1_encryption_algorithms {
let mut list_627 = scope_624.start_list(true, Some("item"));
for item_626 in var_625 {
#[allow(unused_mut)]
let mut entry_628 = list_627.entry();
crate::query_ser::serialize_structure_crate_model_phase1_encryption_algorithms_request_list_value(entry_628, item_626);
}
list_627.finish();
}
#[allow(unused_mut)]
let mut scope_629 = writer.prefix("Phase2EncryptionAlgorithm");
if let Some(var_630) = &input.phase2_encryption_algorithms {
let mut list_632 = scope_629.start_list(true, Some("item"));
for item_631 in var_630 {
#[allow(unused_mut)]
let mut entry_633 = list_632.entry();
crate::query_ser::serialize_structure_crate_model_phase2_encryption_algorithms_request_list_value(entry_633, item_631);
}
list_632.finish();
}
#[allow(unused_mut)]
let mut scope_634 = writer.prefix("Phase1IntegrityAlgorithm");
if let Some(var_635) = &input.phase1_integrity_algorithms {
let mut list_637 = scope_634.start_list(true, Some("item"));
for item_636 in var_635 {
#[allow(unused_mut)]
let mut entry_638 = list_637.entry();
crate::query_ser::serialize_structure_crate_model_phase1_integrity_algorithms_request_list_value(entry_638, item_636);
}
list_637.finish();
}
#[allow(unused_mut)]
let mut scope_639 = writer.prefix("Phase2IntegrityAlgorithm");
if let Some(var_640) = &input.phase2_integrity_algorithms {
let mut list_642 = scope_639.start_list(true, Some("item"));
for item_641 in var_640 {
#[allow(unused_mut)]
let mut entry_643 = list_642.entry();
crate::query_ser::serialize_structure_crate_model_phase2_integrity_algorithms_request_list_value(entry_643, item_641);
}
list_642.finish();
}
#[allow(unused_mut)]
let mut scope_644 = writer.prefix("Phase1DHGroupNumber");
if let Some(var_645) = &input.phase1_dh_group_numbers {
let mut list_647 = scope_644.start_list(true, Some("item"));
for item_646 in var_645 {
#[allow(unused_mut)]
let mut entry_648 = list_647.entry();
crate::query_ser::serialize_structure_crate_model_phase1_dh_group_numbers_request_list_value(entry_648, item_646);
}
list_647.finish();
}
#[allow(unused_mut)]
let mut scope_649 = writer.prefix("Phase2DHGroupNumber");
if let Some(var_650) = &input.phase2_dh_group_numbers {
let mut list_652 = scope_649.start_list(true, Some("item"));
for item_651 in var_650 {
#[allow(unused_mut)]
let mut entry_653 = list_652.entry();
crate::query_ser::serialize_structure_crate_model_phase2_dh_group_numbers_request_list_value(entry_653, item_651);
}
list_652.finish();
}
#[allow(unused_mut)]
let mut scope_654 = writer.prefix("IKEVersion");
if let Some(var_655) = &input.ike_versions {
let mut list_657 = scope_654.start_list(true, Some("item"));
for item_656 in var_655 {
#[allow(unused_mut)]
let mut entry_658 = list_657.entry();
crate::query_ser::serialize_structure_crate_model_ike_versions_request_list_value(
entry_658, item_656,
);
}
list_657.finish();
}
#[allow(unused_mut)]
let mut scope_659 = writer.prefix("StartupAction");
if let Some(var_660) = &input.startup_action {
scope_659.string(var_660);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_cidr_authorization_context(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CidrAuthorizationContext,
) {
#[allow(unused_mut)]
let mut scope_661 = writer.prefix("Message");
if let Some(var_662) = &input.message {
scope_661.string(var_662);
}
#[allow(unused_mut)]
let mut scope_663 = writer.prefix("Signature");
if let Some(var_664) = &input.signature {
scope_663.string(var_664);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_reserved_instance_limit_price(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ReservedInstanceLimitPrice,
) {
#[allow(unused_mut)]
let mut scope_665 = writer.prefix("Amount");
if let Some(var_666) = &input.amount {
scope_665.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_666).into()),
);
}
#[allow(unused_mut)]
let mut scope_667 = writer.prefix("CurrencyCode");
if let Some(var_668) = &input.currency_code {
scope_667.string(var_668.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_purchase_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PurchaseRequest,
) {
#[allow(unused_mut)]
let mut scope_669 = writer.prefix("InstanceCount");
if let Some(var_670) = &input.instance_count {
scope_669.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_670).into()),
);
}
#[allow(unused_mut)]
let mut scope_671 = writer.prefix("PurchaseToken");
if let Some(var_672) = &input.purchase_token {
scope_671.string(var_672);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_register_instance_tag_attribute_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RegisterInstanceTagAttributeRequest,
) {
#[allow(unused_mut)]
let mut scope_673 = writer.prefix("IncludeAllTagsOfInstance");
if let Some(var_674) = &input.include_all_tags_of_instance {
scope_673.boolean(*var_674);
}
#[allow(unused_mut)]
let mut scope_675 = writer.prefix("InstanceTagKey");
if let Some(var_676) = &input.instance_tag_keys {
let mut list_678 = scope_675.start_list(true, Some("item"));
for item_677 in var_676 {
#[allow(unused_mut)]
let mut entry_679 = list_678.entry();
entry_679.string(item_677);
}
list_678.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_fleet_request_config_data(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SpotFleetRequestConfigData,
) {
#[allow(unused_mut)]
let mut scope_680 = writer.prefix("AllocationStrategy");
if let Some(var_681) = &input.allocation_strategy {
scope_680.string(var_681.as_str());
}
#[allow(unused_mut)]
let mut scope_682 = writer.prefix("OnDemandAllocationStrategy");
if let Some(var_683) = &input.on_demand_allocation_strategy {
scope_682.string(var_683.as_str());
}
#[allow(unused_mut)]
let mut scope_684 = writer.prefix("SpotMaintenanceStrategies");
if let Some(var_685) = &input.spot_maintenance_strategies {
crate::query_ser::serialize_structure_crate_model_spot_maintenance_strategies(
scope_684, var_685,
);
}
#[allow(unused_mut)]
let mut scope_686 = writer.prefix("ClientToken");
if let Some(var_687) = &input.client_token {
scope_686.string(var_687);
}
#[allow(unused_mut)]
let mut scope_688 = writer.prefix("ExcessCapacityTerminationPolicy");
if let Some(var_689) = &input.excess_capacity_termination_policy {
scope_688.string(var_689.as_str());
}
#[allow(unused_mut)]
let mut scope_690 = writer.prefix("FulfilledCapacity");
if let Some(var_691) = &input.fulfilled_capacity {
scope_690.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_691).into()),
);
}
#[allow(unused_mut)]
let mut scope_692 = writer.prefix("OnDemandFulfilledCapacity");
if let Some(var_693) = &input.on_demand_fulfilled_capacity {
scope_692.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_693).into()),
);
}
#[allow(unused_mut)]
let mut scope_694 = writer.prefix("IamFleetRole");
if let Some(var_695) = &input.iam_fleet_role {
scope_694.string(var_695);
}
#[allow(unused_mut)]
let mut scope_696 = writer.prefix("LaunchSpecifications");
if let Some(var_697) = &input.launch_specifications {
let mut list_699 = scope_696.start_list(true, Some("item"));
for item_698 in var_697 {
#[allow(unused_mut)]
let mut entry_700 = list_699.entry();
crate::query_ser::serialize_structure_crate_model_spot_fleet_launch_specification(
entry_700, item_698,
);
}
list_699.finish();
}
#[allow(unused_mut)]
let mut scope_701 = writer.prefix("LaunchTemplateConfigs");
if let Some(var_702) = &input.launch_template_configs {
let mut list_704 = scope_701.start_list(true, Some("item"));
for item_703 in var_702 {
#[allow(unused_mut)]
let mut entry_705 = list_704.entry();
crate::query_ser::serialize_structure_crate_model_launch_template_config(
entry_705, item_703,
);
}
list_704.finish();
}
#[allow(unused_mut)]
let mut scope_706 = writer.prefix("SpotPrice");
if let Some(var_707) = &input.spot_price {
scope_706.string(var_707);
}
#[allow(unused_mut)]
let mut scope_708 = writer.prefix("TargetCapacity");
if let Some(var_709) = &input.target_capacity {
scope_708.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_709).into()),
);
}
#[allow(unused_mut)]
let mut scope_710 = writer.prefix("OnDemandTargetCapacity");
if let Some(var_711) = &input.on_demand_target_capacity {
scope_710.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_711).into()),
);
}
#[allow(unused_mut)]
let mut scope_712 = writer.prefix("OnDemandMaxTotalPrice");
if let Some(var_713) = &input.on_demand_max_total_price {
scope_712.string(var_713);
}
#[allow(unused_mut)]
let mut scope_714 = writer.prefix("SpotMaxTotalPrice");
if let Some(var_715) = &input.spot_max_total_price {
scope_714.string(var_715);
}
#[allow(unused_mut)]
let mut scope_716 = writer.prefix("TerminateInstancesWithExpiration");
if let Some(var_717) = &input.terminate_instances_with_expiration {
scope_716.boolean(*var_717);
}
#[allow(unused_mut)]
let mut scope_718 = writer.prefix("Type");
if let Some(var_719) = &input.r#type {
scope_718.string(var_719.as_str());
}
#[allow(unused_mut)]
let mut scope_720 = writer.prefix("ValidFrom");
if let Some(var_721) = &input.valid_from {
scope_720.instant(var_721, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_722 = writer.prefix("ValidUntil");
if let Some(var_723) = &input.valid_until {
scope_722.instant(var_723, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_724 = writer.prefix("ReplaceUnhealthyInstances");
if let Some(var_725) = &input.replace_unhealthy_instances {
scope_724.boolean(*var_725);
}
#[allow(unused_mut)]
let mut scope_726 = writer.prefix("InstanceInterruptionBehavior");
if let Some(var_727) = &input.instance_interruption_behavior {
scope_726.string(var_727.as_str());
}
#[allow(unused_mut)]
let mut scope_728 = writer.prefix("LoadBalancersConfig");
if let Some(var_729) = &input.load_balancers_config {
crate::query_ser::serialize_structure_crate_model_load_balancers_config(scope_728, var_729);
}
#[allow(unused_mut)]
let mut scope_730 = writer.prefix("InstancePoolsToUseCount");
if let Some(var_731) = &input.instance_pools_to_use_count {
scope_730.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_731).into()),
);
}
#[allow(unused_mut)]
let mut scope_732 = writer.prefix("Context");
if let Some(var_733) = &input.context {
scope_732.string(var_733);
}
#[allow(unused_mut)]
let mut scope_734 = writer.prefix("TagSpecification");
if let Some(var_735) = &input.tag_specifications {
let mut list_737 = scope_734.start_list(true, Some("item"));
for item_736 in var_735 {
#[allow(unused_mut)]
let mut entry_738 = list_737.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_738, item_736,
);
}
list_737.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_request_spot_launch_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RequestSpotLaunchSpecification,
) {
#[allow(unused_mut)]
let mut scope_739 = writer.prefix("SecurityGroupId");
if let Some(var_740) = &input.security_group_ids {
let mut list_742 = scope_739.start_list(true, Some("item"));
for item_741 in var_740 {
#[allow(unused_mut)]
let mut entry_743 = list_742.entry();
entry_743.string(item_741);
}
list_742.finish();
}
#[allow(unused_mut)]
let mut scope_744 = writer.prefix("SecurityGroup");
if let Some(var_745) = &input.security_groups {
let mut list_747 = scope_744.start_list(true, Some("item"));
for item_746 in var_745 {
#[allow(unused_mut)]
let mut entry_748 = list_747.entry();
entry_748.string(item_746);
}
list_747.finish();
}
#[allow(unused_mut)]
let mut scope_749 = writer.prefix("AddressingType");
if let Some(var_750) = &input.addressing_type {
scope_749.string(var_750);
}
#[allow(unused_mut)]
let mut scope_751 = writer.prefix("BlockDeviceMapping");
if let Some(var_752) = &input.block_device_mappings {
let mut list_754 = scope_751.start_list(true, Some("item"));
for item_753 in var_752 {
#[allow(unused_mut)]
let mut entry_755 = list_754.entry();
crate::query_ser::serialize_structure_crate_model_block_device_mapping(
entry_755, item_753,
);
}
list_754.finish();
}
#[allow(unused_mut)]
let mut scope_756 = writer.prefix("EbsOptimized");
if let Some(var_757) = &input.ebs_optimized {
scope_756.boolean(*var_757);
}
#[allow(unused_mut)]
let mut scope_758 = writer.prefix("IamInstanceProfile");
if let Some(var_759) = &input.iam_instance_profile {
crate::query_ser::serialize_structure_crate_model_iam_instance_profile_specification(
scope_758, var_759,
);
}
#[allow(unused_mut)]
let mut scope_760 = writer.prefix("ImageId");
if let Some(var_761) = &input.image_id {
scope_760.string(var_761);
}
#[allow(unused_mut)]
let mut scope_762 = writer.prefix("InstanceType");
if let Some(var_763) = &input.instance_type {
scope_762.string(var_763.as_str());
}
#[allow(unused_mut)]
let mut scope_764 = writer.prefix("KernelId");
if let Some(var_765) = &input.kernel_id {
scope_764.string(var_765);
}
#[allow(unused_mut)]
let mut scope_766 = writer.prefix("KeyName");
if let Some(var_767) = &input.key_name {
scope_766.string(var_767);
}
#[allow(unused_mut)]
let mut scope_768 = writer.prefix("Monitoring");
if let Some(var_769) = &input.monitoring {
crate::query_ser::serialize_structure_crate_model_run_instances_monitoring_enabled(
scope_768, var_769,
);
}
#[allow(unused_mut)]
let mut scope_770 = writer.prefix("NetworkInterface");
if let Some(var_771) = &input.network_interfaces {
let mut list_773 = scope_770.start_list(true, Some("item"));
for item_772 in var_771 {
#[allow(unused_mut)]
let mut entry_774 = list_773.entry();
crate::query_ser::serialize_structure_crate_model_instance_network_interface_specification(entry_774, item_772);
}
list_773.finish();
}
#[allow(unused_mut)]
let mut scope_775 = writer.prefix("Placement");
if let Some(var_776) = &input.placement {
crate::query_ser::serialize_structure_crate_model_spot_placement(scope_775, var_776);
}
#[allow(unused_mut)]
let mut scope_777 = writer.prefix("RamdiskId");
if let Some(var_778) = &input.ramdisk_id {
scope_777.string(var_778);
}
#[allow(unused_mut)]
let mut scope_779 = writer.prefix("SubnetId");
if let Some(var_780) = &input.subnet_id {
scope_779.string(var_780);
}
#[allow(unused_mut)]
let mut scope_781 = writer.prefix("UserData");
if let Some(var_782) = &input.user_data {
scope_781.string(var_782);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_run_instances_monitoring_enabled(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RunInstancesMonitoringEnabled,
) {
#[allow(unused_mut)]
let mut scope_783 = writer.prefix("Enabled");
if let Some(var_784) = &input.enabled {
scope_783.boolean(*var_784);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_placement(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Placement,
) {
#[allow(unused_mut)]
let mut scope_785 = writer.prefix("AvailabilityZone");
if let Some(var_786) = &input.availability_zone {
scope_785.string(var_786);
}
#[allow(unused_mut)]
let mut scope_787 = writer.prefix("Affinity");
if let Some(var_788) = &input.affinity {
scope_787.string(var_788);
}
#[allow(unused_mut)]
let mut scope_789 = writer.prefix("GroupName");
if let Some(var_790) = &input.group_name {
scope_789.string(var_790);
}
#[allow(unused_mut)]
let mut scope_791 = writer.prefix("PartitionNumber");
if let Some(var_792) = &input.partition_number {
scope_791.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_792).into()),
);
}
#[allow(unused_mut)]
let mut scope_793 = writer.prefix("HostId");
if let Some(var_794) = &input.host_id {
scope_793.string(var_794);
}
#[allow(unused_mut)]
let mut scope_795 = writer.prefix("Tenancy");
if let Some(var_796) = &input.tenancy {
scope_795.string(var_796.as_str());
}
#[allow(unused_mut)]
let mut scope_797 = writer.prefix("SpreadDomain");
if let Some(var_798) = &input.spread_domain {
scope_797.string(var_798);
}
#[allow(unused_mut)]
let mut scope_799 = writer.prefix("HostResourceGroupArn");
if let Some(var_800) = &input.host_resource_group_arn {
scope_799.string(var_800);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_network_interface_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceNetworkInterfaceSpecification,
) {
#[allow(unused_mut)]
let mut scope_801 = writer.prefix("AssociatePublicIpAddress");
if let Some(var_802) = &input.associate_public_ip_address {
scope_801.boolean(*var_802);
}
#[allow(unused_mut)]
let mut scope_803 = writer.prefix("DeleteOnTermination");
if let Some(var_804) = &input.delete_on_termination {
scope_803.boolean(*var_804);
}
#[allow(unused_mut)]
let mut scope_805 = writer.prefix("Description");
if let Some(var_806) = &input.description {
scope_805.string(var_806);
}
#[allow(unused_mut)]
let mut scope_807 = writer.prefix("DeviceIndex");
if let Some(var_808) = &input.device_index {
scope_807.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_808).into()),
);
}
#[allow(unused_mut)]
let mut scope_809 = writer.prefix("SecurityGroupId");
if let Some(var_810) = &input.groups {
let mut list_812 = scope_809.start_list(true, Some("SecurityGroupId"));
for item_811 in var_810 {
#[allow(unused_mut)]
let mut entry_813 = list_812.entry();
entry_813.string(item_811);
}
list_812.finish();
}
#[allow(unused_mut)]
let mut scope_814 = writer.prefix("Ipv6AddressCount");
if let Some(var_815) = &input.ipv6_address_count {
scope_814.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_815).into()),
);
}
#[allow(unused_mut)]
let mut scope_816 = writer.prefix("Ipv6Addresses");
if let Some(var_817) = &input.ipv6_addresses {
let mut list_819 = scope_816.start_list(true, Some("item"));
for item_818 in var_817 {
#[allow(unused_mut)]
let mut entry_820 = list_819.entry();
crate::query_ser::serialize_structure_crate_model_instance_ipv6_address(
entry_820, item_818,
);
}
list_819.finish();
}
#[allow(unused_mut)]
let mut scope_821 = writer.prefix("NetworkInterfaceId");
if let Some(var_822) = &input.network_interface_id {
scope_821.string(var_822);
}
#[allow(unused_mut)]
let mut scope_823 = writer.prefix("PrivateIpAddress");
if let Some(var_824) = &input.private_ip_address {
scope_823.string(var_824);
}
#[allow(unused_mut)]
let mut scope_825 = writer.prefix("PrivateIpAddresses");
if let Some(var_826) = &input.private_ip_addresses {
let mut list_828 = scope_825.start_list(true, Some("item"));
for item_827 in var_826 {
#[allow(unused_mut)]
let mut entry_829 = list_828.entry();
crate::query_ser::serialize_structure_crate_model_private_ip_address_specification(
entry_829, item_827,
);
}
list_828.finish();
}
#[allow(unused_mut)]
let mut scope_830 = writer.prefix("SecondaryPrivateIpAddressCount");
if let Some(var_831) = &input.secondary_private_ip_address_count {
scope_830.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_831).into()),
);
}
#[allow(unused_mut)]
let mut scope_832 = writer.prefix("SubnetId");
if let Some(var_833) = &input.subnet_id {
scope_832.string(var_833);
}
#[allow(unused_mut)]
let mut scope_834 = writer.prefix("AssociateCarrierIpAddress");
if let Some(var_835) = &input.associate_carrier_ip_address {
scope_834.boolean(*var_835);
}
#[allow(unused_mut)]
let mut scope_836 = writer.prefix("InterfaceType");
if let Some(var_837) = &input.interface_type {
scope_836.string(var_837);
}
#[allow(unused_mut)]
let mut scope_838 = writer.prefix("NetworkCardIndex");
if let Some(var_839) = &input.network_card_index {
scope_838.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_839).into()),
);
}
#[allow(unused_mut)]
let mut scope_840 = writer.prefix("Ipv4Prefix");
if let Some(var_841) = &input.ipv4_prefixes {
let mut list_843 = scope_840.start_list(true, Some("item"));
for item_842 in var_841 {
#[allow(unused_mut)]
let mut entry_844 = list_843.entry();
crate::query_ser::serialize_structure_crate_model_ipv4_prefix_specification_request(
entry_844, item_842,
);
}
list_843.finish();
}
#[allow(unused_mut)]
let mut scope_845 = writer.prefix("Ipv4PrefixCount");
if let Some(var_846) = &input.ipv4_prefix_count {
scope_845.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_846).into()),
);
}
#[allow(unused_mut)]
let mut scope_847 = writer.prefix("Ipv6Prefix");
if let Some(var_848) = &input.ipv6_prefixes {
let mut list_850 = scope_847.start_list(true, Some("item"));
for item_849 in var_848 {
#[allow(unused_mut)]
let mut entry_851 = list_850.entry();
crate::query_ser::serialize_structure_crate_model_ipv6_prefix_specification_request(
entry_851, item_849,
);
}
list_850.finish();
}
#[allow(unused_mut)]
let mut scope_852 = writer.prefix("Ipv6PrefixCount");
if let Some(var_853) = &input.ipv6_prefix_count {
scope_852.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_853).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_elastic_gpu_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ElasticGpuSpecification,
) {
#[allow(unused_mut)]
let mut scope_854 = writer.prefix("Type");
if let Some(var_855) = &input.r#type {
scope_854.string(var_855);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_elastic_inference_accelerator(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ElasticInferenceAccelerator,
) {
#[allow(unused_mut)]
let mut scope_856 = writer.prefix("Type");
if let Some(var_857) = &input.r#type {
scope_856.string(var_857);
}
#[allow(unused_mut)]
let mut scope_858 = writer.prefix("Count");
if let Some(var_859) = &input.count {
scope_858.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_859).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateSpecification,
) {
#[allow(unused_mut)]
let mut scope_860 = writer.prefix("LaunchTemplateId");
if let Some(var_861) = &input.launch_template_id {
scope_860.string(var_861);
}
#[allow(unused_mut)]
let mut scope_862 = writer.prefix("LaunchTemplateName");
if let Some(var_863) = &input.launch_template_name {
scope_862.string(var_863);
}
#[allow(unused_mut)]
let mut scope_864 = writer.prefix("Version");
if let Some(var_865) = &input.version {
scope_864.string(var_865);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_market_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceMarketOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_866 = writer.prefix("MarketType");
if let Some(var_867) = &input.market_type {
scope_866.string(var_867.as_str());
}
#[allow(unused_mut)]
let mut scope_868 = writer.prefix("SpotOptions");
if let Some(var_869) = &input.spot_options {
crate::query_ser::serialize_structure_crate_model_spot_market_options(scope_868, var_869);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_credit_specification_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CreditSpecificationRequest,
) {
#[allow(unused_mut)]
let mut scope_870 = writer.prefix("CpuCredits");
if let Some(var_871) = &input.cpu_credits {
scope_870.string(var_871);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_cpu_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CpuOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_872 = writer.prefix("CoreCount");
if let Some(var_873) = &input.core_count {
scope_872.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_873).into()),
);
}
#[allow(unused_mut)]
let mut scope_874 = writer.prefix("ThreadsPerCore");
if let Some(var_875) = &input.threads_per_core {
scope_874.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_875).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_hibernation_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::HibernationOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_876 = writer.prefix("Configured");
if let Some(var_877) = &input.configured {
scope_876.boolean(*var_877);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_license_configuration_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LicenseConfigurationRequest,
) {
#[allow(unused_mut)]
let mut scope_878 = writer.prefix("LicenseConfigurationArn");
if let Some(var_879) = &input.license_configuration_arn {
scope_878.string(var_879);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_metadata_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceMetadataOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_880 = writer.prefix("HttpTokens");
if let Some(var_881) = &input.http_tokens {
scope_880.string(var_881.as_str());
}
#[allow(unused_mut)]
let mut scope_882 = writer.prefix("HttpPutResponseHopLimit");
if let Some(var_883) = &input.http_put_response_hop_limit {
scope_882.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_883).into()),
);
}
#[allow(unused_mut)]
let mut scope_884 = writer.prefix("HttpEndpoint");
if let Some(var_885) = &input.http_endpoint {
scope_884.string(var_885.as_str());
}
#[allow(unused_mut)]
let mut scope_886 = writer.prefix("HttpProtocolIpv6");
if let Some(var_887) = &input.http_protocol_ipv6 {
scope_886.string(var_887.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_enclave_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::EnclaveOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_888 = writer.prefix("Enabled");
if let Some(var_889) = &input.enabled {
scope_888.boolean(*var_889);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_launch_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledInstancesLaunchSpecification,
) {
#[allow(unused_mut)]
let mut scope_890 = writer.prefix("BlockDeviceMapping");
if let Some(var_891) = &input.block_device_mappings {
let mut list_893 = scope_890.start_list(true, Some("BlockDeviceMapping"));
for item_892 in var_891 {
#[allow(unused_mut)]
let mut entry_894 = list_893.entry();
crate::query_ser::serialize_structure_crate_model_scheduled_instances_block_device_mapping(entry_894, item_892);
}
list_893.finish();
}
#[allow(unused_mut)]
let mut scope_895 = writer.prefix("EbsOptimized");
if let Some(var_896) = &input.ebs_optimized {
scope_895.boolean(*var_896);
}
#[allow(unused_mut)]
let mut scope_897 = writer.prefix("IamInstanceProfile");
if let Some(var_898) = &input.iam_instance_profile {
crate::query_ser::serialize_structure_crate_model_scheduled_instances_iam_instance_profile(
scope_897, var_898,
);
}
#[allow(unused_mut)]
let mut scope_899 = writer.prefix("ImageId");
if let Some(var_900) = &input.image_id {
scope_899.string(var_900);
}
#[allow(unused_mut)]
let mut scope_901 = writer.prefix("InstanceType");
if let Some(var_902) = &input.instance_type {
scope_901.string(var_902);
}
#[allow(unused_mut)]
let mut scope_903 = writer.prefix("KernelId");
if let Some(var_904) = &input.kernel_id {
scope_903.string(var_904);
}
#[allow(unused_mut)]
let mut scope_905 = writer.prefix("KeyName");
if let Some(var_906) = &input.key_name {
scope_905.string(var_906);
}
#[allow(unused_mut)]
let mut scope_907 = writer.prefix("Monitoring");
if let Some(var_908) = &input.monitoring {
crate::query_ser::serialize_structure_crate_model_scheduled_instances_monitoring(
scope_907, var_908,
);
}
#[allow(unused_mut)]
let mut scope_909 = writer.prefix("NetworkInterface");
if let Some(var_910) = &input.network_interfaces {
let mut list_912 = scope_909.start_list(true, Some("NetworkInterface"));
for item_911 in var_910 {
#[allow(unused_mut)]
let mut entry_913 = list_912.entry();
crate::query_ser::serialize_structure_crate_model_scheduled_instances_network_interface(
entry_913, item_911,
);
}
list_912.finish();
}
#[allow(unused_mut)]
let mut scope_914 = writer.prefix("Placement");
if let Some(var_915) = &input.placement {
crate::query_ser::serialize_structure_crate_model_scheduled_instances_placement(
scope_914, var_915,
);
}
#[allow(unused_mut)]
let mut scope_916 = writer.prefix("RamdiskId");
if let Some(var_917) = &input.ramdisk_id {
scope_916.string(var_917);
}
#[allow(unused_mut)]
let mut scope_918 = writer.prefix("SecurityGroupId");
if let Some(var_919) = &input.security_group_ids {
let mut list_921 = scope_918.start_list(true, Some("SecurityGroupId"));
for item_920 in var_919 {
#[allow(unused_mut)]
let mut entry_922 = list_921.entry();
entry_922.string(item_920);
}
list_921.finish();
}
#[allow(unused_mut)]
let mut scope_923 = writer.prefix("SubnetId");
if let Some(var_924) = &input.subnet_id {
scope_923.string(var_924);
}
#[allow(unused_mut)]
let mut scope_925 = writer.prefix("UserData");
if let Some(var_926) = &input.user_data {
scope_925.string(var_926);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_security_group_rule_description(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SecurityGroupRuleDescription,
) {
#[allow(unused_mut)]
let mut scope_927 = writer.prefix("SecurityGroupRuleId");
if let Some(var_928) = &input.security_group_rule_id {
scope_927.string(var_928);
}
#[allow(unused_mut)]
let mut scope_929 = writer.prefix("Description");
if let Some(var_930) = &input.description {
scope_929.string(var_930);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ip_range(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::IpRange,
) {
#[allow(unused_mut)]
let mut scope_931 = writer.prefix("CidrIp");
if let Some(var_932) = &input.cidr_ip {
scope_931.string(var_932);
}
#[allow(unused_mut)]
let mut scope_933 = writer.prefix("Description");
if let Some(var_934) = &input.description {
scope_933.string(var_934);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ipv6_range(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Ipv6Range,
) {
#[allow(unused_mut)]
let mut scope_935 = writer.prefix("CidrIpv6");
if let Some(var_936) = &input.cidr_ipv6 {
scope_935.string(var_936);
}
#[allow(unused_mut)]
let mut scope_937 = writer.prefix("Description");
if let Some(var_938) = &input.description {
scope_937.string(var_938);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_prefix_list_id(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PrefixListId,
) {
#[allow(unused_mut)]
let mut scope_939 = writer.prefix("Description");
if let Some(var_940) = &input.description {
scope_939.string(var_940);
}
#[allow(unused_mut)]
let mut scope_941 = writer.prefix("PrefixListId");
if let Some(var_942) = &input.prefix_list_id {
scope_941.string(var_942);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_user_id_group_pair(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::UserIdGroupPair,
) {
#[allow(unused_mut)]
let mut scope_943 = writer.prefix("Description");
if let Some(var_944) = &input.description {
scope_943.string(var_944);
}
#[allow(unused_mut)]
let mut scope_945 = writer.prefix("GroupId");
if let Some(var_946) = &input.group_id {
scope_945.string(var_946);
}
#[allow(unused_mut)]
let mut scope_947 = writer.prefix("GroupName");
if let Some(var_948) = &input.group_name {
scope_947.string(var_948);
}
#[allow(unused_mut)]
let mut scope_949 = writer.prefix("PeeringStatus");
if let Some(var_950) = &input.peering_status {
scope_949.string(var_950);
}
#[allow(unused_mut)]
let mut scope_951 = writer.prefix("UserId");
if let Some(var_952) = &input.user_id {
scope_951.string(var_952);
}
#[allow(unused_mut)]
let mut scope_953 = writer.prefix("VpcId");
if let Some(var_954) = &input.vpc_id {
scope_953.string(var_954);
}
#[allow(unused_mut)]
let mut scope_955 = writer.prefix("VpcPeeringConnectionId");
if let Some(var_956) = &input.vpc_peering_connection_id {
scope_955.string(var_956);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_s3_storage(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::S3Storage,
) {
#[allow(unused_mut)]
let mut scope_957 = writer.prefix("AWSAccessKeyId");
if let Some(var_958) = &input.aws_access_key_id {
scope_957.string(var_958);
}
#[allow(unused_mut)]
let mut scope_959 = writer.prefix("Bucket");
if let Some(var_960) = &input.bucket {
scope_959.string(var_960);
}
#[allow(unused_mut)]
let mut scope_961 = writer.prefix("Prefix");
if let Some(var_962) = &input.prefix {
scope_961.string(var_962);
}
#[allow(unused_mut)]
let mut scope_963 = writer.prefix("UploadPolicy");
if let Some(var_964) = &input.upload_policy {
scope_963.string(&aws_smithy_types::base64::encode(var_964));
}
#[allow(unused_mut)]
let mut scope_965 = writer.prefix("UploadPolicySignature");
if let Some(var_966) = &input.upload_policy_signature {
scope_965.string(var_966);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_directory_service_authentication_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DirectoryServiceAuthenticationRequest,
) {
#[allow(unused_mut)]
let mut scope_967 = writer.prefix("DirectoryId");
if let Some(var_968) = &input.directory_id {
scope_967.string(var_968);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_certificate_authentication_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CertificateAuthenticationRequest,
) {
#[allow(unused_mut)]
let mut scope_969 = writer.prefix("ClientRootCertificateChainArn");
if let Some(var_970) = &input.client_root_certificate_chain_arn {
scope_969.string(var_970);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_federated_authentication_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::FederatedAuthenticationRequest,
) {
#[allow(unused_mut)]
let mut scope_971 = writer.prefix("SAMLProviderArn");
if let Some(var_972) = &input.saml_provider_arn {
scope_971.string(var_972);
}
#[allow(unused_mut)]
let mut scope_973 = writer.prefix("SelfServiceSAMLProviderArn");
if let Some(var_974) = &input.self_service_saml_provider_arn {
scope_973.string(var_974);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_spot_maintenance_strategies_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::FleetSpotMaintenanceStrategiesRequest,
) {
#[allow(unused_mut)]
let mut scope_975 = writer.prefix("CapacityRebalance");
if let Some(var_976) = &input.capacity_rebalance {
crate::query_ser::serialize_structure_crate_model_fleet_spot_capacity_rebalance_request(
scope_975, var_976,
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_capacity_reservation_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CapacityReservationOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_977 = writer.prefix("UsageStrategy");
if let Some(var_978) = &input.usage_strategy {
scope_977.string(var_978.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_launch_template_specification_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::FleetLaunchTemplateSpecificationRequest,
) {
#[allow(unused_mut)]
let mut scope_979 = writer.prefix("LaunchTemplateId");
if let Some(var_980) = &input.launch_template_id {
scope_979.string(var_980);
}
#[allow(unused_mut)]
let mut scope_981 = writer.prefix("LaunchTemplateName");
if let Some(var_982) = &input.launch_template_name {
scope_981.string(var_982);
}
#[allow(unused_mut)]
let mut scope_983 = writer.prefix("Version");
if let Some(var_984) = &input.version {
scope_983.string(var_984);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_launch_template_overrides_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::FleetLaunchTemplateOverridesRequest,
) {
#[allow(unused_mut)]
let mut scope_985 = writer.prefix("InstanceType");
if let Some(var_986) = &input.instance_type {
scope_985.string(var_986.as_str());
}
#[allow(unused_mut)]
let mut scope_987 = writer.prefix("MaxPrice");
if let Some(var_988) = &input.max_price {
scope_987.string(var_988);
}
#[allow(unused_mut)]
let mut scope_989 = writer.prefix("SubnetId");
if let Some(var_990) = &input.subnet_id {
scope_989.string(var_990);
}
#[allow(unused_mut)]
let mut scope_991 = writer.prefix("AvailabilityZone");
if let Some(var_992) = &input.availability_zone {
scope_991.string(var_992);
}
#[allow(unused_mut)]
let mut scope_993 = writer.prefix("WeightedCapacity");
if let Some(var_994) = &input.weighted_capacity {
scope_993.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_994).into()),
);
}
#[allow(unused_mut)]
let mut scope_995 = writer.prefix("Priority");
if let Some(var_996) = &input.priority {
scope_995.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_996).into()),
);
}
#[allow(unused_mut)]
let mut scope_997 = writer.prefix("Placement");
if let Some(var_998) = &input.placement {
crate::query_ser::serialize_structure_crate_model_placement(scope_997, var_998);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ebs_block_device(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::EbsBlockDevice,
) {
#[allow(unused_mut)]
let mut scope_999 = writer.prefix("DeleteOnTermination");
if let Some(var_1000) = &input.delete_on_termination {
scope_999.boolean(*var_1000);
}
#[allow(unused_mut)]
let mut scope_1001 = writer.prefix("Iops");
if let Some(var_1002) = &input.iops {
scope_1001.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1002).into()),
);
}
#[allow(unused_mut)]
let mut scope_1003 = writer.prefix("SnapshotId");
if let Some(var_1004) = &input.snapshot_id {
scope_1003.string(var_1004);
}
#[allow(unused_mut)]
let mut scope_1005 = writer.prefix("VolumeSize");
if let Some(var_1006) = &input.volume_size {
scope_1005.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1006).into()),
);
}
#[allow(unused_mut)]
let mut scope_1007 = writer.prefix("VolumeType");
if let Some(var_1008) = &input.volume_type {
scope_1007.string(var_1008.as_str());
}
#[allow(unused_mut)]
let mut scope_1009 = writer.prefix("KmsKeyId");
if let Some(var_1010) = &input.kms_key_id {
scope_1009.string(var_1010);
}
#[allow(unused_mut)]
let mut scope_1011 = writer.prefix("Throughput");
if let Some(var_1012) = &input.throughput {
scope_1011.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1012).into()),
);
}
#[allow(unused_mut)]
let mut scope_1013 = writer.prefix("OutpostArn");
if let Some(var_1014) = &input.outpost_arn {
scope_1013.string(var_1014);
}
#[allow(unused_mut)]
let mut scope_1015 = writer.prefix("Encrypted");
if let Some(var_1016) = &input.encrypted {
scope_1015.boolean(*var_1016);
}
}
#[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,
) {
#[allow(unused_mut)]
let mut scope_1017 = writer.prefix("Arn");
if let Some(var_1018) = &input.arn {
scope_1017.string(var_1018);
}
#[allow(unused_mut)]
let mut scope_1019 = writer.prefix("Name");
if let Some(var_1020) = &input.name {
scope_1019.string(var_1020);
}
}
#[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,
) {
#[allow(unused_mut)]
let mut scope_1021 = writer.prefix("DeviceName");
if let Some(var_1022) = &input.device_name {
scope_1021.string(var_1022);
}
#[allow(unused_mut)]
let mut scope_1023 = writer.prefix("VirtualName");
if let Some(var_1024) = &input.virtual_name {
scope_1023.string(var_1024);
}
#[allow(unused_mut)]
let mut scope_1025 = writer.prefix("Ebs");
if let Some(var_1026) = &input.ebs {
crate::query_ser::serialize_structure_crate_model_launch_template_ebs_block_device_request(
scope_1025, var_1026,
);
}
#[allow(unused_mut)]
let mut scope_1027 = writer.prefix("NoDevice");
if let Some(var_1028) = &input.no_device {
scope_1027.string(var_1028);
}
}
#[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,
) {
#[allow(unused_mut)]
let mut scope_1029 = writer.prefix("AssociateCarrierIpAddress");
if let Some(var_1030) = &input.associate_carrier_ip_address {
scope_1029.boolean(*var_1030);
}
#[allow(unused_mut)]
let mut scope_1031 = writer.prefix("AssociatePublicIpAddress");
if let Some(var_1032) = &input.associate_public_ip_address {
scope_1031.boolean(*var_1032);
}
#[allow(unused_mut)]
let mut scope_1033 = writer.prefix("DeleteOnTermination");
if let Some(var_1034) = &input.delete_on_termination {
scope_1033.boolean(*var_1034);
}
#[allow(unused_mut)]
let mut scope_1035 = writer.prefix("Description");
if let Some(var_1036) = &input.description {
scope_1035.string(var_1036);
}
#[allow(unused_mut)]
let mut scope_1037 = writer.prefix("DeviceIndex");
if let Some(var_1038) = &input.device_index {
scope_1037.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1038).into()),
);
}
#[allow(unused_mut)]
let mut scope_1039 = writer.prefix("SecurityGroupId");
if let Some(var_1040) = &input.groups {
let mut list_1042 = scope_1039.start_list(true, Some("SecurityGroupId"));
for item_1041 in var_1040 {
#[allow(unused_mut)]
let mut entry_1043 = list_1042.entry();
entry_1043.string(item_1041);
}
list_1042.finish();
}
#[allow(unused_mut)]
let mut scope_1044 = writer.prefix("InterfaceType");
if let Some(var_1045) = &input.interface_type {
scope_1044.string(var_1045);
}
#[allow(unused_mut)]
let mut scope_1046 = writer.prefix("Ipv6AddressCount");
if let Some(var_1047) = &input.ipv6_address_count {
scope_1046.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1047).into()),
);
}
#[allow(unused_mut)]
let mut scope_1048 = writer.prefix("Ipv6Addresses");
if let Some(var_1049) = &input.ipv6_addresses {
let mut list_1051 = scope_1048.start_list(true, Some("InstanceIpv6Address"));
for item_1050 in var_1049 {
#[allow(unused_mut)]
let mut entry_1052 = list_1051.entry();
crate::query_ser::serialize_structure_crate_model_instance_ipv6_address_request(
entry_1052, item_1050,
);
}
list_1051.finish();
}
#[allow(unused_mut)]
let mut scope_1053 = writer.prefix("NetworkInterfaceId");
if let Some(var_1054) = &input.network_interface_id {
scope_1053.string(var_1054);
}
#[allow(unused_mut)]
let mut scope_1055 = writer.prefix("PrivateIpAddress");
if let Some(var_1056) = &input.private_ip_address {
scope_1055.string(var_1056);
}
#[allow(unused_mut)]
let mut scope_1057 = writer.prefix("PrivateIpAddresses");
if let Some(var_1058) = &input.private_ip_addresses {
let mut list_1060 = scope_1057.start_list(true, Some("item"));
for item_1059 in var_1058 {
#[allow(unused_mut)]
let mut entry_1061 = list_1060.entry();
crate::query_ser::serialize_structure_crate_model_private_ip_address_specification(
entry_1061, item_1059,
);
}
list_1060.finish();
}
#[allow(unused_mut)]
let mut scope_1062 = writer.prefix("SecondaryPrivateIpAddressCount");
if let Some(var_1063) = &input.secondary_private_ip_address_count {
scope_1062.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1063).into()),
);
}
#[allow(unused_mut)]
let mut scope_1064 = writer.prefix("SubnetId");
if let Some(var_1065) = &input.subnet_id {
scope_1064.string(var_1065);
}
#[allow(unused_mut)]
let mut scope_1066 = writer.prefix("NetworkCardIndex");
if let Some(var_1067) = &input.network_card_index {
scope_1066.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1067).into()),
);
}
#[allow(unused_mut)]
let mut scope_1068 = writer.prefix("Ipv4Prefix");
if let Some(var_1069) = &input.ipv4_prefixes {
let mut list_1071 = scope_1068.start_list(true, Some("item"));
for item_1070 in var_1069 {
#[allow(unused_mut)]
let mut entry_1072 = list_1071.entry();
crate::query_ser::serialize_structure_crate_model_ipv4_prefix_specification_request(
entry_1072, item_1070,
);
}
list_1071.finish();
}
#[allow(unused_mut)]
let mut scope_1073 = writer.prefix("Ipv4PrefixCount");
if let Some(var_1074) = &input.ipv4_prefix_count {
scope_1073.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1074).into()),
);
}
#[allow(unused_mut)]
let mut scope_1075 = writer.prefix("Ipv6Prefix");
if let Some(var_1076) = &input.ipv6_prefixes {
let mut list_1078 = scope_1075.start_list(true, Some("item"));
for item_1077 in var_1076 {
#[allow(unused_mut)]
let mut entry_1079 = list_1078.entry();
crate::query_ser::serialize_structure_crate_model_ipv6_prefix_specification_request(
entry_1079, item_1077,
);
}
list_1078.finish();
}
#[allow(unused_mut)]
let mut scope_1080 = writer.prefix("Ipv6PrefixCount");
if let Some(var_1081) = &input.ipv6_prefix_count {
scope_1080.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1081).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_templates_monitoring_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplatesMonitoringRequest,
) {
#[allow(unused_mut)]
let mut scope_1082 = writer.prefix("Enabled");
if let Some(var_1083) = &input.enabled {
scope_1082.boolean(*var_1083);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_placement_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplatePlacementRequest,
) {
#[allow(unused_mut)]
let mut scope_1084 = writer.prefix("AvailabilityZone");
if let Some(var_1085) = &input.availability_zone {
scope_1084.string(var_1085);
}
#[allow(unused_mut)]
let mut scope_1086 = writer.prefix("Affinity");
if let Some(var_1087) = &input.affinity {
scope_1086.string(var_1087);
}
#[allow(unused_mut)]
let mut scope_1088 = writer.prefix("GroupName");
if let Some(var_1089) = &input.group_name {
scope_1088.string(var_1089);
}
#[allow(unused_mut)]
let mut scope_1090 = writer.prefix("HostId");
if let Some(var_1091) = &input.host_id {
scope_1090.string(var_1091);
}
#[allow(unused_mut)]
let mut scope_1092 = writer.prefix("Tenancy");
if let Some(var_1093) = &input.tenancy {
scope_1092.string(var_1093.as_str());
}
#[allow(unused_mut)]
let mut scope_1094 = writer.prefix("SpreadDomain");
if let Some(var_1095) = &input.spread_domain {
scope_1094.string(var_1095);
}
#[allow(unused_mut)]
let mut scope_1096 = writer.prefix("HostResourceGroupArn");
if let Some(var_1097) = &input.host_resource_group_arn {
scope_1096.string(var_1097);
}
#[allow(unused_mut)]
let mut scope_1098 = writer.prefix("PartitionNumber");
if let Some(var_1099) = &input.partition_number {
scope_1098.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1099).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_tag_specification_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateTagSpecificationRequest,
) {
#[allow(unused_mut)]
let mut scope_1100 = writer.prefix("ResourceType");
if let Some(var_1101) = &input.resource_type {
scope_1100.string(var_1101.as_str());
}
#[allow(unused_mut)]
let mut scope_1102 = writer.prefix("Tag");
if let Some(var_1103) = &input.tags {
let mut list_1105 = scope_1102.start_list(true, Some("item"));
for item_1104 in var_1103 {
#[allow(unused_mut)]
let mut entry_1106 = list_1105.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_1106, item_1104);
}
list_1105.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_elastic_inference_accelerator(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateElasticInferenceAccelerator,
) {
#[allow(unused_mut)]
let mut scope_1107 = writer.prefix("Type");
if let Some(var_1108) = &input.r#type {
scope_1107.string(var_1108);
}
#[allow(unused_mut)]
let mut scope_1109 = writer.prefix("Count");
if let Some(var_1110) = &input.count {
scope_1109.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1110).into()),
);
}
}
#[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,
) {
#[allow(unused_mut)]
let mut scope_1111 = writer.prefix("MarketType");
if let Some(var_1112) = &input.market_type {
scope_1111.string(var_1112.as_str());
}
#[allow(unused_mut)]
let mut scope_1113 = writer.prefix("SpotOptions");
if let Some(var_1114) = &input.spot_options {
crate::query_ser::serialize_structure_crate_model_launch_template_spot_market_options_request(scope_1113, var_1114);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_cpu_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateCpuOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_1115 = writer.prefix("CoreCount");
if let Some(var_1116) = &input.core_count {
scope_1115.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1116).into()),
);
}
#[allow(unused_mut)]
let mut scope_1117 = writer.prefix("ThreadsPerCore");
if let Some(var_1118) = &input.threads_per_core {
scope_1117.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1118).into()),
);
}
}
#[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,
) {
#[allow(unused_mut)]
let mut scope_1119 = writer.prefix("CapacityReservationPreference");
if let Some(var_1120) = &input.capacity_reservation_preference {
scope_1119.string(var_1120.as_str());
}
#[allow(unused_mut)]
let mut scope_1121 = writer.prefix("CapacityReservationTarget");
if let Some(var_1122) = &input.capacity_reservation_target {
crate::query_ser::serialize_structure_crate_model_capacity_reservation_target(
scope_1121, var_1122,
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_license_configuration_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateLicenseConfigurationRequest,
) {
#[allow(unused_mut)]
let mut scope_1123 = writer.prefix("LicenseConfigurationArn");
if let Some(var_1124) = &input.license_configuration_arn {
scope_1123.string(var_1124);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_hibernation_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateHibernationOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_1125 = writer.prefix("Configured");
if let Some(var_1126) = &input.configured {
scope_1125.boolean(*var_1126);
}
}
#[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,
) {
#[allow(unused_mut)]
let mut scope_1127 = writer.prefix("HttpTokens");
if let Some(var_1128) = &input.http_tokens {
scope_1127.string(var_1128.as_str());
}
#[allow(unused_mut)]
let mut scope_1129 = writer.prefix("HttpPutResponseHopLimit");
if let Some(var_1130) = &input.http_put_response_hop_limit {
scope_1129.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1130).into()),
);
}
#[allow(unused_mut)]
let mut scope_1131 = writer.prefix("HttpEndpoint");
if let Some(var_1132) = &input.http_endpoint {
scope_1131.string(var_1132.as_str());
}
#[allow(unused_mut)]
let mut scope_1133 = writer.prefix("HttpProtocolIpv6");
if let Some(var_1134) = &input.http_protocol_ipv6 {
scope_1133.string(var_1134.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_enclave_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateEnclaveOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_1135 = writer.prefix("Enabled");
if let Some(var_1136) = &input.enabled {
scope_1135.boolean(*var_1136);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_vpn_tunnel_options_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::VpnTunnelOptionsSpecification,
) {
#[allow(unused_mut)]
let mut scope_1137 = writer.prefix("TunnelInsideCidr");
if let Some(var_1138) = &input.tunnel_inside_cidr {
scope_1137.string(var_1138);
}
#[allow(unused_mut)]
let mut scope_1139 = writer.prefix("TunnelInsideIpv6Cidr");
if let Some(var_1140) = &input.tunnel_inside_ipv6_cidr {
scope_1139.string(var_1140);
}
#[allow(unused_mut)]
let mut scope_1141 = writer.prefix("PreSharedKey");
if let Some(var_1142) = &input.pre_shared_key {
scope_1141.string(var_1142);
}
#[allow(unused_mut)]
let mut scope_1143 = writer.prefix("Phase1LifetimeSeconds");
if let Some(var_1144) = &input.phase1_lifetime_seconds {
scope_1143.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1144).into()),
);
}
#[allow(unused_mut)]
let mut scope_1145 = writer.prefix("Phase2LifetimeSeconds");
if let Some(var_1146) = &input.phase2_lifetime_seconds {
scope_1145.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1146).into()),
);
}
#[allow(unused_mut)]
let mut scope_1147 = writer.prefix("RekeyMarginTimeSeconds");
if let Some(var_1148) = &input.rekey_margin_time_seconds {
scope_1147.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1148).into()),
);
}
#[allow(unused_mut)]
let mut scope_1149 = writer.prefix("RekeyFuzzPercentage");
if let Some(var_1150) = &input.rekey_fuzz_percentage {
scope_1149.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1150).into()),
);
}
#[allow(unused_mut)]
let mut scope_1151 = writer.prefix("ReplayWindowSize");
if let Some(var_1152) = &input.replay_window_size {
scope_1151.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1152).into()),
);
}
#[allow(unused_mut)]
let mut scope_1153 = writer.prefix("DPDTimeoutSeconds");
if let Some(var_1154) = &input.dpd_timeout_seconds {
scope_1153.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1154).into()),
);
}
#[allow(unused_mut)]
let mut scope_1155 = writer.prefix("DPDTimeoutAction");
if let Some(var_1156) = &input.dpd_timeout_action {
scope_1155.string(var_1156);
}
#[allow(unused_mut)]
let mut scope_1157 = writer.prefix("Phase1EncryptionAlgorithm");
if let Some(var_1158) = &input.phase1_encryption_algorithms {
let mut list_1160 = scope_1157.start_list(true, Some("item"));
for item_1159 in var_1158 {
#[allow(unused_mut)]
let mut entry_1161 = list_1160.entry();
crate::query_ser::serialize_structure_crate_model_phase1_encryption_algorithms_request_list_value(entry_1161, item_1159);
}
list_1160.finish();
}
#[allow(unused_mut)]
let mut scope_1162 = writer.prefix("Phase2EncryptionAlgorithm");
if let Some(var_1163) = &input.phase2_encryption_algorithms {
let mut list_1165 = scope_1162.start_list(true, Some("item"));
for item_1164 in var_1163 {
#[allow(unused_mut)]
let mut entry_1166 = list_1165.entry();
crate::query_ser::serialize_structure_crate_model_phase2_encryption_algorithms_request_list_value(entry_1166, item_1164);
}
list_1165.finish();
}
#[allow(unused_mut)]
let mut scope_1167 = writer.prefix("Phase1IntegrityAlgorithm");
if let Some(var_1168) = &input.phase1_integrity_algorithms {
let mut list_1170 = scope_1167.start_list(true, Some("item"));
for item_1169 in var_1168 {
#[allow(unused_mut)]
let mut entry_1171 = list_1170.entry();
crate::query_ser::serialize_structure_crate_model_phase1_integrity_algorithms_request_list_value(entry_1171, item_1169);
}
list_1170.finish();
}
#[allow(unused_mut)]
let mut scope_1172 = writer.prefix("Phase2IntegrityAlgorithm");
if let Some(var_1173) = &input.phase2_integrity_algorithms {
let mut list_1175 = scope_1172.start_list(true, Some("item"));
for item_1174 in var_1173 {
#[allow(unused_mut)]
let mut entry_1176 = list_1175.entry();
crate::query_ser::serialize_structure_crate_model_phase2_integrity_algorithms_request_list_value(entry_1176, item_1174);
}
list_1175.finish();
}
#[allow(unused_mut)]
let mut scope_1177 = writer.prefix("Phase1DHGroupNumber");
if let Some(var_1178) = &input.phase1_dh_group_numbers {
let mut list_1180 = scope_1177.start_list(true, Some("item"));
for item_1179 in var_1178 {
#[allow(unused_mut)]
let mut entry_1181 = list_1180.entry();
crate::query_ser::serialize_structure_crate_model_phase1_dh_group_numbers_request_list_value(entry_1181, item_1179);
}
list_1180.finish();
}
#[allow(unused_mut)]
let mut scope_1182 = writer.prefix("Phase2DHGroupNumber");
if let Some(var_1183) = &input.phase2_dh_group_numbers {
let mut list_1185 = scope_1182.start_list(true, Some("item"));
for item_1184 in var_1183 {
#[allow(unused_mut)]
let mut entry_1186 = list_1185.entry();
crate::query_ser::serialize_structure_crate_model_phase2_dh_group_numbers_request_list_value(entry_1186, item_1184);
}
list_1185.finish();
}
#[allow(unused_mut)]
let mut scope_1187 = writer.prefix("IKEVersion");
if let Some(var_1188) = &input.ike_versions {
let mut list_1190 = scope_1187.start_list(true, Some("item"));
for item_1189 in var_1188 {
#[allow(unused_mut)]
let mut entry_1191 = list_1190.entry();
crate::query_ser::serialize_structure_crate_model_ike_versions_request_list_value(
entry_1191, item_1189,
);
}
list_1190.finish();
}
#[allow(unused_mut)]
let mut scope_1192 = writer.prefix("StartupAction");
if let Some(var_1193) = &input.startup_action {
scope_1192.string(var_1193);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_athena_integration(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AthenaIntegration,
) {
#[allow(unused_mut)]
let mut scope_1194 = writer.prefix("IntegrationResultS3DestinationArn");
if let Some(var_1195) = &input.integration_result_s3_destination_arn {
scope_1194.string(var_1195);
}
#[allow(unused_mut)]
let mut scope_1196 = writer.prefix("PartitionLoadFrequency");
if let Some(var_1197) = &input.partition_load_frequency {
scope_1196.string(var_1197.as_str());
}
#[allow(unused_mut)]
let mut scope_1198 = writer.prefix("PartitionStartDate");
if let Some(var_1199) = &input.partition_start_date {
scope_1198.instant(var_1199, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_1200 = writer.prefix("PartitionEndDate");
if let Some(var_1201) = &input.partition_end_date {
scope_1200.instant(var_1201, aws_smithy_types::instant::Format::DateTime);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_user_bucket(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::UserBucket,
) {
#[allow(unused_mut)]
let mut scope_1202 = writer.prefix("S3Bucket");
if let Some(var_1203) = &input.s3_bucket {
scope_1202.string(var_1203);
}
#[allow(unused_mut)]
let mut scope_1204 = writer.prefix("S3Key");
if let Some(var_1205) = &input.s3_key {
scope_1204.string(var_1205);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_user_data(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::UserData,
) {
#[allow(unused_mut)]
let mut scope_1206 = writer.prefix("Data");
if let Some(var_1207) = &input.data {
scope_1206.string(var_1207);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_load_permission_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LoadPermissionRequest,
) {
#[allow(unused_mut)]
let mut scope_1208 = writer.prefix("Group");
if let Some(var_1209) = &input.group {
scope_1208.string(var_1209.as_str());
}
#[allow(unused_mut)]
let mut scope_1210 = writer.prefix("UserId");
if let Some(var_1211) = &input.user_id {
scope_1210.string(var_1211);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_permission(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchPermission,
) {
#[allow(unused_mut)]
let mut scope_1212 = writer.prefix("Group");
if let Some(var_1213) = &input.group {
scope_1212.string(var_1213.as_str());
}
#[allow(unused_mut)]
let mut scope_1214 = writer.prefix("UserId");
if let Some(var_1215) = &input.user_id {
scope_1214.string(var_1215);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ebs_instance_block_device_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::EbsInstanceBlockDeviceSpecification,
) {
#[allow(unused_mut)]
let mut scope_1216 = writer.prefix("DeleteOnTermination");
if let Some(var_1217) = &input.delete_on_termination {
scope_1216.boolean(*var_1217);
}
#[allow(unused_mut)]
let mut scope_1218 = writer.prefix("VolumeId");
if let Some(var_1219) = &input.volume_id {
scope_1218.string(var_1219);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_capacity_reservation_target(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CapacityReservationTarget,
) {
#[allow(unused_mut)]
let mut scope_1220 = writer.prefix("CapacityReservationId");
if let Some(var_1221) = &input.capacity_reservation_id {
scope_1220.string(var_1221);
}
#[allow(unused_mut)]
let mut scope_1222 = writer.prefix("CapacityReservationResourceGroupArn");
if let Some(var_1223) = &input.capacity_reservation_resource_group_arn {
scope_1222.string(var_1223);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_security_group_rule_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SecurityGroupRuleRequest,
) {
#[allow(unused_mut)]
let mut scope_1224 = writer.prefix("IpProtocol");
if let Some(var_1225) = &input.ip_protocol {
scope_1224.string(var_1225);
}
#[allow(unused_mut)]
let mut scope_1226 = writer.prefix("FromPort");
if let Some(var_1227) = &input.from_port {
scope_1226.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1227).into()),
);
}
#[allow(unused_mut)]
let mut scope_1228 = writer.prefix("ToPort");
if let Some(var_1229) = &input.to_port {
scope_1228.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1229).into()),
);
}
#[allow(unused_mut)]
let mut scope_1230 = writer.prefix("CidrIpv4");
if let Some(var_1231) = &input.cidr_ipv4 {
scope_1230.string(var_1231);
}
#[allow(unused_mut)]
let mut scope_1232 = writer.prefix("CidrIpv6");
if let Some(var_1233) = &input.cidr_ipv6 {
scope_1232.string(var_1233);
}
#[allow(unused_mut)]
let mut scope_1234 = writer.prefix("PrefixListId");
if let Some(var_1235) = &input.prefix_list_id {
scope_1234.string(var_1235);
}
#[allow(unused_mut)]
let mut scope_1236 = writer.prefix("ReferencedGroupId");
if let Some(var_1237) = &input.referenced_group_id {
scope_1236.string(var_1237);
}
#[allow(unused_mut)]
let mut scope_1238 = writer.prefix("Description");
if let Some(var_1239) = &input.description {
scope_1238.string(var_1239);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_create_volume_permission(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CreateVolumePermission,
) {
#[allow(unused_mut)]
let mut scope_1240 = writer.prefix("Group");
if let Some(var_1241) = &input.group {
scope_1240.string(var_1241.as_str());
}
#[allow(unused_mut)]
let mut scope_1242 = writer.prefix("UserId");
if let Some(var_1243) = &input.user_id {
scope_1242.string(var_1243);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_launch_template_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::FleetLaunchTemplateSpecification,
) {
#[allow(unused_mut)]
let mut scope_1244 = writer.prefix("LaunchTemplateId");
if let Some(var_1245) = &input.launch_template_id {
scope_1244.string(var_1245);
}
#[allow(unused_mut)]
let mut scope_1246 = writer.prefix("LaunchTemplateName");
if let Some(var_1247) = &input.launch_template_name {
scope_1246.string(var_1247);
}
#[allow(unused_mut)]
let mut scope_1248 = writer.prefix("Version");
if let Some(var_1249) = &input.version {
scope_1248.string(var_1249);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_overrides(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateOverrides,
) {
#[allow(unused_mut)]
let mut scope_1250 = writer.prefix("InstanceType");
if let Some(var_1251) = &input.instance_type {
scope_1250.string(var_1251.as_str());
}
#[allow(unused_mut)]
let mut scope_1252 = writer.prefix("SpotPrice");
if let Some(var_1253) = &input.spot_price {
scope_1252.string(var_1253);
}
#[allow(unused_mut)]
let mut scope_1254 = writer.prefix("SubnetId");
if let Some(var_1255) = &input.subnet_id {
scope_1254.string(var_1255);
}
#[allow(unused_mut)]
let mut scope_1256 = writer.prefix("AvailabilityZone");
if let Some(var_1257) = &input.availability_zone {
scope_1256.string(var_1257);
}
#[allow(unused_mut)]
let mut scope_1258 = writer.prefix("WeightedCapacity");
if let Some(var_1259) = &input.weighted_capacity {
scope_1258.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_1259).into()),
);
}
#[allow(unused_mut)]
let mut scope_1260 = writer.prefix("Priority");
if let Some(var_1261) = &input.priority {
scope_1260.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_1261).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase1_encryption_algorithms_request_list_value(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Phase1EncryptionAlgorithmsRequestListValue,
) {
#[allow(unused_mut)]
let mut scope_1262 = writer.prefix("Value");
if let Some(var_1263) = &input.value {
scope_1262.string(var_1263);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase2_encryption_algorithms_request_list_value(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Phase2EncryptionAlgorithmsRequestListValue,
) {
#[allow(unused_mut)]
let mut scope_1264 = writer.prefix("Value");
if let Some(var_1265) = &input.value {
scope_1264.string(var_1265);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase1_integrity_algorithms_request_list_value(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Phase1IntegrityAlgorithmsRequestListValue,
) {
#[allow(unused_mut)]
let mut scope_1266 = writer.prefix("Value");
if let Some(var_1267) = &input.value {
scope_1266.string(var_1267);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase2_integrity_algorithms_request_list_value(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Phase2IntegrityAlgorithmsRequestListValue,
) {
#[allow(unused_mut)]
let mut scope_1268 = writer.prefix("Value");
if let Some(var_1269) = &input.value {
scope_1268.string(var_1269);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase1_dh_group_numbers_request_list_value(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Phase1DhGroupNumbersRequestListValue,
) {
#[allow(unused_mut)]
let mut scope_1270 = writer.prefix("Value");
if let Some(var_1271) = &input.value {
scope_1270.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1271).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_phase2_dh_group_numbers_request_list_value(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Phase2DhGroupNumbersRequestListValue,
) {
#[allow(unused_mut)]
let mut scope_1272 = writer.prefix("Value");
if let Some(var_1273) = &input.value {
scope_1272.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1273).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ike_versions_request_list_value(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::IkeVersionsRequestListValue,
) {
#[allow(unused_mut)]
let mut scope_1274 = writer.prefix("Value");
if let Some(var_1275) = &input.value {
scope_1274.string(var_1275);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_maintenance_strategies(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SpotMaintenanceStrategies,
) {
#[allow(unused_mut)]
let mut scope_1276 = writer.prefix("CapacityRebalance");
if let Some(var_1277) = &input.capacity_rebalance {
crate::query_ser::serialize_structure_crate_model_spot_capacity_rebalance(
scope_1276, var_1277,
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_fleet_launch_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SpotFleetLaunchSpecification,
) {
#[allow(unused_mut)]
let mut scope_1278 = writer.prefix("GroupSet");
if let Some(var_1279) = &input.security_groups {
let mut list_1281 = scope_1278.start_list(true, Some("item"));
for item_1280 in var_1279 {
#[allow(unused_mut)]
let mut entry_1282 = list_1281.entry();
crate::query_ser::serialize_structure_crate_model_group_identifier(
entry_1282, item_1280,
);
}
list_1281.finish();
}
#[allow(unused_mut)]
let mut scope_1283 = writer.prefix("AddressingType");
if let Some(var_1284) = &input.addressing_type {
scope_1283.string(var_1284);
}
#[allow(unused_mut)]
let mut scope_1285 = writer.prefix("BlockDeviceMapping");
if let Some(var_1286) = &input.block_device_mappings {
let mut list_1288 = scope_1285.start_list(true, Some("item"));
for item_1287 in var_1286 {
#[allow(unused_mut)]
let mut entry_1289 = list_1288.entry();
crate::query_ser::serialize_structure_crate_model_block_device_mapping(
entry_1289, item_1287,
);
}
list_1288.finish();
}
#[allow(unused_mut)]
let mut scope_1290 = writer.prefix("EbsOptimized");
if let Some(var_1291) = &input.ebs_optimized {
scope_1290.boolean(*var_1291);
}
#[allow(unused_mut)]
let mut scope_1292 = writer.prefix("IamInstanceProfile");
if let Some(var_1293) = &input.iam_instance_profile {
crate::query_ser::serialize_structure_crate_model_iam_instance_profile_specification(
scope_1292, var_1293,
);
}
#[allow(unused_mut)]
let mut scope_1294 = writer.prefix("ImageId");
if let Some(var_1295) = &input.image_id {
scope_1294.string(var_1295);
}
#[allow(unused_mut)]
let mut scope_1296 = writer.prefix("InstanceType");
if let Some(var_1297) = &input.instance_type {
scope_1296.string(var_1297.as_str());
}
#[allow(unused_mut)]
let mut scope_1298 = writer.prefix("KernelId");
if let Some(var_1299) = &input.kernel_id {
scope_1298.string(var_1299);
}
#[allow(unused_mut)]
let mut scope_1300 = writer.prefix("KeyName");
if let Some(var_1301) = &input.key_name {
scope_1300.string(var_1301);
}
#[allow(unused_mut)]
let mut scope_1302 = writer.prefix("Monitoring");
if let Some(var_1303) = &input.monitoring {
crate::query_ser::serialize_structure_crate_model_spot_fleet_monitoring(
scope_1302, var_1303,
);
}
#[allow(unused_mut)]
let mut scope_1304 = writer.prefix("NetworkInterfaceSet");
if let Some(var_1305) = &input.network_interfaces {
let mut list_1307 = scope_1304.start_list(true, Some("item"));
for item_1306 in var_1305 {
#[allow(unused_mut)]
let mut entry_1308 = list_1307.entry();
crate::query_ser::serialize_structure_crate_model_instance_network_interface_specification(entry_1308, item_1306);
}
list_1307.finish();
}
#[allow(unused_mut)]
let mut scope_1309 = writer.prefix("Placement");
if let Some(var_1310) = &input.placement {
crate::query_ser::serialize_structure_crate_model_spot_placement(scope_1309, var_1310);
}
#[allow(unused_mut)]
let mut scope_1311 = writer.prefix("RamdiskId");
if let Some(var_1312) = &input.ramdisk_id {
scope_1311.string(var_1312);
}
#[allow(unused_mut)]
let mut scope_1313 = writer.prefix("SpotPrice");
if let Some(var_1314) = &input.spot_price {
scope_1313.string(var_1314);
}
#[allow(unused_mut)]
let mut scope_1315 = writer.prefix("SubnetId");
if let Some(var_1316) = &input.subnet_id {
scope_1315.string(var_1316);
}
#[allow(unused_mut)]
let mut scope_1317 = writer.prefix("UserData");
if let Some(var_1318) = &input.user_data {
scope_1317.string(var_1318);
}
#[allow(unused_mut)]
let mut scope_1319 = writer.prefix("WeightedCapacity");
if let Some(var_1320) = &input.weighted_capacity {
scope_1319.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_1320).into()),
);
}
#[allow(unused_mut)]
let mut scope_1321 = writer.prefix("TagSpecificationSet");
if let Some(var_1322) = &input.tag_specifications {
let mut list_1324 = scope_1321.start_list(true, Some("item"));
for item_1323 in var_1322 {
#[allow(unused_mut)]
let mut entry_1325 = list_1324.entry();
crate::query_ser::serialize_structure_crate_model_spot_fleet_tag_specification(
entry_1325, item_1323,
);
}
list_1324.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_load_balancers_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LoadBalancersConfig,
) {
#[allow(unused_mut)]
let mut scope_1326 = writer.prefix("ClassicLoadBalancersConfig");
if let Some(var_1327) = &input.classic_load_balancers_config {
crate::query_ser::serialize_structure_crate_model_classic_load_balancers_config(
scope_1326, var_1327,
);
}
#[allow(unused_mut)]
let mut scope_1328 = writer.prefix("TargetGroupsConfig");
if let Some(var_1329) = &input.target_groups_config {
crate::query_ser::serialize_structure_crate_model_target_groups_config(
scope_1328, var_1329,
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_placement(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SpotPlacement,
) {
#[allow(unused_mut)]
let mut scope_1330 = writer.prefix("AvailabilityZone");
if let Some(var_1331) = &input.availability_zone {
scope_1330.string(var_1331);
}
#[allow(unused_mut)]
let mut scope_1332 = writer.prefix("GroupName");
if let Some(var_1333) = &input.group_name {
scope_1332.string(var_1333);
}
#[allow(unused_mut)]
let mut scope_1334 = writer.prefix("Tenancy");
if let Some(var_1335) = &input.tenancy {
scope_1334.string(var_1335.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_market_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SpotMarketOptions,
) {
#[allow(unused_mut)]
let mut scope_1336 = writer.prefix("MaxPrice");
if let Some(var_1337) = &input.max_price {
scope_1336.string(var_1337);
}
#[allow(unused_mut)]
let mut scope_1338 = writer.prefix("SpotInstanceType");
if let Some(var_1339) = &input.spot_instance_type {
scope_1338.string(var_1339.as_str());
}
#[allow(unused_mut)]
let mut scope_1340 = writer.prefix("BlockDurationMinutes");
if let Some(var_1341) = &input.block_duration_minutes {
scope_1340.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1341).into()),
);
}
#[allow(unused_mut)]
let mut scope_1342 = writer.prefix("ValidUntil");
if let Some(var_1343) = &input.valid_until {
scope_1342.instant(var_1343, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_1344 = writer.prefix("InstanceInterruptionBehavior");
if let Some(var_1345) = &input.instance_interruption_behavior {
scope_1344.string(var_1345.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_block_device_mapping(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledInstancesBlockDeviceMapping,
) {
#[allow(unused_mut)]
let mut scope_1346 = writer.prefix("DeviceName");
if let Some(var_1347) = &input.device_name {
scope_1346.string(var_1347);
}
#[allow(unused_mut)]
let mut scope_1348 = writer.prefix("Ebs");
if let Some(var_1349) = &input.ebs {
crate::query_ser::serialize_structure_crate_model_scheduled_instances_ebs(
scope_1348, var_1349,
);
}
#[allow(unused_mut)]
let mut scope_1350 = writer.prefix("NoDevice");
if let Some(var_1351) = &input.no_device {
scope_1350.string(var_1351);
}
#[allow(unused_mut)]
let mut scope_1352 = writer.prefix("VirtualName");
if let Some(var_1353) = &input.virtual_name {
scope_1352.string(var_1353);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_iam_instance_profile(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledInstancesIamInstanceProfile,
) {
#[allow(unused_mut)]
let mut scope_1354 = writer.prefix("Arn");
if let Some(var_1355) = &input.arn {
scope_1354.string(var_1355);
}
#[allow(unused_mut)]
let mut scope_1356 = writer.prefix("Name");
if let Some(var_1357) = &input.name {
scope_1356.string(var_1357);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_monitoring(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledInstancesMonitoring,
) {
#[allow(unused_mut)]
let mut scope_1358 = writer.prefix("Enabled");
if let Some(var_1359) = &input.enabled {
scope_1358.boolean(*var_1359);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_network_interface(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledInstancesNetworkInterface,
) {
#[allow(unused_mut)]
let mut scope_1360 = writer.prefix("AssociatePublicIpAddress");
if let Some(var_1361) = &input.associate_public_ip_address {
scope_1360.boolean(*var_1361);
}
#[allow(unused_mut)]
let mut scope_1362 = writer.prefix("DeleteOnTermination");
if let Some(var_1363) = &input.delete_on_termination {
scope_1362.boolean(*var_1363);
}
#[allow(unused_mut)]
let mut scope_1364 = writer.prefix("Description");
if let Some(var_1365) = &input.description {
scope_1364.string(var_1365);
}
#[allow(unused_mut)]
let mut scope_1366 = writer.prefix("DeviceIndex");
if let Some(var_1367) = &input.device_index {
scope_1366.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1367).into()),
);
}
#[allow(unused_mut)]
let mut scope_1368 = writer.prefix("Group");
if let Some(var_1369) = &input.groups {
let mut list_1371 = scope_1368.start_list(true, Some("SecurityGroupId"));
for item_1370 in var_1369 {
#[allow(unused_mut)]
let mut entry_1372 = list_1371.entry();
entry_1372.string(item_1370);
}
list_1371.finish();
}
#[allow(unused_mut)]
let mut scope_1373 = writer.prefix("Ipv6AddressCount");
if let Some(var_1374) = &input.ipv6_address_count {
scope_1373.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1374).into()),
);
}
#[allow(unused_mut)]
let mut scope_1375 = writer.prefix("Ipv6Address");
if let Some(var_1376) = &input.ipv6_addresses {
let mut list_1378 = scope_1375.start_list(true, Some("Ipv6Address"));
for item_1377 in var_1376 {
#[allow(unused_mut)]
let mut entry_1379 = list_1378.entry();
crate::query_ser::serialize_structure_crate_model_scheduled_instances_ipv6_address(
entry_1379, item_1377,
);
}
list_1378.finish();
}
#[allow(unused_mut)]
let mut scope_1380 = writer.prefix("NetworkInterfaceId");
if let Some(var_1381) = &input.network_interface_id {
scope_1380.string(var_1381);
}
#[allow(unused_mut)]
let mut scope_1382 = writer.prefix("PrivateIpAddress");
if let Some(var_1383) = &input.private_ip_address {
scope_1382.string(var_1383);
}
#[allow(unused_mut)]
let mut scope_1384 = writer.prefix("PrivateIpAddressConfig");
if let Some(var_1385) = &input.private_ip_address_configs {
let mut list_1387 = scope_1384.start_list(true, Some("PrivateIpAddressConfigSet"));
for item_1386 in var_1385 {
#[allow(unused_mut)]
let mut entry_1388 = list_1387.entry();
crate::query_ser::serialize_structure_crate_model_scheduled_instances_private_ip_address_config(entry_1388, item_1386);
}
list_1387.finish();
}
#[allow(unused_mut)]
let mut scope_1389 = writer.prefix("SecondaryPrivateIpAddressCount");
if let Some(var_1390) = &input.secondary_private_ip_address_count {
scope_1389.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1390).into()),
);
}
#[allow(unused_mut)]
let mut scope_1391 = writer.prefix("SubnetId");
if let Some(var_1392) = &input.subnet_id {
scope_1391.string(var_1392);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_placement(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledInstancesPlacement,
) {
#[allow(unused_mut)]
let mut scope_1393 = writer.prefix("AvailabilityZone");
if let Some(var_1394) = &input.availability_zone {
scope_1393.string(var_1394);
}
#[allow(unused_mut)]
let mut scope_1395 = writer.prefix("GroupName");
if let Some(var_1396) = &input.group_name {
scope_1395.string(var_1396);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fleet_spot_capacity_rebalance_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::FleetSpotCapacityRebalanceRequest,
) {
#[allow(unused_mut)]
let mut scope_1397 = writer.prefix("ReplacementStrategy");
if let Some(var_1398) = &input.replacement_strategy {
scope_1397.string(var_1398.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_ebs_block_device_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateEbsBlockDeviceRequest,
) {
#[allow(unused_mut)]
let mut scope_1399 = writer.prefix("Encrypted");
if let Some(var_1400) = &input.encrypted {
scope_1399.boolean(*var_1400);
}
#[allow(unused_mut)]
let mut scope_1401 = writer.prefix("DeleteOnTermination");
if let Some(var_1402) = &input.delete_on_termination {
scope_1401.boolean(*var_1402);
}
#[allow(unused_mut)]
let mut scope_1403 = writer.prefix("Iops");
if let Some(var_1404) = &input.iops {
scope_1403.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1404).into()),
);
}
#[allow(unused_mut)]
let mut scope_1405 = writer.prefix("KmsKeyId");
if let Some(var_1406) = &input.kms_key_id {
scope_1405.string(var_1406);
}
#[allow(unused_mut)]
let mut scope_1407 = writer.prefix("SnapshotId");
if let Some(var_1408) = &input.snapshot_id {
scope_1407.string(var_1408);
}
#[allow(unused_mut)]
let mut scope_1409 = writer.prefix("VolumeSize");
if let Some(var_1410) = &input.volume_size {
scope_1409.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1410).into()),
);
}
#[allow(unused_mut)]
let mut scope_1411 = writer.prefix("VolumeType");
if let Some(var_1412) = &input.volume_type {
scope_1411.string(var_1412.as_str());
}
#[allow(unused_mut)]
let mut scope_1413 = writer.prefix("Throughput");
if let Some(var_1414) = &input.throughput {
scope_1413.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1414).into()),
);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_ipv6_address_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceIpv6AddressRequest,
) {
#[allow(unused_mut)]
let mut scope_1415 = writer.prefix("Ipv6Address");
if let Some(var_1416) = &input.ipv6_address {
scope_1415.string(var_1416);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_spot_market_options_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateSpotMarketOptionsRequest,
) {
#[allow(unused_mut)]
let mut scope_1417 = writer.prefix("MaxPrice");
if let Some(var_1418) = &input.max_price {
scope_1417.string(var_1418);
}
#[allow(unused_mut)]
let mut scope_1419 = writer.prefix("SpotInstanceType");
if let Some(var_1420) = &input.spot_instance_type {
scope_1419.string(var_1420.as_str());
}
#[allow(unused_mut)]
let mut scope_1421 = writer.prefix("BlockDurationMinutes");
if let Some(var_1422) = &input.block_duration_minutes {
scope_1421.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1422).into()),
);
}
#[allow(unused_mut)]
let mut scope_1423 = writer.prefix("ValidUntil");
if let Some(var_1424) = &input.valid_until {
scope_1423.instant(var_1424, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_1425 = writer.prefix("InstanceInterruptionBehavior");
if let Some(var_1426) = &input.instance_interruption_behavior {
scope_1425.string(var_1426.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_capacity_rebalance(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SpotCapacityRebalance,
) {
#[allow(unused_mut)]
let mut scope_1427 = writer.prefix("ReplacementStrategy");
if let Some(var_1428) = &input.replacement_strategy {
scope_1427.string(var_1428.as_str());
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_group_identifier(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::GroupIdentifier,
) {
#[allow(unused_mut)]
let mut scope_1429 = writer.prefix("GroupName");
if let Some(var_1430) = &input.group_name {
scope_1429.string(var_1430);
}
#[allow(unused_mut)]
let mut scope_1431 = writer.prefix("GroupId");
if let Some(var_1432) = &input.group_id {
scope_1431.string(var_1432);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_fleet_monitoring(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SpotFleetMonitoring,
) {
#[allow(unused_mut)]
let mut scope_1433 = writer.prefix("Enabled");
if let Some(var_1434) = &input.enabled {
scope_1433.boolean(*var_1434);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_spot_fleet_tag_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SpotFleetTagSpecification,
) {
#[allow(unused_mut)]
let mut scope_1435 = writer.prefix("ResourceType");
if let Some(var_1436) = &input.resource_type {
scope_1435.string(var_1436.as_str());
}
#[allow(unused_mut)]
let mut scope_1437 = writer.prefix("Tag");
if let Some(var_1438) = &input.tags {
let mut list_1440 = scope_1437.start_list(true, Some("item"));
for item_1439 in var_1438 {
#[allow(unused_mut)]
let mut entry_1441 = list_1440.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_1441, item_1439);
}
list_1440.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_classic_load_balancers_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ClassicLoadBalancersConfig,
) {
#[allow(unused_mut)]
let mut scope_1442 = writer.prefix("ClassicLoadBalancers");
if let Some(var_1443) = &input.classic_load_balancers {
let mut list_1445 = scope_1442.start_list(true, Some("item"));
for item_1444 in var_1443 {
#[allow(unused_mut)]
let mut entry_1446 = list_1445.entry();
crate::query_ser::serialize_structure_crate_model_classic_load_balancer(
entry_1446, item_1444,
);
}
list_1445.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_groups_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetGroupsConfig,
) {
#[allow(unused_mut)]
let mut scope_1447 = writer.prefix("TargetGroups");
if let Some(var_1448) = &input.target_groups {
let mut list_1450 = scope_1447.start_list(true, Some("item"));
for item_1449 in var_1448 {
#[allow(unused_mut)]
let mut entry_1451 = list_1450.entry();
crate::query_ser::serialize_structure_crate_model_target_group(entry_1451, item_1449);
}
list_1450.finish();
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_ebs(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledInstancesEbs,
) {
#[allow(unused_mut)]
let mut scope_1452 = writer.prefix("DeleteOnTermination");
if let Some(var_1453) = &input.delete_on_termination {
scope_1452.boolean(*var_1453);
}
#[allow(unused_mut)]
let mut scope_1454 = writer.prefix("Encrypted");
if let Some(var_1455) = &input.encrypted {
scope_1454.boolean(*var_1455);
}
#[allow(unused_mut)]
let mut scope_1456 = writer.prefix("Iops");
if let Some(var_1457) = &input.iops {
scope_1456.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1457).into()),
);
}
#[allow(unused_mut)]
let mut scope_1458 = writer.prefix("SnapshotId");
if let Some(var_1459) = &input.snapshot_id {
scope_1458.string(var_1459);
}
#[allow(unused_mut)]
let mut scope_1460 = writer.prefix("VolumeSize");
if let Some(var_1461) = &input.volume_size {
scope_1460.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1461).into()),
);
}
#[allow(unused_mut)]
let mut scope_1462 = writer.prefix("VolumeType");
if let Some(var_1463) = &input.volume_type {
scope_1462.string(var_1463);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_ipv6_address(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledInstancesIpv6Address,
) {
#[allow(unused_mut)]
let mut scope_1464 = writer.prefix("Ipv6Address");
if let Some(var_1465) = &input.ipv6_address {
scope_1464.string(var_1465);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_instances_private_ip_address_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledInstancesPrivateIpAddressConfig,
) {
#[allow(unused_mut)]
let mut scope_1466 = writer.prefix("Primary");
if let Some(var_1467) = &input.primary {
scope_1466.boolean(*var_1467);
}
#[allow(unused_mut)]
let mut scope_1468 = writer.prefix("PrivateIpAddress");
if let Some(var_1469) = &input.private_ip_address {
scope_1468.string(var_1469);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_classic_load_balancer(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ClassicLoadBalancer,
) {
#[allow(unused_mut)]
let mut scope_1470 = writer.prefix("Name");
if let Some(var_1471) = &input.name {
scope_1470.string(var_1471);
}
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_group(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetGroup,
) {
#[allow(unused_mut)]
let mut scope_1472 = writer.prefix("Arn");
if let Some(var_1473) = &input.arn {
scope_1472.string(var_1473);
}
}