pub fn ser_run_instances_input_input_input(
input: &crate::operation::run_instances::RunInstancesInput,
) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = ::aws_smithy_query::QueryWriter::new(&mut out, "RunInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("BlockDeviceMapping");
if let Some(var_2) = &input.block_device_mappings {
if !var_2.is_empty() {
let mut list_4 = scope_1.start_list(true, Some("BlockDeviceMapping"));
for item_3 in var_2 {
#[allow(unused_mut)]
let mut entry_5 = list_4.entry();
crate::protocol_serde::shape_block_device_mapping::ser_block_device_mapping(entry_5, item_3)?;
}
list_4.finish();
}
}
#[allow(unused_mut)]
let mut scope_6 = writer.prefix("ImageId");
if let Some(var_7) = &input.image_id {
scope_6.string(var_7);
}
#[allow(unused_mut)]
let mut scope_8 = writer.prefix("InstanceType");
if let Some(var_9) = &input.instance_type {
scope_8.string(var_9.as_str());
}
#[allow(unused_mut)]
let mut scope_10 = writer.prefix("Ipv6AddressCount");
if let Some(var_11) = &input.ipv6_address_count {
scope_10.number(
#[allow(clippy::useless_conversion)]
::aws_smithy_types::Number::NegInt((*var_11).into()),
);
}
#[allow(unused_mut)]
let mut scope_12 = writer.prefix("Ipv6Address");
if let Some(var_13) = &input.ipv6_addresses {
if !var_13.is_empty() {
let mut list_15 = scope_12.start_list(true, Some("item"));
for item_14 in var_13 {
#[allow(unused_mut)]
let mut entry_16 = list_15.entry();
crate::protocol_serde::shape_instance_ipv6_address::ser_instance_ipv6_address(entry_16, item_14)?;
}
list_15.finish();
}
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("KernelId");
if let Some(var_18) = &input.kernel_id {
scope_17.string(var_18);
}
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("KeyName");
if let Some(var_20) = &input.key_name {
scope_19.string(var_20);
}
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("MaxCount");
if let Some(var_22) = &input.max_count {
scope_21.number(
#[allow(clippy::useless_conversion)]
::aws_smithy_types::Number::NegInt((*var_22).into()),
);
}
#[allow(unused_mut)]
let mut scope_23 = writer.prefix("MinCount");
if let Some(var_24) = &input.min_count {
scope_23.number(
#[allow(clippy::useless_conversion)]
::aws_smithy_types::Number::NegInt((*var_24).into()),
);
}
#[allow(unused_mut)]
let mut scope_25 = writer.prefix("Monitoring");
if let Some(var_26) = &input.monitoring {
crate::protocol_serde::shape_run_instances_monitoring_enabled::ser_run_instances_monitoring_enabled(scope_25, var_26)?;
}
#[allow(unused_mut)]
let mut scope_27 = writer.prefix("Placement");
if let Some(var_28) = &input.placement {
crate::protocol_serde::shape_placement::ser_placement(scope_27, var_28)?;
}
#[allow(unused_mut)]
let mut scope_29 = writer.prefix("RamdiskId");
if let Some(var_30) = &input.ramdisk_id {
scope_29.string(var_30);
}
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("SecurityGroupId");
if let Some(var_32) = &input.security_group_ids {
if !var_32.is_empty() {
let mut list_34 = scope_31.start_list(true, Some("SecurityGroupId"));
for item_33 in var_32 {
#[allow(unused_mut)]
let mut entry_35 = list_34.entry();
entry_35.string(item_33);
}
list_34.finish();
}
}
#[allow(unused_mut)]
let mut scope_36 = writer.prefix("SecurityGroup");
if let Some(var_37) = &input.security_groups {
if !var_37.is_empty() {
let mut list_39 = scope_36.start_list(true, Some("SecurityGroup"));
for item_38 in var_37 {
#[allow(unused_mut)]
let mut entry_40 = list_39.entry();
entry_40.string(item_38);
}
list_39.finish();
}
}
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("SubnetId");
if let Some(var_42) = &input.subnet_id {
scope_41.string(var_42);
}
#[allow(unused_mut)]
let mut scope_43 = writer.prefix("UserData");
if let Some(var_44) = &input.user_data {
scope_43.string(var_44);
}
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("ElasticGpuSpecification");
if let Some(var_46) = &input.elastic_gpu_specification {
if !var_46.is_empty() {
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::protocol_serde::shape_elastic_gpu_specification::ser_elastic_gpu_specification(entry_49, item_47)?;
}
list_48.finish();
}
}
#[allow(unused_mut)]
let mut scope_50 = writer.prefix("ElasticInferenceAccelerator");
if let Some(var_51) = &input.elastic_inference_accelerators {
if !var_51.is_empty() {
let mut list_53 = scope_50.start_list(true, Some("item"));
for item_52 in var_51 {
#[allow(unused_mut)]
let mut entry_54 = list_53.entry();
crate::protocol_serde::shape_elastic_inference_accelerator::ser_elastic_inference_accelerator(entry_54, item_52)?;
}
list_53.finish();
}
}
#[allow(unused_mut)]
let mut scope_55 = writer.prefix("TagSpecification");
if let Some(var_56) = &input.tag_specifications {
if !var_56.is_empty() {
let mut list_58 = scope_55.start_list(true, Some("item"));
for item_57 in var_56 {
#[allow(unused_mut)]
let mut entry_59 = list_58.entry();
crate::protocol_serde::shape_tag_specification::ser_tag_specification(entry_59, item_57)?;
}
list_58.finish();
}
}
#[allow(unused_mut)]
let mut scope_60 = writer.prefix("LaunchTemplate");
if let Some(var_61) = &input.launch_template {
crate::protocol_serde::shape_launch_template_specification::ser_launch_template_specification(scope_60, var_61)?;
}
#[allow(unused_mut)]
let mut scope_62 = writer.prefix("InstanceMarketOptions");
if let Some(var_63) = &input.instance_market_options {
crate::protocol_serde::shape_instance_market_options_request::ser_instance_market_options_request(scope_62, var_63)?;
}
#[allow(unused_mut)]
let mut scope_64 = writer.prefix("CreditSpecification");
if let Some(var_65) = &input.credit_specification {
crate::protocol_serde::shape_credit_specification_request::ser_credit_specification_request(scope_64, var_65)?;
}
#[allow(unused_mut)]
let mut scope_66 = writer.prefix("CpuOptions");
if let Some(var_67) = &input.cpu_options {
crate::protocol_serde::shape_cpu_options_request::ser_cpu_options_request(scope_66, var_67)?;
}
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("CapacityReservationSpecification");
if let Some(var_69) = &input.capacity_reservation_specification {
crate::protocol_serde::shape_capacity_reservation_specification::ser_capacity_reservation_specification(scope_68, var_69)?;
}
#[allow(unused_mut)]
let mut scope_70 = writer.prefix("HibernationOptions");
if let Some(var_71) = &input.hibernation_options {
crate::protocol_serde::shape_hibernation_options_request::ser_hibernation_options_request(scope_70, var_71)?;
}
#[allow(unused_mut)]
let mut scope_72 = writer.prefix("LicenseSpecification");
if let Some(var_73) = &input.license_specifications {
if !var_73.is_empty() {
let mut list_75 = scope_72.start_list(true, Some("item"));
for item_74 in var_73 {
#[allow(unused_mut)]
let mut entry_76 = list_75.entry();
crate::protocol_serde::shape_license_configuration_request::ser_license_configuration_request(entry_76, item_74)?;
}
list_75.finish();
}
}
#[allow(unused_mut)]
let mut scope_77 = writer.prefix("MetadataOptions");
if let Some(var_78) = &input.metadata_options {
crate::protocol_serde::shape_instance_metadata_options_request::ser_instance_metadata_options_request(scope_77, var_78)?;
}
#[allow(unused_mut)]
let mut scope_79 = writer.prefix("EnclaveOptions");
if let Some(var_80) = &input.enclave_options {
crate::protocol_serde::shape_enclave_options_request::ser_enclave_options_request(scope_79, var_80)?;
}
#[allow(unused_mut)]
let mut scope_81 = writer.prefix("PrivateDnsNameOptions");
if let Some(var_82) = &input.private_dns_name_options {
crate::protocol_serde::shape_private_dns_name_options_request::ser_private_dns_name_options_request(scope_81, var_82)?;
}
#[allow(unused_mut)]
let mut scope_83 = writer.prefix("MaintenanceOptions");
if let Some(var_84) = &input.maintenance_options {
crate::protocol_serde::shape_instance_maintenance_options_request::ser_instance_maintenance_options_request(scope_83, var_84)?;
}
#[allow(unused_mut)]
let mut scope_85 = writer.prefix("DisableApiStop");
if let Some(var_86) = &input.disable_api_stop {
scope_85.boolean(*var_86);
}
#[allow(unused_mut)]
let mut scope_87 = writer.prefix("EnablePrimaryIpv6");
if let Some(var_88) = &input.enable_primary_ipv6 {
scope_87.boolean(*var_88);
}
#[allow(unused_mut)]
let mut scope_89 = writer.prefix("NetworkPerformanceOptions");
if let Some(var_90) = &input.network_performance_options {
crate::protocol_serde::shape_instance_network_performance_options_request::ser_instance_network_performance_options_request(
scope_89, var_90,
)?;
}
#[allow(unused_mut)]
let mut scope_91 = writer.prefix("Operator");
if let Some(var_92) = &input.operator {
crate::protocol_serde::shape_operator_request::ser_operator_request(scope_91, var_92)?;
}
#[allow(unused_mut)]
let mut scope_93 = writer.prefix("SecondaryInterface");
if let Some(var_94) = &input.secondary_interfaces {
if !var_94.is_empty() {
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();
crate::protocol_serde::shape_instance_secondary_interface_specification_request::ser_instance_secondary_interface_specification_request(entry_97, item_95)?;
}
list_96.finish();
}
}
#[allow(unused_mut)]
let mut scope_98 = writer.prefix("DryRun");
if let Some(var_99) = &input.dry_run {
scope_98.boolean(*var_99);
}
#[allow(unused_mut)]
let mut scope_100 = writer.prefix("DisableApiTermination");
if let Some(var_101) = &input.disable_api_termination {
scope_100.boolean(*var_101);
}
#[allow(unused_mut)]
let mut scope_102 = writer.prefix("InstanceInitiatedShutdownBehavior");
if let Some(var_103) = &input.instance_initiated_shutdown_behavior {
scope_102.string(var_103.as_str());
}
#[allow(unused_mut)]
let mut scope_104 = writer.prefix("PrivateIpAddress");
if let Some(var_105) = &input.private_ip_address {
scope_104.string(var_105);
}
#[allow(unused_mut)]
let mut scope_106 = writer.prefix("ClientToken");
if let Some(var_107) = &input.client_token {
scope_106.string(var_107);
}
#[allow(unused_mut)]
let mut scope_108 = writer.prefix("AdditionalInfo");
if let Some(var_109) = &input.additional_info {
scope_108.string(var_109);
}
#[allow(unused_mut)]
let mut scope_110 = writer.prefix("NetworkInterface");
if let Some(var_111) = &input.network_interfaces {
if !var_111.is_empty() {
let mut list_113 = scope_110.start_list(true, Some("item"));
for item_112 in var_111 {
#[allow(unused_mut)]
let mut entry_114 = list_113.entry();
crate::protocol_serde::shape_instance_network_interface_specification::ser_instance_network_interface_specification(
entry_114, item_112,
)?;
}
list_113.finish();
}
}
#[allow(unused_mut)]
let mut scope_115 = writer.prefix("IamInstanceProfile");
if let Some(var_116) = &input.iam_instance_profile {
crate::protocol_serde::shape_iam_instance_profile_specification::ser_iam_instance_profile_specification(scope_115, var_116)?;
}
#[allow(unused_mut)]
let mut scope_117 = writer.prefix("EbsOptimized");
if let Some(var_118) = &input.ebs_optimized {
scope_117.boolean(*var_118);
}
writer.finish();
Ok(::aws_smithy_types::body::SdkBody::from(out))
}