pub fn serialize_operation_crate_operation_accept_address_transfer(
input: &crate::input::AcceptAddressTransferInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AcceptAddressTransfer", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("Address");
if let Some(var_2) = &input.address {
scope_1.string(var_2);
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("TagSpecification");
if let Some(var_4) = &input.tag_specifications {
let mut list_6 = scope_3.start_list(true, Some("item"));
for item_5 in var_4 {
#[allow(unused_mut)]
let mut entry_7 = list_6.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(entry_7, item_5)?;
}
list_6.finish();
}
#[allow(unused_mut)]
let mut scope_8 = writer.prefix("DryRun");
if let Some(var_9) = &input.dry_run {
scope_8.boolean(*var_9);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_accept_reserved_instances_exchange_quote(
input: &crate::input::AcceptReservedInstancesExchangeQuoteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AcceptReservedInstancesExchangeQuote",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_10 = writer.prefix("DryRun");
if let Some(var_11) = &input.dry_run {
scope_10.boolean(*var_11);
}
#[allow(unused_mut)]
let mut scope_12 = writer.prefix("ReservedInstanceId");
if let Some(var_13) = &input.reserved_instance_ids {
let mut list_15 = scope_12.start_list(true, Some("ReservedInstanceId"));
for item_14 in var_13 {
#[allow(unused_mut)]
let mut entry_16 = list_15.entry();
entry_16.string(item_14);
}
list_15.finish();
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("TargetConfiguration");
if let Some(var_18) = &input.target_configurations {
let mut list_20 = scope_17.start_list(true, Some("TargetConfigurationRequest"));
for item_19 in var_18 {
#[allow(unused_mut)]
let mut entry_21 = list_20.entry();
crate::query_ser::serialize_structure_crate_model_target_configuration_request(
entry_21, item_19,
)?;
}
list_20.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_accept_transit_gateway_multicast_domain_associations(
input: &crate::input::AcceptTransitGatewayMulticastDomainAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AcceptTransitGatewayMulticastDomainAssociations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_22 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_23) = &input.transit_gateway_multicast_domain_id {
scope_22.string(var_23);
}
#[allow(unused_mut)]
let mut scope_24 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_25) = &input.transit_gateway_attachment_id {
scope_24.string(var_25);
}
#[allow(unused_mut)]
let mut scope_26 = writer.prefix("SubnetIds");
if let Some(var_27) = &input.subnet_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)]
let mut scope_31 = writer.prefix("DryRun");
if let Some(var_32) = &input.dry_run {
scope_31.boolean(*var_32);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_accept_transit_gateway_peering_attachment(
input: &crate::input::AcceptTransitGatewayPeeringAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AcceptTransitGatewayPeeringAttachment",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_34) = &input.transit_gateway_attachment_id {
scope_33.string(var_34);
}
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("DryRun");
if let Some(var_36) = &input.dry_run {
scope_35.boolean(*var_36);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_accept_transit_gateway_vpc_attachment(
input: &crate::input::AcceptTransitGatewayVpcAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AcceptTransitGatewayVpcAttachment",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_37 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_38) = &input.transit_gateway_attachment_id {
scope_37.string(var_38);
}
#[allow(unused_mut)]
let mut scope_39 = writer.prefix("DryRun");
if let Some(var_40) = &input.dry_run {
scope_39.boolean(*var_40);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_accept_vpc_endpoint_connections(
input: &crate::input::AcceptVpcEndpointConnectionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AcceptVpcEndpointConnections", "2016-11-15");
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("DryRun");
if let Some(var_42) = &input.dry_run {
scope_41.boolean(*var_42);
}
#[allow(unused_mut)]
let mut scope_43 = writer.prefix("ServiceId");
if let Some(var_44) = &input.service_id {
scope_43.string(var_44);
}
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("VpcEndpointId");
if let Some(var_46) = &input.vpc_endpoint_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();
entry_49.string(item_47);
}
list_48.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_accept_vpc_peering_connection(
input: &crate::input::AcceptVpcPeeringConnectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AcceptVpcPeeringConnection", "2016-11-15");
#[allow(unused_mut)]
let mut scope_50 = writer.prefix("DryRun");
if let Some(var_51) = &input.dry_run {
scope_50.boolean(*var_51);
}
#[allow(unused_mut)]
let mut scope_52 = writer.prefix("VpcPeeringConnectionId");
if let Some(var_53) = &input.vpc_peering_connection_id {
scope_52.string(var_53);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_advertise_byoip_cidr(
input: &crate::input::AdvertiseByoipCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AdvertiseByoipCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_54 = writer.prefix("Cidr");
if let Some(var_55) = &input.cidr {
scope_54.string(var_55);
}
#[allow(unused_mut)]
let mut scope_56 = writer.prefix("DryRun");
if let Some(var_57) = &input.dry_run {
scope_56.boolean(*var_57);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_allocate_address(
input: &crate::input::AllocateAddressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AllocateAddress", "2016-11-15");
#[allow(unused_mut)]
let mut scope_58 = writer.prefix("Domain");
if let Some(var_59) = &input.domain {
scope_58.string(var_59.as_str());
}
#[allow(unused_mut)]
let mut scope_60 = writer.prefix("Address");
if let Some(var_61) = &input.address {
scope_60.string(var_61);
}
#[allow(unused_mut)]
let mut scope_62 = writer.prefix("PublicIpv4Pool");
if let Some(var_63) = &input.public_ipv4_pool {
scope_62.string(var_63);
}
#[allow(unused_mut)]
let mut scope_64 = writer.prefix("NetworkBorderGroup");
if let Some(var_65) = &input.network_border_group {
scope_64.string(var_65);
}
#[allow(unused_mut)]
let mut scope_66 = writer.prefix("CustomerOwnedIpv4Pool");
if let Some(var_67) = &input.customer_owned_ipv4_pool {
scope_66.string(var_67);
}
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("DryRun");
if let Some(var_69) = &input.dry_run {
scope_68.boolean(*var_69);
}
#[allow(unused_mut)]
let mut scope_70 = writer.prefix("TagSpecification");
if let Some(var_71) = &input.tag_specifications {
let mut list_73 = scope_70.start_list(true, Some("item"));
for item_72 in var_71 {
#[allow(unused_mut)]
let mut entry_74 = list_73.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(entry_74, item_72)?;
}
list_73.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_allocate_hosts(
input: &crate::input::AllocateHostsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AllocateHosts", "2016-11-15");
#[allow(unused_mut)]
let mut scope_75 = writer.prefix("AutoPlacement");
if let Some(var_76) = &input.auto_placement {
scope_75.string(var_76.as_str());
}
#[allow(unused_mut)]
let mut scope_77 = writer.prefix("AvailabilityZone");
if let Some(var_78) = &input.availability_zone {
scope_77.string(var_78);
}
#[allow(unused_mut)]
let mut scope_79 = writer.prefix("ClientToken");
if let Some(var_80) = &input.client_token {
scope_79.string(var_80);
}
#[allow(unused_mut)]
let mut scope_81 = writer.prefix("InstanceType");
if let Some(var_82) = &input.instance_type {
scope_81.string(var_82);
}
#[allow(unused_mut)]
let mut scope_83 = writer.prefix("InstanceFamily");
if let Some(var_84) = &input.instance_family {
scope_83.string(var_84);
}
#[allow(unused_mut)]
let mut scope_85 = writer.prefix("Quantity");
if let Some(var_86) = &input.quantity {
scope_85.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_86).into()),
);
}
#[allow(unused_mut)]
let mut scope_87 = writer.prefix("TagSpecification");
if let Some(var_88) = &input.tag_specifications {
let mut list_90 = scope_87.start_list(true, Some("item"));
for item_89 in var_88 {
#[allow(unused_mut)]
let mut entry_91 = list_90.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(entry_91, item_89)?;
}
list_90.finish();
}
#[allow(unused_mut)]
let mut scope_92 = writer.prefix("HostRecovery");
if let Some(var_93) = &input.host_recovery {
scope_92.string(var_93.as_str());
}
#[allow(unused_mut)]
let mut scope_94 = writer.prefix("OutpostArn");
if let Some(var_95) = &input.outpost_arn {
scope_94.string(var_95);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_allocate_ipam_pool_cidr(
input: &crate::input::AllocateIpamPoolCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AllocateIpamPoolCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_96 = writer.prefix("DryRun");
if let Some(var_97) = &input.dry_run {
scope_96.boolean(*var_97);
}
#[allow(unused_mut)]
let mut scope_98 = writer.prefix("IpamPoolId");
if let Some(var_99) = &input.ipam_pool_id {
scope_98.string(var_99);
}
#[allow(unused_mut)]
let mut scope_100 = writer.prefix("Cidr");
if let Some(var_101) = &input.cidr {
scope_100.string(var_101);
}
#[allow(unused_mut)]
let mut scope_102 = writer.prefix("NetmaskLength");
if let Some(var_103) = &input.netmask_length {
scope_102.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_103).into()),
);
}
#[allow(unused_mut)]
let mut scope_104 = writer.prefix("ClientToken");
if let Some(var_105) = &input.client_token {
scope_104.string(var_105);
}
#[allow(unused_mut)]
let mut scope_106 = writer.prefix("Description");
if let Some(var_107) = &input.description {
scope_106.string(var_107);
}
#[allow(unused_mut)]
let mut scope_108 = writer.prefix("PreviewNextCidr");
if let Some(var_109) = &input.preview_next_cidr {
scope_108.boolean(*var_109);
}
#[allow(unused_mut)]
let mut scope_110 = writer.prefix("DisallowedCidr");
if let Some(var_111) = &input.disallowed_cidrs {
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();
entry_114.string(item_112);
}
list_113.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_apply_security_groups_to_client_vpn_target_network(
input: &crate::input::ApplySecurityGroupsToClientVpnTargetNetworkInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ApplySecurityGroupsToClientVpnTargetNetwork",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_115 = writer.prefix("ClientVpnEndpointId");
if let Some(var_116) = &input.client_vpn_endpoint_id {
scope_115.string(var_116);
}
#[allow(unused_mut)]
let mut scope_117 = writer.prefix("VpcId");
if let Some(var_118) = &input.vpc_id {
scope_117.string(var_118);
}
#[allow(unused_mut)]
let mut scope_119 = writer.prefix("SecurityGroupId");
if let Some(var_120) = &input.security_group_ids {
let mut list_122 = scope_119.start_list(true, Some("item"));
for item_121 in var_120 {
#[allow(unused_mut)]
let mut entry_123 = list_122.entry();
entry_123.string(item_121);
}
list_122.finish();
}
#[allow(unused_mut)]
let mut scope_124 = writer.prefix("DryRun");
if let Some(var_125) = &input.dry_run {
scope_124.boolean(*var_125);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_assign_ipv6_addresses(
input: &crate::input::AssignIpv6AddressesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AssignIpv6Addresses", "2016-11-15");
#[allow(unused_mut)]
let mut scope_126 = writer.prefix("Ipv6AddressCount");
if let Some(var_127) = &input.ipv6_address_count {
scope_126.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_127).into()),
);
}
#[allow(unused_mut)]
let mut scope_128 = writer.prefix("Ipv6Addresses");
if let Some(var_129) = &input.ipv6_addresses {
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();
entry_132.string(item_130);
}
list_131.finish();
}
#[allow(unused_mut)]
let mut scope_133 = writer.prefix("Ipv6PrefixCount");
if let Some(var_134) = &input.ipv6_prefix_count {
scope_133.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_134).into()),
);
}
#[allow(unused_mut)]
let mut scope_135 = writer.prefix("Ipv6Prefix");
if let Some(var_136) = &input.ipv6_prefixes {
let mut list_138 = scope_135.start_list(true, Some("item"));
for item_137 in var_136 {
#[allow(unused_mut)]
let mut entry_139 = list_138.entry();
entry_139.string(item_137);
}
list_138.finish();
}
#[allow(unused_mut)]
let mut scope_140 = writer.prefix("NetworkInterfaceId");
if let Some(var_141) = &input.network_interface_id {
scope_140.string(var_141);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_assign_private_ip_addresses(
input: &crate::input::AssignPrivateIpAddressesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AssignPrivateIpAddresses", "2016-11-15");
#[allow(unused_mut)]
let mut scope_142 = writer.prefix("AllowReassignment");
if let Some(var_143) = &input.allow_reassignment {
scope_142.boolean(*var_143);
}
#[allow(unused_mut)]
let mut scope_144 = writer.prefix("NetworkInterfaceId");
if let Some(var_145) = &input.network_interface_id {
scope_144.string(var_145);
}
#[allow(unused_mut)]
let mut scope_146 = writer.prefix("PrivateIpAddress");
if let Some(var_147) = &input.private_ip_addresses {
let mut list_149 = scope_146.start_list(true, Some("PrivateIpAddress"));
for item_148 in var_147 {
#[allow(unused_mut)]
let mut entry_150 = list_149.entry();
entry_150.string(item_148);
}
list_149.finish();
}
#[allow(unused_mut)]
let mut scope_151 = writer.prefix("SecondaryPrivateIpAddressCount");
if let Some(var_152) = &input.secondary_private_ip_address_count {
scope_151.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_152).into()),
);
}
#[allow(unused_mut)]
let mut scope_153 = writer.prefix("Ipv4Prefix");
if let Some(var_154) = &input.ipv4_prefixes {
let mut list_156 = scope_153.start_list(true, Some("item"));
for item_155 in var_154 {
#[allow(unused_mut)]
let mut entry_157 = list_156.entry();
entry_157.string(item_155);
}
list_156.finish();
}
#[allow(unused_mut)]
let mut scope_158 = writer.prefix("Ipv4PrefixCount");
if let Some(var_159) = &input.ipv4_prefix_count {
scope_158.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_159).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_address(
input: &crate::input::AssociateAddressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AssociateAddress", "2016-11-15");
#[allow(unused_mut)]
let mut scope_160 = writer.prefix("AllocationId");
if let Some(var_161) = &input.allocation_id {
scope_160.string(var_161);
}
#[allow(unused_mut)]
let mut scope_162 = writer.prefix("InstanceId");
if let Some(var_163) = &input.instance_id {
scope_162.string(var_163);
}
#[allow(unused_mut)]
let mut scope_164 = writer.prefix("PublicIp");
if let Some(var_165) = &input.public_ip {
scope_164.string(var_165);
}
#[allow(unused_mut)]
let mut scope_166 = writer.prefix("AllowReassociation");
if let Some(var_167) = &input.allow_reassociation {
scope_166.boolean(*var_167);
}
#[allow(unused_mut)]
let mut scope_168 = writer.prefix("DryRun");
if let Some(var_169) = &input.dry_run {
scope_168.boolean(*var_169);
}
#[allow(unused_mut)]
let mut scope_170 = writer.prefix("NetworkInterfaceId");
if let Some(var_171) = &input.network_interface_id {
scope_170.string(var_171);
}
#[allow(unused_mut)]
let mut scope_172 = writer.prefix("PrivateIpAddress");
if let Some(var_173) = &input.private_ip_address {
scope_172.string(var_173);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_client_vpn_target_network(
input: &crate::input::AssociateClientVpnTargetNetworkInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AssociateClientVpnTargetNetwork",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_174 = writer.prefix("ClientVpnEndpointId");
if let Some(var_175) = &input.client_vpn_endpoint_id {
scope_174.string(var_175);
}
#[allow(unused_mut)]
let mut scope_176 = writer.prefix("SubnetId");
if let Some(var_177) = &input.subnet_id {
scope_176.string(var_177);
}
#[allow(unused_mut)]
let mut scope_178 = writer.prefix("ClientToken");
if let Some(var_179) = &input.client_token {
scope_178.string(var_179);
}
#[allow(unused_mut)]
let mut scope_180 = writer.prefix("DryRun");
if let Some(var_181) = &input.dry_run {
scope_180.boolean(*var_181);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_dhcp_options(
input: &crate::input::AssociateDhcpOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AssociateDhcpOptions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_182 = writer.prefix("DhcpOptionsId");
if let Some(var_183) = &input.dhcp_options_id {
scope_182.string(var_183);
}
#[allow(unused_mut)]
let mut scope_184 = writer.prefix("VpcId");
if let Some(var_185) = &input.vpc_id {
scope_184.string(var_185);
}
#[allow(unused_mut)]
let mut scope_186 = writer.prefix("DryRun");
if let Some(var_187) = &input.dry_run {
scope_186.boolean(*var_187);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_enclave_certificate_iam_role(
input: &crate::input::AssociateEnclaveCertificateIamRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AssociateEnclaveCertificateIamRole",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_188 = writer.prefix("CertificateArn");
if let Some(var_189) = &input.certificate_arn {
scope_188.string(var_189);
}
#[allow(unused_mut)]
let mut scope_190 = writer.prefix("RoleArn");
if let Some(var_191) = &input.role_arn {
scope_190.string(var_191);
}
#[allow(unused_mut)]
let mut scope_192 = writer.prefix("DryRun");
if let Some(var_193) = &input.dry_run {
scope_192.boolean(*var_193);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_iam_instance_profile(
input: &crate::input::AssociateIamInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AssociateIamInstanceProfile", "2016-11-15");
#[allow(unused_mut)]
let mut scope_194 = writer.prefix("IamInstanceProfile");
if let Some(var_195) = &input.iam_instance_profile {
crate::query_ser::serialize_structure_crate_model_iam_instance_profile_specification(
scope_194, var_195,
)?;
}
#[allow(unused_mut)]
let mut scope_196 = writer.prefix("InstanceId");
if let Some(var_197) = &input.instance_id {
scope_196.string(var_197);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_instance_event_window(
input: &crate::input::AssociateInstanceEventWindowInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AssociateInstanceEventWindow", "2016-11-15");
#[allow(unused_mut)]
let mut scope_198 = writer.prefix("DryRun");
if let Some(var_199) = &input.dry_run {
scope_198.boolean(*var_199);
}
#[allow(unused_mut)]
let mut scope_200 = writer.prefix("InstanceEventWindowId");
if let Some(var_201) = &input.instance_event_window_id {
scope_200.string(var_201);
}
#[allow(unused_mut)]
let mut scope_202 = writer.prefix("AssociationTarget");
if let Some(var_203) = &input.association_target {
crate::query_ser::serialize_structure_crate_model_instance_event_window_association_request(scope_202, var_203)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_route_table(
input: &crate::input::AssociateRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AssociateRouteTable", "2016-11-15");
#[allow(unused_mut)]
let mut scope_204 = writer.prefix("DryRun");
if let Some(var_205) = &input.dry_run {
scope_204.boolean(*var_205);
}
#[allow(unused_mut)]
let mut scope_206 = writer.prefix("RouteTableId");
if let Some(var_207) = &input.route_table_id {
scope_206.string(var_207);
}
#[allow(unused_mut)]
let mut scope_208 = writer.prefix("SubnetId");
if let Some(var_209) = &input.subnet_id {
scope_208.string(var_209);
}
#[allow(unused_mut)]
let mut scope_210 = writer.prefix("GatewayId");
if let Some(var_211) = &input.gateway_id {
scope_210.string(var_211);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_subnet_cidr_block(
input: &crate::input::AssociateSubnetCidrBlockInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AssociateSubnetCidrBlock", "2016-11-15");
#[allow(unused_mut)]
let mut scope_212 = writer.prefix("Ipv6CidrBlock");
if let Some(var_213) = &input.ipv6_cidr_block {
scope_212.string(var_213);
}
#[allow(unused_mut)]
let mut scope_214 = writer.prefix("SubnetId");
if let Some(var_215) = &input.subnet_id {
scope_214.string(var_215);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_transit_gateway_multicast_domain(
input: &crate::input::AssociateTransitGatewayMulticastDomainInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AssociateTransitGatewayMulticastDomain",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_216 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_217) = &input.transit_gateway_multicast_domain_id {
scope_216.string(var_217);
}
#[allow(unused_mut)]
let mut scope_218 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_219) = &input.transit_gateway_attachment_id {
scope_218.string(var_219);
}
#[allow(unused_mut)]
let mut scope_220 = writer.prefix("SubnetIds");
if let Some(var_221) = &input.subnet_ids {
let mut list_223 = scope_220.start_list(true, Some("item"));
for item_222 in var_221 {
#[allow(unused_mut)]
let mut entry_224 = list_223.entry();
entry_224.string(item_222);
}
list_223.finish();
}
#[allow(unused_mut)]
let mut scope_225 = writer.prefix("DryRun");
if let Some(var_226) = &input.dry_run {
scope_225.boolean(*var_226);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_transit_gateway_policy_table(
input: &crate::input::AssociateTransitGatewayPolicyTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AssociateTransitGatewayPolicyTable",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_227 = writer.prefix("TransitGatewayPolicyTableId");
if let Some(var_228) = &input.transit_gateway_policy_table_id {
scope_227.string(var_228);
}
#[allow(unused_mut)]
let mut scope_229 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_230) = &input.transit_gateway_attachment_id {
scope_229.string(var_230);
}
#[allow(unused_mut)]
let mut scope_231 = writer.prefix("DryRun");
if let Some(var_232) = &input.dry_run {
scope_231.boolean(*var_232);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_transit_gateway_route_table(
input: &crate::input::AssociateTransitGatewayRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AssociateTransitGatewayRouteTable",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_233 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_234) = &input.transit_gateway_route_table_id {
scope_233.string(var_234);
}
#[allow(unused_mut)]
let mut scope_235 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_236) = &input.transit_gateway_attachment_id {
scope_235.string(var_236);
}
#[allow(unused_mut)]
let mut scope_237 = writer.prefix("DryRun");
if let Some(var_238) = &input.dry_run {
scope_237.boolean(*var_238);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_trunk_interface(
input: &crate::input::AssociateTrunkInterfaceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AssociateTrunkInterface", "2016-11-15");
#[allow(unused_mut)]
let mut scope_239 = writer.prefix("BranchInterfaceId");
if let Some(var_240) = &input.branch_interface_id {
scope_239.string(var_240);
}
#[allow(unused_mut)]
let mut scope_241 = writer.prefix("TrunkInterfaceId");
if let Some(var_242) = &input.trunk_interface_id {
scope_241.string(var_242);
}
#[allow(unused_mut)]
let mut scope_243 = writer.prefix("VlanId");
if let Some(var_244) = &input.vlan_id {
scope_243.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_244).into()),
);
}
#[allow(unused_mut)]
let mut scope_245 = writer.prefix("GreKey");
if let Some(var_246) = &input.gre_key {
scope_245.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_246).into()),
);
}
#[allow(unused_mut)]
let mut scope_247 = writer.prefix("ClientToken");
if let Some(var_248) = &input.client_token {
scope_247.string(var_248);
}
#[allow(unused_mut)]
let mut scope_249 = writer.prefix("DryRun");
if let Some(var_250) = &input.dry_run {
scope_249.boolean(*var_250);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_vpc_cidr_block(
input: &crate::input::AssociateVpcCidrBlockInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AssociateVpcCidrBlock", "2016-11-15");
#[allow(unused_mut)]
let mut scope_251 = writer.prefix("AmazonProvidedIpv6CidrBlock");
if let Some(var_252) = &input.amazon_provided_ipv6_cidr_block {
scope_251.boolean(*var_252);
}
#[allow(unused_mut)]
let mut scope_253 = writer.prefix("CidrBlock");
if let Some(var_254) = &input.cidr_block {
scope_253.string(var_254);
}
#[allow(unused_mut)]
let mut scope_255 = writer.prefix("VpcId");
if let Some(var_256) = &input.vpc_id {
scope_255.string(var_256);
}
#[allow(unused_mut)]
let mut scope_257 = writer.prefix("Ipv6CidrBlockNetworkBorderGroup");
if let Some(var_258) = &input.ipv6_cidr_block_network_border_group {
scope_257.string(var_258);
}
#[allow(unused_mut)]
let mut scope_259 = writer.prefix("Ipv6Pool");
if let Some(var_260) = &input.ipv6_pool {
scope_259.string(var_260);
}
#[allow(unused_mut)]
let mut scope_261 = writer.prefix("Ipv6CidrBlock");
if let Some(var_262) = &input.ipv6_cidr_block {
scope_261.string(var_262);
}
#[allow(unused_mut)]
let mut scope_263 = writer.prefix("Ipv4IpamPoolId");
if let Some(var_264) = &input.ipv4_ipam_pool_id {
scope_263.string(var_264);
}
#[allow(unused_mut)]
let mut scope_265 = writer.prefix("Ipv4NetmaskLength");
if let Some(var_266) = &input.ipv4_netmask_length {
scope_265.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_266).into()),
);
}
#[allow(unused_mut)]
let mut scope_267 = writer.prefix("Ipv6IpamPoolId");
if let Some(var_268) = &input.ipv6_ipam_pool_id {
scope_267.string(var_268);
}
#[allow(unused_mut)]
let mut scope_269 = writer.prefix("Ipv6NetmaskLength");
if let Some(var_270) = &input.ipv6_netmask_length {
scope_269.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_270).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_classic_link_vpc(
input: &crate::input::AttachClassicLinkVpcInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AttachClassicLinkVpc", "2016-11-15");
#[allow(unused_mut)]
let mut scope_271 = writer.prefix("DryRun");
if let Some(var_272) = &input.dry_run {
scope_271.boolean(*var_272);
}
#[allow(unused_mut)]
let mut scope_273 = writer.prefix("SecurityGroupId");
if let Some(var_274) = &input.groups {
let mut list_276 = scope_273.start_list(true, Some("groupId"));
for item_275 in var_274 {
#[allow(unused_mut)]
let mut entry_277 = list_276.entry();
entry_277.string(item_275);
}
list_276.finish();
}
#[allow(unused_mut)]
let mut scope_278 = writer.prefix("InstanceId");
if let Some(var_279) = &input.instance_id {
scope_278.string(var_279);
}
#[allow(unused_mut)]
let mut scope_280 = writer.prefix("VpcId");
if let Some(var_281) = &input.vpc_id {
scope_280.string(var_281);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_internet_gateway(
input: &crate::input::AttachInternetGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AttachInternetGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_282 = writer.prefix("DryRun");
if let Some(var_283) = &input.dry_run {
scope_282.boolean(*var_283);
}
#[allow(unused_mut)]
let mut scope_284 = writer.prefix("InternetGatewayId");
if let Some(var_285) = &input.internet_gateway_id {
scope_284.string(var_285);
}
#[allow(unused_mut)]
let mut scope_286 = writer.prefix("VpcId");
if let Some(var_287) = &input.vpc_id {
scope_286.string(var_287);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_network_interface(
input: &crate::input::AttachNetworkInterfaceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AttachNetworkInterface", "2016-11-15");
#[allow(unused_mut)]
let mut scope_288 = writer.prefix("DeviceIndex");
if let Some(var_289) = &input.device_index {
scope_288.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_289).into()),
);
}
#[allow(unused_mut)]
let mut scope_290 = writer.prefix("DryRun");
if let Some(var_291) = &input.dry_run {
scope_290.boolean(*var_291);
}
#[allow(unused_mut)]
let mut scope_292 = writer.prefix("InstanceId");
if let Some(var_293) = &input.instance_id {
scope_292.string(var_293);
}
#[allow(unused_mut)]
let mut scope_294 = writer.prefix("NetworkInterfaceId");
if let Some(var_295) = &input.network_interface_id {
scope_294.string(var_295);
}
#[allow(unused_mut)]
let mut scope_296 = writer.prefix("NetworkCardIndex");
if let Some(var_297) = &input.network_card_index {
scope_296.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_297).into()),
);
}
#[allow(unused_mut)]
let mut scope_298 = writer.prefix("EnaSrdSpecification");
if let Some(var_299) = &input.ena_srd_specification {
crate::query_ser::serialize_structure_crate_model_ena_srd_specification(
scope_298, var_299,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_verified_access_trust_provider(
input: &crate::input::AttachVerifiedAccessTrustProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AttachVerifiedAccessTrustProvider",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_300 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_301) = &input.verified_access_instance_id {
scope_300.string(var_301);
}
#[allow(unused_mut)]
let mut scope_302 = writer.prefix("VerifiedAccessTrustProviderId");
if let Some(var_303) = &input.verified_access_trust_provider_id {
scope_302.string(var_303);
}
#[allow(unused_mut)]
let mut scope_304 = writer.prefix("ClientToken");
if let Some(var_305) = &input.client_token {
scope_304.string(var_305);
}
#[allow(unused_mut)]
let mut scope_306 = writer.prefix("DryRun");
if let Some(var_307) = &input.dry_run {
scope_306.boolean(*var_307);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_volume(
input: &crate::input::AttachVolumeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AttachVolume", "2016-11-15");
#[allow(unused_mut)]
let mut scope_308 = writer.prefix("Device");
if let Some(var_309) = &input.device {
scope_308.string(var_309);
}
#[allow(unused_mut)]
let mut scope_310 = writer.prefix("InstanceId");
if let Some(var_311) = &input.instance_id {
scope_310.string(var_311);
}
#[allow(unused_mut)]
let mut scope_312 = writer.prefix("VolumeId");
if let Some(var_313) = &input.volume_id {
scope_312.string(var_313);
}
#[allow(unused_mut)]
let mut scope_314 = writer.prefix("DryRun");
if let Some(var_315) = &input.dry_run {
scope_314.boolean(*var_315);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_vpn_gateway(
input: &crate::input::AttachVpnGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AttachVpnGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_316 = writer.prefix("VpcId");
if let Some(var_317) = &input.vpc_id {
scope_316.string(var_317);
}
#[allow(unused_mut)]
let mut scope_318 = writer.prefix("VpnGatewayId");
if let Some(var_319) = &input.vpn_gateway_id {
scope_318.string(var_319);
}
#[allow(unused_mut)]
let mut scope_320 = writer.prefix("DryRun");
if let Some(var_321) = &input.dry_run {
scope_320.boolean(*var_321);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_authorize_client_vpn_ingress(
input: &crate::input::AuthorizeClientVpnIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AuthorizeClientVpnIngress", "2016-11-15");
#[allow(unused_mut)]
let mut scope_322 = writer.prefix("ClientVpnEndpointId");
if let Some(var_323) = &input.client_vpn_endpoint_id {
scope_322.string(var_323);
}
#[allow(unused_mut)]
let mut scope_324 = writer.prefix("TargetNetworkCidr");
if let Some(var_325) = &input.target_network_cidr {
scope_324.string(var_325);
}
#[allow(unused_mut)]
let mut scope_326 = writer.prefix("AccessGroupId");
if let Some(var_327) = &input.access_group_id {
scope_326.string(var_327);
}
#[allow(unused_mut)]
let mut scope_328 = writer.prefix("AuthorizeAllGroups");
if let Some(var_329) = &input.authorize_all_groups {
scope_328.boolean(*var_329);
}
#[allow(unused_mut)]
let mut scope_330 = writer.prefix("Description");
if let Some(var_331) = &input.description {
scope_330.string(var_331);
}
#[allow(unused_mut)]
let mut scope_332 = writer.prefix("ClientToken");
if let Some(var_333) = &input.client_token {
scope_332.string(var_333);
}
#[allow(unused_mut)]
let mut scope_334 = writer.prefix("DryRun");
if let Some(var_335) = &input.dry_run {
scope_334.boolean(*var_335);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_authorize_security_group_egress(
input: &crate::input::AuthorizeSecurityGroupEgressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AuthorizeSecurityGroupEgress", "2016-11-15");
#[allow(unused_mut)]
let mut scope_336 = writer.prefix("DryRun");
if let Some(var_337) = &input.dry_run {
scope_336.boolean(*var_337);
}
#[allow(unused_mut)]
let mut scope_338 = writer.prefix("GroupId");
if let Some(var_339) = &input.group_id {
scope_338.string(var_339);
}
#[allow(unused_mut)]
let mut scope_340 = writer.prefix("IpPermissions");
if let Some(var_341) = &input.ip_permissions {
let mut list_343 = scope_340.start_list(true, Some("item"));
for item_342 in var_341 {
#[allow(unused_mut)]
let mut entry_344 = list_343.entry();
crate::query_ser::serialize_structure_crate_model_ip_permission(entry_344, item_342)?;
}
list_343.finish();
}
#[allow(unused_mut)]
let mut scope_345 = writer.prefix("TagSpecification");
if let Some(var_346) = &input.tag_specifications {
let mut list_348 = scope_345.start_list(true, Some("item"));
for item_347 in var_346 {
#[allow(unused_mut)]
let mut entry_349 = list_348.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_349, item_347,
)?;
}
list_348.finish();
}
#[allow(unused_mut)]
let mut scope_350 = writer.prefix("CidrIp");
if let Some(var_351) = &input.cidr_ip {
scope_350.string(var_351);
}
#[allow(unused_mut)]
let mut scope_352 = writer.prefix("FromPort");
if let Some(var_353) = &input.from_port {
scope_352.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_353).into()),
);
}
#[allow(unused_mut)]
let mut scope_354 = writer.prefix("IpProtocol");
if let Some(var_355) = &input.ip_protocol {
scope_354.string(var_355);
}
#[allow(unused_mut)]
let mut scope_356 = writer.prefix("ToPort");
if let Some(var_357) = &input.to_port {
scope_356.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_357).into()),
);
}
#[allow(unused_mut)]
let mut scope_358 = writer.prefix("SourceSecurityGroupName");
if let Some(var_359) = &input.source_security_group_name {
scope_358.string(var_359);
}
#[allow(unused_mut)]
let mut scope_360 = writer.prefix("SourceSecurityGroupOwnerId");
if let Some(var_361) = &input.source_security_group_owner_id {
scope_360.string(var_361);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_authorize_security_group_ingress(
input: &crate::input::AuthorizeSecurityGroupIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AuthorizeSecurityGroupIngress", "2016-11-15");
#[allow(unused_mut)]
let mut scope_362 = writer.prefix("CidrIp");
if let Some(var_363) = &input.cidr_ip {
scope_362.string(var_363);
}
#[allow(unused_mut)]
let mut scope_364 = writer.prefix("FromPort");
if let Some(var_365) = &input.from_port {
scope_364.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_365).into()),
);
}
#[allow(unused_mut)]
let mut scope_366 = writer.prefix("GroupId");
if let Some(var_367) = &input.group_id {
scope_366.string(var_367);
}
#[allow(unused_mut)]
let mut scope_368 = writer.prefix("GroupName");
if let Some(var_369) = &input.group_name {
scope_368.string(var_369);
}
#[allow(unused_mut)]
let mut scope_370 = writer.prefix("IpPermissions");
if let Some(var_371) = &input.ip_permissions {
let mut list_373 = scope_370.start_list(true, Some("item"));
for item_372 in var_371 {
#[allow(unused_mut)]
let mut entry_374 = list_373.entry();
crate::query_ser::serialize_structure_crate_model_ip_permission(entry_374, item_372)?;
}
list_373.finish();
}
#[allow(unused_mut)]
let mut scope_375 = writer.prefix("IpProtocol");
if let Some(var_376) = &input.ip_protocol {
scope_375.string(var_376);
}
#[allow(unused_mut)]
let mut scope_377 = writer.prefix("SourceSecurityGroupName");
if let Some(var_378) = &input.source_security_group_name {
scope_377.string(var_378);
}
#[allow(unused_mut)]
let mut scope_379 = writer.prefix("SourceSecurityGroupOwnerId");
if let Some(var_380) = &input.source_security_group_owner_id {
scope_379.string(var_380);
}
#[allow(unused_mut)]
let mut scope_381 = writer.prefix("ToPort");
if let Some(var_382) = &input.to_port {
scope_381.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_382).into()),
);
}
#[allow(unused_mut)]
let mut scope_383 = writer.prefix("DryRun");
if let Some(var_384) = &input.dry_run {
scope_383.boolean(*var_384);
}
#[allow(unused_mut)]
let mut scope_385 = writer.prefix("TagSpecification");
if let Some(var_386) = &input.tag_specifications {
let mut list_388 = scope_385.start_list(true, Some("item"));
for item_387 in var_386 {
#[allow(unused_mut)]
let mut entry_389 = list_388.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_389, item_387,
)?;
}
list_388.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_bundle_instance(
input: &crate::input::BundleInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "BundleInstance", "2016-11-15");
#[allow(unused_mut)]
let mut scope_390 = writer.prefix("InstanceId");
if let Some(var_391) = &input.instance_id {
scope_390.string(var_391);
}
#[allow(unused_mut)]
let mut scope_392 = writer.prefix("Storage");
if let Some(var_393) = &input.storage {
crate::query_ser::serialize_structure_crate_model_storage(scope_392, var_393)?;
}
#[allow(unused_mut)]
let mut scope_394 = writer.prefix("DryRun");
if let Some(var_395) = &input.dry_run {
scope_394.boolean(*var_395);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_bundle_task(
input: &crate::input::CancelBundleTaskInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CancelBundleTask", "2016-11-15");
#[allow(unused_mut)]
let mut scope_396 = writer.prefix("BundleId");
if let Some(var_397) = &input.bundle_id {
scope_396.string(var_397);
}
#[allow(unused_mut)]
let mut scope_398 = writer.prefix("DryRun");
if let Some(var_399) = &input.dry_run {
scope_398.boolean(*var_399);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_capacity_reservation(
input: &crate::input::CancelCapacityReservationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CancelCapacityReservation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_400 = writer.prefix("CapacityReservationId");
if let Some(var_401) = &input.capacity_reservation_id {
scope_400.string(var_401);
}
#[allow(unused_mut)]
let mut scope_402 = writer.prefix("DryRun");
if let Some(var_403) = &input.dry_run {
scope_402.boolean(*var_403);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_capacity_reservation_fleets(
input: &crate::input::CancelCapacityReservationFleetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CancelCapacityReservationFleets",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_404 = writer.prefix("DryRun");
if let Some(var_405) = &input.dry_run {
scope_404.boolean(*var_405);
}
#[allow(unused_mut)]
let mut scope_406 = writer.prefix("CapacityReservationFleetId");
if let Some(var_407) = &input.capacity_reservation_fleet_ids {
let mut list_409 = scope_406.start_list(true, Some("item"));
for item_408 in var_407 {
#[allow(unused_mut)]
let mut entry_410 = list_409.entry();
entry_410.string(item_408);
}
list_409.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_conversion_task(
input: &crate::input::CancelConversionTaskInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CancelConversionTask", "2016-11-15");
#[allow(unused_mut)]
let mut scope_411 = writer.prefix("ConversionTaskId");
if let Some(var_412) = &input.conversion_task_id {
scope_411.string(var_412);
}
#[allow(unused_mut)]
let mut scope_413 = writer.prefix("DryRun");
if let Some(var_414) = &input.dry_run {
scope_413.boolean(*var_414);
}
#[allow(unused_mut)]
let mut scope_415 = writer.prefix("ReasonMessage");
if let Some(var_416) = &input.reason_message {
scope_415.string(var_416);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_export_task(
input: &crate::input::CancelExportTaskInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CancelExportTask", "2016-11-15");
#[allow(unused_mut)]
let mut scope_417 = writer.prefix("ExportTaskId");
if let Some(var_418) = &input.export_task_id {
scope_417.string(var_418);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_image_launch_permission(
input: &crate::input::CancelImageLaunchPermissionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CancelImageLaunchPermission", "2016-11-15");
#[allow(unused_mut)]
let mut scope_419 = writer.prefix("ImageId");
if let Some(var_420) = &input.image_id {
scope_419.string(var_420);
}
#[allow(unused_mut)]
let mut scope_421 = writer.prefix("DryRun");
if let Some(var_422) = &input.dry_run {
scope_421.boolean(*var_422);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_import_task(
input: &crate::input::CancelImportTaskInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CancelImportTask", "2016-11-15");
#[allow(unused_mut)]
let mut scope_423 = writer.prefix("CancelReason");
if let Some(var_424) = &input.cancel_reason {
scope_423.string(var_424);
}
#[allow(unused_mut)]
let mut scope_425 = writer.prefix("DryRun");
if let Some(var_426) = &input.dry_run {
scope_425.boolean(*var_426);
}
#[allow(unused_mut)]
let mut scope_427 = writer.prefix("ImportTaskId");
if let Some(var_428) = &input.import_task_id {
scope_427.string(var_428);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_reserved_instances_listing(
input: &crate::input::CancelReservedInstancesListingInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CancelReservedInstancesListing",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_429 = writer.prefix("ReservedInstancesListingId");
if let Some(var_430) = &input.reserved_instances_listing_id {
scope_429.string(var_430);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_spot_fleet_requests(
input: &crate::input::CancelSpotFleetRequestsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CancelSpotFleetRequests", "2016-11-15");
#[allow(unused_mut)]
let mut scope_431 = writer.prefix("DryRun");
if let Some(var_432) = &input.dry_run {
scope_431.boolean(*var_432);
}
#[allow(unused_mut)]
let mut scope_433 = writer.prefix("SpotFleetRequestId");
if let Some(var_434) = &input.spot_fleet_request_ids {
let mut list_436 = scope_433.start_list(true, Some("item"));
for item_435 in var_434 {
#[allow(unused_mut)]
let mut entry_437 = list_436.entry();
entry_437.string(item_435);
}
list_436.finish();
}
#[allow(unused_mut)]
let mut scope_438 = writer.prefix("TerminateInstances");
if let Some(var_439) = &input.terminate_instances {
scope_438.boolean(*var_439);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_spot_instance_requests(
input: &crate::input::CancelSpotInstanceRequestsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CancelSpotInstanceRequests", "2016-11-15");
#[allow(unused_mut)]
let mut scope_440 = writer.prefix("DryRun");
if let Some(var_441) = &input.dry_run {
scope_440.boolean(*var_441);
}
#[allow(unused_mut)]
let mut scope_442 = writer.prefix("SpotInstanceRequestId");
if let Some(var_443) = &input.spot_instance_request_ids {
let mut list_445 = scope_442.start_list(true, Some("SpotInstanceRequestId"));
for item_444 in var_443 {
#[allow(unused_mut)]
let mut entry_446 = list_445.entry();
entry_446.string(item_444);
}
list_445.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_confirm_product_instance(
input: &crate::input::ConfirmProductInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ConfirmProductInstance", "2016-11-15");
#[allow(unused_mut)]
let mut scope_447 = writer.prefix("InstanceId");
if let Some(var_448) = &input.instance_id {
scope_447.string(var_448);
}
#[allow(unused_mut)]
let mut scope_449 = writer.prefix("ProductCode");
if let Some(var_450) = &input.product_code {
scope_449.string(var_450);
}
#[allow(unused_mut)]
let mut scope_451 = writer.prefix("DryRun");
if let Some(var_452) = &input.dry_run {
scope_451.boolean(*var_452);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_copy_fpga_image(
input: &crate::input::CopyFpgaImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CopyFpgaImage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_453 = writer.prefix("DryRun");
if let Some(var_454) = &input.dry_run {
scope_453.boolean(*var_454);
}
#[allow(unused_mut)]
let mut scope_455 = writer.prefix("SourceFpgaImageId");
if let Some(var_456) = &input.source_fpga_image_id {
scope_455.string(var_456);
}
#[allow(unused_mut)]
let mut scope_457 = writer.prefix("Description");
if let Some(var_458) = &input.description {
scope_457.string(var_458);
}
#[allow(unused_mut)]
let mut scope_459 = writer.prefix("Name");
if let Some(var_460) = &input.name {
scope_459.string(var_460);
}
#[allow(unused_mut)]
let mut scope_461 = writer.prefix("SourceRegion");
if let Some(var_462) = &input.source_region {
scope_461.string(var_462);
}
#[allow(unused_mut)]
let mut scope_463 = writer.prefix("ClientToken");
if let Some(var_464) = &input.client_token {
scope_463.string(var_464);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_copy_image(
input: &crate::input::CopyImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CopyImage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_465 = writer.prefix("ClientToken");
if let Some(var_466) = &input.client_token {
scope_465.string(var_466);
}
#[allow(unused_mut)]
let mut scope_467 = writer.prefix("Description");
if let Some(var_468) = &input.description {
scope_467.string(var_468);
}
#[allow(unused_mut)]
let mut scope_469 = writer.prefix("Encrypted");
if let Some(var_470) = &input.encrypted {
scope_469.boolean(*var_470);
}
#[allow(unused_mut)]
let mut scope_471 = writer.prefix("KmsKeyId");
if let Some(var_472) = &input.kms_key_id {
scope_471.string(var_472);
}
#[allow(unused_mut)]
let mut scope_473 = writer.prefix("Name");
if let Some(var_474) = &input.name {
scope_473.string(var_474);
}
#[allow(unused_mut)]
let mut scope_475 = writer.prefix("SourceImageId");
if let Some(var_476) = &input.source_image_id {
scope_475.string(var_476);
}
#[allow(unused_mut)]
let mut scope_477 = writer.prefix("SourceRegion");
if let Some(var_478) = &input.source_region {
scope_477.string(var_478);
}
#[allow(unused_mut)]
let mut scope_479 = writer.prefix("DestinationOutpostArn");
if let Some(var_480) = &input.destination_outpost_arn {
scope_479.string(var_480);
}
#[allow(unused_mut)]
let mut scope_481 = writer.prefix("DryRun");
if let Some(var_482) = &input.dry_run {
scope_481.boolean(*var_482);
}
#[allow(unused_mut)]
let mut scope_483 = writer.prefix("CopyImageTags");
if let Some(var_484) = &input.copy_image_tags {
scope_483.boolean(*var_484);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_copy_snapshot(
input: &crate::input::CopySnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CopySnapshot", "2016-11-15");
#[allow(unused_mut)]
let mut scope_485 = writer.prefix("Description");
if let Some(var_486) = &input.description {
scope_485.string(var_486);
}
#[allow(unused_mut)]
let mut scope_487 = writer.prefix("DestinationOutpostArn");
if let Some(var_488) = &input.destination_outpost_arn {
scope_487.string(var_488);
}
#[allow(unused_mut)]
let mut scope_489 = writer.prefix("DestinationRegion");
if let Some(var_490) = &input.destination_region {
scope_489.string(var_490);
}
#[allow(unused_mut)]
let mut scope_491 = writer.prefix("Encrypted");
if let Some(var_492) = &input.encrypted {
scope_491.boolean(*var_492);
}
#[allow(unused_mut)]
let mut scope_493 = writer.prefix("KmsKeyId");
if let Some(var_494) = &input.kms_key_id {
scope_493.string(var_494);
}
#[allow(unused_mut)]
let mut scope_495 = writer.prefix("PresignedUrl");
if let Some(var_496) = &input.presigned_url {
scope_495.string(var_496);
}
#[allow(unused_mut)]
let mut scope_497 = writer.prefix("SourceRegion");
if let Some(var_498) = &input.source_region {
scope_497.string(var_498);
}
#[allow(unused_mut)]
let mut scope_499 = writer.prefix("SourceSnapshotId");
if let Some(var_500) = &input.source_snapshot_id {
scope_499.string(var_500);
}
#[allow(unused_mut)]
let mut scope_501 = writer.prefix("TagSpecification");
if let Some(var_502) = &input.tag_specifications {
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_tag_specification(
entry_505, item_503,
)?;
}
list_504.finish();
}
#[allow(unused_mut)]
let mut scope_506 = writer.prefix("DryRun");
if let Some(var_507) = &input.dry_run {
scope_506.boolean(*var_507);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_capacity_reservation(
input: &crate::input::CreateCapacityReservationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateCapacityReservation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_508 = writer.prefix("ClientToken");
if let Some(var_509) = &input.client_token {
scope_508.string(var_509);
}
#[allow(unused_mut)]
let mut scope_510 = writer.prefix("InstanceType");
if let Some(var_511) = &input.instance_type {
scope_510.string(var_511);
}
#[allow(unused_mut)]
let mut scope_512 = writer.prefix("InstancePlatform");
if let Some(var_513) = &input.instance_platform {
scope_512.string(var_513.as_str());
}
#[allow(unused_mut)]
let mut scope_514 = writer.prefix("AvailabilityZone");
if let Some(var_515) = &input.availability_zone {
scope_514.string(var_515);
}
#[allow(unused_mut)]
let mut scope_516 = writer.prefix("AvailabilityZoneId");
if let Some(var_517) = &input.availability_zone_id {
scope_516.string(var_517);
}
#[allow(unused_mut)]
let mut scope_518 = writer.prefix("Tenancy");
if let Some(var_519) = &input.tenancy {
scope_518.string(var_519.as_str());
}
#[allow(unused_mut)]
let mut scope_520 = writer.prefix("InstanceCount");
if let Some(var_521) = &input.instance_count {
scope_520.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_521).into()),
);
}
#[allow(unused_mut)]
let mut scope_522 = writer.prefix("EbsOptimized");
if let Some(var_523) = &input.ebs_optimized {
scope_522.boolean(*var_523);
}
#[allow(unused_mut)]
let mut scope_524 = writer.prefix("EphemeralStorage");
if let Some(var_525) = &input.ephemeral_storage {
scope_524.boolean(*var_525);
}
#[allow(unused_mut)]
let mut scope_526 = writer.prefix("EndDate");
if let Some(var_527) = &input.end_date {
scope_526.date_time(var_527, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_528 = writer.prefix("EndDateType");
if let Some(var_529) = &input.end_date_type {
scope_528.string(var_529.as_str());
}
#[allow(unused_mut)]
let mut scope_530 = writer.prefix("InstanceMatchCriteria");
if let Some(var_531) = &input.instance_match_criteria {
scope_530.string(var_531.as_str());
}
#[allow(unused_mut)]
let mut scope_532 = writer.prefix("TagSpecifications");
if let Some(var_533) = &input.tag_specifications {
let mut list_535 = scope_532.start_list(true, Some("item"));
for item_534 in var_533 {
#[allow(unused_mut)]
let mut entry_536 = list_535.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_536, item_534,
)?;
}
list_535.finish();
}
#[allow(unused_mut)]
let mut scope_537 = writer.prefix("DryRun");
if let Some(var_538) = &input.dry_run {
scope_537.boolean(*var_538);
}
#[allow(unused_mut)]
let mut scope_539 = writer.prefix("OutpostArn");
if let Some(var_540) = &input.outpost_arn {
scope_539.string(var_540);
}
#[allow(unused_mut)]
let mut scope_541 = writer.prefix("PlacementGroupArn");
if let Some(var_542) = &input.placement_group_arn {
scope_541.string(var_542);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_capacity_reservation_fleet(
input: &crate::input::CreateCapacityReservationFleetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateCapacityReservationFleet",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_543 = writer.prefix("AllocationStrategy");
if let Some(var_544) = &input.allocation_strategy {
scope_543.string(var_544);
}
#[allow(unused_mut)]
let mut scope_545 = writer.prefix("ClientToken");
if let Some(var_546) = &input.client_token {
scope_545.string(var_546);
}
#[allow(unused_mut)]
let mut scope_547 = writer.prefix("InstanceTypeSpecification");
if let Some(var_548) = &input.instance_type_specifications {
let mut list_550 = scope_547.start_list(true, None);
for item_549 in var_548 {
#[allow(unused_mut)]
let mut entry_551 = list_550.entry();
crate::query_ser::serialize_structure_crate_model_reservation_fleet_instance_specification(entry_551, item_549)?;
}
list_550.finish();
}
#[allow(unused_mut)]
let mut scope_552 = writer.prefix("Tenancy");
if let Some(var_553) = &input.tenancy {
scope_552.string(var_553.as_str());
}
#[allow(unused_mut)]
let mut scope_554 = writer.prefix("TotalTargetCapacity");
if let Some(var_555) = &input.total_target_capacity {
scope_554.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_555).into()),
);
}
#[allow(unused_mut)]
let mut scope_556 = writer.prefix("EndDate");
if let Some(var_557) = &input.end_date {
scope_556.date_time(var_557, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_558 = writer.prefix("InstanceMatchCriteria");
if let Some(var_559) = &input.instance_match_criteria {
scope_558.string(var_559.as_str());
}
#[allow(unused_mut)]
let mut scope_560 = writer.prefix("TagSpecification");
if let Some(var_561) = &input.tag_specifications {
let mut list_563 = scope_560.start_list(true, Some("item"));
for item_562 in var_561 {
#[allow(unused_mut)]
let mut entry_564 = list_563.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_564, item_562,
)?;
}
list_563.finish();
}
#[allow(unused_mut)]
let mut scope_565 = writer.prefix("DryRun");
if let Some(var_566) = &input.dry_run {
scope_565.boolean(*var_566);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_carrier_gateway(
input: &crate::input::CreateCarrierGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateCarrierGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_567 = writer.prefix("VpcId");
if let Some(var_568) = &input.vpc_id {
scope_567.string(var_568);
}
#[allow(unused_mut)]
let mut scope_569 = writer.prefix("TagSpecification");
if let Some(var_570) = &input.tag_specifications {
let mut list_572 = scope_569.start_list(true, Some("item"));
for item_571 in var_570 {
#[allow(unused_mut)]
let mut entry_573 = list_572.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_573, item_571,
)?;
}
list_572.finish();
}
#[allow(unused_mut)]
let mut scope_574 = writer.prefix("DryRun");
if let Some(var_575) = &input.dry_run {
scope_574.boolean(*var_575);
}
#[allow(unused_mut)]
let mut scope_576 = writer.prefix("ClientToken");
if let Some(var_577) = &input.client_token {
scope_576.string(var_577);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_client_vpn_endpoint(
input: &crate::input::CreateClientVpnEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateClientVpnEndpoint", "2016-11-15");
#[allow(unused_mut)]
let mut scope_578 = writer.prefix("ClientCidrBlock");
if let Some(var_579) = &input.client_cidr_block {
scope_578.string(var_579);
}
#[allow(unused_mut)]
let mut scope_580 = writer.prefix("ServerCertificateArn");
if let Some(var_581) = &input.server_certificate_arn {
scope_580.string(var_581);
}
#[allow(unused_mut)]
let mut scope_582 = writer.prefix("Authentication");
if let Some(var_583) = &input.authentication_options {
let mut list_585 = scope_582.start_list(true, None);
for item_584 in var_583 {
#[allow(unused_mut)]
let mut entry_586 = list_585.entry();
crate::query_ser::serialize_structure_crate_model_client_vpn_authentication_request(
entry_586, item_584,
)?;
}
list_585.finish();
}
#[allow(unused_mut)]
let mut scope_587 = writer.prefix("ConnectionLogOptions");
if let Some(var_588) = &input.connection_log_options {
crate::query_ser::serialize_structure_crate_model_connection_log_options(
scope_587, var_588,
)?;
}
#[allow(unused_mut)]
let mut scope_589 = writer.prefix("DnsServers");
if let Some(var_590) = &input.dns_servers {
let mut list_592 = scope_589.start_list(true, Some("item"));
for item_591 in var_590 {
#[allow(unused_mut)]
let mut entry_593 = list_592.entry();
entry_593.string(item_591);
}
list_592.finish();
}
#[allow(unused_mut)]
let mut scope_594 = writer.prefix("TransportProtocol");
if let Some(var_595) = &input.transport_protocol {
scope_594.string(var_595.as_str());
}
#[allow(unused_mut)]
let mut scope_596 = writer.prefix("VpnPort");
if let Some(var_597) = &input.vpn_port {
scope_596.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_597).into()),
);
}
#[allow(unused_mut)]
let mut scope_598 = writer.prefix("Description");
if let Some(var_599) = &input.description {
scope_598.string(var_599);
}
#[allow(unused_mut)]
let mut scope_600 = writer.prefix("SplitTunnel");
if let Some(var_601) = &input.split_tunnel {
scope_600.boolean(*var_601);
}
#[allow(unused_mut)]
let mut scope_602 = writer.prefix("DryRun");
if let Some(var_603) = &input.dry_run {
scope_602.boolean(*var_603);
}
#[allow(unused_mut)]
let mut scope_604 = writer.prefix("ClientToken");
if let Some(var_605) = &input.client_token {
scope_604.string(var_605);
}
#[allow(unused_mut)]
let mut scope_606 = writer.prefix("TagSpecification");
if let Some(var_607) = &input.tag_specifications {
let mut list_609 = scope_606.start_list(true, Some("item"));
for item_608 in var_607 {
#[allow(unused_mut)]
let mut entry_610 = list_609.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_610, item_608,
)?;
}
list_609.finish();
}
#[allow(unused_mut)]
let mut scope_611 = writer.prefix("SecurityGroupId");
if let Some(var_612) = &input.security_group_ids {
let mut list_614 = scope_611.start_list(true, Some("item"));
for item_613 in var_612 {
#[allow(unused_mut)]
let mut entry_615 = list_614.entry();
entry_615.string(item_613);
}
list_614.finish();
}
#[allow(unused_mut)]
let mut scope_616 = writer.prefix("VpcId");
if let Some(var_617) = &input.vpc_id {
scope_616.string(var_617);
}
#[allow(unused_mut)]
let mut scope_618 = writer.prefix("SelfServicePortal");
if let Some(var_619) = &input.self_service_portal {
scope_618.string(var_619.as_str());
}
#[allow(unused_mut)]
let mut scope_620 = writer.prefix("ClientConnectOptions");
if let Some(var_621) = &input.client_connect_options {
crate::query_ser::serialize_structure_crate_model_client_connect_options(
scope_620, var_621,
)?;
}
#[allow(unused_mut)]
let mut scope_622 = writer.prefix("SessionTimeoutHours");
if let Some(var_623) = &input.session_timeout_hours {
scope_622.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_623).into()),
);
}
#[allow(unused_mut)]
let mut scope_624 = writer.prefix("ClientLoginBannerOptions");
if let Some(var_625) = &input.client_login_banner_options {
crate::query_ser::serialize_structure_crate_model_client_login_banner_options(
scope_624, var_625,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_client_vpn_route(
input: &crate::input::CreateClientVpnRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateClientVpnRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_626 = writer.prefix("ClientVpnEndpointId");
if let Some(var_627) = &input.client_vpn_endpoint_id {
scope_626.string(var_627);
}
#[allow(unused_mut)]
let mut scope_628 = writer.prefix("DestinationCidrBlock");
if let Some(var_629) = &input.destination_cidr_block {
scope_628.string(var_629);
}
#[allow(unused_mut)]
let mut scope_630 = writer.prefix("TargetVpcSubnetId");
if let Some(var_631) = &input.target_vpc_subnet_id {
scope_630.string(var_631);
}
#[allow(unused_mut)]
let mut scope_632 = writer.prefix("Description");
if let Some(var_633) = &input.description {
scope_632.string(var_633);
}
#[allow(unused_mut)]
let mut scope_634 = writer.prefix("ClientToken");
if let Some(var_635) = &input.client_token {
scope_634.string(var_635);
}
#[allow(unused_mut)]
let mut scope_636 = writer.prefix("DryRun");
if let Some(var_637) = &input.dry_run {
scope_636.boolean(*var_637);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_coip_cidr(
input: &crate::input::CreateCoipCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateCoipCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_638 = writer.prefix("Cidr");
if let Some(var_639) = &input.cidr {
scope_638.string(var_639);
}
#[allow(unused_mut)]
let mut scope_640 = writer.prefix("CoipPoolId");
if let Some(var_641) = &input.coip_pool_id {
scope_640.string(var_641);
}
#[allow(unused_mut)]
let mut scope_642 = writer.prefix("DryRun");
if let Some(var_643) = &input.dry_run {
scope_642.boolean(*var_643);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_coip_pool(
input: &crate::input::CreateCoipPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateCoipPool", "2016-11-15");
#[allow(unused_mut)]
let mut scope_644 = writer.prefix("LocalGatewayRouteTableId");
if let Some(var_645) = &input.local_gateway_route_table_id {
scope_644.string(var_645);
}
#[allow(unused_mut)]
let mut scope_646 = writer.prefix("TagSpecification");
if let Some(var_647) = &input.tag_specifications {
let mut list_649 = scope_646.start_list(true, Some("item"));
for item_648 in var_647 {
#[allow(unused_mut)]
let mut entry_650 = list_649.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_650, item_648,
)?;
}
list_649.finish();
}
#[allow(unused_mut)]
let mut scope_651 = writer.prefix("DryRun");
if let Some(var_652) = &input.dry_run {
scope_651.boolean(*var_652);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_customer_gateway(
input: &crate::input::CreateCustomerGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateCustomerGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_653 = writer.prefix("BgpAsn");
if let Some(var_654) = &input.bgp_asn {
scope_653.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_654).into()),
);
}
#[allow(unused_mut)]
let mut scope_655 = writer.prefix("PublicIp");
if let Some(var_656) = &input.public_ip {
scope_655.string(var_656);
}
#[allow(unused_mut)]
let mut scope_657 = writer.prefix("CertificateArn");
if let Some(var_658) = &input.certificate_arn {
scope_657.string(var_658);
}
#[allow(unused_mut)]
let mut scope_659 = writer.prefix("Type");
if let Some(var_660) = &input.r#type {
scope_659.string(var_660.as_str());
}
#[allow(unused_mut)]
let mut scope_661 = writer.prefix("TagSpecification");
if let Some(var_662) = &input.tag_specifications {
let mut list_664 = scope_661.start_list(true, Some("item"));
for item_663 in var_662 {
#[allow(unused_mut)]
let mut entry_665 = list_664.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_665, item_663,
)?;
}
list_664.finish();
}
#[allow(unused_mut)]
let mut scope_666 = writer.prefix("DeviceName");
if let Some(var_667) = &input.device_name {
scope_666.string(var_667);
}
#[allow(unused_mut)]
let mut scope_668 = writer.prefix("IpAddress");
if let Some(var_669) = &input.ip_address {
scope_668.string(var_669);
}
#[allow(unused_mut)]
let mut scope_670 = writer.prefix("DryRun");
if let Some(var_671) = &input.dry_run {
scope_670.boolean(*var_671);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_default_subnet(
input: &crate::input::CreateDefaultSubnetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateDefaultSubnet", "2016-11-15");
#[allow(unused_mut)]
let mut scope_672 = writer.prefix("AvailabilityZone");
if let Some(var_673) = &input.availability_zone {
scope_672.string(var_673);
}
#[allow(unused_mut)]
let mut scope_674 = writer.prefix("DryRun");
if let Some(var_675) = &input.dry_run {
scope_674.boolean(*var_675);
}
#[allow(unused_mut)]
let mut scope_676 = writer.prefix("Ipv6Native");
if let Some(var_677) = &input.ipv6_native {
scope_676.boolean(*var_677);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_default_vpc(
input: &crate::input::CreateDefaultVpcInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateDefaultVpc", "2016-11-15");
#[allow(unused_mut)]
let mut scope_678 = writer.prefix("DryRun");
if let Some(var_679) = &input.dry_run {
scope_678.boolean(*var_679);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_dhcp_options(
input: &crate::input::CreateDhcpOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateDhcpOptions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_680 = writer.prefix("DhcpConfiguration");
if let Some(var_681) = &input.dhcp_configurations {
let mut list_683 = scope_680.start_list(true, Some("item"));
for item_682 in var_681 {
#[allow(unused_mut)]
let mut entry_684 = list_683.entry();
crate::query_ser::serialize_structure_crate_model_new_dhcp_configuration(
entry_684, item_682,
)?;
}
list_683.finish();
}
#[allow(unused_mut)]
let mut scope_685 = writer.prefix("TagSpecification");
if let Some(var_686) = &input.tag_specifications {
let mut list_688 = scope_685.start_list(true, Some("item"));
for item_687 in var_686 {
#[allow(unused_mut)]
let mut entry_689 = list_688.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_689, item_687,
)?;
}
list_688.finish();
}
#[allow(unused_mut)]
let mut scope_690 = writer.prefix("DryRun");
if let Some(var_691) = &input.dry_run {
scope_690.boolean(*var_691);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_egress_only_internet_gateway(
input: &crate::input::CreateEgressOnlyInternetGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateEgressOnlyInternetGateway",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_692 = writer.prefix("ClientToken");
if let Some(var_693) = &input.client_token {
scope_692.string(var_693);
}
#[allow(unused_mut)]
let mut scope_694 = writer.prefix("DryRun");
if let Some(var_695) = &input.dry_run {
scope_694.boolean(*var_695);
}
#[allow(unused_mut)]
let mut scope_696 = writer.prefix("VpcId");
if let Some(var_697) = &input.vpc_id {
scope_696.string(var_697);
}
#[allow(unused_mut)]
let mut scope_698 = writer.prefix("TagSpecification");
if let Some(var_699) = &input.tag_specifications {
let mut list_701 = scope_698.start_list(true, Some("item"));
for item_700 in var_699 {
#[allow(unused_mut)]
let mut entry_702 = list_701.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_702, item_700,
)?;
}
list_701.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_fleet(
input: &crate::input::CreateFleetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateFleet", "2016-11-15");
#[allow(unused_mut)]
let mut scope_703 = writer.prefix("DryRun");
if let Some(var_704) = &input.dry_run {
scope_703.boolean(*var_704);
}
#[allow(unused_mut)]
let mut scope_705 = writer.prefix("ClientToken");
if let Some(var_706) = &input.client_token {
scope_705.string(var_706);
}
#[allow(unused_mut)]
let mut scope_707 = writer.prefix("SpotOptions");
if let Some(var_708) = &input.spot_options {
crate::query_ser::serialize_structure_crate_model_spot_options_request(scope_707, var_708)?;
}
#[allow(unused_mut)]
let mut scope_709 = writer.prefix("OnDemandOptions");
if let Some(var_710) = &input.on_demand_options {
crate::query_ser::serialize_structure_crate_model_on_demand_options_request(
scope_709, var_710,
)?;
}
#[allow(unused_mut)]
let mut scope_711 = writer.prefix("ExcessCapacityTerminationPolicy");
if let Some(var_712) = &input.excess_capacity_termination_policy {
scope_711.string(var_712.as_str());
}
#[allow(unused_mut)]
let mut scope_713 = writer.prefix("LaunchTemplateConfigs");
if let Some(var_714) = &input.launch_template_configs {
let mut list_716 = scope_713.start_list(true, Some("item"));
for item_715 in var_714 {
#[allow(unused_mut)]
let mut entry_717 = list_716.entry();
crate::query_ser::serialize_structure_crate_model_fleet_launch_template_config_request(
entry_717, item_715,
)?;
}
list_716.finish();
}
#[allow(unused_mut)]
let mut scope_718 = writer.prefix("TargetCapacitySpecification");
if let Some(var_719) = &input.target_capacity_specification {
crate::query_ser::serialize_structure_crate_model_target_capacity_specification_request(
scope_718, var_719,
)?;
}
#[allow(unused_mut)]
let mut scope_720 = writer.prefix("TerminateInstancesWithExpiration");
if let Some(var_721) = &input.terminate_instances_with_expiration {
scope_720.boolean(*var_721);
}
#[allow(unused_mut)]
let mut scope_722 = writer.prefix("Type");
if let Some(var_723) = &input.r#type {
scope_722.string(var_723.as_str());
}
#[allow(unused_mut)]
let mut scope_724 = writer.prefix("ValidFrom");
if let Some(var_725) = &input.valid_from {
scope_724.date_time(var_725, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_726 = writer.prefix("ValidUntil");
if let Some(var_727) = &input.valid_until {
scope_726.date_time(var_727, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_728 = writer.prefix("ReplaceUnhealthyInstances");
if let Some(var_729) = &input.replace_unhealthy_instances {
scope_728.boolean(*var_729);
}
#[allow(unused_mut)]
let mut scope_730 = writer.prefix("TagSpecification");
if let Some(var_731) = &input.tag_specifications {
let mut list_733 = scope_730.start_list(true, Some("item"));
for item_732 in var_731 {
#[allow(unused_mut)]
let mut entry_734 = list_733.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_734, item_732,
)?;
}
list_733.finish();
}
#[allow(unused_mut)]
let mut scope_735 = writer.prefix("Context");
if let Some(var_736) = &input.context {
scope_735.string(var_736);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_flow_logs(
input: &crate::input::CreateFlowLogsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateFlowLogs", "2016-11-15");
#[allow(unused_mut)]
let mut scope_737 = writer.prefix("DryRun");
if let Some(var_738) = &input.dry_run {
scope_737.boolean(*var_738);
}
#[allow(unused_mut)]
let mut scope_739 = writer.prefix("ClientToken");
if let Some(var_740) = &input.client_token {
scope_739.string(var_740);
}
#[allow(unused_mut)]
let mut scope_741 = writer.prefix("DeliverLogsPermissionArn");
if let Some(var_742) = &input.deliver_logs_permission_arn {
scope_741.string(var_742);
}
#[allow(unused_mut)]
let mut scope_743 = writer.prefix("DeliverCrossAccountRole");
if let Some(var_744) = &input.deliver_cross_account_role {
scope_743.string(var_744);
}
#[allow(unused_mut)]
let mut scope_745 = writer.prefix("LogGroupName");
if let Some(var_746) = &input.log_group_name {
scope_745.string(var_746);
}
#[allow(unused_mut)]
let mut scope_747 = writer.prefix("ResourceId");
if let Some(var_748) = &input.resource_ids {
let mut list_750 = scope_747.start_list(true, Some("item"));
for item_749 in var_748 {
#[allow(unused_mut)]
let mut entry_751 = list_750.entry();
entry_751.string(item_749);
}
list_750.finish();
}
#[allow(unused_mut)]
let mut scope_752 = writer.prefix("ResourceType");
if let Some(var_753) = &input.resource_type {
scope_752.string(var_753.as_str());
}
#[allow(unused_mut)]
let mut scope_754 = writer.prefix("TrafficType");
if let Some(var_755) = &input.traffic_type {
scope_754.string(var_755.as_str());
}
#[allow(unused_mut)]
let mut scope_756 = writer.prefix("LogDestinationType");
if let Some(var_757) = &input.log_destination_type {
scope_756.string(var_757.as_str());
}
#[allow(unused_mut)]
let mut scope_758 = writer.prefix("LogDestination");
if let Some(var_759) = &input.log_destination {
scope_758.string(var_759);
}
#[allow(unused_mut)]
let mut scope_760 = writer.prefix("LogFormat");
if let Some(var_761) = &input.log_format {
scope_760.string(var_761);
}
#[allow(unused_mut)]
let mut scope_762 = writer.prefix("TagSpecification");
if let Some(var_763) = &input.tag_specifications {
let mut list_765 = scope_762.start_list(true, Some("item"));
for item_764 in var_763 {
#[allow(unused_mut)]
let mut entry_766 = list_765.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_766, item_764,
)?;
}
list_765.finish();
}
#[allow(unused_mut)]
let mut scope_767 = writer.prefix("MaxAggregationInterval");
if let Some(var_768) = &input.max_aggregation_interval {
scope_767.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_768).into()),
);
}
#[allow(unused_mut)]
let mut scope_769 = writer.prefix("DestinationOptions");
if let Some(var_770) = &input.destination_options {
crate::query_ser::serialize_structure_crate_model_destination_options_request(
scope_769, var_770,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_fpga_image(
input: &crate::input::CreateFpgaImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateFpgaImage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_771 = writer.prefix("DryRun");
if let Some(var_772) = &input.dry_run {
scope_771.boolean(*var_772);
}
#[allow(unused_mut)]
let mut scope_773 = writer.prefix("InputStorageLocation");
if let Some(var_774) = &input.input_storage_location {
crate::query_ser::serialize_structure_crate_model_storage_location(scope_773, var_774)?;
}
#[allow(unused_mut)]
let mut scope_775 = writer.prefix("LogsStorageLocation");
if let Some(var_776) = &input.logs_storage_location {
crate::query_ser::serialize_structure_crate_model_storage_location(scope_775, var_776)?;
}
#[allow(unused_mut)]
let mut scope_777 = writer.prefix("Description");
if let Some(var_778) = &input.description {
scope_777.string(var_778);
}
#[allow(unused_mut)]
let mut scope_779 = writer.prefix("Name");
if let Some(var_780) = &input.name {
scope_779.string(var_780);
}
#[allow(unused_mut)]
let mut scope_781 = writer.prefix("ClientToken");
if let Some(var_782) = &input.client_token {
scope_781.string(var_782);
}
#[allow(unused_mut)]
let mut scope_783 = writer.prefix("TagSpecification");
if let Some(var_784) = &input.tag_specifications {
let mut list_786 = scope_783.start_list(true, Some("item"));
for item_785 in var_784 {
#[allow(unused_mut)]
let mut entry_787 = list_786.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_787, item_785,
)?;
}
list_786.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_image(
input: &crate::input::CreateImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateImage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_788 = writer.prefix("BlockDeviceMapping");
if let Some(var_789) = &input.block_device_mappings {
let mut list_791 = scope_788.start_list(true, Some("BlockDeviceMapping"));
for item_790 in var_789 {
#[allow(unused_mut)]
let mut entry_792 = list_791.entry();
crate::query_ser::serialize_structure_crate_model_block_device_mapping(
entry_792, item_790,
)?;
}
list_791.finish();
}
#[allow(unused_mut)]
let mut scope_793 = writer.prefix("Description");
if let Some(var_794) = &input.description {
scope_793.string(var_794);
}
#[allow(unused_mut)]
let mut scope_795 = writer.prefix("DryRun");
if let Some(var_796) = &input.dry_run {
scope_795.boolean(*var_796);
}
#[allow(unused_mut)]
let mut scope_797 = writer.prefix("InstanceId");
if let Some(var_798) = &input.instance_id {
scope_797.string(var_798);
}
#[allow(unused_mut)]
let mut scope_799 = writer.prefix("Name");
if let Some(var_800) = &input.name {
scope_799.string(var_800);
}
#[allow(unused_mut)]
let mut scope_801 = writer.prefix("NoReboot");
if let Some(var_802) = &input.no_reboot {
scope_801.boolean(*var_802);
}
#[allow(unused_mut)]
let mut scope_803 = writer.prefix("TagSpecification");
if let Some(var_804) = &input.tag_specifications {
let mut list_806 = scope_803.start_list(true, Some("item"));
for item_805 in var_804 {
#[allow(unused_mut)]
let mut entry_807 = list_806.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_807, item_805,
)?;
}
list_806.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_instance_event_window(
input: &crate::input::CreateInstanceEventWindowInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateInstanceEventWindow", "2016-11-15");
#[allow(unused_mut)]
let mut scope_808 = writer.prefix("DryRun");
if let Some(var_809) = &input.dry_run {
scope_808.boolean(*var_809);
}
#[allow(unused_mut)]
let mut scope_810 = writer.prefix("Name");
if let Some(var_811) = &input.name {
scope_810.string(var_811);
}
#[allow(unused_mut)]
let mut scope_812 = writer.prefix("TimeRange");
if let Some(var_813) = &input.time_ranges {
let mut list_815 = scope_812.start_list(true, None);
for item_814 in var_813 {
#[allow(unused_mut)]
let mut entry_816 = list_815.entry();
crate::query_ser::serialize_structure_crate_model_instance_event_window_time_range_request(entry_816, item_814)?;
}
list_815.finish();
}
#[allow(unused_mut)]
let mut scope_817 = writer.prefix("CronExpression");
if let Some(var_818) = &input.cron_expression {
scope_817.string(var_818);
}
#[allow(unused_mut)]
let mut scope_819 = writer.prefix("TagSpecification");
if let Some(var_820) = &input.tag_specifications {
let mut list_822 = scope_819.start_list(true, Some("item"));
for item_821 in var_820 {
#[allow(unused_mut)]
let mut entry_823 = list_822.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_823, item_821,
)?;
}
list_822.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_instance_export_task(
input: &crate::input::CreateInstanceExportTaskInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateInstanceExportTask", "2016-11-15");
#[allow(unused_mut)]
let mut scope_824 = writer.prefix("Description");
if let Some(var_825) = &input.description {
scope_824.string(var_825);
}
#[allow(unused_mut)]
let mut scope_826 = writer.prefix("ExportToS3");
if let Some(var_827) = &input.export_to_s3_task {
crate::query_ser::serialize_structure_crate_model_export_to_s3_task_specification(
scope_826, var_827,
)?;
}
#[allow(unused_mut)]
let mut scope_828 = writer.prefix("InstanceId");
if let Some(var_829) = &input.instance_id {
scope_828.string(var_829);
}
#[allow(unused_mut)]
let mut scope_830 = writer.prefix("TargetEnvironment");
if let Some(var_831) = &input.target_environment {
scope_830.string(var_831.as_str());
}
#[allow(unused_mut)]
let mut scope_832 = writer.prefix("TagSpecification");
if let Some(var_833) = &input.tag_specifications {
let mut list_835 = scope_832.start_list(true, Some("item"));
for item_834 in var_833 {
#[allow(unused_mut)]
let mut entry_836 = list_835.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_836, item_834,
)?;
}
list_835.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_internet_gateway(
input: &crate::input::CreateInternetGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateInternetGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_837 = writer.prefix("TagSpecification");
if let Some(var_838) = &input.tag_specifications {
let mut list_840 = scope_837.start_list(true, Some("item"));
for item_839 in var_838 {
#[allow(unused_mut)]
let mut entry_841 = list_840.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_841, item_839,
)?;
}
list_840.finish();
}
#[allow(unused_mut)]
let mut scope_842 = writer.prefix("DryRun");
if let Some(var_843) = &input.dry_run {
scope_842.boolean(*var_843);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_ipam(
input: &crate::input::CreateIpamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateIpam", "2016-11-15");
#[allow(unused_mut)]
let mut scope_844 = writer.prefix("DryRun");
if let Some(var_845) = &input.dry_run {
scope_844.boolean(*var_845);
}
#[allow(unused_mut)]
let mut scope_846 = writer.prefix("Description");
if let Some(var_847) = &input.description {
scope_846.string(var_847);
}
#[allow(unused_mut)]
let mut scope_848 = writer.prefix("OperatingRegion");
if let Some(var_849) = &input.operating_regions {
let mut list_851 = scope_848.start_list(true, None);
for item_850 in var_849 {
#[allow(unused_mut)]
let mut entry_852 = list_851.entry();
crate::query_ser::serialize_structure_crate_model_add_ipam_operating_region(
entry_852, item_850,
)?;
}
list_851.finish();
}
#[allow(unused_mut)]
let mut scope_853 = writer.prefix("TagSpecification");
if let Some(var_854) = &input.tag_specifications {
let mut list_856 = scope_853.start_list(true, Some("item"));
for item_855 in var_854 {
#[allow(unused_mut)]
let mut entry_857 = list_856.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_857, item_855,
)?;
}
list_856.finish();
}
#[allow(unused_mut)]
let mut scope_858 = writer.prefix("ClientToken");
if let Some(var_859) = &input.client_token {
scope_858.string(var_859);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_ipam_pool(
input: &crate::input::CreateIpamPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateIpamPool", "2016-11-15");
#[allow(unused_mut)]
let mut scope_860 = writer.prefix("DryRun");
if let Some(var_861) = &input.dry_run {
scope_860.boolean(*var_861);
}
#[allow(unused_mut)]
let mut scope_862 = writer.prefix("IpamScopeId");
if let Some(var_863) = &input.ipam_scope_id {
scope_862.string(var_863);
}
#[allow(unused_mut)]
let mut scope_864 = writer.prefix("Locale");
if let Some(var_865) = &input.locale {
scope_864.string(var_865);
}
#[allow(unused_mut)]
let mut scope_866 = writer.prefix("SourceIpamPoolId");
if let Some(var_867) = &input.source_ipam_pool_id {
scope_866.string(var_867);
}
#[allow(unused_mut)]
let mut scope_868 = writer.prefix("Description");
if let Some(var_869) = &input.description {
scope_868.string(var_869);
}
#[allow(unused_mut)]
let mut scope_870 = writer.prefix("AddressFamily");
if let Some(var_871) = &input.address_family {
scope_870.string(var_871.as_str());
}
#[allow(unused_mut)]
let mut scope_872 = writer.prefix("AutoImport");
if let Some(var_873) = &input.auto_import {
scope_872.boolean(*var_873);
}
#[allow(unused_mut)]
let mut scope_874 = writer.prefix("PubliclyAdvertisable");
if let Some(var_875) = &input.publicly_advertisable {
scope_874.boolean(*var_875);
}
#[allow(unused_mut)]
let mut scope_876 = writer.prefix("AllocationMinNetmaskLength");
if let Some(var_877) = &input.allocation_min_netmask_length {
scope_876.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_877).into()),
);
}
#[allow(unused_mut)]
let mut scope_878 = writer.prefix("AllocationMaxNetmaskLength");
if let Some(var_879) = &input.allocation_max_netmask_length {
scope_878.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_879).into()),
);
}
#[allow(unused_mut)]
let mut scope_880 = writer.prefix("AllocationDefaultNetmaskLength");
if let Some(var_881) = &input.allocation_default_netmask_length {
scope_880.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_881).into()),
);
}
#[allow(unused_mut)]
let mut scope_882 = writer.prefix("AllocationResourceTag");
if let Some(var_883) = &input.allocation_resource_tags {
let mut list_885 = scope_882.start_list(true, Some("item"));
for item_884 in var_883 {
#[allow(unused_mut)]
let mut entry_886 = list_885.entry();
crate::query_ser::serialize_structure_crate_model_request_ipam_resource_tag(
entry_886, item_884,
)?;
}
list_885.finish();
}
#[allow(unused_mut)]
let mut scope_887 = writer.prefix("TagSpecification");
if let Some(var_888) = &input.tag_specifications {
let mut list_890 = scope_887.start_list(true, Some("item"));
for item_889 in var_888 {
#[allow(unused_mut)]
let mut entry_891 = list_890.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_891, item_889,
)?;
}
list_890.finish();
}
#[allow(unused_mut)]
let mut scope_892 = writer.prefix("ClientToken");
if let Some(var_893) = &input.client_token {
scope_892.string(var_893);
}
#[allow(unused_mut)]
let mut scope_894 = writer.prefix("AwsService");
if let Some(var_895) = &input.aws_service {
scope_894.string(var_895.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_ipam_scope(
input: &crate::input::CreateIpamScopeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateIpamScope", "2016-11-15");
#[allow(unused_mut)]
let mut scope_896 = writer.prefix("DryRun");
if let Some(var_897) = &input.dry_run {
scope_896.boolean(*var_897);
}
#[allow(unused_mut)]
let mut scope_898 = writer.prefix("IpamId");
if let Some(var_899) = &input.ipam_id {
scope_898.string(var_899);
}
#[allow(unused_mut)]
let mut scope_900 = writer.prefix("Description");
if let Some(var_901) = &input.description {
scope_900.string(var_901);
}
#[allow(unused_mut)]
let mut scope_902 = writer.prefix("TagSpecification");
if let Some(var_903) = &input.tag_specifications {
let mut list_905 = scope_902.start_list(true, Some("item"));
for item_904 in var_903 {
#[allow(unused_mut)]
let mut entry_906 = list_905.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_906, item_904,
)?;
}
list_905.finish();
}
#[allow(unused_mut)]
let mut scope_907 = writer.prefix("ClientToken");
if let Some(var_908) = &input.client_token {
scope_907.string(var_908);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_key_pair(
input: &crate::input::CreateKeyPairInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateKeyPair", "2016-11-15");
#[allow(unused_mut)]
let mut scope_909 = writer.prefix("KeyName");
if let Some(var_910) = &input.key_name {
scope_909.string(var_910);
}
#[allow(unused_mut)]
let mut scope_911 = writer.prefix("DryRun");
if let Some(var_912) = &input.dry_run {
scope_911.boolean(*var_912);
}
#[allow(unused_mut)]
let mut scope_913 = writer.prefix("KeyType");
if let Some(var_914) = &input.key_type {
scope_913.string(var_914.as_str());
}
#[allow(unused_mut)]
let mut scope_915 = writer.prefix("TagSpecification");
if let Some(var_916) = &input.tag_specifications {
let mut list_918 = scope_915.start_list(true, Some("item"));
for item_917 in var_916 {
#[allow(unused_mut)]
let mut entry_919 = list_918.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_919, item_917,
)?;
}
list_918.finish();
}
#[allow(unused_mut)]
let mut scope_920 = writer.prefix("KeyFormat");
if let Some(var_921) = &input.key_format {
scope_920.string(var_921.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_launch_template(
input: &crate::input::CreateLaunchTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateLaunchTemplate", "2016-11-15");
#[allow(unused_mut)]
let mut scope_922 = writer.prefix("DryRun");
if let Some(var_923) = &input.dry_run {
scope_922.boolean(*var_923);
}
#[allow(unused_mut)]
let mut scope_924 = writer.prefix("ClientToken");
if let Some(var_925) = &input.client_token {
scope_924.string(var_925);
}
#[allow(unused_mut)]
let mut scope_926 = writer.prefix("LaunchTemplateName");
if let Some(var_927) = &input.launch_template_name {
scope_926.string(var_927);
}
#[allow(unused_mut)]
let mut scope_928 = writer.prefix("VersionDescription");
if let Some(var_929) = &input.version_description {
scope_928.string(var_929);
}
#[allow(unused_mut)]
let mut scope_930 = writer.prefix("LaunchTemplateData");
if let Some(var_931) = &input.launch_template_data {
crate::query_ser::serialize_structure_crate_model_request_launch_template_data(
scope_930, var_931,
)?;
}
#[allow(unused_mut)]
let mut scope_932 = writer.prefix("TagSpecification");
if let Some(var_933) = &input.tag_specifications {
let mut list_935 = scope_932.start_list(true, Some("item"));
for item_934 in var_933 {
#[allow(unused_mut)]
let mut entry_936 = list_935.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_936, item_934,
)?;
}
list_935.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_launch_template_version(
input: &crate::input::CreateLaunchTemplateVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateLaunchTemplateVersion", "2016-11-15");
#[allow(unused_mut)]
let mut scope_937 = writer.prefix("DryRun");
if let Some(var_938) = &input.dry_run {
scope_937.boolean(*var_938);
}
#[allow(unused_mut)]
let mut scope_939 = writer.prefix("ClientToken");
if let Some(var_940) = &input.client_token {
scope_939.string(var_940);
}
#[allow(unused_mut)]
let mut scope_941 = writer.prefix("LaunchTemplateId");
if let Some(var_942) = &input.launch_template_id {
scope_941.string(var_942);
}
#[allow(unused_mut)]
let mut scope_943 = writer.prefix("LaunchTemplateName");
if let Some(var_944) = &input.launch_template_name {
scope_943.string(var_944);
}
#[allow(unused_mut)]
let mut scope_945 = writer.prefix("SourceVersion");
if let Some(var_946) = &input.source_version {
scope_945.string(var_946);
}
#[allow(unused_mut)]
let mut scope_947 = writer.prefix("VersionDescription");
if let Some(var_948) = &input.version_description {
scope_947.string(var_948);
}
#[allow(unused_mut)]
let mut scope_949 = writer.prefix("LaunchTemplateData");
if let Some(var_950) = &input.launch_template_data {
crate::query_ser::serialize_structure_crate_model_request_launch_template_data(
scope_949, var_950,
)?;
}
#[allow(unused_mut)]
let mut scope_951 = writer.prefix("ResolveAlias");
if let Some(var_952) = &input.resolve_alias {
scope_951.boolean(*var_952);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_local_gateway_route(
input: &crate::input::CreateLocalGatewayRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateLocalGatewayRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_953 = writer.prefix("DestinationCidrBlock");
if let Some(var_954) = &input.destination_cidr_block {
scope_953.string(var_954);
}
#[allow(unused_mut)]
let mut scope_955 = writer.prefix("LocalGatewayRouteTableId");
if let Some(var_956) = &input.local_gateway_route_table_id {
scope_955.string(var_956);
}
#[allow(unused_mut)]
let mut scope_957 = writer.prefix("LocalGatewayVirtualInterfaceGroupId");
if let Some(var_958) = &input.local_gateway_virtual_interface_group_id {
scope_957.string(var_958);
}
#[allow(unused_mut)]
let mut scope_959 = writer.prefix("DryRun");
if let Some(var_960) = &input.dry_run {
scope_959.boolean(*var_960);
}
#[allow(unused_mut)]
let mut scope_961 = writer.prefix("NetworkInterfaceId");
if let Some(var_962) = &input.network_interface_id {
scope_961.string(var_962);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_local_gateway_route_table(
input: &crate::input::CreateLocalGatewayRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateLocalGatewayRouteTable", "2016-11-15");
#[allow(unused_mut)]
let mut scope_963 = writer.prefix("LocalGatewayId");
if let Some(var_964) = &input.local_gateway_id {
scope_963.string(var_964);
}
#[allow(unused_mut)]
let mut scope_965 = writer.prefix("Mode");
if let Some(var_966) = &input.mode {
scope_965.string(var_966.as_str());
}
#[allow(unused_mut)]
let mut scope_967 = writer.prefix("TagSpecification");
if let Some(var_968) = &input.tag_specifications {
let mut list_970 = scope_967.start_list(true, Some("item"));
for item_969 in var_968 {
#[allow(unused_mut)]
let mut entry_971 = list_970.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_971, item_969,
)?;
}
list_970.finish();
}
#[allow(unused_mut)]
let mut scope_972 = writer.prefix("DryRun");
if let Some(var_973) = &input.dry_run {
scope_972.boolean(*var_973);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_local_gateway_route_table_virtual_interface_group_association(
input: &crate::input::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_974 = writer.prefix("LocalGatewayRouteTableId");
if let Some(var_975) = &input.local_gateway_route_table_id {
scope_974.string(var_975);
}
#[allow(unused_mut)]
let mut scope_976 = writer.prefix("LocalGatewayVirtualInterfaceGroupId");
if let Some(var_977) = &input.local_gateway_virtual_interface_group_id {
scope_976.string(var_977);
}
#[allow(unused_mut)]
let mut scope_978 = writer.prefix("TagSpecification");
if let Some(var_979) = &input.tag_specifications {
let mut list_981 = scope_978.start_list(true, Some("item"));
for item_980 in var_979 {
#[allow(unused_mut)]
let mut entry_982 = list_981.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_982, item_980,
)?;
}
list_981.finish();
}
#[allow(unused_mut)]
let mut scope_983 = writer.prefix("DryRun");
if let Some(var_984) = &input.dry_run {
scope_983.boolean(*var_984);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_local_gateway_route_table_vpc_association(
input: &crate::input::CreateLocalGatewayRouteTableVpcAssociationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateLocalGatewayRouteTableVpcAssociation",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_985 = writer.prefix("LocalGatewayRouteTableId");
if let Some(var_986) = &input.local_gateway_route_table_id {
scope_985.string(var_986);
}
#[allow(unused_mut)]
let mut scope_987 = writer.prefix("VpcId");
if let Some(var_988) = &input.vpc_id {
scope_987.string(var_988);
}
#[allow(unused_mut)]
let mut scope_989 = writer.prefix("TagSpecification");
if let Some(var_990) = &input.tag_specifications {
let mut list_992 = scope_989.start_list(true, Some("item"));
for item_991 in var_990 {
#[allow(unused_mut)]
let mut entry_993 = list_992.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_993, item_991,
)?;
}
list_992.finish();
}
#[allow(unused_mut)]
let mut scope_994 = writer.prefix("DryRun");
if let Some(var_995) = &input.dry_run {
scope_994.boolean(*var_995);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_managed_prefix_list(
input: &crate::input::CreateManagedPrefixListInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateManagedPrefixList", "2016-11-15");
#[allow(unused_mut)]
let mut scope_996 = writer.prefix("DryRun");
if let Some(var_997) = &input.dry_run {
scope_996.boolean(*var_997);
}
#[allow(unused_mut)]
let mut scope_998 = writer.prefix("PrefixListName");
if let Some(var_999) = &input.prefix_list_name {
scope_998.string(var_999);
}
#[allow(unused_mut)]
let mut scope_1000 = writer.prefix("Entry");
if let Some(var_1001) = &input.entries {
let mut list_1003 = scope_1000.start_list(true, None);
for item_1002 in var_1001 {
#[allow(unused_mut)]
let mut entry_1004 = list_1003.entry();
crate::query_ser::serialize_structure_crate_model_add_prefix_list_entry(
entry_1004, item_1002,
)?;
}
list_1003.finish();
}
#[allow(unused_mut)]
let mut scope_1005 = writer.prefix("MaxEntries");
if let Some(var_1006) = &input.max_entries {
scope_1005.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1006).into()),
);
}
#[allow(unused_mut)]
let mut scope_1007 = writer.prefix("TagSpecification");
if let Some(var_1008) = &input.tag_specifications {
let mut list_1010 = scope_1007.start_list(true, Some("item"));
for item_1009 in var_1008 {
#[allow(unused_mut)]
let mut entry_1011 = list_1010.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1011, item_1009,
)?;
}
list_1010.finish();
}
#[allow(unused_mut)]
let mut scope_1012 = writer.prefix("AddressFamily");
if let Some(var_1013) = &input.address_family {
scope_1012.string(var_1013);
}
#[allow(unused_mut)]
let mut scope_1014 = writer.prefix("ClientToken");
if let Some(var_1015) = &input.client_token {
scope_1014.string(var_1015);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_nat_gateway(
input: &crate::input::CreateNatGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateNatGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1016 = writer.prefix("AllocationId");
if let Some(var_1017) = &input.allocation_id {
scope_1016.string(var_1017);
}
#[allow(unused_mut)]
let mut scope_1018 = writer.prefix("ClientToken");
if let Some(var_1019) = &input.client_token {
scope_1018.string(var_1019);
}
#[allow(unused_mut)]
let mut scope_1020 = writer.prefix("DryRun");
if let Some(var_1021) = &input.dry_run {
scope_1020.boolean(*var_1021);
}
#[allow(unused_mut)]
let mut scope_1022 = writer.prefix("SubnetId");
if let Some(var_1023) = &input.subnet_id {
scope_1022.string(var_1023);
}
#[allow(unused_mut)]
let mut scope_1024 = writer.prefix("TagSpecification");
if let Some(var_1025) = &input.tag_specifications {
let mut list_1027 = scope_1024.start_list(true, Some("item"));
for item_1026 in var_1025 {
#[allow(unused_mut)]
let mut entry_1028 = list_1027.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1028, item_1026,
)?;
}
list_1027.finish();
}
#[allow(unused_mut)]
let mut scope_1029 = writer.prefix("ConnectivityType");
if let Some(var_1030) = &input.connectivity_type {
scope_1029.string(var_1030.as_str());
}
#[allow(unused_mut)]
let mut scope_1031 = writer.prefix("PrivateIpAddress");
if let Some(var_1032) = &input.private_ip_address {
scope_1031.string(var_1032);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_network_acl(
input: &crate::input::CreateNetworkAclInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateNetworkAcl", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1033 = writer.prefix("DryRun");
if let Some(var_1034) = &input.dry_run {
scope_1033.boolean(*var_1034);
}
#[allow(unused_mut)]
let mut scope_1035 = writer.prefix("VpcId");
if let Some(var_1036) = &input.vpc_id {
scope_1035.string(var_1036);
}
#[allow(unused_mut)]
let mut scope_1037 = writer.prefix("TagSpecification");
if let Some(var_1038) = &input.tag_specifications {
let mut list_1040 = scope_1037.start_list(true, Some("item"));
for item_1039 in var_1038 {
#[allow(unused_mut)]
let mut entry_1041 = list_1040.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1041, item_1039,
)?;
}
list_1040.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_network_acl_entry(
input: &crate::input::CreateNetworkAclEntryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateNetworkAclEntry", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1042 = writer.prefix("CidrBlock");
if let Some(var_1043) = &input.cidr_block {
scope_1042.string(var_1043);
}
#[allow(unused_mut)]
let mut scope_1044 = writer.prefix("DryRun");
if let Some(var_1045) = &input.dry_run {
scope_1044.boolean(*var_1045);
}
#[allow(unused_mut)]
let mut scope_1046 = writer.prefix("Egress");
if let Some(var_1047) = &input.egress {
scope_1046.boolean(*var_1047);
}
#[allow(unused_mut)]
let mut scope_1048 = writer.prefix("Icmp");
if let Some(var_1049) = &input.icmp_type_code {
crate::query_ser::serialize_structure_crate_model_icmp_type_code(scope_1048, var_1049)?;
}
#[allow(unused_mut)]
let mut scope_1050 = writer.prefix("Ipv6CidrBlock");
if let Some(var_1051) = &input.ipv6_cidr_block {
scope_1050.string(var_1051);
}
#[allow(unused_mut)]
let mut scope_1052 = writer.prefix("NetworkAclId");
if let Some(var_1053) = &input.network_acl_id {
scope_1052.string(var_1053);
}
#[allow(unused_mut)]
let mut scope_1054 = writer.prefix("PortRange");
if let Some(var_1055) = &input.port_range {
crate::query_ser::serialize_structure_crate_model_port_range(scope_1054, var_1055)?;
}
#[allow(unused_mut)]
let mut scope_1056 = writer.prefix("Protocol");
if let Some(var_1057) = &input.protocol {
scope_1056.string(var_1057);
}
#[allow(unused_mut)]
let mut scope_1058 = writer.prefix("RuleAction");
if let Some(var_1059) = &input.rule_action {
scope_1058.string(var_1059.as_str());
}
#[allow(unused_mut)]
let mut scope_1060 = writer.prefix("RuleNumber");
if let Some(var_1061) = &input.rule_number {
scope_1060.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1061).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_network_insights_access_scope(
input: &crate::input::CreateNetworkInsightsAccessScopeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateNetworkInsightsAccessScope",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1062 = writer.prefix("MatchPath");
if let Some(var_1063) = &input.match_paths {
let mut list_1065 = scope_1062.start_list(true, Some("item"));
for item_1064 in var_1063 {
#[allow(unused_mut)]
let mut entry_1066 = list_1065.entry();
crate::query_ser::serialize_structure_crate_model_access_scope_path_request(
entry_1066, item_1064,
)?;
}
list_1065.finish();
}
#[allow(unused_mut)]
let mut scope_1067 = writer.prefix("ExcludePath");
if let Some(var_1068) = &input.exclude_paths {
let mut list_1070 = scope_1067.start_list(true, Some("item"));
for item_1069 in var_1068 {
#[allow(unused_mut)]
let mut entry_1071 = list_1070.entry();
crate::query_ser::serialize_structure_crate_model_access_scope_path_request(
entry_1071, item_1069,
)?;
}
list_1070.finish();
}
#[allow(unused_mut)]
let mut scope_1072 = writer.prefix("ClientToken");
if let Some(var_1073) = &input.client_token {
scope_1072.string(var_1073);
}
#[allow(unused_mut)]
let mut scope_1074 = writer.prefix("TagSpecification");
if let Some(var_1075) = &input.tag_specifications {
let mut list_1077 = scope_1074.start_list(true, Some("item"));
for item_1076 in var_1075 {
#[allow(unused_mut)]
let mut entry_1078 = list_1077.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1078, item_1076,
)?;
}
list_1077.finish();
}
#[allow(unused_mut)]
let mut scope_1079 = writer.prefix("DryRun");
if let Some(var_1080) = &input.dry_run {
scope_1079.boolean(*var_1080);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_network_insights_path(
input: &crate::input::CreateNetworkInsightsPathInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateNetworkInsightsPath", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1081 = writer.prefix("SourceIp");
if let Some(var_1082) = &input.source_ip {
scope_1081.string(var_1082);
}
#[allow(unused_mut)]
let mut scope_1083 = writer.prefix("DestinationIp");
if let Some(var_1084) = &input.destination_ip {
scope_1083.string(var_1084);
}
#[allow(unused_mut)]
let mut scope_1085 = writer.prefix("Source");
if let Some(var_1086) = &input.source {
scope_1085.string(var_1086);
}
#[allow(unused_mut)]
let mut scope_1087 = writer.prefix("Destination");
if let Some(var_1088) = &input.destination {
scope_1087.string(var_1088);
}
#[allow(unused_mut)]
let mut scope_1089 = writer.prefix("Protocol");
if let Some(var_1090) = &input.protocol {
scope_1089.string(var_1090.as_str());
}
#[allow(unused_mut)]
let mut scope_1091 = writer.prefix("DestinationPort");
if let Some(var_1092) = &input.destination_port {
scope_1091.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1092).into()),
);
}
#[allow(unused_mut)]
let mut scope_1093 = writer.prefix("TagSpecification");
if let Some(var_1094) = &input.tag_specifications {
let mut list_1096 = scope_1093.start_list(true, Some("item"));
for item_1095 in var_1094 {
#[allow(unused_mut)]
let mut entry_1097 = list_1096.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1097, item_1095,
)?;
}
list_1096.finish();
}
#[allow(unused_mut)]
let mut scope_1098 = writer.prefix("DryRun");
if let Some(var_1099) = &input.dry_run {
scope_1098.boolean(*var_1099);
}
#[allow(unused_mut)]
let mut scope_1100 = writer.prefix("ClientToken");
if let Some(var_1101) = &input.client_token {
scope_1100.string(var_1101);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_network_interface(
input: &crate::input::CreateNetworkInterfaceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateNetworkInterface", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1102 = writer.prefix("Description");
if let Some(var_1103) = &input.description {
scope_1102.string(var_1103);
}
#[allow(unused_mut)]
let mut scope_1104 = writer.prefix("DryRun");
if let Some(var_1105) = &input.dry_run {
scope_1104.boolean(*var_1105);
}
#[allow(unused_mut)]
let mut scope_1106 = writer.prefix("SecurityGroupId");
if let Some(var_1107) = &input.groups {
let mut list_1109 = scope_1106.start_list(true, Some("SecurityGroupId"));
for item_1108 in var_1107 {
#[allow(unused_mut)]
let mut entry_1110 = list_1109.entry();
entry_1110.string(item_1108);
}
list_1109.finish();
}
#[allow(unused_mut)]
let mut scope_1111 = writer.prefix("Ipv6AddressCount");
if let Some(var_1112) = &input.ipv6_address_count {
scope_1111.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1112).into()),
);
}
#[allow(unused_mut)]
let mut scope_1113 = writer.prefix("Ipv6Addresses");
if let Some(var_1114) = &input.ipv6_addresses {
let mut list_1116 = scope_1113.start_list(true, Some("item"));
for item_1115 in var_1114 {
#[allow(unused_mut)]
let mut entry_1117 = list_1116.entry();
crate::query_ser::serialize_structure_crate_model_instance_ipv6_address(
entry_1117, item_1115,
)?;
}
list_1116.finish();
}
#[allow(unused_mut)]
let mut scope_1118 = writer.prefix("PrivateIpAddress");
if let Some(var_1119) = &input.private_ip_address {
scope_1118.string(var_1119);
}
#[allow(unused_mut)]
let mut scope_1120 = writer.prefix("PrivateIpAddresses");
if let Some(var_1121) = &input.private_ip_addresses {
let mut list_1123 = scope_1120.start_list(true, Some("item"));
for item_1122 in var_1121 {
#[allow(unused_mut)]
let mut entry_1124 = list_1123.entry();
crate::query_ser::serialize_structure_crate_model_private_ip_address_specification(
entry_1124, item_1122,
)?;
}
list_1123.finish();
}
#[allow(unused_mut)]
let mut scope_1125 = writer.prefix("SecondaryPrivateIpAddressCount");
if let Some(var_1126) = &input.secondary_private_ip_address_count {
scope_1125.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1126).into()),
);
}
#[allow(unused_mut)]
let mut scope_1127 = writer.prefix("Ipv4Prefix");
if let Some(var_1128) = &input.ipv4_prefixes {
let mut list_1130 = scope_1127.start_list(true, Some("item"));
for item_1129 in var_1128 {
#[allow(unused_mut)]
let mut entry_1131 = list_1130.entry();
crate::query_ser::serialize_structure_crate_model_ipv4_prefix_specification_request(
entry_1131, item_1129,
)?;
}
list_1130.finish();
}
#[allow(unused_mut)]
let mut scope_1132 = writer.prefix("Ipv4PrefixCount");
if let Some(var_1133) = &input.ipv4_prefix_count {
scope_1132.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1133).into()),
);
}
#[allow(unused_mut)]
let mut scope_1134 = writer.prefix("Ipv6Prefix");
if let Some(var_1135) = &input.ipv6_prefixes {
let mut list_1137 = scope_1134.start_list(true, Some("item"));
for item_1136 in var_1135 {
#[allow(unused_mut)]
let mut entry_1138 = list_1137.entry();
crate::query_ser::serialize_structure_crate_model_ipv6_prefix_specification_request(
entry_1138, item_1136,
)?;
}
list_1137.finish();
}
#[allow(unused_mut)]
let mut scope_1139 = writer.prefix("Ipv6PrefixCount");
if let Some(var_1140) = &input.ipv6_prefix_count {
scope_1139.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1140).into()),
);
}
#[allow(unused_mut)]
let mut scope_1141 = writer.prefix("InterfaceType");
if let Some(var_1142) = &input.interface_type {
scope_1141.string(var_1142.as_str());
}
#[allow(unused_mut)]
let mut scope_1143 = writer.prefix("SubnetId");
if let Some(var_1144) = &input.subnet_id {
scope_1143.string(var_1144);
}
#[allow(unused_mut)]
let mut scope_1145 = writer.prefix("TagSpecification");
if let Some(var_1146) = &input.tag_specifications {
let mut list_1148 = scope_1145.start_list(true, Some("item"));
for item_1147 in var_1146 {
#[allow(unused_mut)]
let mut entry_1149 = list_1148.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1149, item_1147,
)?;
}
list_1148.finish();
}
#[allow(unused_mut)]
let mut scope_1150 = writer.prefix("ClientToken");
if let Some(var_1151) = &input.client_token {
scope_1150.string(var_1151);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_network_interface_permission(
input: &crate::input::CreateNetworkInterfacePermissionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateNetworkInterfacePermission",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1152 = writer.prefix("NetworkInterfaceId");
if let Some(var_1153) = &input.network_interface_id {
scope_1152.string(var_1153);
}
#[allow(unused_mut)]
let mut scope_1154 = writer.prefix("AwsAccountId");
if let Some(var_1155) = &input.aws_account_id {
scope_1154.string(var_1155);
}
#[allow(unused_mut)]
let mut scope_1156 = writer.prefix("AwsService");
if let Some(var_1157) = &input.aws_service {
scope_1156.string(var_1157);
}
#[allow(unused_mut)]
let mut scope_1158 = writer.prefix("Permission");
if let Some(var_1159) = &input.permission {
scope_1158.string(var_1159.as_str());
}
#[allow(unused_mut)]
let mut scope_1160 = writer.prefix("DryRun");
if let Some(var_1161) = &input.dry_run {
scope_1160.boolean(*var_1161);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_placement_group(
input: &crate::input::CreatePlacementGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreatePlacementGroup", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1162 = writer.prefix("DryRun");
if let Some(var_1163) = &input.dry_run {
scope_1162.boolean(*var_1163);
}
#[allow(unused_mut)]
let mut scope_1164 = writer.prefix("GroupName");
if let Some(var_1165) = &input.group_name {
scope_1164.string(var_1165);
}
#[allow(unused_mut)]
let mut scope_1166 = writer.prefix("Strategy");
if let Some(var_1167) = &input.strategy {
scope_1166.string(var_1167.as_str());
}
#[allow(unused_mut)]
let mut scope_1168 = writer.prefix("PartitionCount");
if let Some(var_1169) = &input.partition_count {
scope_1168.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1169).into()),
);
}
#[allow(unused_mut)]
let mut scope_1170 = writer.prefix("TagSpecification");
if let Some(var_1171) = &input.tag_specifications {
let mut list_1173 = scope_1170.start_list(true, Some("item"));
for item_1172 in var_1171 {
#[allow(unused_mut)]
let mut entry_1174 = list_1173.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1174, item_1172,
)?;
}
list_1173.finish();
}
#[allow(unused_mut)]
let mut scope_1175 = writer.prefix("SpreadLevel");
if let Some(var_1176) = &input.spread_level {
scope_1175.string(var_1176.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_public_ipv4_pool(
input: &crate::input::CreatePublicIpv4PoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreatePublicIpv4Pool", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1177 = writer.prefix("DryRun");
if let Some(var_1178) = &input.dry_run {
scope_1177.boolean(*var_1178);
}
#[allow(unused_mut)]
let mut scope_1179 = writer.prefix("TagSpecification");
if let Some(var_1180) = &input.tag_specifications {
let mut list_1182 = scope_1179.start_list(true, Some("item"));
for item_1181 in var_1180 {
#[allow(unused_mut)]
let mut entry_1183 = list_1182.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1183, item_1181,
)?;
}
list_1182.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_replace_root_volume_task(
input: &crate::input::CreateReplaceRootVolumeTaskInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateReplaceRootVolumeTask", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1184 = writer.prefix("InstanceId");
if let Some(var_1185) = &input.instance_id {
scope_1184.string(var_1185);
}
#[allow(unused_mut)]
let mut scope_1186 = writer.prefix("SnapshotId");
if let Some(var_1187) = &input.snapshot_id {
scope_1186.string(var_1187);
}
#[allow(unused_mut)]
let mut scope_1188 = writer.prefix("ClientToken");
if let Some(var_1189) = &input.client_token {
scope_1188.string(var_1189);
}
#[allow(unused_mut)]
let mut scope_1190 = writer.prefix("DryRun");
if let Some(var_1191) = &input.dry_run {
scope_1190.boolean(*var_1191);
}
#[allow(unused_mut)]
let mut scope_1192 = writer.prefix("TagSpecification");
if let Some(var_1193) = &input.tag_specifications {
let mut list_1195 = scope_1192.start_list(true, Some("item"));
for item_1194 in var_1193 {
#[allow(unused_mut)]
let mut entry_1196 = list_1195.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1196, item_1194,
)?;
}
list_1195.finish();
}
#[allow(unused_mut)]
let mut scope_1197 = writer.prefix("ImageId");
if let Some(var_1198) = &input.image_id {
scope_1197.string(var_1198);
}
#[allow(unused_mut)]
let mut scope_1199 = writer.prefix("DeleteReplacedRootVolume");
if let Some(var_1200) = &input.delete_replaced_root_volume {
scope_1199.boolean(*var_1200);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_reserved_instances_listing(
input: &crate::input::CreateReservedInstancesListingInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateReservedInstancesListing",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1201 = writer.prefix("ClientToken");
if let Some(var_1202) = &input.client_token {
scope_1201.string(var_1202);
}
#[allow(unused_mut)]
let mut scope_1203 = writer.prefix("InstanceCount");
if let Some(var_1204) = &input.instance_count {
scope_1203.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1204).into()),
);
}
#[allow(unused_mut)]
let mut scope_1205 = writer.prefix("PriceSchedules");
if let Some(var_1206) = &input.price_schedules {
let mut list_1208 = scope_1205.start_list(true, Some("item"));
for item_1207 in var_1206 {
#[allow(unused_mut)]
let mut entry_1209 = list_1208.entry();
crate::query_ser::serialize_structure_crate_model_price_schedule_specification(
entry_1209, item_1207,
)?;
}
list_1208.finish();
}
#[allow(unused_mut)]
let mut scope_1210 = writer.prefix("ReservedInstancesId");
if let Some(var_1211) = &input.reserved_instances_id {
scope_1210.string(var_1211);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_restore_image_task(
input: &crate::input::CreateRestoreImageTaskInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateRestoreImageTask", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1212 = writer.prefix("Bucket");
if let Some(var_1213) = &input.bucket {
scope_1212.string(var_1213);
}
#[allow(unused_mut)]
let mut scope_1214 = writer.prefix("ObjectKey");
if let Some(var_1215) = &input.object_key {
scope_1214.string(var_1215);
}
#[allow(unused_mut)]
let mut scope_1216 = writer.prefix("Name");
if let Some(var_1217) = &input.name {
scope_1216.string(var_1217);
}
#[allow(unused_mut)]
let mut scope_1218 = writer.prefix("TagSpecification");
if let Some(var_1219) = &input.tag_specifications {
let mut list_1221 = scope_1218.start_list(true, Some("item"));
for item_1220 in var_1219 {
#[allow(unused_mut)]
let mut entry_1222 = list_1221.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1222, item_1220,
)?;
}
list_1221.finish();
}
#[allow(unused_mut)]
let mut scope_1223 = writer.prefix("DryRun");
if let Some(var_1224) = &input.dry_run {
scope_1223.boolean(*var_1224);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_route(
input: &crate::input::CreateRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1225 = writer.prefix("DestinationCidrBlock");
if let Some(var_1226) = &input.destination_cidr_block {
scope_1225.string(var_1226);
}
#[allow(unused_mut)]
let mut scope_1227 = writer.prefix("DestinationIpv6CidrBlock");
if let Some(var_1228) = &input.destination_ipv6_cidr_block {
scope_1227.string(var_1228);
}
#[allow(unused_mut)]
let mut scope_1229 = writer.prefix("DestinationPrefixListId");
if let Some(var_1230) = &input.destination_prefix_list_id {
scope_1229.string(var_1230);
}
#[allow(unused_mut)]
let mut scope_1231 = writer.prefix("DryRun");
if let Some(var_1232) = &input.dry_run {
scope_1231.boolean(*var_1232);
}
#[allow(unused_mut)]
let mut scope_1233 = writer.prefix("VpcEndpointId");
if let Some(var_1234) = &input.vpc_endpoint_id {
scope_1233.string(var_1234);
}
#[allow(unused_mut)]
let mut scope_1235 = writer.prefix("EgressOnlyInternetGatewayId");
if let Some(var_1236) = &input.egress_only_internet_gateway_id {
scope_1235.string(var_1236);
}
#[allow(unused_mut)]
let mut scope_1237 = writer.prefix("GatewayId");
if let Some(var_1238) = &input.gateway_id {
scope_1237.string(var_1238);
}
#[allow(unused_mut)]
let mut scope_1239 = writer.prefix("InstanceId");
if let Some(var_1240) = &input.instance_id {
scope_1239.string(var_1240);
}
#[allow(unused_mut)]
let mut scope_1241 = writer.prefix("NatGatewayId");
if let Some(var_1242) = &input.nat_gateway_id {
scope_1241.string(var_1242);
}
#[allow(unused_mut)]
let mut scope_1243 = writer.prefix("TransitGatewayId");
if let Some(var_1244) = &input.transit_gateway_id {
scope_1243.string(var_1244);
}
#[allow(unused_mut)]
let mut scope_1245 = writer.prefix("LocalGatewayId");
if let Some(var_1246) = &input.local_gateway_id {
scope_1245.string(var_1246);
}
#[allow(unused_mut)]
let mut scope_1247 = writer.prefix("CarrierGatewayId");
if let Some(var_1248) = &input.carrier_gateway_id {
scope_1247.string(var_1248);
}
#[allow(unused_mut)]
let mut scope_1249 = writer.prefix("NetworkInterfaceId");
if let Some(var_1250) = &input.network_interface_id {
scope_1249.string(var_1250);
}
#[allow(unused_mut)]
let mut scope_1251 = writer.prefix("RouteTableId");
if let Some(var_1252) = &input.route_table_id {
scope_1251.string(var_1252);
}
#[allow(unused_mut)]
let mut scope_1253 = writer.prefix("VpcPeeringConnectionId");
if let Some(var_1254) = &input.vpc_peering_connection_id {
scope_1253.string(var_1254);
}
#[allow(unused_mut)]
let mut scope_1255 = writer.prefix("CoreNetworkArn");
if let Some(var_1256) = &input.core_network_arn {
scope_1255.string(var_1256);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_route_table(
input: &crate::input::CreateRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateRouteTable", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1257 = writer.prefix("DryRun");
if let Some(var_1258) = &input.dry_run {
scope_1257.boolean(*var_1258);
}
#[allow(unused_mut)]
let mut scope_1259 = writer.prefix("VpcId");
if let Some(var_1260) = &input.vpc_id {
scope_1259.string(var_1260);
}
#[allow(unused_mut)]
let mut scope_1261 = writer.prefix("TagSpecification");
if let Some(var_1262) = &input.tag_specifications {
let mut list_1264 = scope_1261.start_list(true, Some("item"));
for item_1263 in var_1262 {
#[allow(unused_mut)]
let mut entry_1265 = list_1264.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1265, item_1263,
)?;
}
list_1264.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_security_group(
input: &crate::input::CreateSecurityGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateSecurityGroup", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1266 = writer.prefix("GroupDescription");
if let Some(var_1267) = &input.description {
scope_1266.string(var_1267);
}
#[allow(unused_mut)]
let mut scope_1268 = writer.prefix("GroupName");
if let Some(var_1269) = &input.group_name {
scope_1268.string(var_1269);
}
#[allow(unused_mut)]
let mut scope_1270 = writer.prefix("VpcId");
if let Some(var_1271) = &input.vpc_id {
scope_1270.string(var_1271);
}
#[allow(unused_mut)]
let mut scope_1272 = writer.prefix("TagSpecification");
if let Some(var_1273) = &input.tag_specifications {
let mut list_1275 = scope_1272.start_list(true, Some("item"));
for item_1274 in var_1273 {
#[allow(unused_mut)]
let mut entry_1276 = list_1275.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1276, item_1274,
)?;
}
list_1275.finish();
}
#[allow(unused_mut)]
let mut scope_1277 = writer.prefix("DryRun");
if let Some(var_1278) = &input.dry_run {
scope_1277.boolean(*var_1278);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_snapshot(
input: &crate::input::CreateSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateSnapshot", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1279 = writer.prefix("Description");
if let Some(var_1280) = &input.description {
scope_1279.string(var_1280);
}
#[allow(unused_mut)]
let mut scope_1281 = writer.prefix("OutpostArn");
if let Some(var_1282) = &input.outpost_arn {
scope_1281.string(var_1282);
}
#[allow(unused_mut)]
let mut scope_1283 = writer.prefix("VolumeId");
if let Some(var_1284) = &input.volume_id {
scope_1283.string(var_1284);
}
#[allow(unused_mut)]
let mut scope_1285 = writer.prefix("TagSpecification");
if let Some(var_1286) = &input.tag_specifications {
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_tag_specification(
entry_1289, item_1287,
)?;
}
list_1288.finish();
}
#[allow(unused_mut)]
let mut scope_1290 = writer.prefix("DryRun");
if let Some(var_1291) = &input.dry_run {
scope_1290.boolean(*var_1291);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_snapshots(
input: &crate::input::CreateSnapshotsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateSnapshots", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1292 = writer.prefix("Description");
if let Some(var_1293) = &input.description {
scope_1292.string(var_1293);
}
#[allow(unused_mut)]
let mut scope_1294 = writer.prefix("InstanceSpecification");
if let Some(var_1295) = &input.instance_specification {
crate::query_ser::serialize_structure_crate_model_instance_specification(
scope_1294, var_1295,
)?;
}
#[allow(unused_mut)]
let mut scope_1296 = writer.prefix("OutpostArn");
if let Some(var_1297) = &input.outpost_arn {
scope_1296.string(var_1297);
}
#[allow(unused_mut)]
let mut scope_1298 = writer.prefix("TagSpecification");
if let Some(var_1299) = &input.tag_specifications {
let mut list_1301 = scope_1298.start_list(true, Some("item"));
for item_1300 in var_1299 {
#[allow(unused_mut)]
let mut entry_1302 = list_1301.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1302, item_1300,
)?;
}
list_1301.finish();
}
#[allow(unused_mut)]
let mut scope_1303 = writer.prefix("DryRun");
if let Some(var_1304) = &input.dry_run {
scope_1303.boolean(*var_1304);
}
#[allow(unused_mut)]
let mut scope_1305 = writer.prefix("CopyTagsFromSource");
if let Some(var_1306) = &input.copy_tags_from_source {
scope_1305.string(var_1306.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_spot_datafeed_subscription(
input: &crate::input::CreateSpotDatafeedSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateSpotDatafeedSubscription",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1307 = writer.prefix("Bucket");
if let Some(var_1308) = &input.bucket {
scope_1307.string(var_1308);
}
#[allow(unused_mut)]
let mut scope_1309 = writer.prefix("DryRun");
if let Some(var_1310) = &input.dry_run {
scope_1309.boolean(*var_1310);
}
#[allow(unused_mut)]
let mut scope_1311 = writer.prefix("Prefix");
if let Some(var_1312) = &input.prefix {
scope_1311.string(var_1312);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_store_image_task(
input: &crate::input::CreateStoreImageTaskInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateStoreImageTask", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1313 = writer.prefix("ImageId");
if let Some(var_1314) = &input.image_id {
scope_1313.string(var_1314);
}
#[allow(unused_mut)]
let mut scope_1315 = writer.prefix("Bucket");
if let Some(var_1316) = &input.bucket {
scope_1315.string(var_1316);
}
#[allow(unused_mut)]
let mut scope_1317 = writer.prefix("S3ObjectTag");
if let Some(var_1318) = &input.s3_object_tags {
let mut list_1320 = scope_1317.start_list(true, Some("item"));
for item_1319 in var_1318 {
#[allow(unused_mut)]
let mut entry_1321 = list_1320.entry();
crate::query_ser::serialize_structure_crate_model_s3_object_tag(entry_1321, item_1319)?;
}
list_1320.finish();
}
#[allow(unused_mut)]
let mut scope_1322 = writer.prefix("DryRun");
if let Some(var_1323) = &input.dry_run {
scope_1322.boolean(*var_1323);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_subnet(
input: &crate::input::CreateSubnetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateSubnet", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1324 = writer.prefix("TagSpecification");
if let Some(var_1325) = &input.tag_specifications {
let mut list_1327 = scope_1324.start_list(true, Some("item"));
for item_1326 in var_1325 {
#[allow(unused_mut)]
let mut entry_1328 = list_1327.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1328, item_1326,
)?;
}
list_1327.finish();
}
#[allow(unused_mut)]
let mut scope_1329 = writer.prefix("AvailabilityZone");
if let Some(var_1330) = &input.availability_zone {
scope_1329.string(var_1330);
}
#[allow(unused_mut)]
let mut scope_1331 = writer.prefix("AvailabilityZoneId");
if let Some(var_1332) = &input.availability_zone_id {
scope_1331.string(var_1332);
}
#[allow(unused_mut)]
let mut scope_1333 = writer.prefix("CidrBlock");
if let Some(var_1334) = &input.cidr_block {
scope_1333.string(var_1334);
}
#[allow(unused_mut)]
let mut scope_1335 = writer.prefix("Ipv6CidrBlock");
if let Some(var_1336) = &input.ipv6_cidr_block {
scope_1335.string(var_1336);
}
#[allow(unused_mut)]
let mut scope_1337 = writer.prefix("OutpostArn");
if let Some(var_1338) = &input.outpost_arn {
scope_1337.string(var_1338);
}
#[allow(unused_mut)]
let mut scope_1339 = writer.prefix("VpcId");
if let Some(var_1340) = &input.vpc_id {
scope_1339.string(var_1340);
}
#[allow(unused_mut)]
let mut scope_1341 = writer.prefix("DryRun");
if let Some(var_1342) = &input.dry_run {
scope_1341.boolean(*var_1342);
}
#[allow(unused_mut)]
let mut scope_1343 = writer.prefix("Ipv6Native");
if let Some(var_1344) = &input.ipv6_native {
scope_1343.boolean(*var_1344);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_subnet_cidr_reservation(
input: &crate::input::CreateSubnetCidrReservationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateSubnetCidrReservation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1345 = writer.prefix("SubnetId");
if let Some(var_1346) = &input.subnet_id {
scope_1345.string(var_1346);
}
#[allow(unused_mut)]
let mut scope_1347 = writer.prefix("Cidr");
if let Some(var_1348) = &input.cidr {
scope_1347.string(var_1348);
}
#[allow(unused_mut)]
let mut scope_1349 = writer.prefix("ReservationType");
if let Some(var_1350) = &input.reservation_type {
scope_1349.string(var_1350.as_str());
}
#[allow(unused_mut)]
let mut scope_1351 = writer.prefix("Description");
if let Some(var_1352) = &input.description {
scope_1351.string(var_1352);
}
#[allow(unused_mut)]
let mut scope_1353 = writer.prefix("DryRun");
if let Some(var_1354) = &input.dry_run {
scope_1353.boolean(*var_1354);
}
#[allow(unused_mut)]
let mut scope_1355 = writer.prefix("TagSpecification");
if let Some(var_1356) = &input.tag_specifications {
let mut list_1358 = scope_1355.start_list(true, Some("item"));
for item_1357 in var_1356 {
#[allow(unused_mut)]
let mut entry_1359 = list_1358.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1359, item_1357,
)?;
}
list_1358.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_tags(
input: &crate::input::CreateTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateTags", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1360 = writer.prefix("DryRun");
if let Some(var_1361) = &input.dry_run {
scope_1360.boolean(*var_1361);
}
#[allow(unused_mut)]
let mut scope_1362 = writer.prefix("ResourceId");
if let Some(var_1363) = &input.resources {
let mut list_1365 = scope_1362.start_list(true, None);
for item_1364 in var_1363 {
#[allow(unused_mut)]
let mut entry_1366 = list_1365.entry();
entry_1366.string(item_1364);
}
list_1365.finish();
}
#[allow(unused_mut)]
let mut scope_1367 = writer.prefix("Tag");
if let Some(var_1368) = &input.tags {
let mut list_1370 = scope_1367.start_list(true, Some("item"));
for item_1369 in var_1368 {
#[allow(unused_mut)]
let mut entry_1371 = list_1370.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_1371, item_1369)?;
}
list_1370.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_traffic_mirror_filter(
input: &crate::input::CreateTrafficMirrorFilterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateTrafficMirrorFilter", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1372 = writer.prefix("Description");
if let Some(var_1373) = &input.description {
scope_1372.string(var_1373);
}
#[allow(unused_mut)]
let mut scope_1374 = writer.prefix("TagSpecification");
if let Some(var_1375) = &input.tag_specifications {
let mut list_1377 = scope_1374.start_list(true, Some("item"));
for item_1376 in var_1375 {
#[allow(unused_mut)]
let mut entry_1378 = list_1377.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1378, item_1376,
)?;
}
list_1377.finish();
}
#[allow(unused_mut)]
let mut scope_1379 = writer.prefix("DryRun");
if let Some(var_1380) = &input.dry_run {
scope_1379.boolean(*var_1380);
}
#[allow(unused_mut)]
let mut scope_1381 = writer.prefix("ClientToken");
if let Some(var_1382) = &input.client_token {
scope_1381.string(var_1382);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_traffic_mirror_filter_rule(
input: &crate::input::CreateTrafficMirrorFilterRuleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateTrafficMirrorFilterRule", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1383 = writer.prefix("TrafficMirrorFilterId");
if let Some(var_1384) = &input.traffic_mirror_filter_id {
scope_1383.string(var_1384);
}
#[allow(unused_mut)]
let mut scope_1385 = writer.prefix("TrafficDirection");
if let Some(var_1386) = &input.traffic_direction {
scope_1385.string(var_1386.as_str());
}
#[allow(unused_mut)]
let mut scope_1387 = writer.prefix("RuleNumber");
if let Some(var_1388) = &input.rule_number {
scope_1387.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1388).into()),
);
}
#[allow(unused_mut)]
let mut scope_1389 = writer.prefix("RuleAction");
if let Some(var_1390) = &input.rule_action {
scope_1389.string(var_1390.as_str());
}
#[allow(unused_mut)]
let mut scope_1391 = writer.prefix("DestinationPortRange");
if let Some(var_1392) = &input.destination_port_range {
crate::query_ser::serialize_structure_crate_model_traffic_mirror_port_range_request(
scope_1391, var_1392,
)?;
}
#[allow(unused_mut)]
let mut scope_1393 = writer.prefix("SourcePortRange");
if let Some(var_1394) = &input.source_port_range {
crate::query_ser::serialize_structure_crate_model_traffic_mirror_port_range_request(
scope_1393, var_1394,
)?;
}
#[allow(unused_mut)]
let mut scope_1395 = writer.prefix("Protocol");
if let Some(var_1396) = &input.protocol {
scope_1395.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1396).into()),
);
}
#[allow(unused_mut)]
let mut scope_1397 = writer.prefix("DestinationCidrBlock");
if let Some(var_1398) = &input.destination_cidr_block {
scope_1397.string(var_1398);
}
#[allow(unused_mut)]
let mut scope_1399 = writer.prefix("SourceCidrBlock");
if let Some(var_1400) = &input.source_cidr_block {
scope_1399.string(var_1400);
}
#[allow(unused_mut)]
let mut scope_1401 = writer.prefix("Description");
if let Some(var_1402) = &input.description {
scope_1401.string(var_1402);
}
#[allow(unused_mut)]
let mut scope_1403 = writer.prefix("DryRun");
if let Some(var_1404) = &input.dry_run {
scope_1403.boolean(*var_1404);
}
#[allow(unused_mut)]
let mut scope_1405 = writer.prefix("ClientToken");
if let Some(var_1406) = &input.client_token {
scope_1405.string(var_1406);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_traffic_mirror_session(
input: &crate::input::CreateTrafficMirrorSessionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateTrafficMirrorSession", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1407 = writer.prefix("NetworkInterfaceId");
if let Some(var_1408) = &input.network_interface_id {
scope_1407.string(var_1408);
}
#[allow(unused_mut)]
let mut scope_1409 = writer.prefix("TrafficMirrorTargetId");
if let Some(var_1410) = &input.traffic_mirror_target_id {
scope_1409.string(var_1410);
}
#[allow(unused_mut)]
let mut scope_1411 = writer.prefix("TrafficMirrorFilterId");
if let Some(var_1412) = &input.traffic_mirror_filter_id {
scope_1411.string(var_1412);
}
#[allow(unused_mut)]
let mut scope_1413 = writer.prefix("PacketLength");
if let Some(var_1414) = &input.packet_length {
scope_1413.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1414).into()),
);
}
#[allow(unused_mut)]
let mut scope_1415 = writer.prefix("SessionNumber");
if let Some(var_1416) = &input.session_number {
scope_1415.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1416).into()),
);
}
#[allow(unused_mut)]
let mut scope_1417 = writer.prefix("VirtualNetworkId");
if let Some(var_1418) = &input.virtual_network_id {
scope_1417.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1418).into()),
);
}
#[allow(unused_mut)]
let mut scope_1419 = writer.prefix("Description");
if let Some(var_1420) = &input.description {
scope_1419.string(var_1420);
}
#[allow(unused_mut)]
let mut scope_1421 = writer.prefix("TagSpecification");
if let Some(var_1422) = &input.tag_specifications {
let mut list_1424 = scope_1421.start_list(true, Some("item"));
for item_1423 in var_1422 {
#[allow(unused_mut)]
let mut entry_1425 = list_1424.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1425, item_1423,
)?;
}
list_1424.finish();
}
#[allow(unused_mut)]
let mut scope_1426 = writer.prefix("DryRun");
if let Some(var_1427) = &input.dry_run {
scope_1426.boolean(*var_1427);
}
#[allow(unused_mut)]
let mut scope_1428 = writer.prefix("ClientToken");
if let Some(var_1429) = &input.client_token {
scope_1428.string(var_1429);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_traffic_mirror_target(
input: &crate::input::CreateTrafficMirrorTargetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateTrafficMirrorTarget", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1430 = writer.prefix("NetworkInterfaceId");
if let Some(var_1431) = &input.network_interface_id {
scope_1430.string(var_1431);
}
#[allow(unused_mut)]
let mut scope_1432 = writer.prefix("NetworkLoadBalancerArn");
if let Some(var_1433) = &input.network_load_balancer_arn {
scope_1432.string(var_1433);
}
#[allow(unused_mut)]
let mut scope_1434 = writer.prefix("Description");
if let Some(var_1435) = &input.description {
scope_1434.string(var_1435);
}
#[allow(unused_mut)]
let mut scope_1436 = writer.prefix("TagSpecification");
if let Some(var_1437) = &input.tag_specifications {
let mut list_1439 = scope_1436.start_list(true, Some("item"));
for item_1438 in var_1437 {
#[allow(unused_mut)]
let mut entry_1440 = list_1439.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1440, item_1438,
)?;
}
list_1439.finish();
}
#[allow(unused_mut)]
let mut scope_1441 = writer.prefix("DryRun");
if let Some(var_1442) = &input.dry_run {
scope_1441.boolean(*var_1442);
}
#[allow(unused_mut)]
let mut scope_1443 = writer.prefix("ClientToken");
if let Some(var_1444) = &input.client_token {
scope_1443.string(var_1444);
}
#[allow(unused_mut)]
let mut scope_1445 = writer.prefix("GatewayLoadBalancerEndpointId");
if let Some(var_1446) = &input.gateway_load_balancer_endpoint_id {
scope_1445.string(var_1446);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway(
input: &crate::input::CreateTransitGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateTransitGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1447 = writer.prefix("Description");
if let Some(var_1448) = &input.description {
scope_1447.string(var_1448);
}
#[allow(unused_mut)]
let mut scope_1449 = writer.prefix("Options");
if let Some(var_1450) = &input.options {
crate::query_ser::serialize_structure_crate_model_transit_gateway_request_options(
scope_1449, var_1450,
)?;
}
#[allow(unused_mut)]
let mut scope_1451 = writer.prefix("TagSpecification");
if let Some(var_1452) = &input.tag_specifications {
let mut list_1454 = scope_1451.start_list(true, Some("item"));
for item_1453 in var_1452 {
#[allow(unused_mut)]
let mut entry_1455 = list_1454.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1455, item_1453,
)?;
}
list_1454.finish();
}
#[allow(unused_mut)]
let mut scope_1456 = writer.prefix("DryRun");
if let Some(var_1457) = &input.dry_run {
scope_1456.boolean(*var_1457);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway_connect(
input: &crate::input::CreateTransitGatewayConnectInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateTransitGatewayConnect", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1458 = writer.prefix("TransportTransitGatewayAttachmentId");
if let Some(var_1459) = &input.transport_transit_gateway_attachment_id {
scope_1458.string(var_1459);
}
#[allow(unused_mut)]
let mut scope_1460 = writer.prefix("Options");
if let Some(var_1461) = &input.options {
crate::query_ser::serialize_structure_crate_model_create_transit_gateway_connect_request_options(scope_1460, var_1461)?;
}
#[allow(unused_mut)]
let mut scope_1462 = writer.prefix("TagSpecification");
if let Some(var_1463) = &input.tag_specifications {
let mut list_1465 = scope_1462.start_list(true, Some("item"));
for item_1464 in var_1463 {
#[allow(unused_mut)]
let mut entry_1466 = list_1465.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1466, item_1464,
)?;
}
list_1465.finish();
}
#[allow(unused_mut)]
let mut scope_1467 = writer.prefix("DryRun");
if let Some(var_1468) = &input.dry_run {
scope_1467.boolean(*var_1468);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway_connect_peer(
input: &crate::input::CreateTransitGatewayConnectPeerInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateTransitGatewayConnectPeer",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1469 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_1470) = &input.transit_gateway_attachment_id {
scope_1469.string(var_1470);
}
#[allow(unused_mut)]
let mut scope_1471 = writer.prefix("TransitGatewayAddress");
if let Some(var_1472) = &input.transit_gateway_address {
scope_1471.string(var_1472);
}
#[allow(unused_mut)]
let mut scope_1473 = writer.prefix("PeerAddress");
if let Some(var_1474) = &input.peer_address {
scope_1473.string(var_1474);
}
#[allow(unused_mut)]
let mut scope_1475 = writer.prefix("BgpOptions");
if let Some(var_1476) = &input.bgp_options {
crate::query_ser::serialize_structure_crate_model_transit_gateway_connect_request_bgp_options(scope_1475, var_1476)?;
}
#[allow(unused_mut)]
let mut scope_1477 = writer.prefix("InsideCidrBlocks");
if let Some(var_1478) = &input.inside_cidr_blocks {
let mut list_1480 = scope_1477.start_list(true, Some("item"));
for item_1479 in var_1478 {
#[allow(unused_mut)]
let mut entry_1481 = list_1480.entry();
entry_1481.string(item_1479);
}
list_1480.finish();
}
#[allow(unused_mut)]
let mut scope_1482 = writer.prefix("TagSpecification");
if let Some(var_1483) = &input.tag_specifications {
let mut list_1485 = scope_1482.start_list(true, Some("item"));
for item_1484 in var_1483 {
#[allow(unused_mut)]
let mut entry_1486 = list_1485.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1486, item_1484,
)?;
}
list_1485.finish();
}
#[allow(unused_mut)]
let mut scope_1487 = writer.prefix("DryRun");
if let Some(var_1488) = &input.dry_run {
scope_1487.boolean(*var_1488);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway_multicast_domain(
input: &crate::input::CreateTransitGatewayMulticastDomainInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateTransitGatewayMulticastDomain",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1489 = writer.prefix("TransitGatewayId");
if let Some(var_1490) = &input.transit_gateway_id {
scope_1489.string(var_1490);
}
#[allow(unused_mut)]
let mut scope_1491 = writer.prefix("Options");
if let Some(var_1492) = &input.options {
crate::query_ser::serialize_structure_crate_model_create_transit_gateway_multicast_domain_request_options(scope_1491, var_1492)?;
}
#[allow(unused_mut)]
let mut scope_1493 = writer.prefix("TagSpecification");
if let Some(var_1494) = &input.tag_specifications {
let mut list_1496 = scope_1493.start_list(true, Some("item"));
for item_1495 in var_1494 {
#[allow(unused_mut)]
let mut entry_1497 = list_1496.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1497, item_1495,
)?;
}
list_1496.finish();
}
#[allow(unused_mut)]
let mut scope_1498 = writer.prefix("DryRun");
if let Some(var_1499) = &input.dry_run {
scope_1498.boolean(*var_1499);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway_peering_attachment(
input: &crate::input::CreateTransitGatewayPeeringAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateTransitGatewayPeeringAttachment",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1500 = writer.prefix("TransitGatewayId");
if let Some(var_1501) = &input.transit_gateway_id {
scope_1500.string(var_1501);
}
#[allow(unused_mut)]
let mut scope_1502 = writer.prefix("PeerTransitGatewayId");
if let Some(var_1503) = &input.peer_transit_gateway_id {
scope_1502.string(var_1503);
}
#[allow(unused_mut)]
let mut scope_1504 = writer.prefix("PeerAccountId");
if let Some(var_1505) = &input.peer_account_id {
scope_1504.string(var_1505);
}
#[allow(unused_mut)]
let mut scope_1506 = writer.prefix("PeerRegion");
if let Some(var_1507) = &input.peer_region {
scope_1506.string(var_1507);
}
#[allow(unused_mut)]
let mut scope_1508 = writer.prefix("Options");
if let Some(var_1509) = &input.options {
crate::query_ser::serialize_structure_crate_model_create_transit_gateway_peering_attachment_request_options(scope_1508, var_1509)?;
}
#[allow(unused_mut)]
let mut scope_1510 = writer.prefix("TagSpecification");
if let Some(var_1511) = &input.tag_specifications {
let mut list_1513 = scope_1510.start_list(true, Some("item"));
for item_1512 in var_1511 {
#[allow(unused_mut)]
let mut entry_1514 = list_1513.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1514, item_1512,
)?;
}
list_1513.finish();
}
#[allow(unused_mut)]
let mut scope_1515 = writer.prefix("DryRun");
if let Some(var_1516) = &input.dry_run {
scope_1515.boolean(*var_1516);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway_policy_table(
input: &crate::input::CreateTransitGatewayPolicyTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateTransitGatewayPolicyTable",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1517 = writer.prefix("TransitGatewayId");
if let Some(var_1518) = &input.transit_gateway_id {
scope_1517.string(var_1518);
}
#[allow(unused_mut)]
let mut scope_1519 = writer.prefix("TagSpecifications");
if let Some(var_1520) = &input.tag_specifications {
let mut list_1522 = scope_1519.start_list(true, Some("item"));
for item_1521 in var_1520 {
#[allow(unused_mut)]
let mut entry_1523 = list_1522.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1523, item_1521,
)?;
}
list_1522.finish();
}
#[allow(unused_mut)]
let mut scope_1524 = writer.prefix("DryRun");
if let Some(var_1525) = &input.dry_run {
scope_1524.boolean(*var_1525);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway_prefix_list_reference(
input: &crate::input::CreateTransitGatewayPrefixListReferenceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateTransitGatewayPrefixListReference",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1526 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_1527) = &input.transit_gateway_route_table_id {
scope_1526.string(var_1527);
}
#[allow(unused_mut)]
let mut scope_1528 = writer.prefix("PrefixListId");
if let Some(var_1529) = &input.prefix_list_id {
scope_1528.string(var_1529);
}
#[allow(unused_mut)]
let mut scope_1530 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_1531) = &input.transit_gateway_attachment_id {
scope_1530.string(var_1531);
}
#[allow(unused_mut)]
let mut scope_1532 = writer.prefix("Blackhole");
if let Some(var_1533) = &input.blackhole {
scope_1532.boolean(*var_1533);
}
#[allow(unused_mut)]
let mut scope_1534 = writer.prefix("DryRun");
if let Some(var_1535) = &input.dry_run {
scope_1534.boolean(*var_1535);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway_route(
input: &crate::input::CreateTransitGatewayRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateTransitGatewayRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1536 = writer.prefix("DestinationCidrBlock");
if let Some(var_1537) = &input.destination_cidr_block {
scope_1536.string(var_1537);
}
#[allow(unused_mut)]
let mut scope_1538 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_1539) = &input.transit_gateway_route_table_id {
scope_1538.string(var_1539);
}
#[allow(unused_mut)]
let mut scope_1540 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_1541) = &input.transit_gateway_attachment_id {
scope_1540.string(var_1541);
}
#[allow(unused_mut)]
let mut scope_1542 = writer.prefix("Blackhole");
if let Some(var_1543) = &input.blackhole {
scope_1542.boolean(*var_1543);
}
#[allow(unused_mut)]
let mut scope_1544 = writer.prefix("DryRun");
if let Some(var_1545) = &input.dry_run {
scope_1544.boolean(*var_1545);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway_route_table(
input: &crate::input::CreateTransitGatewayRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateTransitGatewayRouteTable",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1546 = writer.prefix("TransitGatewayId");
if let Some(var_1547) = &input.transit_gateway_id {
scope_1546.string(var_1547);
}
#[allow(unused_mut)]
let mut scope_1548 = writer.prefix("TagSpecifications");
if let Some(var_1549) = &input.tag_specifications {
let mut list_1551 = scope_1548.start_list(true, Some("item"));
for item_1550 in var_1549 {
#[allow(unused_mut)]
let mut entry_1552 = list_1551.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1552, item_1550,
)?;
}
list_1551.finish();
}
#[allow(unused_mut)]
let mut scope_1553 = writer.prefix("DryRun");
if let Some(var_1554) = &input.dry_run {
scope_1553.boolean(*var_1554);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway_route_table_announcement(
input: &crate::input::CreateTransitGatewayRouteTableAnnouncementInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateTransitGatewayRouteTableAnnouncement",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1555 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_1556) = &input.transit_gateway_route_table_id {
scope_1555.string(var_1556);
}
#[allow(unused_mut)]
let mut scope_1557 = writer.prefix("PeeringAttachmentId");
if let Some(var_1558) = &input.peering_attachment_id {
scope_1557.string(var_1558);
}
#[allow(unused_mut)]
let mut scope_1559 = writer.prefix("TagSpecification");
if let Some(var_1560) = &input.tag_specifications {
let mut list_1562 = scope_1559.start_list(true, Some("item"));
for item_1561 in var_1560 {
#[allow(unused_mut)]
let mut entry_1563 = list_1562.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1563, item_1561,
)?;
}
list_1562.finish();
}
#[allow(unused_mut)]
let mut scope_1564 = writer.prefix("DryRun");
if let Some(var_1565) = &input.dry_run {
scope_1564.boolean(*var_1565);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_transit_gateway_vpc_attachment(
input: &crate::input::CreateTransitGatewayVpcAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateTransitGatewayVpcAttachment",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1566 = writer.prefix("TransitGatewayId");
if let Some(var_1567) = &input.transit_gateway_id {
scope_1566.string(var_1567);
}
#[allow(unused_mut)]
let mut scope_1568 = writer.prefix("VpcId");
if let Some(var_1569) = &input.vpc_id {
scope_1568.string(var_1569);
}
#[allow(unused_mut)]
let mut scope_1570 = writer.prefix("SubnetIds");
if let Some(var_1571) = &input.subnet_ids {
let mut list_1573 = scope_1570.start_list(true, Some("item"));
for item_1572 in var_1571 {
#[allow(unused_mut)]
let mut entry_1574 = list_1573.entry();
entry_1574.string(item_1572);
}
list_1573.finish();
}
#[allow(unused_mut)]
let mut scope_1575 = writer.prefix("Options");
if let Some(var_1576) = &input.options {
crate::query_ser::serialize_structure_crate_model_create_transit_gateway_vpc_attachment_request_options(scope_1575, var_1576)?;
}
#[allow(unused_mut)]
let mut scope_1577 = writer.prefix("TagSpecifications");
if let Some(var_1578) = &input.tag_specifications {
let mut list_1580 = scope_1577.start_list(true, Some("item"));
for item_1579 in var_1578 {
#[allow(unused_mut)]
let mut entry_1581 = list_1580.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1581, item_1579,
)?;
}
list_1580.finish();
}
#[allow(unused_mut)]
let mut scope_1582 = writer.prefix("DryRun");
if let Some(var_1583) = &input.dry_run {
scope_1582.boolean(*var_1583);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_verified_access_endpoint(
input: &crate::input::CreateVerifiedAccessEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateVerifiedAccessEndpoint", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1584 = writer.prefix("VerifiedAccessGroupId");
if let Some(var_1585) = &input.verified_access_group_id {
scope_1584.string(var_1585);
}
#[allow(unused_mut)]
let mut scope_1586 = writer.prefix("EndpointType");
if let Some(var_1587) = &input.endpoint_type {
scope_1586.string(var_1587.as_str());
}
#[allow(unused_mut)]
let mut scope_1588 = writer.prefix("AttachmentType");
if let Some(var_1589) = &input.attachment_type {
scope_1588.string(var_1589.as_str());
}
#[allow(unused_mut)]
let mut scope_1590 = writer.prefix("DomainCertificateArn");
if let Some(var_1591) = &input.domain_certificate_arn {
scope_1590.string(var_1591);
}
#[allow(unused_mut)]
let mut scope_1592 = writer.prefix("ApplicationDomain");
if let Some(var_1593) = &input.application_domain {
scope_1592.string(var_1593);
}
#[allow(unused_mut)]
let mut scope_1594 = writer.prefix("EndpointDomainPrefix");
if let Some(var_1595) = &input.endpoint_domain_prefix {
scope_1594.string(var_1595);
}
#[allow(unused_mut)]
let mut scope_1596 = writer.prefix("SecurityGroupId");
if let Some(var_1597) = &input.security_group_ids {
let mut list_1599 = scope_1596.start_list(true, Some("item"));
for item_1598 in var_1597 {
#[allow(unused_mut)]
let mut entry_1600 = list_1599.entry();
entry_1600.string(item_1598);
}
list_1599.finish();
}
#[allow(unused_mut)]
let mut scope_1601 = writer.prefix("LoadBalancerOptions");
if let Some(var_1602) = &input.load_balancer_options {
crate::query_ser::serialize_structure_crate_model_create_verified_access_endpoint_load_balancer_options(scope_1601, var_1602)?;
}
#[allow(unused_mut)]
let mut scope_1603 = writer.prefix("NetworkInterfaceOptions");
if let Some(var_1604) = &input.network_interface_options {
crate::query_ser::serialize_structure_crate_model_create_verified_access_endpoint_eni_options(scope_1603, var_1604)?;
}
#[allow(unused_mut)]
let mut scope_1605 = writer.prefix("Description");
if let Some(var_1606) = &input.description {
scope_1605.string(var_1606);
}
#[allow(unused_mut)]
let mut scope_1607 = writer.prefix("PolicyDocument");
if let Some(var_1608) = &input.policy_document {
scope_1607.string(var_1608);
}
#[allow(unused_mut)]
let mut scope_1609 = writer.prefix("TagSpecification");
if let Some(var_1610) = &input.tag_specifications {
let mut list_1612 = scope_1609.start_list(true, Some("item"));
for item_1611 in var_1610 {
#[allow(unused_mut)]
let mut entry_1613 = list_1612.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1613, item_1611,
)?;
}
list_1612.finish();
}
#[allow(unused_mut)]
let mut scope_1614 = writer.prefix("ClientToken");
if let Some(var_1615) = &input.client_token {
scope_1614.string(var_1615);
}
#[allow(unused_mut)]
let mut scope_1616 = writer.prefix("DryRun");
if let Some(var_1617) = &input.dry_run {
scope_1616.boolean(*var_1617);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_verified_access_group(
input: &crate::input::CreateVerifiedAccessGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateVerifiedAccessGroup", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1618 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_1619) = &input.verified_access_instance_id {
scope_1618.string(var_1619);
}
#[allow(unused_mut)]
let mut scope_1620 = writer.prefix("Description");
if let Some(var_1621) = &input.description {
scope_1620.string(var_1621);
}
#[allow(unused_mut)]
let mut scope_1622 = writer.prefix("PolicyDocument");
if let Some(var_1623) = &input.policy_document {
scope_1622.string(var_1623);
}
#[allow(unused_mut)]
let mut scope_1624 = writer.prefix("TagSpecification");
if let Some(var_1625) = &input.tag_specifications {
let mut list_1627 = scope_1624.start_list(true, Some("item"));
for item_1626 in var_1625 {
#[allow(unused_mut)]
let mut entry_1628 = list_1627.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1628, item_1626,
)?;
}
list_1627.finish();
}
#[allow(unused_mut)]
let mut scope_1629 = writer.prefix("ClientToken");
if let Some(var_1630) = &input.client_token {
scope_1629.string(var_1630);
}
#[allow(unused_mut)]
let mut scope_1631 = writer.prefix("DryRun");
if let Some(var_1632) = &input.dry_run {
scope_1631.boolean(*var_1632);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_verified_access_instance(
input: &crate::input::CreateVerifiedAccessInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateVerifiedAccessInstance", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1633 = writer.prefix("Description");
if let Some(var_1634) = &input.description {
scope_1633.string(var_1634);
}
#[allow(unused_mut)]
let mut scope_1635 = writer.prefix("TagSpecification");
if let Some(var_1636) = &input.tag_specifications {
let mut list_1638 = scope_1635.start_list(true, Some("item"));
for item_1637 in var_1636 {
#[allow(unused_mut)]
let mut entry_1639 = list_1638.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1639, item_1637,
)?;
}
list_1638.finish();
}
#[allow(unused_mut)]
let mut scope_1640 = writer.prefix("ClientToken");
if let Some(var_1641) = &input.client_token {
scope_1640.string(var_1641);
}
#[allow(unused_mut)]
let mut scope_1642 = writer.prefix("DryRun");
if let Some(var_1643) = &input.dry_run {
scope_1642.boolean(*var_1643);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_verified_access_trust_provider(
input: &crate::input::CreateVerifiedAccessTrustProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateVerifiedAccessTrustProvider",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1644 = writer.prefix("TrustProviderType");
if let Some(var_1645) = &input.trust_provider_type {
scope_1644.string(var_1645.as_str());
}
#[allow(unused_mut)]
let mut scope_1646 = writer.prefix("UserTrustProviderType");
if let Some(var_1647) = &input.user_trust_provider_type {
scope_1646.string(var_1647.as_str());
}
#[allow(unused_mut)]
let mut scope_1648 = writer.prefix("DeviceTrustProviderType");
if let Some(var_1649) = &input.device_trust_provider_type {
scope_1648.string(var_1649.as_str());
}
#[allow(unused_mut)]
let mut scope_1650 = writer.prefix("OidcOptions");
if let Some(var_1651) = &input.oidc_options {
crate::query_ser::serialize_structure_crate_model_create_verified_access_trust_provider_oidc_options(scope_1650, var_1651)?;
}
#[allow(unused_mut)]
let mut scope_1652 = writer.prefix("DeviceOptions");
if let Some(var_1653) = &input.device_options {
crate::query_ser::serialize_structure_crate_model_create_verified_access_trust_provider_device_options(scope_1652, var_1653)?;
}
#[allow(unused_mut)]
let mut scope_1654 = writer.prefix("PolicyReferenceName");
if let Some(var_1655) = &input.policy_reference_name {
scope_1654.string(var_1655);
}
#[allow(unused_mut)]
let mut scope_1656 = writer.prefix("Description");
if let Some(var_1657) = &input.description {
scope_1656.string(var_1657);
}
#[allow(unused_mut)]
let mut scope_1658 = writer.prefix("TagSpecification");
if let Some(var_1659) = &input.tag_specifications {
let mut list_1661 = scope_1658.start_list(true, Some("item"));
for item_1660 in var_1659 {
#[allow(unused_mut)]
let mut entry_1662 = list_1661.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1662, item_1660,
)?;
}
list_1661.finish();
}
#[allow(unused_mut)]
let mut scope_1663 = writer.prefix("ClientToken");
if let Some(var_1664) = &input.client_token {
scope_1663.string(var_1664);
}
#[allow(unused_mut)]
let mut scope_1665 = writer.prefix("DryRun");
if let Some(var_1666) = &input.dry_run {
scope_1665.boolean(*var_1666);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_volume(
input: &crate::input::CreateVolumeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateVolume", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1667 = writer.prefix("AvailabilityZone");
if let Some(var_1668) = &input.availability_zone {
scope_1667.string(var_1668);
}
#[allow(unused_mut)]
let mut scope_1669 = writer.prefix("Encrypted");
if let Some(var_1670) = &input.encrypted {
scope_1669.boolean(*var_1670);
}
#[allow(unused_mut)]
let mut scope_1671 = writer.prefix("Iops");
if let Some(var_1672) = &input.iops {
scope_1671.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1672).into()),
);
}
#[allow(unused_mut)]
let mut scope_1673 = writer.prefix("KmsKeyId");
if let Some(var_1674) = &input.kms_key_id {
scope_1673.string(var_1674);
}
#[allow(unused_mut)]
let mut scope_1675 = writer.prefix("OutpostArn");
if let Some(var_1676) = &input.outpost_arn {
scope_1675.string(var_1676);
}
#[allow(unused_mut)]
let mut scope_1677 = writer.prefix("Size");
if let Some(var_1678) = &input.size {
scope_1677.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1678).into()),
);
}
#[allow(unused_mut)]
let mut scope_1679 = writer.prefix("SnapshotId");
if let Some(var_1680) = &input.snapshot_id {
scope_1679.string(var_1680);
}
#[allow(unused_mut)]
let mut scope_1681 = writer.prefix("VolumeType");
if let Some(var_1682) = &input.volume_type {
scope_1681.string(var_1682.as_str());
}
#[allow(unused_mut)]
let mut scope_1683 = writer.prefix("DryRun");
if let Some(var_1684) = &input.dry_run {
scope_1683.boolean(*var_1684);
}
#[allow(unused_mut)]
let mut scope_1685 = writer.prefix("TagSpecification");
if let Some(var_1686) = &input.tag_specifications {
let mut list_1688 = scope_1685.start_list(true, Some("item"));
for item_1687 in var_1686 {
#[allow(unused_mut)]
let mut entry_1689 = list_1688.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1689, item_1687,
)?;
}
list_1688.finish();
}
#[allow(unused_mut)]
let mut scope_1690 = writer.prefix("MultiAttachEnabled");
if let Some(var_1691) = &input.multi_attach_enabled {
scope_1690.boolean(*var_1691);
}
#[allow(unused_mut)]
let mut scope_1692 = writer.prefix("Throughput");
if let Some(var_1693) = &input.throughput {
scope_1692.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1693).into()),
);
}
#[allow(unused_mut)]
let mut scope_1694 = writer.prefix("ClientToken");
if let Some(var_1695) = &input.client_token {
scope_1694.string(var_1695);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_vpc(
input: &crate::input::CreateVpcInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateVpc", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1696 = writer.prefix("CidrBlock");
if let Some(var_1697) = &input.cidr_block {
scope_1696.string(var_1697);
}
#[allow(unused_mut)]
let mut scope_1698 = writer.prefix("AmazonProvidedIpv6CidrBlock");
if let Some(var_1699) = &input.amazon_provided_ipv6_cidr_block {
scope_1698.boolean(*var_1699);
}
#[allow(unused_mut)]
let mut scope_1700 = writer.prefix("Ipv6Pool");
if let Some(var_1701) = &input.ipv6_pool {
scope_1700.string(var_1701);
}
#[allow(unused_mut)]
let mut scope_1702 = writer.prefix("Ipv6CidrBlock");
if let Some(var_1703) = &input.ipv6_cidr_block {
scope_1702.string(var_1703);
}
#[allow(unused_mut)]
let mut scope_1704 = writer.prefix("Ipv4IpamPoolId");
if let Some(var_1705) = &input.ipv4_ipam_pool_id {
scope_1704.string(var_1705);
}
#[allow(unused_mut)]
let mut scope_1706 = writer.prefix("Ipv4NetmaskLength");
if let Some(var_1707) = &input.ipv4_netmask_length {
scope_1706.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1707).into()),
);
}
#[allow(unused_mut)]
let mut scope_1708 = writer.prefix("Ipv6IpamPoolId");
if let Some(var_1709) = &input.ipv6_ipam_pool_id {
scope_1708.string(var_1709);
}
#[allow(unused_mut)]
let mut scope_1710 = writer.prefix("Ipv6NetmaskLength");
if let Some(var_1711) = &input.ipv6_netmask_length {
scope_1710.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1711).into()),
);
}
#[allow(unused_mut)]
let mut scope_1712 = writer.prefix("DryRun");
if let Some(var_1713) = &input.dry_run {
scope_1712.boolean(*var_1713);
}
#[allow(unused_mut)]
let mut scope_1714 = writer.prefix("InstanceTenancy");
if let Some(var_1715) = &input.instance_tenancy {
scope_1714.string(var_1715.as_str());
}
#[allow(unused_mut)]
let mut scope_1716 = writer.prefix("Ipv6CidrBlockNetworkBorderGroup");
if let Some(var_1717) = &input.ipv6_cidr_block_network_border_group {
scope_1716.string(var_1717);
}
#[allow(unused_mut)]
let mut scope_1718 = writer.prefix("TagSpecification");
if let Some(var_1719) = &input.tag_specifications {
let mut list_1721 = scope_1718.start_list(true, Some("item"));
for item_1720 in var_1719 {
#[allow(unused_mut)]
let mut entry_1722 = list_1721.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1722, item_1720,
)?;
}
list_1721.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_vpc_endpoint(
input: &crate::input::CreateVpcEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateVpcEndpoint", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1723 = writer.prefix("DryRun");
if let Some(var_1724) = &input.dry_run {
scope_1723.boolean(*var_1724);
}
#[allow(unused_mut)]
let mut scope_1725 = writer.prefix("VpcEndpointType");
if let Some(var_1726) = &input.vpc_endpoint_type {
scope_1725.string(var_1726.as_str());
}
#[allow(unused_mut)]
let mut scope_1727 = writer.prefix("VpcId");
if let Some(var_1728) = &input.vpc_id {
scope_1727.string(var_1728);
}
#[allow(unused_mut)]
let mut scope_1729 = writer.prefix("ServiceName");
if let Some(var_1730) = &input.service_name {
scope_1729.string(var_1730);
}
#[allow(unused_mut)]
let mut scope_1731 = writer.prefix("PolicyDocument");
if let Some(var_1732) = &input.policy_document {
scope_1731.string(var_1732);
}
#[allow(unused_mut)]
let mut scope_1733 = writer.prefix("RouteTableId");
if let Some(var_1734) = &input.route_table_ids {
let mut list_1736 = scope_1733.start_list(true, Some("item"));
for item_1735 in var_1734 {
#[allow(unused_mut)]
let mut entry_1737 = list_1736.entry();
entry_1737.string(item_1735);
}
list_1736.finish();
}
#[allow(unused_mut)]
let mut scope_1738 = writer.prefix("SubnetId");
if let Some(var_1739) = &input.subnet_ids {
let mut list_1741 = scope_1738.start_list(true, Some("item"));
for item_1740 in var_1739 {
#[allow(unused_mut)]
let mut entry_1742 = list_1741.entry();
entry_1742.string(item_1740);
}
list_1741.finish();
}
#[allow(unused_mut)]
let mut scope_1743 = writer.prefix("SecurityGroupId");
if let Some(var_1744) = &input.security_group_ids {
let mut list_1746 = scope_1743.start_list(true, Some("item"));
for item_1745 in var_1744 {
#[allow(unused_mut)]
let mut entry_1747 = list_1746.entry();
entry_1747.string(item_1745);
}
list_1746.finish();
}
#[allow(unused_mut)]
let mut scope_1748 = writer.prefix("IpAddressType");
if let Some(var_1749) = &input.ip_address_type {
scope_1748.string(var_1749.as_str());
}
#[allow(unused_mut)]
let mut scope_1750 = writer.prefix("DnsOptions");
if let Some(var_1751) = &input.dns_options {
crate::query_ser::serialize_structure_crate_model_dns_options_specification(
scope_1750, var_1751,
)?;
}
#[allow(unused_mut)]
let mut scope_1752 = writer.prefix("ClientToken");
if let Some(var_1753) = &input.client_token {
scope_1752.string(var_1753);
}
#[allow(unused_mut)]
let mut scope_1754 = writer.prefix("PrivateDnsEnabled");
if let Some(var_1755) = &input.private_dns_enabled {
scope_1754.boolean(*var_1755);
}
#[allow(unused_mut)]
let mut scope_1756 = writer.prefix("TagSpecification");
if let Some(var_1757) = &input.tag_specifications {
let mut list_1759 = scope_1756.start_list(true, Some("item"));
for item_1758 in var_1757 {
#[allow(unused_mut)]
let mut entry_1760 = list_1759.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1760, item_1758,
)?;
}
list_1759.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_vpc_endpoint_connection_notification(
input: &crate::input::CreateVpcEndpointConnectionNotificationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateVpcEndpointConnectionNotification",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1761 = writer.prefix("DryRun");
if let Some(var_1762) = &input.dry_run {
scope_1761.boolean(*var_1762);
}
#[allow(unused_mut)]
let mut scope_1763 = writer.prefix("ServiceId");
if let Some(var_1764) = &input.service_id {
scope_1763.string(var_1764);
}
#[allow(unused_mut)]
let mut scope_1765 = writer.prefix("VpcEndpointId");
if let Some(var_1766) = &input.vpc_endpoint_id {
scope_1765.string(var_1766);
}
#[allow(unused_mut)]
let mut scope_1767 = writer.prefix("ConnectionNotificationArn");
if let Some(var_1768) = &input.connection_notification_arn {
scope_1767.string(var_1768);
}
#[allow(unused_mut)]
let mut scope_1769 = writer.prefix("ConnectionEvents");
if let Some(var_1770) = &input.connection_events {
let mut list_1772 = scope_1769.start_list(true, Some("item"));
for item_1771 in var_1770 {
#[allow(unused_mut)]
let mut entry_1773 = list_1772.entry();
entry_1773.string(item_1771);
}
list_1772.finish();
}
#[allow(unused_mut)]
let mut scope_1774 = writer.prefix("ClientToken");
if let Some(var_1775) = &input.client_token {
scope_1774.string(var_1775);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_vpc_endpoint_service_configuration(
input: &crate::input::CreateVpcEndpointServiceConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateVpcEndpointServiceConfiguration",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1776 = writer.prefix("DryRun");
if let Some(var_1777) = &input.dry_run {
scope_1776.boolean(*var_1777);
}
#[allow(unused_mut)]
let mut scope_1778 = writer.prefix("AcceptanceRequired");
if let Some(var_1779) = &input.acceptance_required {
scope_1778.boolean(*var_1779);
}
#[allow(unused_mut)]
let mut scope_1780 = writer.prefix("PrivateDnsName");
if let Some(var_1781) = &input.private_dns_name {
scope_1780.string(var_1781);
}
#[allow(unused_mut)]
let mut scope_1782 = writer.prefix("NetworkLoadBalancerArn");
if let Some(var_1783) = &input.network_load_balancer_arns {
let mut list_1785 = scope_1782.start_list(true, Some("item"));
for item_1784 in var_1783 {
#[allow(unused_mut)]
let mut entry_1786 = list_1785.entry();
entry_1786.string(item_1784);
}
list_1785.finish();
}
#[allow(unused_mut)]
let mut scope_1787 = writer.prefix("GatewayLoadBalancerArn");
if let Some(var_1788) = &input.gateway_load_balancer_arns {
let mut list_1790 = scope_1787.start_list(true, Some("item"));
for item_1789 in var_1788 {
#[allow(unused_mut)]
let mut entry_1791 = list_1790.entry();
entry_1791.string(item_1789);
}
list_1790.finish();
}
#[allow(unused_mut)]
let mut scope_1792 = writer.prefix("SupportedIpAddressType");
if let Some(var_1793) = &input.supported_ip_address_types {
let mut list_1795 = scope_1792.start_list(true, Some("item"));
for item_1794 in var_1793 {
#[allow(unused_mut)]
let mut entry_1796 = list_1795.entry();
entry_1796.string(item_1794);
}
list_1795.finish();
}
#[allow(unused_mut)]
let mut scope_1797 = writer.prefix("ClientToken");
if let Some(var_1798) = &input.client_token {
scope_1797.string(var_1798);
}
#[allow(unused_mut)]
let mut scope_1799 = writer.prefix("TagSpecification");
if let Some(var_1800) = &input.tag_specifications {
let mut list_1802 = scope_1799.start_list(true, Some("item"));
for item_1801 in var_1800 {
#[allow(unused_mut)]
let mut entry_1803 = list_1802.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1803, item_1801,
)?;
}
list_1802.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_vpc_peering_connection(
input: &crate::input::CreateVpcPeeringConnectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateVpcPeeringConnection", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1804 = writer.prefix("DryRun");
if let Some(var_1805) = &input.dry_run {
scope_1804.boolean(*var_1805);
}
#[allow(unused_mut)]
let mut scope_1806 = writer.prefix("PeerOwnerId");
if let Some(var_1807) = &input.peer_owner_id {
scope_1806.string(var_1807);
}
#[allow(unused_mut)]
let mut scope_1808 = writer.prefix("PeerVpcId");
if let Some(var_1809) = &input.peer_vpc_id {
scope_1808.string(var_1809);
}
#[allow(unused_mut)]
let mut scope_1810 = writer.prefix("VpcId");
if let Some(var_1811) = &input.vpc_id {
scope_1810.string(var_1811);
}
#[allow(unused_mut)]
let mut scope_1812 = writer.prefix("PeerRegion");
if let Some(var_1813) = &input.peer_region {
scope_1812.string(var_1813);
}
#[allow(unused_mut)]
let mut scope_1814 = writer.prefix("TagSpecification");
if let Some(var_1815) = &input.tag_specifications {
let mut list_1817 = scope_1814.start_list(true, Some("item"));
for item_1816 in var_1815 {
#[allow(unused_mut)]
let mut entry_1818 = list_1817.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1818, item_1816,
)?;
}
list_1817.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_vpn_connection(
input: &crate::input::CreateVpnConnectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateVpnConnection", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1819 = writer.prefix("CustomerGatewayId");
if let Some(var_1820) = &input.customer_gateway_id {
scope_1819.string(var_1820);
}
#[allow(unused_mut)]
let mut scope_1821 = writer.prefix("Type");
if let Some(var_1822) = &input.r#type {
scope_1821.string(var_1822);
}
#[allow(unused_mut)]
let mut scope_1823 = writer.prefix("VpnGatewayId");
if let Some(var_1824) = &input.vpn_gateway_id {
scope_1823.string(var_1824);
}
#[allow(unused_mut)]
let mut scope_1825 = writer.prefix("TransitGatewayId");
if let Some(var_1826) = &input.transit_gateway_id {
scope_1825.string(var_1826);
}
#[allow(unused_mut)]
let mut scope_1827 = writer.prefix("DryRun");
if let Some(var_1828) = &input.dry_run {
scope_1827.boolean(*var_1828);
}
#[allow(unused_mut)]
let mut scope_1829 = writer.prefix("Options");
if let Some(var_1830) = &input.options {
crate::query_ser::serialize_structure_crate_model_vpn_connection_options_specification(
scope_1829, var_1830,
)?;
}
#[allow(unused_mut)]
let mut scope_1831 = writer.prefix("TagSpecification");
if let Some(var_1832) = &input.tag_specifications {
let mut list_1834 = scope_1831.start_list(true, Some("item"));
for item_1833 in var_1832 {
#[allow(unused_mut)]
let mut entry_1835 = list_1834.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1835, item_1833,
)?;
}
list_1834.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_vpn_connection_route(
input: &crate::input::CreateVpnConnectionRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateVpnConnectionRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1836 = writer.prefix("DestinationCidrBlock");
if let Some(var_1837) = &input.destination_cidr_block {
scope_1836.string(var_1837);
}
#[allow(unused_mut)]
let mut scope_1838 = writer.prefix("VpnConnectionId");
if let Some(var_1839) = &input.vpn_connection_id {
scope_1838.string(var_1839);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_vpn_gateway(
input: &crate::input::CreateVpnGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateVpnGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1840 = writer.prefix("AvailabilityZone");
if let Some(var_1841) = &input.availability_zone {
scope_1840.string(var_1841);
}
#[allow(unused_mut)]
let mut scope_1842 = writer.prefix("Type");
if let Some(var_1843) = &input.r#type {
scope_1842.string(var_1843.as_str());
}
#[allow(unused_mut)]
let mut scope_1844 = writer.prefix("TagSpecification");
if let Some(var_1845) = &input.tag_specifications {
let mut list_1847 = scope_1844.start_list(true, Some("item"));
for item_1846 in var_1845 {
#[allow(unused_mut)]
let mut entry_1848 = list_1847.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_1848, item_1846,
)?;
}
list_1847.finish();
}
#[allow(unused_mut)]
let mut scope_1849 = writer.prefix("AmazonSideAsn");
if let Some(var_1850) = &input.amazon_side_asn {
scope_1849.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1850).into()),
);
}
#[allow(unused_mut)]
let mut scope_1851 = writer.prefix("DryRun");
if let Some(var_1852) = &input.dry_run {
scope_1851.boolean(*var_1852);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_carrier_gateway(
input: &crate::input::DeleteCarrierGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteCarrierGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1853 = writer.prefix("CarrierGatewayId");
if let Some(var_1854) = &input.carrier_gateway_id {
scope_1853.string(var_1854);
}
#[allow(unused_mut)]
let mut scope_1855 = writer.prefix("DryRun");
if let Some(var_1856) = &input.dry_run {
scope_1855.boolean(*var_1856);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_client_vpn_endpoint(
input: &crate::input::DeleteClientVpnEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteClientVpnEndpoint", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1857 = writer.prefix("ClientVpnEndpointId");
if let Some(var_1858) = &input.client_vpn_endpoint_id {
scope_1857.string(var_1858);
}
#[allow(unused_mut)]
let mut scope_1859 = writer.prefix("DryRun");
if let Some(var_1860) = &input.dry_run {
scope_1859.boolean(*var_1860);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_client_vpn_route(
input: &crate::input::DeleteClientVpnRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteClientVpnRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1861 = writer.prefix("ClientVpnEndpointId");
if let Some(var_1862) = &input.client_vpn_endpoint_id {
scope_1861.string(var_1862);
}
#[allow(unused_mut)]
let mut scope_1863 = writer.prefix("TargetVpcSubnetId");
if let Some(var_1864) = &input.target_vpc_subnet_id {
scope_1863.string(var_1864);
}
#[allow(unused_mut)]
let mut scope_1865 = writer.prefix("DestinationCidrBlock");
if let Some(var_1866) = &input.destination_cidr_block {
scope_1865.string(var_1866);
}
#[allow(unused_mut)]
let mut scope_1867 = writer.prefix("DryRun");
if let Some(var_1868) = &input.dry_run {
scope_1867.boolean(*var_1868);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_coip_cidr(
input: &crate::input::DeleteCoipCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteCoipCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1869 = writer.prefix("Cidr");
if let Some(var_1870) = &input.cidr {
scope_1869.string(var_1870);
}
#[allow(unused_mut)]
let mut scope_1871 = writer.prefix("CoipPoolId");
if let Some(var_1872) = &input.coip_pool_id {
scope_1871.string(var_1872);
}
#[allow(unused_mut)]
let mut scope_1873 = writer.prefix("DryRun");
if let Some(var_1874) = &input.dry_run {
scope_1873.boolean(*var_1874);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_coip_pool(
input: &crate::input::DeleteCoipPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteCoipPool", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1875 = writer.prefix("CoipPoolId");
if let Some(var_1876) = &input.coip_pool_id {
scope_1875.string(var_1876);
}
#[allow(unused_mut)]
let mut scope_1877 = writer.prefix("DryRun");
if let Some(var_1878) = &input.dry_run {
scope_1877.boolean(*var_1878);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_customer_gateway(
input: &crate::input::DeleteCustomerGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteCustomerGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1879 = writer.prefix("CustomerGatewayId");
if let Some(var_1880) = &input.customer_gateway_id {
scope_1879.string(var_1880);
}
#[allow(unused_mut)]
let mut scope_1881 = writer.prefix("DryRun");
if let Some(var_1882) = &input.dry_run {
scope_1881.boolean(*var_1882);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_dhcp_options(
input: &crate::input::DeleteDhcpOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteDhcpOptions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1883 = writer.prefix("DhcpOptionsId");
if let Some(var_1884) = &input.dhcp_options_id {
scope_1883.string(var_1884);
}
#[allow(unused_mut)]
let mut scope_1885 = writer.prefix("DryRun");
if let Some(var_1886) = &input.dry_run {
scope_1885.boolean(*var_1886);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_egress_only_internet_gateway(
input: &crate::input::DeleteEgressOnlyInternetGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteEgressOnlyInternetGateway",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1887 = writer.prefix("DryRun");
if let Some(var_1888) = &input.dry_run {
scope_1887.boolean(*var_1888);
}
#[allow(unused_mut)]
let mut scope_1889 = writer.prefix("EgressOnlyInternetGatewayId");
if let Some(var_1890) = &input.egress_only_internet_gateway_id {
scope_1889.string(var_1890);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_fleets(
input: &crate::input::DeleteFleetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteFleets", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1891 = writer.prefix("DryRun");
if let Some(var_1892) = &input.dry_run {
scope_1891.boolean(*var_1892);
}
#[allow(unused_mut)]
let mut scope_1893 = writer.prefix("FleetId");
if let Some(var_1894) = &input.fleet_ids {
let mut list_1896 = scope_1893.start_list(true, None);
for item_1895 in var_1894 {
#[allow(unused_mut)]
let mut entry_1897 = list_1896.entry();
entry_1897.string(item_1895);
}
list_1896.finish();
}
#[allow(unused_mut)]
let mut scope_1898 = writer.prefix("TerminateInstances");
if let Some(var_1899) = &input.terminate_instances {
scope_1898.boolean(*var_1899);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_flow_logs(
input: &crate::input::DeleteFlowLogsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteFlowLogs", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1900 = writer.prefix("DryRun");
if let Some(var_1901) = &input.dry_run {
scope_1900.boolean(*var_1901);
}
#[allow(unused_mut)]
let mut scope_1902 = writer.prefix("FlowLogId");
if let Some(var_1903) = &input.flow_log_ids {
let mut list_1905 = scope_1902.start_list(true, Some("item"));
for item_1904 in var_1903 {
#[allow(unused_mut)]
let mut entry_1906 = list_1905.entry();
entry_1906.string(item_1904);
}
list_1905.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_fpga_image(
input: &crate::input::DeleteFpgaImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteFpgaImage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1907 = writer.prefix("DryRun");
if let Some(var_1908) = &input.dry_run {
scope_1907.boolean(*var_1908);
}
#[allow(unused_mut)]
let mut scope_1909 = writer.prefix("FpgaImageId");
if let Some(var_1910) = &input.fpga_image_id {
scope_1909.string(var_1910);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_instance_event_window(
input: &crate::input::DeleteInstanceEventWindowInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteInstanceEventWindow", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1911 = writer.prefix("DryRun");
if let Some(var_1912) = &input.dry_run {
scope_1911.boolean(*var_1912);
}
#[allow(unused_mut)]
let mut scope_1913 = writer.prefix("ForceDelete");
if let Some(var_1914) = &input.force_delete {
scope_1913.boolean(*var_1914);
}
#[allow(unused_mut)]
let mut scope_1915 = writer.prefix("InstanceEventWindowId");
if let Some(var_1916) = &input.instance_event_window_id {
scope_1915.string(var_1916);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_internet_gateway(
input: &crate::input::DeleteInternetGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteInternetGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1917 = writer.prefix("DryRun");
if let Some(var_1918) = &input.dry_run {
scope_1917.boolean(*var_1918);
}
#[allow(unused_mut)]
let mut scope_1919 = writer.prefix("InternetGatewayId");
if let Some(var_1920) = &input.internet_gateway_id {
scope_1919.string(var_1920);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_ipam(
input: &crate::input::DeleteIpamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteIpam", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1921 = writer.prefix("DryRun");
if let Some(var_1922) = &input.dry_run {
scope_1921.boolean(*var_1922);
}
#[allow(unused_mut)]
let mut scope_1923 = writer.prefix("IpamId");
if let Some(var_1924) = &input.ipam_id {
scope_1923.string(var_1924);
}
#[allow(unused_mut)]
let mut scope_1925 = writer.prefix("Cascade");
if let Some(var_1926) = &input.cascade {
scope_1925.boolean(*var_1926);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_ipam_pool(
input: &crate::input::DeleteIpamPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteIpamPool", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1927 = writer.prefix("DryRun");
if let Some(var_1928) = &input.dry_run {
scope_1927.boolean(*var_1928);
}
#[allow(unused_mut)]
let mut scope_1929 = writer.prefix("IpamPoolId");
if let Some(var_1930) = &input.ipam_pool_id {
scope_1929.string(var_1930);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_ipam_scope(
input: &crate::input::DeleteIpamScopeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteIpamScope", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1931 = writer.prefix("DryRun");
if let Some(var_1932) = &input.dry_run {
scope_1931.boolean(*var_1932);
}
#[allow(unused_mut)]
let mut scope_1933 = writer.prefix("IpamScopeId");
if let Some(var_1934) = &input.ipam_scope_id {
scope_1933.string(var_1934);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_key_pair(
input: &crate::input::DeleteKeyPairInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteKeyPair", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1935 = writer.prefix("KeyName");
if let Some(var_1936) = &input.key_name {
scope_1935.string(var_1936);
}
#[allow(unused_mut)]
let mut scope_1937 = writer.prefix("KeyPairId");
if let Some(var_1938) = &input.key_pair_id {
scope_1937.string(var_1938);
}
#[allow(unused_mut)]
let mut scope_1939 = writer.prefix("DryRun");
if let Some(var_1940) = &input.dry_run {
scope_1939.boolean(*var_1940);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_launch_template(
input: &crate::input::DeleteLaunchTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteLaunchTemplate", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1941 = writer.prefix("DryRun");
if let Some(var_1942) = &input.dry_run {
scope_1941.boolean(*var_1942);
}
#[allow(unused_mut)]
let mut scope_1943 = writer.prefix("LaunchTemplateId");
if let Some(var_1944) = &input.launch_template_id {
scope_1943.string(var_1944);
}
#[allow(unused_mut)]
let mut scope_1945 = writer.prefix("LaunchTemplateName");
if let Some(var_1946) = &input.launch_template_name {
scope_1945.string(var_1946);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_launch_template_versions(
input: &crate::input::DeleteLaunchTemplateVersionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteLaunchTemplateVersions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1947 = writer.prefix("DryRun");
if let Some(var_1948) = &input.dry_run {
scope_1947.boolean(*var_1948);
}
#[allow(unused_mut)]
let mut scope_1949 = writer.prefix("LaunchTemplateId");
if let Some(var_1950) = &input.launch_template_id {
scope_1949.string(var_1950);
}
#[allow(unused_mut)]
let mut scope_1951 = writer.prefix("LaunchTemplateName");
if let Some(var_1952) = &input.launch_template_name {
scope_1951.string(var_1952);
}
#[allow(unused_mut)]
let mut scope_1953 = writer.prefix("LaunchTemplateVersion");
if let Some(var_1954) = &input.versions {
let mut list_1956 = scope_1953.start_list(true, Some("item"));
for item_1955 in var_1954 {
#[allow(unused_mut)]
let mut entry_1957 = list_1956.entry();
entry_1957.string(item_1955);
}
list_1956.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_local_gateway_route(
input: &crate::input::DeleteLocalGatewayRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteLocalGatewayRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1958 = writer.prefix("DestinationCidrBlock");
if let Some(var_1959) = &input.destination_cidr_block {
scope_1958.string(var_1959);
}
#[allow(unused_mut)]
let mut scope_1960 = writer.prefix("LocalGatewayRouteTableId");
if let Some(var_1961) = &input.local_gateway_route_table_id {
scope_1960.string(var_1961);
}
#[allow(unused_mut)]
let mut scope_1962 = writer.prefix("DryRun");
if let Some(var_1963) = &input.dry_run {
scope_1962.boolean(*var_1963);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_local_gateway_route_table(
input: &crate::input::DeleteLocalGatewayRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteLocalGatewayRouteTable", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1964 = writer.prefix("LocalGatewayRouteTableId");
if let Some(var_1965) = &input.local_gateway_route_table_id {
scope_1964.string(var_1965);
}
#[allow(unused_mut)]
let mut scope_1966 = writer.prefix("DryRun");
if let Some(var_1967) = &input.dry_run {
scope_1966.boolean(*var_1967);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_local_gateway_route_table_virtual_interface_group_association(
input: &crate::input::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1968 = writer.prefix("LocalGatewayRouteTableVirtualInterfaceGroupAssociationId");
if let Some(var_1969) = &input.local_gateway_route_table_virtual_interface_group_association_id
{
scope_1968.string(var_1969);
}
#[allow(unused_mut)]
let mut scope_1970 = writer.prefix("DryRun");
if let Some(var_1971) = &input.dry_run {
scope_1970.boolean(*var_1971);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_local_gateway_route_table_vpc_association(
input: &crate::input::DeleteLocalGatewayRouteTableVpcAssociationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteLocalGatewayRouteTableVpcAssociation",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1972 = writer.prefix("LocalGatewayRouteTableVpcAssociationId");
if let Some(var_1973) = &input.local_gateway_route_table_vpc_association_id {
scope_1972.string(var_1973);
}
#[allow(unused_mut)]
let mut scope_1974 = writer.prefix("DryRun");
if let Some(var_1975) = &input.dry_run {
scope_1974.boolean(*var_1975);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_managed_prefix_list(
input: &crate::input::DeleteManagedPrefixListInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteManagedPrefixList", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1976 = writer.prefix("DryRun");
if let Some(var_1977) = &input.dry_run {
scope_1976.boolean(*var_1977);
}
#[allow(unused_mut)]
let mut scope_1978 = writer.prefix("PrefixListId");
if let Some(var_1979) = &input.prefix_list_id {
scope_1978.string(var_1979);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_nat_gateway(
input: &crate::input::DeleteNatGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteNatGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1980 = writer.prefix("DryRun");
if let Some(var_1981) = &input.dry_run {
scope_1980.boolean(*var_1981);
}
#[allow(unused_mut)]
let mut scope_1982 = writer.prefix("NatGatewayId");
if let Some(var_1983) = &input.nat_gateway_id {
scope_1982.string(var_1983);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_network_acl(
input: &crate::input::DeleteNetworkAclInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteNetworkAcl", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1984 = writer.prefix("DryRun");
if let Some(var_1985) = &input.dry_run {
scope_1984.boolean(*var_1985);
}
#[allow(unused_mut)]
let mut scope_1986 = writer.prefix("NetworkAclId");
if let Some(var_1987) = &input.network_acl_id {
scope_1986.string(var_1987);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_network_acl_entry(
input: &crate::input::DeleteNetworkAclEntryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteNetworkAclEntry", "2016-11-15");
#[allow(unused_mut)]
let mut scope_1988 = writer.prefix("DryRun");
if let Some(var_1989) = &input.dry_run {
scope_1988.boolean(*var_1989);
}
#[allow(unused_mut)]
let mut scope_1990 = writer.prefix("Egress");
if let Some(var_1991) = &input.egress {
scope_1990.boolean(*var_1991);
}
#[allow(unused_mut)]
let mut scope_1992 = writer.prefix("NetworkAclId");
if let Some(var_1993) = &input.network_acl_id {
scope_1992.string(var_1993);
}
#[allow(unused_mut)]
let mut scope_1994 = writer.prefix("RuleNumber");
if let Some(var_1995) = &input.rule_number {
scope_1994.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1995).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_network_insights_access_scope(
input: &crate::input::DeleteNetworkInsightsAccessScopeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteNetworkInsightsAccessScope",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_1996 = writer.prefix("DryRun");
if let Some(var_1997) = &input.dry_run {
scope_1996.boolean(*var_1997);
}
#[allow(unused_mut)]
let mut scope_1998 = writer.prefix("NetworkInsightsAccessScopeId");
if let Some(var_1999) = &input.network_insights_access_scope_id {
scope_1998.string(var_1999);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_network_insights_access_scope_analysis(
input: &crate::input::DeleteNetworkInsightsAccessScopeAnalysisInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteNetworkInsightsAccessScopeAnalysis",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2000 = writer.prefix("NetworkInsightsAccessScopeAnalysisId");
if let Some(var_2001) = &input.network_insights_access_scope_analysis_id {
scope_2000.string(var_2001);
}
#[allow(unused_mut)]
let mut scope_2002 = writer.prefix("DryRun");
if let Some(var_2003) = &input.dry_run {
scope_2002.boolean(*var_2003);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_network_insights_analysis(
input: &crate::input::DeleteNetworkInsightsAnalysisInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteNetworkInsightsAnalysis", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2004 = writer.prefix("DryRun");
if let Some(var_2005) = &input.dry_run {
scope_2004.boolean(*var_2005);
}
#[allow(unused_mut)]
let mut scope_2006 = writer.prefix("NetworkInsightsAnalysisId");
if let Some(var_2007) = &input.network_insights_analysis_id {
scope_2006.string(var_2007);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_network_insights_path(
input: &crate::input::DeleteNetworkInsightsPathInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteNetworkInsightsPath", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2008 = writer.prefix("DryRun");
if let Some(var_2009) = &input.dry_run {
scope_2008.boolean(*var_2009);
}
#[allow(unused_mut)]
let mut scope_2010 = writer.prefix("NetworkInsightsPathId");
if let Some(var_2011) = &input.network_insights_path_id {
scope_2010.string(var_2011);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_network_interface(
input: &crate::input::DeleteNetworkInterfaceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteNetworkInterface", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2012 = writer.prefix("DryRun");
if let Some(var_2013) = &input.dry_run {
scope_2012.boolean(*var_2013);
}
#[allow(unused_mut)]
let mut scope_2014 = writer.prefix("NetworkInterfaceId");
if let Some(var_2015) = &input.network_interface_id {
scope_2014.string(var_2015);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_network_interface_permission(
input: &crate::input::DeleteNetworkInterfacePermissionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteNetworkInterfacePermission",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2016 = writer.prefix("NetworkInterfacePermissionId");
if let Some(var_2017) = &input.network_interface_permission_id {
scope_2016.string(var_2017);
}
#[allow(unused_mut)]
let mut scope_2018 = writer.prefix("Force");
if let Some(var_2019) = &input.force {
scope_2018.boolean(*var_2019);
}
#[allow(unused_mut)]
let mut scope_2020 = writer.prefix("DryRun");
if let Some(var_2021) = &input.dry_run {
scope_2020.boolean(*var_2021);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_placement_group(
input: &crate::input::DeletePlacementGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeletePlacementGroup", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2022 = writer.prefix("DryRun");
if let Some(var_2023) = &input.dry_run {
scope_2022.boolean(*var_2023);
}
#[allow(unused_mut)]
let mut scope_2024 = writer.prefix("GroupName");
if let Some(var_2025) = &input.group_name {
scope_2024.string(var_2025);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_public_ipv4_pool(
input: &crate::input::DeletePublicIpv4PoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeletePublicIpv4Pool", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2026 = writer.prefix("DryRun");
if let Some(var_2027) = &input.dry_run {
scope_2026.boolean(*var_2027);
}
#[allow(unused_mut)]
let mut scope_2028 = writer.prefix("PoolId");
if let Some(var_2029) = &input.pool_id {
scope_2028.string(var_2029);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_queued_reserved_instances(
input: &crate::input::DeleteQueuedReservedInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteQueuedReservedInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2030 = writer.prefix("DryRun");
if let Some(var_2031) = &input.dry_run {
scope_2030.boolean(*var_2031);
}
#[allow(unused_mut)]
let mut scope_2032 = writer.prefix("ReservedInstancesId");
if let Some(var_2033) = &input.reserved_instances_ids {
let mut list_2035 = scope_2032.start_list(true, Some("item"));
for item_2034 in var_2033 {
#[allow(unused_mut)]
let mut entry_2036 = list_2035.entry();
entry_2036.string(item_2034);
}
list_2035.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_route(
input: &crate::input::DeleteRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2037 = writer.prefix("DestinationCidrBlock");
if let Some(var_2038) = &input.destination_cidr_block {
scope_2037.string(var_2038);
}
#[allow(unused_mut)]
let mut scope_2039 = writer.prefix("DestinationIpv6CidrBlock");
if let Some(var_2040) = &input.destination_ipv6_cidr_block {
scope_2039.string(var_2040);
}
#[allow(unused_mut)]
let mut scope_2041 = writer.prefix("DestinationPrefixListId");
if let Some(var_2042) = &input.destination_prefix_list_id {
scope_2041.string(var_2042);
}
#[allow(unused_mut)]
let mut scope_2043 = writer.prefix("DryRun");
if let Some(var_2044) = &input.dry_run {
scope_2043.boolean(*var_2044);
}
#[allow(unused_mut)]
let mut scope_2045 = writer.prefix("RouteTableId");
if let Some(var_2046) = &input.route_table_id {
scope_2045.string(var_2046);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_route_table(
input: &crate::input::DeleteRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteRouteTable", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2047 = writer.prefix("DryRun");
if let Some(var_2048) = &input.dry_run {
scope_2047.boolean(*var_2048);
}
#[allow(unused_mut)]
let mut scope_2049 = writer.prefix("RouteTableId");
if let Some(var_2050) = &input.route_table_id {
scope_2049.string(var_2050);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_security_group(
input: &crate::input::DeleteSecurityGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteSecurityGroup", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2051 = writer.prefix("GroupId");
if let Some(var_2052) = &input.group_id {
scope_2051.string(var_2052);
}
#[allow(unused_mut)]
let mut scope_2053 = writer.prefix("GroupName");
if let Some(var_2054) = &input.group_name {
scope_2053.string(var_2054);
}
#[allow(unused_mut)]
let mut scope_2055 = writer.prefix("DryRun");
if let Some(var_2056) = &input.dry_run {
scope_2055.boolean(*var_2056);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_snapshot(
input: &crate::input::DeleteSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteSnapshot", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2057 = writer.prefix("SnapshotId");
if let Some(var_2058) = &input.snapshot_id {
scope_2057.string(var_2058);
}
#[allow(unused_mut)]
let mut scope_2059 = writer.prefix("DryRun");
if let Some(var_2060) = &input.dry_run {
scope_2059.boolean(*var_2060);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_spot_datafeed_subscription(
input: &crate::input::DeleteSpotDatafeedSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteSpotDatafeedSubscription",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2061 = writer.prefix("DryRun");
if let Some(var_2062) = &input.dry_run {
scope_2061.boolean(*var_2062);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_subnet(
input: &crate::input::DeleteSubnetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteSubnet", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2063 = writer.prefix("SubnetId");
if let Some(var_2064) = &input.subnet_id {
scope_2063.string(var_2064);
}
#[allow(unused_mut)]
let mut scope_2065 = writer.prefix("DryRun");
if let Some(var_2066) = &input.dry_run {
scope_2065.boolean(*var_2066);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_subnet_cidr_reservation(
input: &crate::input::DeleteSubnetCidrReservationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteSubnetCidrReservation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2067 = writer.prefix("SubnetCidrReservationId");
if let Some(var_2068) = &input.subnet_cidr_reservation_id {
scope_2067.string(var_2068);
}
#[allow(unused_mut)]
let mut scope_2069 = writer.prefix("DryRun");
if let Some(var_2070) = &input.dry_run {
scope_2069.boolean(*var_2070);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_tags(
input: &crate::input::DeleteTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteTags", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2071 = writer.prefix("DryRun");
if let Some(var_2072) = &input.dry_run {
scope_2071.boolean(*var_2072);
}
#[allow(unused_mut)]
let mut scope_2073 = writer.prefix("ResourceId");
if let Some(var_2074) = &input.resources {
let mut list_2076 = scope_2073.start_list(true, None);
for item_2075 in var_2074 {
#[allow(unused_mut)]
let mut entry_2077 = list_2076.entry();
entry_2077.string(item_2075);
}
list_2076.finish();
}
#[allow(unused_mut)]
let mut scope_2078 = writer.prefix("Tag");
if let Some(var_2079) = &input.tags {
let mut list_2081 = scope_2078.start_list(true, Some("item"));
for item_2080 in var_2079 {
#[allow(unused_mut)]
let mut entry_2082 = list_2081.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_2082, item_2080)?;
}
list_2081.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_traffic_mirror_filter(
input: &crate::input::DeleteTrafficMirrorFilterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteTrafficMirrorFilter", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2083 = writer.prefix("TrafficMirrorFilterId");
if let Some(var_2084) = &input.traffic_mirror_filter_id {
scope_2083.string(var_2084);
}
#[allow(unused_mut)]
let mut scope_2085 = writer.prefix("DryRun");
if let Some(var_2086) = &input.dry_run {
scope_2085.boolean(*var_2086);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_traffic_mirror_filter_rule(
input: &crate::input::DeleteTrafficMirrorFilterRuleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteTrafficMirrorFilterRule", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2087 = writer.prefix("TrafficMirrorFilterRuleId");
if let Some(var_2088) = &input.traffic_mirror_filter_rule_id {
scope_2087.string(var_2088);
}
#[allow(unused_mut)]
let mut scope_2089 = writer.prefix("DryRun");
if let Some(var_2090) = &input.dry_run {
scope_2089.boolean(*var_2090);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_traffic_mirror_session(
input: &crate::input::DeleteTrafficMirrorSessionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteTrafficMirrorSession", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2091 = writer.prefix("TrafficMirrorSessionId");
if let Some(var_2092) = &input.traffic_mirror_session_id {
scope_2091.string(var_2092);
}
#[allow(unused_mut)]
let mut scope_2093 = writer.prefix("DryRun");
if let Some(var_2094) = &input.dry_run {
scope_2093.boolean(*var_2094);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_traffic_mirror_target(
input: &crate::input::DeleteTrafficMirrorTargetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteTrafficMirrorTarget", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2095 = writer.prefix("TrafficMirrorTargetId");
if let Some(var_2096) = &input.traffic_mirror_target_id {
scope_2095.string(var_2096);
}
#[allow(unused_mut)]
let mut scope_2097 = writer.prefix("DryRun");
if let Some(var_2098) = &input.dry_run {
scope_2097.boolean(*var_2098);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway(
input: &crate::input::DeleteTransitGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteTransitGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2099 = writer.prefix("TransitGatewayId");
if let Some(var_2100) = &input.transit_gateway_id {
scope_2099.string(var_2100);
}
#[allow(unused_mut)]
let mut scope_2101 = writer.prefix("DryRun");
if let Some(var_2102) = &input.dry_run {
scope_2101.boolean(*var_2102);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway_connect(
input: &crate::input::DeleteTransitGatewayConnectInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteTransitGatewayConnect", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2103 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_2104) = &input.transit_gateway_attachment_id {
scope_2103.string(var_2104);
}
#[allow(unused_mut)]
let mut scope_2105 = writer.prefix("DryRun");
if let Some(var_2106) = &input.dry_run {
scope_2105.boolean(*var_2106);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway_connect_peer(
input: &crate::input::DeleteTransitGatewayConnectPeerInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteTransitGatewayConnectPeer",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2107 = writer.prefix("TransitGatewayConnectPeerId");
if let Some(var_2108) = &input.transit_gateway_connect_peer_id {
scope_2107.string(var_2108);
}
#[allow(unused_mut)]
let mut scope_2109 = writer.prefix("DryRun");
if let Some(var_2110) = &input.dry_run {
scope_2109.boolean(*var_2110);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway_multicast_domain(
input: &crate::input::DeleteTransitGatewayMulticastDomainInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteTransitGatewayMulticastDomain",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2111 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_2112) = &input.transit_gateway_multicast_domain_id {
scope_2111.string(var_2112);
}
#[allow(unused_mut)]
let mut scope_2113 = writer.prefix("DryRun");
if let Some(var_2114) = &input.dry_run {
scope_2113.boolean(*var_2114);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway_peering_attachment(
input: &crate::input::DeleteTransitGatewayPeeringAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteTransitGatewayPeeringAttachment",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2115 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_2116) = &input.transit_gateway_attachment_id {
scope_2115.string(var_2116);
}
#[allow(unused_mut)]
let mut scope_2117 = writer.prefix("DryRun");
if let Some(var_2118) = &input.dry_run {
scope_2117.boolean(*var_2118);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway_policy_table(
input: &crate::input::DeleteTransitGatewayPolicyTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteTransitGatewayPolicyTable",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2119 = writer.prefix("TransitGatewayPolicyTableId");
if let Some(var_2120) = &input.transit_gateway_policy_table_id {
scope_2119.string(var_2120);
}
#[allow(unused_mut)]
let mut scope_2121 = writer.prefix("DryRun");
if let Some(var_2122) = &input.dry_run {
scope_2121.boolean(*var_2122);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway_prefix_list_reference(
input: &crate::input::DeleteTransitGatewayPrefixListReferenceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteTransitGatewayPrefixListReference",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2123 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_2124) = &input.transit_gateway_route_table_id {
scope_2123.string(var_2124);
}
#[allow(unused_mut)]
let mut scope_2125 = writer.prefix("PrefixListId");
if let Some(var_2126) = &input.prefix_list_id {
scope_2125.string(var_2126);
}
#[allow(unused_mut)]
let mut scope_2127 = writer.prefix("DryRun");
if let Some(var_2128) = &input.dry_run {
scope_2127.boolean(*var_2128);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway_route(
input: &crate::input::DeleteTransitGatewayRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteTransitGatewayRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2129 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_2130) = &input.transit_gateway_route_table_id {
scope_2129.string(var_2130);
}
#[allow(unused_mut)]
let mut scope_2131 = writer.prefix("DestinationCidrBlock");
if let Some(var_2132) = &input.destination_cidr_block {
scope_2131.string(var_2132);
}
#[allow(unused_mut)]
let mut scope_2133 = writer.prefix("DryRun");
if let Some(var_2134) = &input.dry_run {
scope_2133.boolean(*var_2134);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway_route_table(
input: &crate::input::DeleteTransitGatewayRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteTransitGatewayRouteTable",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2135 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_2136) = &input.transit_gateway_route_table_id {
scope_2135.string(var_2136);
}
#[allow(unused_mut)]
let mut scope_2137 = writer.prefix("DryRun");
if let Some(var_2138) = &input.dry_run {
scope_2137.boolean(*var_2138);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway_route_table_announcement(
input: &crate::input::DeleteTransitGatewayRouteTableAnnouncementInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteTransitGatewayRouteTableAnnouncement",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2139 = writer.prefix("TransitGatewayRouteTableAnnouncementId");
if let Some(var_2140) = &input.transit_gateway_route_table_announcement_id {
scope_2139.string(var_2140);
}
#[allow(unused_mut)]
let mut scope_2141 = writer.prefix("DryRun");
if let Some(var_2142) = &input.dry_run {
scope_2141.boolean(*var_2142);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_transit_gateway_vpc_attachment(
input: &crate::input::DeleteTransitGatewayVpcAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteTransitGatewayVpcAttachment",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2143 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_2144) = &input.transit_gateway_attachment_id {
scope_2143.string(var_2144);
}
#[allow(unused_mut)]
let mut scope_2145 = writer.prefix("DryRun");
if let Some(var_2146) = &input.dry_run {
scope_2145.boolean(*var_2146);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_verified_access_endpoint(
input: &crate::input::DeleteVerifiedAccessEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteVerifiedAccessEndpoint", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2147 = writer.prefix("VerifiedAccessEndpointId");
if let Some(var_2148) = &input.verified_access_endpoint_id {
scope_2147.string(var_2148);
}
#[allow(unused_mut)]
let mut scope_2149 = writer.prefix("ClientToken");
if let Some(var_2150) = &input.client_token {
scope_2149.string(var_2150);
}
#[allow(unused_mut)]
let mut scope_2151 = writer.prefix("DryRun");
if let Some(var_2152) = &input.dry_run {
scope_2151.boolean(*var_2152);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_verified_access_group(
input: &crate::input::DeleteVerifiedAccessGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteVerifiedAccessGroup", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2153 = writer.prefix("VerifiedAccessGroupId");
if let Some(var_2154) = &input.verified_access_group_id {
scope_2153.string(var_2154);
}
#[allow(unused_mut)]
let mut scope_2155 = writer.prefix("ClientToken");
if let Some(var_2156) = &input.client_token {
scope_2155.string(var_2156);
}
#[allow(unused_mut)]
let mut scope_2157 = writer.prefix("DryRun");
if let Some(var_2158) = &input.dry_run {
scope_2157.boolean(*var_2158);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_verified_access_instance(
input: &crate::input::DeleteVerifiedAccessInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteVerifiedAccessInstance", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2159 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_2160) = &input.verified_access_instance_id {
scope_2159.string(var_2160);
}
#[allow(unused_mut)]
let mut scope_2161 = writer.prefix("DryRun");
if let Some(var_2162) = &input.dry_run {
scope_2161.boolean(*var_2162);
}
#[allow(unused_mut)]
let mut scope_2163 = writer.prefix("ClientToken");
if let Some(var_2164) = &input.client_token {
scope_2163.string(var_2164);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_verified_access_trust_provider(
input: &crate::input::DeleteVerifiedAccessTrustProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteVerifiedAccessTrustProvider",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2165 = writer.prefix("VerifiedAccessTrustProviderId");
if let Some(var_2166) = &input.verified_access_trust_provider_id {
scope_2165.string(var_2166);
}
#[allow(unused_mut)]
let mut scope_2167 = writer.prefix("DryRun");
if let Some(var_2168) = &input.dry_run {
scope_2167.boolean(*var_2168);
}
#[allow(unused_mut)]
let mut scope_2169 = writer.prefix("ClientToken");
if let Some(var_2170) = &input.client_token {
scope_2169.string(var_2170);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_volume(
input: &crate::input::DeleteVolumeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteVolume", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2171 = writer.prefix("VolumeId");
if let Some(var_2172) = &input.volume_id {
scope_2171.string(var_2172);
}
#[allow(unused_mut)]
let mut scope_2173 = writer.prefix("DryRun");
if let Some(var_2174) = &input.dry_run {
scope_2173.boolean(*var_2174);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_vpc(
input: &crate::input::DeleteVpcInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpc", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2175 = writer.prefix("VpcId");
if let Some(var_2176) = &input.vpc_id {
scope_2175.string(var_2176);
}
#[allow(unused_mut)]
let mut scope_2177 = writer.prefix("DryRun");
if let Some(var_2178) = &input.dry_run {
scope_2177.boolean(*var_2178);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_vpc_endpoint_connection_notifications(
input: &crate::input::DeleteVpcEndpointConnectionNotificationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteVpcEndpointConnectionNotifications",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2179 = writer.prefix("DryRun");
if let Some(var_2180) = &input.dry_run {
scope_2179.boolean(*var_2180);
}
#[allow(unused_mut)]
let mut scope_2181 = writer.prefix("ConnectionNotificationId");
if let Some(var_2182) = &input.connection_notification_ids {
let mut list_2184 = scope_2181.start_list(true, Some("item"));
for item_2183 in var_2182 {
#[allow(unused_mut)]
let mut entry_2185 = list_2184.entry();
entry_2185.string(item_2183);
}
list_2184.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_vpc_endpoints(
input: &crate::input::DeleteVpcEndpointsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpcEndpoints", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2186 = writer.prefix("DryRun");
if let Some(var_2187) = &input.dry_run {
scope_2186.boolean(*var_2187);
}
#[allow(unused_mut)]
let mut scope_2188 = writer.prefix("VpcEndpointId");
if let Some(var_2189) = &input.vpc_endpoint_ids {
let mut list_2191 = scope_2188.start_list(true, Some("item"));
for item_2190 in var_2189 {
#[allow(unused_mut)]
let mut entry_2192 = list_2191.entry();
entry_2192.string(item_2190);
}
list_2191.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_vpc_endpoint_service_configurations(
input: &crate::input::DeleteVpcEndpointServiceConfigurationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteVpcEndpointServiceConfigurations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2193 = writer.prefix("DryRun");
if let Some(var_2194) = &input.dry_run {
scope_2193.boolean(*var_2194);
}
#[allow(unused_mut)]
let mut scope_2195 = writer.prefix("ServiceId");
if let Some(var_2196) = &input.service_ids {
let mut list_2198 = scope_2195.start_list(true, Some("item"));
for item_2197 in var_2196 {
#[allow(unused_mut)]
let mut entry_2199 = list_2198.entry();
entry_2199.string(item_2197);
}
list_2198.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_vpc_peering_connection(
input: &crate::input::DeleteVpcPeeringConnectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpcPeeringConnection", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2200 = writer.prefix("DryRun");
if let Some(var_2201) = &input.dry_run {
scope_2200.boolean(*var_2201);
}
#[allow(unused_mut)]
let mut scope_2202 = writer.prefix("VpcPeeringConnectionId");
if let Some(var_2203) = &input.vpc_peering_connection_id {
scope_2202.string(var_2203);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_vpn_connection(
input: &crate::input::DeleteVpnConnectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpnConnection", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2204 = writer.prefix("VpnConnectionId");
if let Some(var_2205) = &input.vpn_connection_id {
scope_2204.string(var_2205);
}
#[allow(unused_mut)]
let mut scope_2206 = writer.prefix("DryRun");
if let Some(var_2207) = &input.dry_run {
scope_2206.boolean(*var_2207);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_vpn_connection_route(
input: &crate::input::DeleteVpnConnectionRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpnConnectionRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2208 = writer.prefix("DestinationCidrBlock");
if let Some(var_2209) = &input.destination_cidr_block {
scope_2208.string(var_2209);
}
#[allow(unused_mut)]
let mut scope_2210 = writer.prefix("VpnConnectionId");
if let Some(var_2211) = &input.vpn_connection_id {
scope_2210.string(var_2211);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_vpn_gateway(
input: &crate::input::DeleteVpnGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteVpnGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2212 = writer.prefix("VpnGatewayId");
if let Some(var_2213) = &input.vpn_gateway_id {
scope_2212.string(var_2213);
}
#[allow(unused_mut)]
let mut scope_2214 = writer.prefix("DryRun");
if let Some(var_2215) = &input.dry_run {
scope_2214.boolean(*var_2215);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deprovision_byoip_cidr(
input: &crate::input::DeprovisionByoipCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeprovisionByoipCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2216 = writer.prefix("Cidr");
if let Some(var_2217) = &input.cidr {
scope_2216.string(var_2217);
}
#[allow(unused_mut)]
let mut scope_2218 = writer.prefix("DryRun");
if let Some(var_2219) = &input.dry_run {
scope_2218.boolean(*var_2219);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deprovision_ipam_pool_cidr(
input: &crate::input::DeprovisionIpamPoolCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeprovisionIpamPoolCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2220 = writer.prefix("DryRun");
if let Some(var_2221) = &input.dry_run {
scope_2220.boolean(*var_2221);
}
#[allow(unused_mut)]
let mut scope_2222 = writer.prefix("IpamPoolId");
if let Some(var_2223) = &input.ipam_pool_id {
scope_2222.string(var_2223);
}
#[allow(unused_mut)]
let mut scope_2224 = writer.prefix("Cidr");
if let Some(var_2225) = &input.cidr {
scope_2224.string(var_2225);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deprovision_public_ipv4_pool_cidr(
input: &crate::input::DeprovisionPublicIpv4PoolCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeprovisionPublicIpv4PoolCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2226 = writer.prefix("DryRun");
if let Some(var_2227) = &input.dry_run {
scope_2226.boolean(*var_2227);
}
#[allow(unused_mut)]
let mut scope_2228 = writer.prefix("PoolId");
if let Some(var_2229) = &input.pool_id {
scope_2228.string(var_2229);
}
#[allow(unused_mut)]
let mut scope_2230 = writer.prefix("Cidr");
if let Some(var_2231) = &input.cidr {
scope_2230.string(var_2231);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deregister_image(
input: &crate::input::DeregisterImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeregisterImage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2232 = writer.prefix("ImageId");
if let Some(var_2233) = &input.image_id {
scope_2232.string(var_2233);
}
#[allow(unused_mut)]
let mut scope_2234 = writer.prefix("DryRun");
if let Some(var_2235) = &input.dry_run {
scope_2234.boolean(*var_2235);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deregister_instance_event_notification_attributes(
input: &crate::input::DeregisterInstanceEventNotificationAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeregisterInstanceEventNotificationAttributes",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2236 = writer.prefix("DryRun");
if let Some(var_2237) = &input.dry_run {
scope_2236.boolean(*var_2237);
}
#[allow(unused_mut)]
let mut scope_2238 = writer.prefix("InstanceTagAttribute");
if let Some(var_2239) = &input.instance_tag_attribute {
crate::query_ser::serialize_structure_crate_model_deregister_instance_tag_attribute_request(scope_2238, var_2239)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deregister_transit_gateway_multicast_group_members(
input: &crate::input::DeregisterTransitGatewayMulticastGroupMembersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeregisterTransitGatewayMulticastGroupMembers",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2240 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_2241) = &input.transit_gateway_multicast_domain_id {
scope_2240.string(var_2241);
}
#[allow(unused_mut)]
let mut scope_2242 = writer.prefix("GroupIpAddress");
if let Some(var_2243) = &input.group_ip_address {
scope_2242.string(var_2243);
}
#[allow(unused_mut)]
let mut scope_2244 = writer.prefix("NetworkInterfaceIds");
if let Some(var_2245) = &input.network_interface_ids {
let mut list_2247 = scope_2244.start_list(true, Some("item"));
for item_2246 in var_2245 {
#[allow(unused_mut)]
let mut entry_2248 = list_2247.entry();
entry_2248.string(item_2246);
}
list_2247.finish();
}
#[allow(unused_mut)]
let mut scope_2249 = writer.prefix("DryRun");
if let Some(var_2250) = &input.dry_run {
scope_2249.boolean(*var_2250);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deregister_transit_gateway_multicast_group_sources(
input: &crate::input::DeregisterTransitGatewayMulticastGroupSourcesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeregisterTransitGatewayMulticastGroupSources",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2251 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_2252) = &input.transit_gateway_multicast_domain_id {
scope_2251.string(var_2252);
}
#[allow(unused_mut)]
let mut scope_2253 = writer.prefix("GroupIpAddress");
if let Some(var_2254) = &input.group_ip_address {
scope_2253.string(var_2254);
}
#[allow(unused_mut)]
let mut scope_2255 = writer.prefix("NetworkInterfaceIds");
if let Some(var_2256) = &input.network_interface_ids {
let mut list_2258 = scope_2255.start_list(true, Some("item"));
for item_2257 in var_2256 {
#[allow(unused_mut)]
let mut entry_2259 = list_2258.entry();
entry_2259.string(item_2257);
}
list_2258.finish();
}
#[allow(unused_mut)]
let mut scope_2260 = writer.prefix("DryRun");
if let Some(var_2261) = &input.dry_run {
scope_2260.boolean(*var_2261);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_account_attributes(
input: &crate::input::DescribeAccountAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAccountAttributes", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2262 = writer.prefix("AttributeName");
if let Some(var_2263) = &input.attribute_names {
let mut list_2265 = scope_2262.start_list(true, Some("attributeName"));
for item_2264 in var_2263 {
#[allow(unused_mut)]
let mut entry_2266 = list_2265.entry();
entry_2266.string(item_2264.as_str());
}
list_2265.finish();
}
#[allow(unused_mut)]
let mut scope_2267 = writer.prefix("DryRun");
if let Some(var_2268) = &input.dry_run {
scope_2267.boolean(*var_2268);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_addresses(
input: &crate::input::DescribeAddressesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAddresses", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2269 = writer.prefix("Filter");
if let Some(var_2270) = &input.filters {
let mut list_2272 = scope_2269.start_list(true, Some("Filter"));
for item_2271 in var_2270 {
#[allow(unused_mut)]
let mut entry_2273 = list_2272.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2273, item_2271)?;
}
list_2272.finish();
}
#[allow(unused_mut)]
let mut scope_2274 = writer.prefix("PublicIp");
if let Some(var_2275) = &input.public_ips {
let mut list_2277 = scope_2274.start_list(true, Some("PublicIp"));
for item_2276 in var_2275 {
#[allow(unused_mut)]
let mut entry_2278 = list_2277.entry();
entry_2278.string(item_2276);
}
list_2277.finish();
}
#[allow(unused_mut)]
let mut scope_2279 = writer.prefix("AllocationId");
if let Some(var_2280) = &input.allocation_ids {
let mut list_2282 = scope_2279.start_list(true, Some("AllocationId"));
for item_2281 in var_2280 {
#[allow(unused_mut)]
let mut entry_2283 = list_2282.entry();
entry_2283.string(item_2281);
}
list_2282.finish();
}
#[allow(unused_mut)]
let mut scope_2284 = writer.prefix("DryRun");
if let Some(var_2285) = &input.dry_run {
scope_2284.boolean(*var_2285);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_addresses_attribute(
input: &crate::input::DescribeAddressesAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAddressesAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2286 = writer.prefix("AllocationId");
if let Some(var_2287) = &input.allocation_ids {
let mut list_2289 = scope_2286.start_list(true, Some("item"));
for item_2288 in var_2287 {
#[allow(unused_mut)]
let mut entry_2290 = list_2289.entry();
entry_2290.string(item_2288);
}
list_2289.finish();
}
#[allow(unused_mut)]
let mut scope_2291 = writer.prefix("Attribute");
if let Some(var_2292) = &input.attribute {
scope_2291.string(var_2292.as_str());
}
#[allow(unused_mut)]
let mut scope_2293 = writer.prefix("NextToken");
if let Some(var_2294) = &input.next_token {
scope_2293.string(var_2294);
}
#[allow(unused_mut)]
let mut scope_2295 = writer.prefix("MaxResults");
if let Some(var_2296) = &input.max_results {
scope_2295.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2296).into()),
);
}
#[allow(unused_mut)]
let mut scope_2297 = writer.prefix("DryRun");
if let Some(var_2298) = &input.dry_run {
scope_2297.boolean(*var_2298);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_address_transfers(
input: &crate::input::DescribeAddressTransfersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAddressTransfers", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2299 = writer.prefix("AllocationId");
if let Some(var_2300) = &input.allocation_ids {
let mut list_2302 = scope_2299.start_list(true, Some("AllocationId"));
for item_2301 in var_2300 {
#[allow(unused_mut)]
let mut entry_2303 = list_2302.entry();
entry_2303.string(item_2301);
}
list_2302.finish();
}
#[allow(unused_mut)]
let mut scope_2304 = writer.prefix("NextToken");
if let Some(var_2305) = &input.next_token {
scope_2304.string(var_2305);
}
#[allow(unused_mut)]
let mut scope_2306 = writer.prefix("MaxResults");
if let Some(var_2307) = &input.max_results {
scope_2306.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2307).into()),
);
}
#[allow(unused_mut)]
let mut scope_2308 = writer.prefix("DryRun");
if let Some(var_2309) = &input.dry_run {
scope_2308.boolean(*var_2309);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_aggregate_id_format(
input: &crate::input::DescribeAggregateIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAggregateIdFormat", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2310 = writer.prefix("DryRun");
if let Some(var_2311) = &input.dry_run {
scope_2310.boolean(*var_2311);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_availability_zones(
input: &crate::input::DescribeAvailabilityZonesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAvailabilityZones", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2312 = writer.prefix("Filter");
if let Some(var_2313) = &input.filters {
let mut list_2315 = scope_2312.start_list(true, Some("Filter"));
for item_2314 in var_2313 {
#[allow(unused_mut)]
let mut entry_2316 = list_2315.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2316, item_2314)?;
}
list_2315.finish();
}
#[allow(unused_mut)]
let mut scope_2317 = writer.prefix("ZoneName");
if let Some(var_2318) = &input.zone_names {
let mut list_2320 = scope_2317.start_list(true, Some("ZoneName"));
for item_2319 in var_2318 {
#[allow(unused_mut)]
let mut entry_2321 = list_2320.entry();
entry_2321.string(item_2319);
}
list_2320.finish();
}
#[allow(unused_mut)]
let mut scope_2322 = writer.prefix("ZoneId");
if let Some(var_2323) = &input.zone_ids {
let mut list_2325 = scope_2322.start_list(true, Some("ZoneId"));
for item_2324 in var_2323 {
#[allow(unused_mut)]
let mut entry_2326 = list_2325.entry();
entry_2326.string(item_2324);
}
list_2325.finish();
}
#[allow(unused_mut)]
let mut scope_2327 = writer.prefix("AllAvailabilityZones");
if let Some(var_2328) = &input.all_availability_zones {
scope_2327.boolean(*var_2328);
}
#[allow(unused_mut)]
let mut scope_2329 = writer.prefix("DryRun");
if let Some(var_2330) = &input.dry_run {
scope_2329.boolean(*var_2330);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_aws_network_performance_metric_subscriptions(
input: &crate::input::DescribeAwsNetworkPerformanceMetricSubscriptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeAwsNetworkPerformanceMetricSubscriptions",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2331 = writer.prefix("MaxResults");
if let Some(var_2332) = &input.max_results {
scope_2331.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2332).into()),
);
}
#[allow(unused_mut)]
let mut scope_2333 = writer.prefix("NextToken");
if let Some(var_2334) = &input.next_token {
scope_2333.string(var_2334);
}
#[allow(unused_mut)]
let mut scope_2335 = writer.prefix("Filter");
if let Some(var_2336) = &input.filters {
let mut list_2338 = scope_2335.start_list(true, Some("Filter"));
for item_2337 in var_2336 {
#[allow(unused_mut)]
let mut entry_2339 = list_2338.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2339, item_2337)?;
}
list_2338.finish();
}
#[allow(unused_mut)]
let mut scope_2340 = writer.prefix("DryRun");
if let Some(var_2341) = &input.dry_run {
scope_2340.boolean(*var_2341);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_bundle_tasks(
input: &crate::input::DescribeBundleTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeBundleTasks", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2342 = writer.prefix("BundleId");
if let Some(var_2343) = &input.bundle_ids {
let mut list_2345 = scope_2342.start_list(true, Some("BundleId"));
for item_2344 in var_2343 {
#[allow(unused_mut)]
let mut entry_2346 = list_2345.entry();
entry_2346.string(item_2344);
}
list_2345.finish();
}
#[allow(unused_mut)]
let mut scope_2347 = writer.prefix("Filter");
if let Some(var_2348) = &input.filters {
let mut list_2350 = scope_2347.start_list(true, Some("Filter"));
for item_2349 in var_2348 {
#[allow(unused_mut)]
let mut entry_2351 = list_2350.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2351, item_2349)?;
}
list_2350.finish();
}
#[allow(unused_mut)]
let mut scope_2352 = writer.prefix("DryRun");
if let Some(var_2353) = &input.dry_run {
scope_2352.boolean(*var_2353);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_byoip_cidrs(
input: &crate::input::DescribeByoipCidrsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeByoipCidrs", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2354 = writer.prefix("DryRun");
if let Some(var_2355) = &input.dry_run {
scope_2354.boolean(*var_2355);
}
#[allow(unused_mut)]
let mut scope_2356 = writer.prefix("MaxResults");
if let Some(var_2357) = &input.max_results {
scope_2356.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2357).into()),
);
}
#[allow(unused_mut)]
let mut scope_2358 = writer.prefix("NextToken");
if let Some(var_2359) = &input.next_token {
scope_2358.string(var_2359);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_capacity_reservation_fleets(
input: &crate::input::DescribeCapacityReservationFleetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeCapacityReservationFleets",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2360 = writer.prefix("CapacityReservationFleetId");
if let Some(var_2361) = &input.capacity_reservation_fleet_ids {
let mut list_2363 = scope_2360.start_list(true, Some("item"));
for item_2362 in var_2361 {
#[allow(unused_mut)]
let mut entry_2364 = list_2363.entry();
entry_2364.string(item_2362);
}
list_2363.finish();
}
#[allow(unused_mut)]
let mut scope_2365 = writer.prefix("NextToken");
if let Some(var_2366) = &input.next_token {
scope_2365.string(var_2366);
}
#[allow(unused_mut)]
let mut scope_2367 = writer.prefix("MaxResults");
if let Some(var_2368) = &input.max_results {
scope_2367.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2368).into()),
);
}
#[allow(unused_mut)]
let mut scope_2369 = writer.prefix("Filter");
if let Some(var_2370) = &input.filters {
let mut list_2372 = scope_2369.start_list(true, Some("Filter"));
for item_2371 in var_2370 {
#[allow(unused_mut)]
let mut entry_2373 = list_2372.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2373, item_2371)?;
}
list_2372.finish();
}
#[allow(unused_mut)]
let mut scope_2374 = writer.prefix("DryRun");
if let Some(var_2375) = &input.dry_run {
scope_2374.boolean(*var_2375);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_capacity_reservations(
input: &crate::input::DescribeCapacityReservationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeCapacityReservations", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2376 = writer.prefix("CapacityReservationId");
if let Some(var_2377) = &input.capacity_reservation_ids {
let mut list_2379 = scope_2376.start_list(true, Some("item"));
for item_2378 in var_2377 {
#[allow(unused_mut)]
let mut entry_2380 = list_2379.entry();
entry_2380.string(item_2378);
}
list_2379.finish();
}
#[allow(unused_mut)]
let mut scope_2381 = writer.prefix("NextToken");
if let Some(var_2382) = &input.next_token {
scope_2381.string(var_2382);
}
#[allow(unused_mut)]
let mut scope_2383 = writer.prefix("MaxResults");
if let Some(var_2384) = &input.max_results {
scope_2383.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2384).into()),
);
}
#[allow(unused_mut)]
let mut scope_2385 = writer.prefix("Filter");
if let Some(var_2386) = &input.filters {
let mut list_2388 = scope_2385.start_list(true, Some("Filter"));
for item_2387 in var_2386 {
#[allow(unused_mut)]
let mut entry_2389 = list_2388.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2389, item_2387)?;
}
list_2388.finish();
}
#[allow(unused_mut)]
let mut scope_2390 = writer.prefix("DryRun");
if let Some(var_2391) = &input.dry_run {
scope_2390.boolean(*var_2391);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_carrier_gateways(
input: &crate::input::DescribeCarrierGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeCarrierGateways", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2392 = writer.prefix("CarrierGatewayId");
if let Some(var_2393) = &input.carrier_gateway_ids {
let mut list_2395 = scope_2392.start_list(true, None);
for item_2394 in var_2393 {
#[allow(unused_mut)]
let mut entry_2396 = list_2395.entry();
entry_2396.string(item_2394);
}
list_2395.finish();
}
#[allow(unused_mut)]
let mut scope_2397 = writer.prefix("Filter");
if let Some(var_2398) = &input.filters {
let mut list_2400 = scope_2397.start_list(true, Some("Filter"));
for item_2399 in var_2398 {
#[allow(unused_mut)]
let mut entry_2401 = list_2400.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2401, item_2399)?;
}
list_2400.finish();
}
#[allow(unused_mut)]
let mut scope_2402 = writer.prefix("MaxResults");
if let Some(var_2403) = &input.max_results {
scope_2402.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2403).into()),
);
}
#[allow(unused_mut)]
let mut scope_2404 = writer.prefix("NextToken");
if let Some(var_2405) = &input.next_token {
scope_2404.string(var_2405);
}
#[allow(unused_mut)]
let mut scope_2406 = writer.prefix("DryRun");
if let Some(var_2407) = &input.dry_run {
scope_2406.boolean(*var_2407);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_classic_link_instances(
input: &crate::input::DescribeClassicLinkInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClassicLinkInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2408 = writer.prefix("Filter");
if let Some(var_2409) = &input.filters {
let mut list_2411 = scope_2408.start_list(true, Some("Filter"));
for item_2410 in var_2409 {
#[allow(unused_mut)]
let mut entry_2412 = list_2411.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2412, item_2410)?;
}
list_2411.finish();
}
#[allow(unused_mut)]
let mut scope_2413 = writer.prefix("DryRun");
if let Some(var_2414) = &input.dry_run {
scope_2413.boolean(*var_2414);
}
#[allow(unused_mut)]
let mut scope_2415 = writer.prefix("InstanceId");
if let Some(var_2416) = &input.instance_ids {
let mut list_2418 = scope_2415.start_list(true, Some("InstanceId"));
for item_2417 in var_2416 {
#[allow(unused_mut)]
let mut entry_2419 = list_2418.entry();
entry_2419.string(item_2417);
}
list_2418.finish();
}
#[allow(unused_mut)]
let mut scope_2420 = writer.prefix("MaxResults");
if let Some(var_2421) = &input.max_results {
scope_2420.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2421).into()),
);
}
#[allow(unused_mut)]
let mut scope_2422 = writer.prefix("NextToken");
if let Some(var_2423) = &input.next_token {
scope_2422.string(var_2423);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_client_vpn_authorization_rules(
input: &crate::input::DescribeClientVpnAuthorizationRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeClientVpnAuthorizationRules",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2424 = writer.prefix("ClientVpnEndpointId");
if let Some(var_2425) = &input.client_vpn_endpoint_id {
scope_2424.string(var_2425);
}
#[allow(unused_mut)]
let mut scope_2426 = writer.prefix("DryRun");
if let Some(var_2427) = &input.dry_run {
scope_2426.boolean(*var_2427);
}
#[allow(unused_mut)]
let mut scope_2428 = writer.prefix("NextToken");
if let Some(var_2429) = &input.next_token {
scope_2428.string(var_2429);
}
#[allow(unused_mut)]
let mut scope_2430 = writer.prefix("Filter");
if let Some(var_2431) = &input.filters {
let mut list_2433 = scope_2430.start_list(true, Some("Filter"));
for item_2432 in var_2431 {
#[allow(unused_mut)]
let mut entry_2434 = list_2433.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2434, item_2432)?;
}
list_2433.finish();
}
#[allow(unused_mut)]
let mut scope_2435 = writer.prefix("MaxResults");
if let Some(var_2436) = &input.max_results {
scope_2435.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2436).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_client_vpn_connections(
input: &crate::input::DescribeClientVpnConnectionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClientVpnConnections", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2437 = writer.prefix("ClientVpnEndpointId");
if let Some(var_2438) = &input.client_vpn_endpoint_id {
scope_2437.string(var_2438);
}
#[allow(unused_mut)]
let mut scope_2439 = writer.prefix("Filter");
if let Some(var_2440) = &input.filters {
let mut list_2442 = scope_2439.start_list(true, Some("Filter"));
for item_2441 in var_2440 {
#[allow(unused_mut)]
let mut entry_2443 = list_2442.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2443, item_2441)?;
}
list_2442.finish();
}
#[allow(unused_mut)]
let mut scope_2444 = writer.prefix("NextToken");
if let Some(var_2445) = &input.next_token {
scope_2444.string(var_2445);
}
#[allow(unused_mut)]
let mut scope_2446 = writer.prefix("MaxResults");
if let Some(var_2447) = &input.max_results {
scope_2446.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2447).into()),
);
}
#[allow(unused_mut)]
let mut scope_2448 = writer.prefix("DryRun");
if let Some(var_2449) = &input.dry_run {
scope_2448.boolean(*var_2449);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_client_vpn_endpoints(
input: &crate::input::DescribeClientVpnEndpointsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClientVpnEndpoints", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2450 = writer.prefix("ClientVpnEndpointId");
if let Some(var_2451) = &input.client_vpn_endpoint_ids {
let mut list_2453 = scope_2450.start_list(true, Some("item"));
for item_2452 in var_2451 {
#[allow(unused_mut)]
let mut entry_2454 = list_2453.entry();
entry_2454.string(item_2452);
}
list_2453.finish();
}
#[allow(unused_mut)]
let mut scope_2455 = writer.prefix("MaxResults");
if let Some(var_2456) = &input.max_results {
scope_2455.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2456).into()),
);
}
#[allow(unused_mut)]
let mut scope_2457 = writer.prefix("NextToken");
if let Some(var_2458) = &input.next_token {
scope_2457.string(var_2458);
}
#[allow(unused_mut)]
let mut scope_2459 = writer.prefix("Filter");
if let Some(var_2460) = &input.filters {
let mut list_2462 = scope_2459.start_list(true, Some("Filter"));
for item_2461 in var_2460 {
#[allow(unused_mut)]
let mut entry_2463 = list_2462.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2463, item_2461)?;
}
list_2462.finish();
}
#[allow(unused_mut)]
let mut scope_2464 = writer.prefix("DryRun");
if let Some(var_2465) = &input.dry_run {
scope_2464.boolean(*var_2465);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_client_vpn_routes(
input: &crate::input::DescribeClientVpnRoutesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClientVpnRoutes", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2466 = writer.prefix("ClientVpnEndpointId");
if let Some(var_2467) = &input.client_vpn_endpoint_id {
scope_2466.string(var_2467);
}
#[allow(unused_mut)]
let mut scope_2468 = writer.prefix("Filter");
if let Some(var_2469) = &input.filters {
let mut list_2471 = scope_2468.start_list(true, Some("Filter"));
for item_2470 in var_2469 {
#[allow(unused_mut)]
let mut entry_2472 = list_2471.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2472, item_2470)?;
}
list_2471.finish();
}
#[allow(unused_mut)]
let mut scope_2473 = writer.prefix("MaxResults");
if let Some(var_2474) = &input.max_results {
scope_2473.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2474).into()),
);
}
#[allow(unused_mut)]
let mut scope_2475 = writer.prefix("NextToken");
if let Some(var_2476) = &input.next_token {
scope_2475.string(var_2476);
}
#[allow(unused_mut)]
let mut scope_2477 = writer.prefix("DryRun");
if let Some(var_2478) = &input.dry_run {
scope_2477.boolean(*var_2478);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_client_vpn_target_networks(
input: &crate::input::DescribeClientVpnTargetNetworksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeClientVpnTargetNetworks",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2479 = writer.prefix("ClientVpnEndpointId");
if let Some(var_2480) = &input.client_vpn_endpoint_id {
scope_2479.string(var_2480);
}
#[allow(unused_mut)]
let mut scope_2481 = writer.prefix("AssociationIds");
if let Some(var_2482) = &input.association_ids {
let mut list_2484 = scope_2481.start_list(true, Some("item"));
for item_2483 in var_2482 {
#[allow(unused_mut)]
let mut entry_2485 = list_2484.entry();
entry_2485.string(item_2483);
}
list_2484.finish();
}
#[allow(unused_mut)]
let mut scope_2486 = writer.prefix("MaxResults");
if let Some(var_2487) = &input.max_results {
scope_2486.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2487).into()),
);
}
#[allow(unused_mut)]
let mut scope_2488 = writer.prefix("NextToken");
if let Some(var_2489) = &input.next_token {
scope_2488.string(var_2489);
}
#[allow(unused_mut)]
let mut scope_2490 = writer.prefix("Filter");
if let Some(var_2491) = &input.filters {
let mut list_2493 = scope_2490.start_list(true, Some("Filter"));
for item_2492 in var_2491 {
#[allow(unused_mut)]
let mut entry_2494 = list_2493.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2494, item_2492)?;
}
list_2493.finish();
}
#[allow(unused_mut)]
let mut scope_2495 = writer.prefix("DryRun");
if let Some(var_2496) = &input.dry_run {
scope_2495.boolean(*var_2496);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_coip_pools(
input: &crate::input::DescribeCoipPoolsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeCoipPools", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2497 = writer.prefix("PoolId");
if let Some(var_2498) = &input.pool_ids {
let mut list_2500 = scope_2497.start_list(true, Some("item"));
for item_2499 in var_2498 {
#[allow(unused_mut)]
let mut entry_2501 = list_2500.entry();
entry_2501.string(item_2499);
}
list_2500.finish();
}
#[allow(unused_mut)]
let mut scope_2502 = writer.prefix("Filter");
if let Some(var_2503) = &input.filters {
let mut list_2505 = scope_2502.start_list(true, Some("Filter"));
for item_2504 in var_2503 {
#[allow(unused_mut)]
let mut entry_2506 = list_2505.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2506, item_2504)?;
}
list_2505.finish();
}
#[allow(unused_mut)]
let mut scope_2507 = writer.prefix("MaxResults");
if let Some(var_2508) = &input.max_results {
scope_2507.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2508).into()),
);
}
#[allow(unused_mut)]
let mut scope_2509 = writer.prefix("NextToken");
if let Some(var_2510) = &input.next_token {
scope_2509.string(var_2510);
}
#[allow(unused_mut)]
let mut scope_2511 = writer.prefix("DryRun");
if let Some(var_2512) = &input.dry_run {
scope_2511.boolean(*var_2512);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_conversion_tasks(
input: &crate::input::DescribeConversionTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeConversionTasks", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2513 = writer.prefix("ConversionTaskId");
if let Some(var_2514) = &input.conversion_task_ids {
let mut list_2516 = scope_2513.start_list(true, Some("item"));
for item_2515 in var_2514 {
#[allow(unused_mut)]
let mut entry_2517 = list_2516.entry();
entry_2517.string(item_2515);
}
list_2516.finish();
}
#[allow(unused_mut)]
let mut scope_2518 = writer.prefix("DryRun");
if let Some(var_2519) = &input.dry_run {
scope_2518.boolean(*var_2519);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_customer_gateways(
input: &crate::input::DescribeCustomerGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeCustomerGateways", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2520 = writer.prefix("CustomerGatewayId");
if let Some(var_2521) = &input.customer_gateway_ids {
let mut list_2523 = scope_2520.start_list(true, Some("CustomerGatewayId"));
for item_2522 in var_2521 {
#[allow(unused_mut)]
let mut entry_2524 = list_2523.entry();
entry_2524.string(item_2522);
}
list_2523.finish();
}
#[allow(unused_mut)]
let mut scope_2525 = writer.prefix("Filter");
if let Some(var_2526) = &input.filters {
let mut list_2528 = scope_2525.start_list(true, Some("Filter"));
for item_2527 in var_2526 {
#[allow(unused_mut)]
let mut entry_2529 = list_2528.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2529, item_2527)?;
}
list_2528.finish();
}
#[allow(unused_mut)]
let mut scope_2530 = writer.prefix("DryRun");
if let Some(var_2531) = &input.dry_run {
scope_2530.boolean(*var_2531);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_dhcp_options(
input: &crate::input::DescribeDhcpOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDhcpOptions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2532 = writer.prefix("DhcpOptionsId");
if let Some(var_2533) = &input.dhcp_options_ids {
let mut list_2535 = scope_2532.start_list(true, Some("DhcpOptionsId"));
for item_2534 in var_2533 {
#[allow(unused_mut)]
let mut entry_2536 = list_2535.entry();
entry_2536.string(item_2534);
}
list_2535.finish();
}
#[allow(unused_mut)]
let mut scope_2537 = writer.prefix("Filter");
if let Some(var_2538) = &input.filters {
let mut list_2540 = scope_2537.start_list(true, Some("Filter"));
for item_2539 in var_2538 {
#[allow(unused_mut)]
let mut entry_2541 = list_2540.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2541, item_2539)?;
}
list_2540.finish();
}
#[allow(unused_mut)]
let mut scope_2542 = writer.prefix("DryRun");
if let Some(var_2543) = &input.dry_run {
scope_2542.boolean(*var_2543);
}
#[allow(unused_mut)]
let mut scope_2544 = writer.prefix("NextToken");
if let Some(var_2545) = &input.next_token {
scope_2544.string(var_2545);
}
#[allow(unused_mut)]
let mut scope_2546 = writer.prefix("MaxResults");
if let Some(var_2547) = &input.max_results {
scope_2546.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2547).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_egress_only_internet_gateways(
input: &crate::input::DescribeEgressOnlyInternetGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeEgressOnlyInternetGateways",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2548 = writer.prefix("DryRun");
if let Some(var_2549) = &input.dry_run {
scope_2548.boolean(*var_2549);
}
#[allow(unused_mut)]
let mut scope_2550 = writer.prefix("EgressOnlyInternetGatewayId");
if let Some(var_2551) = &input.egress_only_internet_gateway_ids {
let mut list_2553 = scope_2550.start_list(true, Some("item"));
for item_2552 in var_2551 {
#[allow(unused_mut)]
let mut entry_2554 = list_2553.entry();
entry_2554.string(item_2552);
}
list_2553.finish();
}
#[allow(unused_mut)]
let mut scope_2555 = writer.prefix("MaxResults");
if let Some(var_2556) = &input.max_results {
scope_2555.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2556).into()),
);
}
#[allow(unused_mut)]
let mut scope_2557 = writer.prefix("NextToken");
if let Some(var_2558) = &input.next_token {
scope_2557.string(var_2558);
}
#[allow(unused_mut)]
let mut scope_2559 = writer.prefix("Filter");
if let Some(var_2560) = &input.filters {
let mut list_2562 = scope_2559.start_list(true, Some("Filter"));
for item_2561 in var_2560 {
#[allow(unused_mut)]
let mut entry_2563 = list_2562.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2563, item_2561)?;
}
list_2562.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_elastic_gpus(
input: &crate::input::DescribeElasticGpusInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeElasticGpus", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2564 = writer.prefix("ElasticGpuId");
if let Some(var_2565) = &input.elastic_gpu_ids {
let mut list_2567 = scope_2564.start_list(true, Some("item"));
for item_2566 in var_2565 {
#[allow(unused_mut)]
let mut entry_2568 = list_2567.entry();
entry_2568.string(item_2566);
}
list_2567.finish();
}
#[allow(unused_mut)]
let mut scope_2569 = writer.prefix("DryRun");
if let Some(var_2570) = &input.dry_run {
scope_2569.boolean(*var_2570);
}
#[allow(unused_mut)]
let mut scope_2571 = writer.prefix("Filter");
if let Some(var_2572) = &input.filters {
let mut list_2574 = scope_2571.start_list(true, Some("Filter"));
for item_2573 in var_2572 {
#[allow(unused_mut)]
let mut entry_2575 = list_2574.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2575, item_2573)?;
}
list_2574.finish();
}
#[allow(unused_mut)]
let mut scope_2576 = writer.prefix("MaxResults");
if let Some(var_2577) = &input.max_results {
scope_2576.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2577).into()),
);
}
#[allow(unused_mut)]
let mut scope_2578 = writer.prefix("NextToken");
if let Some(var_2579) = &input.next_token {
scope_2578.string(var_2579);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_export_image_tasks(
input: &crate::input::DescribeExportImageTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeExportImageTasks", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2580 = writer.prefix("DryRun");
if let Some(var_2581) = &input.dry_run {
scope_2580.boolean(*var_2581);
}
#[allow(unused_mut)]
let mut scope_2582 = writer.prefix("Filter");
if let Some(var_2583) = &input.filters {
let mut list_2585 = scope_2582.start_list(true, Some("Filter"));
for item_2584 in var_2583 {
#[allow(unused_mut)]
let mut entry_2586 = list_2585.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2586, item_2584)?;
}
list_2585.finish();
}
#[allow(unused_mut)]
let mut scope_2587 = writer.prefix("ExportImageTaskId");
if let Some(var_2588) = &input.export_image_task_ids {
let mut list_2590 = scope_2587.start_list(true, Some("ExportImageTaskId"));
for item_2589 in var_2588 {
#[allow(unused_mut)]
let mut entry_2591 = list_2590.entry();
entry_2591.string(item_2589);
}
list_2590.finish();
}
#[allow(unused_mut)]
let mut scope_2592 = writer.prefix("MaxResults");
if let Some(var_2593) = &input.max_results {
scope_2592.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2593).into()),
);
}
#[allow(unused_mut)]
let mut scope_2594 = writer.prefix("NextToken");
if let Some(var_2595) = &input.next_token {
scope_2594.string(var_2595);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_export_tasks(
input: &crate::input::DescribeExportTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeExportTasks", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2596 = writer.prefix("ExportTaskId");
if let Some(var_2597) = &input.export_task_ids {
let mut list_2599 = scope_2596.start_list(true, Some("ExportTaskId"));
for item_2598 in var_2597 {
#[allow(unused_mut)]
let mut entry_2600 = list_2599.entry();
entry_2600.string(item_2598);
}
list_2599.finish();
}
#[allow(unused_mut)]
let mut scope_2601 = writer.prefix("Filter");
if let Some(var_2602) = &input.filters {
let mut list_2604 = scope_2601.start_list(true, Some("Filter"));
for item_2603 in var_2602 {
#[allow(unused_mut)]
let mut entry_2605 = list_2604.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2605, item_2603)?;
}
list_2604.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_fast_launch_images(
input: &crate::input::DescribeFastLaunchImagesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeFastLaunchImages", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2606 = writer.prefix("ImageId");
if let Some(var_2607) = &input.image_ids {
let mut list_2609 = scope_2606.start_list(true, Some("ImageId"));
for item_2608 in var_2607 {
#[allow(unused_mut)]
let mut entry_2610 = list_2609.entry();
entry_2610.string(item_2608);
}
list_2609.finish();
}
#[allow(unused_mut)]
let mut scope_2611 = writer.prefix("Filter");
if let Some(var_2612) = &input.filters {
let mut list_2614 = scope_2611.start_list(true, Some("Filter"));
for item_2613 in var_2612 {
#[allow(unused_mut)]
let mut entry_2615 = list_2614.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2615, item_2613)?;
}
list_2614.finish();
}
#[allow(unused_mut)]
let mut scope_2616 = writer.prefix("MaxResults");
if let Some(var_2617) = &input.max_results {
scope_2616.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2617).into()),
);
}
#[allow(unused_mut)]
let mut scope_2618 = writer.prefix("NextToken");
if let Some(var_2619) = &input.next_token {
scope_2618.string(var_2619);
}
#[allow(unused_mut)]
let mut scope_2620 = writer.prefix("DryRun");
if let Some(var_2621) = &input.dry_run {
scope_2620.boolean(*var_2621);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_fast_snapshot_restores(
input: &crate::input::DescribeFastSnapshotRestoresInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeFastSnapshotRestores", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2622 = writer.prefix("Filter");
if let Some(var_2623) = &input.filters {
let mut list_2625 = scope_2622.start_list(true, Some("Filter"));
for item_2624 in var_2623 {
#[allow(unused_mut)]
let mut entry_2626 = list_2625.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2626, item_2624)?;
}
list_2625.finish();
}
#[allow(unused_mut)]
let mut scope_2627 = writer.prefix("MaxResults");
if let Some(var_2628) = &input.max_results {
scope_2627.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2628).into()),
);
}
#[allow(unused_mut)]
let mut scope_2629 = writer.prefix("NextToken");
if let Some(var_2630) = &input.next_token {
scope_2629.string(var_2630);
}
#[allow(unused_mut)]
let mut scope_2631 = writer.prefix("DryRun");
if let Some(var_2632) = &input.dry_run {
scope_2631.boolean(*var_2632);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_fleet_history(
input: &crate::input::DescribeFleetHistoryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeFleetHistory", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2633 = writer.prefix("DryRun");
if let Some(var_2634) = &input.dry_run {
scope_2633.boolean(*var_2634);
}
#[allow(unused_mut)]
let mut scope_2635 = writer.prefix("EventType");
if let Some(var_2636) = &input.event_type {
scope_2635.string(var_2636.as_str());
}
#[allow(unused_mut)]
let mut scope_2637 = writer.prefix("MaxResults");
if let Some(var_2638) = &input.max_results {
scope_2637.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2638).into()),
);
}
#[allow(unused_mut)]
let mut scope_2639 = writer.prefix("NextToken");
if let Some(var_2640) = &input.next_token {
scope_2639.string(var_2640);
}
#[allow(unused_mut)]
let mut scope_2641 = writer.prefix("FleetId");
if let Some(var_2642) = &input.fleet_id {
scope_2641.string(var_2642);
}
#[allow(unused_mut)]
let mut scope_2643 = writer.prefix("StartTime");
if let Some(var_2644) = &input.start_time {
scope_2643.date_time(var_2644, aws_smithy_types::date_time::Format::DateTime)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_fleet_instances(
input: &crate::input::DescribeFleetInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeFleetInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2645 = writer.prefix("DryRun");
if let Some(var_2646) = &input.dry_run {
scope_2645.boolean(*var_2646);
}
#[allow(unused_mut)]
let mut scope_2647 = writer.prefix("MaxResults");
if let Some(var_2648) = &input.max_results {
scope_2647.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2648).into()),
);
}
#[allow(unused_mut)]
let mut scope_2649 = writer.prefix("NextToken");
if let Some(var_2650) = &input.next_token {
scope_2649.string(var_2650);
}
#[allow(unused_mut)]
let mut scope_2651 = writer.prefix("FleetId");
if let Some(var_2652) = &input.fleet_id {
scope_2651.string(var_2652);
}
#[allow(unused_mut)]
let mut scope_2653 = writer.prefix("Filter");
if let Some(var_2654) = &input.filters {
let mut list_2656 = scope_2653.start_list(true, Some("Filter"));
for item_2655 in var_2654 {
#[allow(unused_mut)]
let mut entry_2657 = list_2656.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2657, item_2655)?;
}
list_2656.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_fleets(
input: &crate::input::DescribeFleetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeFleets", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2658 = writer.prefix("DryRun");
if let Some(var_2659) = &input.dry_run {
scope_2658.boolean(*var_2659);
}
#[allow(unused_mut)]
let mut scope_2660 = writer.prefix("MaxResults");
if let Some(var_2661) = &input.max_results {
scope_2660.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2661).into()),
);
}
#[allow(unused_mut)]
let mut scope_2662 = writer.prefix("NextToken");
if let Some(var_2663) = &input.next_token {
scope_2662.string(var_2663);
}
#[allow(unused_mut)]
let mut scope_2664 = writer.prefix("FleetId");
if let Some(var_2665) = &input.fleet_ids {
let mut list_2667 = scope_2664.start_list(true, None);
for item_2666 in var_2665 {
#[allow(unused_mut)]
let mut entry_2668 = list_2667.entry();
entry_2668.string(item_2666);
}
list_2667.finish();
}
#[allow(unused_mut)]
let mut scope_2669 = writer.prefix("Filter");
if let Some(var_2670) = &input.filters {
let mut list_2672 = scope_2669.start_list(true, Some("Filter"));
for item_2671 in var_2670 {
#[allow(unused_mut)]
let mut entry_2673 = list_2672.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2673, item_2671)?;
}
list_2672.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_flow_logs(
input: &crate::input::DescribeFlowLogsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeFlowLogs", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2674 = writer.prefix("DryRun");
if let Some(var_2675) = &input.dry_run {
scope_2674.boolean(*var_2675);
}
#[allow(unused_mut)]
let mut scope_2676 = writer.prefix("Filter");
if let Some(var_2677) = &input.filter {
let mut list_2679 = scope_2676.start_list(true, Some("Filter"));
for item_2678 in var_2677 {
#[allow(unused_mut)]
let mut entry_2680 = list_2679.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2680, item_2678)?;
}
list_2679.finish();
}
#[allow(unused_mut)]
let mut scope_2681 = writer.prefix("FlowLogId");
if let Some(var_2682) = &input.flow_log_ids {
let mut list_2684 = scope_2681.start_list(true, Some("item"));
for item_2683 in var_2682 {
#[allow(unused_mut)]
let mut entry_2685 = list_2684.entry();
entry_2685.string(item_2683);
}
list_2684.finish();
}
#[allow(unused_mut)]
let mut scope_2686 = writer.prefix("MaxResults");
if let Some(var_2687) = &input.max_results {
scope_2686.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2687).into()),
);
}
#[allow(unused_mut)]
let mut scope_2688 = writer.prefix("NextToken");
if let Some(var_2689) = &input.next_token {
scope_2688.string(var_2689);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_fpga_image_attribute(
input: &crate::input::DescribeFpgaImageAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeFpgaImageAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2690 = writer.prefix("DryRun");
if let Some(var_2691) = &input.dry_run {
scope_2690.boolean(*var_2691);
}
#[allow(unused_mut)]
let mut scope_2692 = writer.prefix("FpgaImageId");
if let Some(var_2693) = &input.fpga_image_id {
scope_2692.string(var_2693);
}
#[allow(unused_mut)]
let mut scope_2694 = writer.prefix("Attribute");
if let Some(var_2695) = &input.attribute {
scope_2694.string(var_2695.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_fpga_images(
input: &crate::input::DescribeFpgaImagesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeFpgaImages", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2696 = writer.prefix("DryRun");
if let Some(var_2697) = &input.dry_run {
scope_2696.boolean(*var_2697);
}
#[allow(unused_mut)]
let mut scope_2698 = writer.prefix("FpgaImageId");
if let Some(var_2699) = &input.fpga_image_ids {
let mut list_2701 = scope_2698.start_list(true, Some("item"));
for item_2700 in var_2699 {
#[allow(unused_mut)]
let mut entry_2702 = list_2701.entry();
entry_2702.string(item_2700);
}
list_2701.finish();
}
#[allow(unused_mut)]
let mut scope_2703 = writer.prefix("Owner");
if let Some(var_2704) = &input.owners {
let mut list_2706 = scope_2703.start_list(true, Some("Owner"));
for item_2705 in var_2704 {
#[allow(unused_mut)]
let mut entry_2707 = list_2706.entry();
entry_2707.string(item_2705);
}
list_2706.finish();
}
#[allow(unused_mut)]
let mut scope_2708 = writer.prefix("Filter");
if let Some(var_2709) = &input.filters {
let mut list_2711 = scope_2708.start_list(true, Some("Filter"));
for item_2710 in var_2709 {
#[allow(unused_mut)]
let mut entry_2712 = list_2711.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2712, item_2710)?;
}
list_2711.finish();
}
#[allow(unused_mut)]
let mut scope_2713 = writer.prefix("NextToken");
if let Some(var_2714) = &input.next_token {
scope_2713.string(var_2714);
}
#[allow(unused_mut)]
let mut scope_2715 = writer.prefix("MaxResults");
if let Some(var_2716) = &input.max_results {
scope_2715.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2716).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_host_reservation_offerings(
input: &crate::input::DescribeHostReservationOfferingsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeHostReservationOfferings",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2717 = writer.prefix("Filter");
if let Some(var_2718) = &input.filter {
let mut list_2720 = scope_2717.start_list(true, Some("Filter"));
for item_2719 in var_2718 {
#[allow(unused_mut)]
let mut entry_2721 = list_2720.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2721, item_2719)?;
}
list_2720.finish();
}
#[allow(unused_mut)]
let mut scope_2722 = writer.prefix("MaxDuration");
if let Some(var_2723) = &input.max_duration {
scope_2722.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2723).into()),
);
}
#[allow(unused_mut)]
let mut scope_2724 = writer.prefix("MaxResults");
if let Some(var_2725) = &input.max_results {
scope_2724.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2725).into()),
);
}
#[allow(unused_mut)]
let mut scope_2726 = writer.prefix("MinDuration");
if let Some(var_2727) = &input.min_duration {
scope_2726.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2727).into()),
);
}
#[allow(unused_mut)]
let mut scope_2728 = writer.prefix("NextToken");
if let Some(var_2729) = &input.next_token {
scope_2728.string(var_2729);
}
#[allow(unused_mut)]
let mut scope_2730 = writer.prefix("OfferingId");
if let Some(var_2731) = &input.offering_id {
scope_2730.string(var_2731);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_host_reservations(
input: &crate::input::DescribeHostReservationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeHostReservations", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2732 = writer.prefix("Filter");
if let Some(var_2733) = &input.filter {
let mut list_2735 = scope_2732.start_list(true, Some("Filter"));
for item_2734 in var_2733 {
#[allow(unused_mut)]
let mut entry_2736 = list_2735.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2736, item_2734)?;
}
list_2735.finish();
}
#[allow(unused_mut)]
let mut scope_2737 = writer.prefix("HostReservationIdSet");
if let Some(var_2738) = &input.host_reservation_id_set {
let mut list_2740 = scope_2737.start_list(true, Some("item"));
for item_2739 in var_2738 {
#[allow(unused_mut)]
let mut entry_2741 = list_2740.entry();
entry_2741.string(item_2739);
}
list_2740.finish();
}
#[allow(unused_mut)]
let mut scope_2742 = writer.prefix("MaxResults");
if let Some(var_2743) = &input.max_results {
scope_2742.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2743).into()),
);
}
#[allow(unused_mut)]
let mut scope_2744 = writer.prefix("NextToken");
if let Some(var_2745) = &input.next_token {
scope_2744.string(var_2745);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_hosts(
input: &crate::input::DescribeHostsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeHosts", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2746 = writer.prefix("Filter");
if let Some(var_2747) = &input.filter {
let mut list_2749 = scope_2746.start_list(true, Some("Filter"));
for item_2748 in var_2747 {
#[allow(unused_mut)]
let mut entry_2750 = list_2749.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2750, item_2748)?;
}
list_2749.finish();
}
#[allow(unused_mut)]
let mut scope_2751 = writer.prefix("HostId");
if let Some(var_2752) = &input.host_ids {
let mut list_2754 = scope_2751.start_list(true, Some("item"));
for item_2753 in var_2752 {
#[allow(unused_mut)]
let mut entry_2755 = list_2754.entry();
entry_2755.string(item_2753);
}
list_2754.finish();
}
#[allow(unused_mut)]
let mut scope_2756 = writer.prefix("MaxResults");
if let Some(var_2757) = &input.max_results {
scope_2756.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2757).into()),
);
}
#[allow(unused_mut)]
let mut scope_2758 = writer.prefix("NextToken");
if let Some(var_2759) = &input.next_token {
scope_2758.string(var_2759);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_iam_instance_profile_associations(
input: &crate::input::DescribeIamInstanceProfileAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeIamInstanceProfileAssociations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2760 = writer.prefix("AssociationId");
if let Some(var_2761) = &input.association_ids {
let mut list_2763 = scope_2760.start_list(true, Some("AssociationId"));
for item_2762 in var_2761 {
#[allow(unused_mut)]
let mut entry_2764 = list_2763.entry();
entry_2764.string(item_2762);
}
list_2763.finish();
}
#[allow(unused_mut)]
let mut scope_2765 = writer.prefix("Filter");
if let Some(var_2766) = &input.filters {
let mut list_2768 = scope_2765.start_list(true, Some("Filter"));
for item_2767 in var_2766 {
#[allow(unused_mut)]
let mut entry_2769 = list_2768.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2769, item_2767)?;
}
list_2768.finish();
}
#[allow(unused_mut)]
let mut scope_2770 = writer.prefix("MaxResults");
if let Some(var_2771) = &input.max_results {
scope_2770.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2771).into()),
);
}
#[allow(unused_mut)]
let mut scope_2772 = writer.prefix("NextToken");
if let Some(var_2773) = &input.next_token {
scope_2772.string(var_2773);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_identity_id_format(
input: &crate::input::DescribeIdentityIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeIdentityIdFormat", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2774 = writer.prefix("PrincipalArn");
if let Some(var_2775) = &input.principal_arn {
scope_2774.string(var_2775);
}
#[allow(unused_mut)]
let mut scope_2776 = writer.prefix("Resource");
if let Some(var_2777) = &input.resource {
scope_2776.string(var_2777);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_id_format(
input: &crate::input::DescribeIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeIdFormat", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2778 = writer.prefix("Resource");
if let Some(var_2779) = &input.resource {
scope_2778.string(var_2779);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_image_attribute(
input: &crate::input::DescribeImageAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeImageAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2780 = writer.prefix("Attribute");
if let Some(var_2781) = &input.attribute {
scope_2780.string(var_2781.as_str());
}
#[allow(unused_mut)]
let mut scope_2782 = writer.prefix("ImageId");
if let Some(var_2783) = &input.image_id {
scope_2782.string(var_2783);
}
#[allow(unused_mut)]
let mut scope_2784 = writer.prefix("DryRun");
if let Some(var_2785) = &input.dry_run {
scope_2784.boolean(*var_2785);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_images(
input: &crate::input::DescribeImagesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeImages", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2786 = writer.prefix("ExecutableBy");
if let Some(var_2787) = &input.executable_users {
let mut list_2789 = scope_2786.start_list(true, Some("ExecutableBy"));
for item_2788 in var_2787 {
#[allow(unused_mut)]
let mut entry_2790 = list_2789.entry();
entry_2790.string(item_2788);
}
list_2789.finish();
}
#[allow(unused_mut)]
let mut scope_2791 = writer.prefix("Filter");
if let Some(var_2792) = &input.filters {
let mut list_2794 = scope_2791.start_list(true, Some("Filter"));
for item_2793 in var_2792 {
#[allow(unused_mut)]
let mut entry_2795 = list_2794.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2795, item_2793)?;
}
list_2794.finish();
}
#[allow(unused_mut)]
let mut scope_2796 = writer.prefix("ImageId");
if let Some(var_2797) = &input.image_ids {
let mut list_2799 = scope_2796.start_list(true, Some("ImageId"));
for item_2798 in var_2797 {
#[allow(unused_mut)]
let mut entry_2800 = list_2799.entry();
entry_2800.string(item_2798);
}
list_2799.finish();
}
#[allow(unused_mut)]
let mut scope_2801 = writer.prefix("Owner");
if let Some(var_2802) = &input.owners {
let mut list_2804 = scope_2801.start_list(true, Some("Owner"));
for item_2803 in var_2802 {
#[allow(unused_mut)]
let mut entry_2805 = list_2804.entry();
entry_2805.string(item_2803);
}
list_2804.finish();
}
#[allow(unused_mut)]
let mut scope_2806 = writer.prefix("IncludeDeprecated");
if let Some(var_2807) = &input.include_deprecated {
scope_2806.boolean(*var_2807);
}
#[allow(unused_mut)]
let mut scope_2808 = writer.prefix("DryRun");
if let Some(var_2809) = &input.dry_run {
scope_2808.boolean(*var_2809);
}
#[allow(unused_mut)]
let mut scope_2810 = writer.prefix("MaxResults");
if let Some(var_2811) = &input.max_results {
scope_2810.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2811).into()),
);
}
#[allow(unused_mut)]
let mut scope_2812 = writer.prefix("NextToken");
if let Some(var_2813) = &input.next_token {
scope_2812.string(var_2813);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_import_image_tasks(
input: &crate::input::DescribeImportImageTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeImportImageTasks", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2814 = writer.prefix("DryRun");
if let Some(var_2815) = &input.dry_run {
scope_2814.boolean(*var_2815);
}
#[allow(unused_mut)]
let mut scope_2816 = writer.prefix("Filters");
if let Some(var_2817) = &input.filters {
let mut list_2819 = scope_2816.start_list(true, Some("Filter"));
for item_2818 in var_2817 {
#[allow(unused_mut)]
let mut entry_2820 = list_2819.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2820, item_2818)?;
}
list_2819.finish();
}
#[allow(unused_mut)]
let mut scope_2821 = writer.prefix("ImportTaskId");
if let Some(var_2822) = &input.import_task_ids {
let mut list_2824 = scope_2821.start_list(true, Some("ImportTaskId"));
for item_2823 in var_2822 {
#[allow(unused_mut)]
let mut entry_2825 = list_2824.entry();
entry_2825.string(item_2823);
}
list_2824.finish();
}
#[allow(unused_mut)]
let mut scope_2826 = writer.prefix("MaxResults");
if let Some(var_2827) = &input.max_results {
scope_2826.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2827).into()),
);
}
#[allow(unused_mut)]
let mut scope_2828 = writer.prefix("NextToken");
if let Some(var_2829) = &input.next_token {
scope_2828.string(var_2829);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_import_snapshot_tasks(
input: &crate::input::DescribeImportSnapshotTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeImportSnapshotTasks", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2830 = writer.prefix("DryRun");
if let Some(var_2831) = &input.dry_run {
scope_2830.boolean(*var_2831);
}
#[allow(unused_mut)]
let mut scope_2832 = writer.prefix("Filters");
if let Some(var_2833) = &input.filters {
let mut list_2835 = scope_2832.start_list(true, Some("Filter"));
for item_2834 in var_2833 {
#[allow(unused_mut)]
let mut entry_2836 = list_2835.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2836, item_2834)?;
}
list_2835.finish();
}
#[allow(unused_mut)]
let mut scope_2837 = writer.prefix("ImportTaskId");
if let Some(var_2838) = &input.import_task_ids {
let mut list_2840 = scope_2837.start_list(true, Some("ImportTaskId"));
for item_2839 in var_2838 {
#[allow(unused_mut)]
let mut entry_2841 = list_2840.entry();
entry_2841.string(item_2839);
}
list_2840.finish();
}
#[allow(unused_mut)]
let mut scope_2842 = writer.prefix("MaxResults");
if let Some(var_2843) = &input.max_results {
scope_2842.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2843).into()),
);
}
#[allow(unused_mut)]
let mut scope_2844 = writer.prefix("NextToken");
if let Some(var_2845) = &input.next_token {
scope_2844.string(var_2845);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_instance_attribute(
input: &crate::input::DescribeInstanceAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeInstanceAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2846 = writer.prefix("Attribute");
if let Some(var_2847) = &input.attribute {
scope_2846.string(var_2847.as_str());
}
#[allow(unused_mut)]
let mut scope_2848 = writer.prefix("DryRun");
if let Some(var_2849) = &input.dry_run {
scope_2848.boolean(*var_2849);
}
#[allow(unused_mut)]
let mut scope_2850 = writer.prefix("InstanceId");
if let Some(var_2851) = &input.instance_id {
scope_2850.string(var_2851);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_instance_credit_specifications(
input: &crate::input::DescribeInstanceCreditSpecificationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeInstanceCreditSpecifications",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2852 = writer.prefix("DryRun");
if let Some(var_2853) = &input.dry_run {
scope_2852.boolean(*var_2853);
}
#[allow(unused_mut)]
let mut scope_2854 = writer.prefix("Filter");
if let Some(var_2855) = &input.filters {
let mut list_2857 = scope_2854.start_list(true, Some("Filter"));
for item_2856 in var_2855 {
#[allow(unused_mut)]
let mut entry_2858 = list_2857.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2858, item_2856)?;
}
list_2857.finish();
}
#[allow(unused_mut)]
let mut scope_2859 = writer.prefix("InstanceId");
if let Some(var_2860) = &input.instance_ids {
let mut list_2862 = scope_2859.start_list(true, Some("InstanceId"));
for item_2861 in var_2860 {
#[allow(unused_mut)]
let mut entry_2863 = list_2862.entry();
entry_2863.string(item_2861);
}
list_2862.finish();
}
#[allow(unused_mut)]
let mut scope_2864 = writer.prefix("MaxResults");
if let Some(var_2865) = &input.max_results {
scope_2864.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2865).into()),
);
}
#[allow(unused_mut)]
let mut scope_2866 = writer.prefix("NextToken");
if let Some(var_2867) = &input.next_token {
scope_2866.string(var_2867);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_instance_event_notification_attributes(
input: &crate::input::DescribeInstanceEventNotificationAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeInstanceEventNotificationAttributes",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_2868 = writer.prefix("DryRun");
if let Some(var_2869) = &input.dry_run {
scope_2868.boolean(*var_2869);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_instance_event_windows(
input: &crate::input::DescribeInstanceEventWindowsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeInstanceEventWindows", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2870 = writer.prefix("DryRun");
if let Some(var_2871) = &input.dry_run {
scope_2870.boolean(*var_2871);
}
#[allow(unused_mut)]
let mut scope_2872 = writer.prefix("InstanceEventWindowId");
if let Some(var_2873) = &input.instance_event_window_ids {
let mut list_2875 = scope_2872.start_list(true, Some("InstanceEventWindowId"));
for item_2874 in var_2873 {
#[allow(unused_mut)]
let mut entry_2876 = list_2875.entry();
entry_2876.string(item_2874);
}
list_2875.finish();
}
#[allow(unused_mut)]
let mut scope_2877 = writer.prefix("Filter");
if let Some(var_2878) = &input.filters {
let mut list_2880 = scope_2877.start_list(true, Some("Filter"));
for item_2879 in var_2878 {
#[allow(unused_mut)]
let mut entry_2881 = list_2880.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2881, item_2879)?;
}
list_2880.finish();
}
#[allow(unused_mut)]
let mut scope_2882 = writer.prefix("MaxResults");
if let Some(var_2883) = &input.max_results {
scope_2882.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2883).into()),
);
}
#[allow(unused_mut)]
let mut scope_2884 = writer.prefix("NextToken");
if let Some(var_2885) = &input.next_token {
scope_2884.string(var_2885);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_instances(
input: &crate::input::DescribeInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2886 = writer.prefix("Filter");
if let Some(var_2887) = &input.filters {
let mut list_2889 = scope_2886.start_list(true, Some("Filter"));
for item_2888 in var_2887 {
#[allow(unused_mut)]
let mut entry_2890 = list_2889.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2890, item_2888)?;
}
list_2889.finish();
}
#[allow(unused_mut)]
let mut scope_2891 = writer.prefix("InstanceId");
if let Some(var_2892) = &input.instance_ids {
let mut list_2894 = scope_2891.start_list(true, Some("InstanceId"));
for item_2893 in var_2892 {
#[allow(unused_mut)]
let mut entry_2895 = list_2894.entry();
entry_2895.string(item_2893);
}
list_2894.finish();
}
#[allow(unused_mut)]
let mut scope_2896 = writer.prefix("DryRun");
if let Some(var_2897) = &input.dry_run {
scope_2896.boolean(*var_2897);
}
#[allow(unused_mut)]
let mut scope_2898 = writer.prefix("MaxResults");
if let Some(var_2899) = &input.max_results {
scope_2898.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2899).into()),
);
}
#[allow(unused_mut)]
let mut scope_2900 = writer.prefix("NextToken");
if let Some(var_2901) = &input.next_token {
scope_2900.string(var_2901);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_instance_status(
input: &crate::input::DescribeInstanceStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeInstanceStatus", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2902 = writer.prefix("Filter");
if let Some(var_2903) = &input.filters {
let mut list_2905 = scope_2902.start_list(true, Some("Filter"));
for item_2904 in var_2903 {
#[allow(unused_mut)]
let mut entry_2906 = list_2905.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2906, item_2904)?;
}
list_2905.finish();
}
#[allow(unused_mut)]
let mut scope_2907 = writer.prefix("InstanceId");
if let Some(var_2908) = &input.instance_ids {
let mut list_2910 = scope_2907.start_list(true, Some("InstanceId"));
for item_2909 in var_2908 {
#[allow(unused_mut)]
let mut entry_2911 = list_2910.entry();
entry_2911.string(item_2909);
}
list_2910.finish();
}
#[allow(unused_mut)]
let mut scope_2912 = writer.prefix("MaxResults");
if let Some(var_2913) = &input.max_results {
scope_2912.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2913).into()),
);
}
#[allow(unused_mut)]
let mut scope_2914 = writer.prefix("NextToken");
if let Some(var_2915) = &input.next_token {
scope_2914.string(var_2915);
}
#[allow(unused_mut)]
let mut scope_2916 = writer.prefix("DryRun");
if let Some(var_2917) = &input.dry_run {
scope_2916.boolean(*var_2917);
}
#[allow(unused_mut)]
let mut scope_2918 = writer.prefix("IncludeAllInstances");
if let Some(var_2919) = &input.include_all_instances {
scope_2918.boolean(*var_2919);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_instance_type_offerings(
input: &crate::input::DescribeInstanceTypeOfferingsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeInstanceTypeOfferings", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2920 = writer.prefix("DryRun");
if let Some(var_2921) = &input.dry_run {
scope_2920.boolean(*var_2921);
}
#[allow(unused_mut)]
let mut scope_2922 = writer.prefix("LocationType");
if let Some(var_2923) = &input.location_type {
scope_2922.string(var_2923.as_str());
}
#[allow(unused_mut)]
let mut scope_2924 = writer.prefix("Filter");
if let Some(var_2925) = &input.filters {
let mut list_2927 = scope_2924.start_list(true, Some("Filter"));
for item_2926 in var_2925 {
#[allow(unused_mut)]
let mut entry_2928 = list_2927.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2928, item_2926)?;
}
list_2927.finish();
}
#[allow(unused_mut)]
let mut scope_2929 = writer.prefix("MaxResults");
if let Some(var_2930) = &input.max_results {
scope_2929.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2930).into()),
);
}
#[allow(unused_mut)]
let mut scope_2931 = writer.prefix("NextToken");
if let Some(var_2932) = &input.next_token {
scope_2931.string(var_2932);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_instance_types(
input: &crate::input::DescribeInstanceTypesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeInstanceTypes", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2933 = writer.prefix("DryRun");
if let Some(var_2934) = &input.dry_run {
scope_2933.boolean(*var_2934);
}
#[allow(unused_mut)]
let mut scope_2935 = writer.prefix("InstanceType");
if let Some(var_2936) = &input.instance_types {
let mut list_2938 = scope_2935.start_list(true, None);
for item_2937 in var_2936 {
#[allow(unused_mut)]
let mut entry_2939 = list_2938.entry();
entry_2939.string(item_2937.as_str());
}
list_2938.finish();
}
#[allow(unused_mut)]
let mut scope_2940 = writer.prefix("Filter");
if let Some(var_2941) = &input.filters {
let mut list_2943 = scope_2940.start_list(true, Some("Filter"));
for item_2942 in var_2941 {
#[allow(unused_mut)]
let mut entry_2944 = list_2943.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2944, item_2942)?;
}
list_2943.finish();
}
#[allow(unused_mut)]
let mut scope_2945 = writer.prefix("MaxResults");
if let Some(var_2946) = &input.max_results {
scope_2945.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2946).into()),
);
}
#[allow(unused_mut)]
let mut scope_2947 = writer.prefix("NextToken");
if let Some(var_2948) = &input.next_token {
scope_2947.string(var_2948);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_internet_gateways(
input: &crate::input::DescribeInternetGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeInternetGateways", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2949 = writer.prefix("Filter");
if let Some(var_2950) = &input.filters {
let mut list_2952 = scope_2949.start_list(true, Some("Filter"));
for item_2951 in var_2950 {
#[allow(unused_mut)]
let mut entry_2953 = list_2952.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2953, item_2951)?;
}
list_2952.finish();
}
#[allow(unused_mut)]
let mut scope_2954 = writer.prefix("DryRun");
if let Some(var_2955) = &input.dry_run {
scope_2954.boolean(*var_2955);
}
#[allow(unused_mut)]
let mut scope_2956 = writer.prefix("InternetGatewayId");
if let Some(var_2957) = &input.internet_gateway_ids {
let mut list_2959 = scope_2956.start_list(true, Some("item"));
for item_2958 in var_2957 {
#[allow(unused_mut)]
let mut entry_2960 = list_2959.entry();
entry_2960.string(item_2958);
}
list_2959.finish();
}
#[allow(unused_mut)]
let mut scope_2961 = writer.prefix("NextToken");
if let Some(var_2962) = &input.next_token {
scope_2961.string(var_2962);
}
#[allow(unused_mut)]
let mut scope_2963 = writer.prefix("MaxResults");
if let Some(var_2964) = &input.max_results {
scope_2963.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2964).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_ipam_pools(
input: &crate::input::DescribeIpamPoolsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeIpamPools", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2965 = writer.prefix("DryRun");
if let Some(var_2966) = &input.dry_run {
scope_2965.boolean(*var_2966);
}
#[allow(unused_mut)]
let mut scope_2967 = writer.prefix("Filter");
if let Some(var_2968) = &input.filters {
let mut list_2970 = scope_2967.start_list(true, Some("Filter"));
for item_2969 in var_2968 {
#[allow(unused_mut)]
let mut entry_2971 = list_2970.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2971, item_2969)?;
}
list_2970.finish();
}
#[allow(unused_mut)]
let mut scope_2972 = writer.prefix("MaxResults");
if let Some(var_2973) = &input.max_results {
scope_2972.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2973).into()),
);
}
#[allow(unused_mut)]
let mut scope_2974 = writer.prefix("NextToken");
if let Some(var_2975) = &input.next_token {
scope_2974.string(var_2975);
}
#[allow(unused_mut)]
let mut scope_2976 = writer.prefix("IpamPoolId");
if let Some(var_2977) = &input.ipam_pool_ids {
let mut list_2979 = scope_2976.start_list(true, Some("item"));
for item_2978 in var_2977 {
#[allow(unused_mut)]
let mut entry_2980 = list_2979.entry();
entry_2980.string(item_2978);
}
list_2979.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_ipams(
input: &crate::input::DescribeIpamsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeIpams", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2981 = writer.prefix("DryRun");
if let Some(var_2982) = &input.dry_run {
scope_2981.boolean(*var_2982);
}
#[allow(unused_mut)]
let mut scope_2983 = writer.prefix("Filter");
if let Some(var_2984) = &input.filters {
let mut list_2986 = scope_2983.start_list(true, Some("Filter"));
for item_2985 in var_2984 {
#[allow(unused_mut)]
let mut entry_2987 = list_2986.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_2987, item_2985)?;
}
list_2986.finish();
}
#[allow(unused_mut)]
let mut scope_2988 = writer.prefix("MaxResults");
if let Some(var_2989) = &input.max_results {
scope_2988.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2989).into()),
);
}
#[allow(unused_mut)]
let mut scope_2990 = writer.prefix("NextToken");
if let Some(var_2991) = &input.next_token {
scope_2990.string(var_2991);
}
#[allow(unused_mut)]
let mut scope_2992 = writer.prefix("IpamId");
if let Some(var_2993) = &input.ipam_ids {
let mut list_2995 = scope_2992.start_list(true, Some("item"));
for item_2994 in var_2993 {
#[allow(unused_mut)]
let mut entry_2996 = list_2995.entry();
entry_2996.string(item_2994);
}
list_2995.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_ipam_scopes(
input: &crate::input::DescribeIpamScopesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeIpamScopes", "2016-11-15");
#[allow(unused_mut)]
let mut scope_2997 = writer.prefix("DryRun");
if let Some(var_2998) = &input.dry_run {
scope_2997.boolean(*var_2998);
}
#[allow(unused_mut)]
let mut scope_2999 = writer.prefix("Filter");
if let Some(var_3000) = &input.filters {
let mut list_3002 = scope_2999.start_list(true, Some("Filter"));
for item_3001 in var_3000 {
#[allow(unused_mut)]
let mut entry_3003 = list_3002.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3003, item_3001)?;
}
list_3002.finish();
}
#[allow(unused_mut)]
let mut scope_3004 = writer.prefix("MaxResults");
if let Some(var_3005) = &input.max_results {
scope_3004.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3005).into()),
);
}
#[allow(unused_mut)]
let mut scope_3006 = writer.prefix("NextToken");
if let Some(var_3007) = &input.next_token {
scope_3006.string(var_3007);
}
#[allow(unused_mut)]
let mut scope_3008 = writer.prefix("IpamScopeId");
if let Some(var_3009) = &input.ipam_scope_ids {
let mut list_3011 = scope_3008.start_list(true, Some("item"));
for item_3010 in var_3009 {
#[allow(unused_mut)]
let mut entry_3012 = list_3011.entry();
entry_3012.string(item_3010);
}
list_3011.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_ipv6_pools(
input: &crate::input::DescribeIpv6PoolsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeIpv6Pools", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3013 = writer.prefix("PoolId");
if let Some(var_3014) = &input.pool_ids {
let mut list_3016 = scope_3013.start_list(true, Some("item"));
for item_3015 in var_3014 {
#[allow(unused_mut)]
let mut entry_3017 = list_3016.entry();
entry_3017.string(item_3015);
}
list_3016.finish();
}
#[allow(unused_mut)]
let mut scope_3018 = writer.prefix("NextToken");
if let Some(var_3019) = &input.next_token {
scope_3018.string(var_3019);
}
#[allow(unused_mut)]
let mut scope_3020 = writer.prefix("MaxResults");
if let Some(var_3021) = &input.max_results {
scope_3020.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3021).into()),
);
}
#[allow(unused_mut)]
let mut scope_3022 = writer.prefix("DryRun");
if let Some(var_3023) = &input.dry_run {
scope_3022.boolean(*var_3023);
}
#[allow(unused_mut)]
let mut scope_3024 = writer.prefix("Filter");
if let Some(var_3025) = &input.filters {
let mut list_3027 = scope_3024.start_list(true, Some("Filter"));
for item_3026 in var_3025 {
#[allow(unused_mut)]
let mut entry_3028 = list_3027.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3028, item_3026)?;
}
list_3027.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_key_pairs(
input: &crate::input::DescribeKeyPairsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeKeyPairs", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3029 = writer.prefix("Filter");
if let Some(var_3030) = &input.filters {
let mut list_3032 = scope_3029.start_list(true, Some("Filter"));
for item_3031 in var_3030 {
#[allow(unused_mut)]
let mut entry_3033 = list_3032.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3033, item_3031)?;
}
list_3032.finish();
}
#[allow(unused_mut)]
let mut scope_3034 = writer.prefix("KeyName");
if let Some(var_3035) = &input.key_names {
let mut list_3037 = scope_3034.start_list(true, Some("KeyName"));
for item_3036 in var_3035 {
#[allow(unused_mut)]
let mut entry_3038 = list_3037.entry();
entry_3038.string(item_3036);
}
list_3037.finish();
}
#[allow(unused_mut)]
let mut scope_3039 = writer.prefix("KeyPairId");
if let Some(var_3040) = &input.key_pair_ids {
let mut list_3042 = scope_3039.start_list(true, Some("KeyPairId"));
for item_3041 in var_3040 {
#[allow(unused_mut)]
let mut entry_3043 = list_3042.entry();
entry_3043.string(item_3041);
}
list_3042.finish();
}
#[allow(unused_mut)]
let mut scope_3044 = writer.prefix("DryRun");
if let Some(var_3045) = &input.dry_run {
scope_3044.boolean(*var_3045);
}
#[allow(unused_mut)]
let mut scope_3046 = writer.prefix("IncludePublicKey");
if let Some(var_3047) = &input.include_public_key {
scope_3046.boolean(*var_3047);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_launch_templates(
input: &crate::input::DescribeLaunchTemplatesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeLaunchTemplates", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3048 = writer.prefix("DryRun");
if let Some(var_3049) = &input.dry_run {
scope_3048.boolean(*var_3049);
}
#[allow(unused_mut)]
let mut scope_3050 = writer.prefix("LaunchTemplateId");
if let Some(var_3051) = &input.launch_template_ids {
let mut list_3053 = scope_3050.start_list(true, Some("item"));
for item_3052 in var_3051 {
#[allow(unused_mut)]
let mut entry_3054 = list_3053.entry();
entry_3054.string(item_3052);
}
list_3053.finish();
}
#[allow(unused_mut)]
let mut scope_3055 = writer.prefix("LaunchTemplateName");
if let Some(var_3056) = &input.launch_template_names {
let mut list_3058 = scope_3055.start_list(true, Some("item"));
for item_3057 in var_3056 {
#[allow(unused_mut)]
let mut entry_3059 = list_3058.entry();
entry_3059.string(item_3057);
}
list_3058.finish();
}
#[allow(unused_mut)]
let mut scope_3060 = writer.prefix("Filter");
if let Some(var_3061) = &input.filters {
let mut list_3063 = scope_3060.start_list(true, Some("Filter"));
for item_3062 in var_3061 {
#[allow(unused_mut)]
let mut entry_3064 = list_3063.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3064, item_3062)?;
}
list_3063.finish();
}
#[allow(unused_mut)]
let mut scope_3065 = writer.prefix("NextToken");
if let Some(var_3066) = &input.next_token {
scope_3065.string(var_3066);
}
#[allow(unused_mut)]
let mut scope_3067 = writer.prefix("MaxResults");
if let Some(var_3068) = &input.max_results {
scope_3067.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3068).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_launch_template_versions(
input: &crate::input::DescribeLaunchTemplateVersionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeLaunchTemplateVersions",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3069 = writer.prefix("DryRun");
if let Some(var_3070) = &input.dry_run {
scope_3069.boolean(*var_3070);
}
#[allow(unused_mut)]
let mut scope_3071 = writer.prefix("LaunchTemplateId");
if let Some(var_3072) = &input.launch_template_id {
scope_3071.string(var_3072);
}
#[allow(unused_mut)]
let mut scope_3073 = writer.prefix("LaunchTemplateName");
if let Some(var_3074) = &input.launch_template_name {
scope_3073.string(var_3074);
}
#[allow(unused_mut)]
let mut scope_3075 = writer.prefix("LaunchTemplateVersion");
if let Some(var_3076) = &input.versions {
let mut list_3078 = scope_3075.start_list(true, Some("item"));
for item_3077 in var_3076 {
#[allow(unused_mut)]
let mut entry_3079 = list_3078.entry();
entry_3079.string(item_3077);
}
list_3078.finish();
}
#[allow(unused_mut)]
let mut scope_3080 = writer.prefix("MinVersion");
if let Some(var_3081) = &input.min_version {
scope_3080.string(var_3081);
}
#[allow(unused_mut)]
let mut scope_3082 = writer.prefix("MaxVersion");
if let Some(var_3083) = &input.max_version {
scope_3082.string(var_3083);
}
#[allow(unused_mut)]
let mut scope_3084 = writer.prefix("NextToken");
if let Some(var_3085) = &input.next_token {
scope_3084.string(var_3085);
}
#[allow(unused_mut)]
let mut scope_3086 = writer.prefix("MaxResults");
if let Some(var_3087) = &input.max_results {
scope_3086.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3087).into()),
);
}
#[allow(unused_mut)]
let mut scope_3088 = writer.prefix("Filter");
if let Some(var_3089) = &input.filters {
let mut list_3091 = scope_3088.start_list(true, Some("Filter"));
for item_3090 in var_3089 {
#[allow(unused_mut)]
let mut entry_3092 = list_3091.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3092, item_3090)?;
}
list_3091.finish();
}
#[allow(unused_mut)]
let mut scope_3093 = writer.prefix("ResolveAlias");
if let Some(var_3094) = &input.resolve_alias {
scope_3093.boolean(*var_3094);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_local_gateway_route_tables(
input: &crate::input::DescribeLocalGatewayRouteTablesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeLocalGatewayRouteTables",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3095 = writer.prefix("LocalGatewayRouteTableId");
if let Some(var_3096) = &input.local_gateway_route_table_ids {
let mut list_3098 = scope_3095.start_list(true, Some("item"));
for item_3097 in var_3096 {
#[allow(unused_mut)]
let mut entry_3099 = list_3098.entry();
entry_3099.string(item_3097);
}
list_3098.finish();
}
#[allow(unused_mut)]
let mut scope_3100 = writer.prefix("Filter");
if let Some(var_3101) = &input.filters {
let mut list_3103 = scope_3100.start_list(true, Some("Filter"));
for item_3102 in var_3101 {
#[allow(unused_mut)]
let mut entry_3104 = list_3103.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3104, item_3102)?;
}
list_3103.finish();
}
#[allow(unused_mut)]
let mut scope_3105 = writer.prefix("MaxResults");
if let Some(var_3106) = &input.max_results {
scope_3105.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3106).into()),
);
}
#[allow(unused_mut)]
let mut scope_3107 = writer.prefix("NextToken");
if let Some(var_3108) = &input.next_token {
scope_3107.string(var_3108);
}
#[allow(unused_mut)]
let mut scope_3109 = writer.prefix("DryRun");
if let Some(var_3110) = &input.dry_run {
scope_3109.boolean(*var_3110);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_local_gateway_route_table_virtual_interface_group_associations(
input: &crate::input::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3111 = writer.prefix("LocalGatewayRouteTableVirtualInterfaceGroupAssociationId");
if let Some(var_3112) = &input.local_gateway_route_table_virtual_interface_group_association_ids
{
let mut list_3114 = scope_3111.start_list(true, Some("item"));
for item_3113 in var_3112 {
#[allow(unused_mut)]
let mut entry_3115 = list_3114.entry();
entry_3115.string(item_3113);
}
list_3114.finish();
}
#[allow(unused_mut)]
let mut scope_3116 = writer.prefix("Filter");
if let Some(var_3117) = &input.filters {
let mut list_3119 = scope_3116.start_list(true, Some("Filter"));
for item_3118 in var_3117 {
#[allow(unused_mut)]
let mut entry_3120 = list_3119.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3120, item_3118)?;
}
list_3119.finish();
}
#[allow(unused_mut)]
let mut scope_3121 = writer.prefix("MaxResults");
if let Some(var_3122) = &input.max_results {
scope_3121.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3122).into()),
);
}
#[allow(unused_mut)]
let mut scope_3123 = writer.prefix("NextToken");
if let Some(var_3124) = &input.next_token {
scope_3123.string(var_3124);
}
#[allow(unused_mut)]
let mut scope_3125 = writer.prefix("DryRun");
if let Some(var_3126) = &input.dry_run {
scope_3125.boolean(*var_3126);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_local_gateway_route_table_vpc_associations(
input: &crate::input::DescribeLocalGatewayRouteTableVpcAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeLocalGatewayRouteTableVpcAssociations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3127 = writer.prefix("LocalGatewayRouteTableVpcAssociationId");
if let Some(var_3128) = &input.local_gateway_route_table_vpc_association_ids {
let mut list_3130 = scope_3127.start_list(true, Some("item"));
for item_3129 in var_3128 {
#[allow(unused_mut)]
let mut entry_3131 = list_3130.entry();
entry_3131.string(item_3129);
}
list_3130.finish();
}
#[allow(unused_mut)]
let mut scope_3132 = writer.prefix("Filter");
if let Some(var_3133) = &input.filters {
let mut list_3135 = scope_3132.start_list(true, Some("Filter"));
for item_3134 in var_3133 {
#[allow(unused_mut)]
let mut entry_3136 = list_3135.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3136, item_3134)?;
}
list_3135.finish();
}
#[allow(unused_mut)]
let mut scope_3137 = writer.prefix("MaxResults");
if let Some(var_3138) = &input.max_results {
scope_3137.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3138).into()),
);
}
#[allow(unused_mut)]
let mut scope_3139 = writer.prefix("NextToken");
if let Some(var_3140) = &input.next_token {
scope_3139.string(var_3140);
}
#[allow(unused_mut)]
let mut scope_3141 = writer.prefix("DryRun");
if let Some(var_3142) = &input.dry_run {
scope_3141.boolean(*var_3142);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_local_gateways(
input: &crate::input::DescribeLocalGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeLocalGateways", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3143 = writer.prefix("LocalGatewayId");
if let Some(var_3144) = &input.local_gateway_ids {
let mut list_3146 = scope_3143.start_list(true, Some("item"));
for item_3145 in var_3144 {
#[allow(unused_mut)]
let mut entry_3147 = list_3146.entry();
entry_3147.string(item_3145);
}
list_3146.finish();
}
#[allow(unused_mut)]
let mut scope_3148 = writer.prefix("Filter");
if let Some(var_3149) = &input.filters {
let mut list_3151 = scope_3148.start_list(true, Some("Filter"));
for item_3150 in var_3149 {
#[allow(unused_mut)]
let mut entry_3152 = list_3151.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3152, item_3150)?;
}
list_3151.finish();
}
#[allow(unused_mut)]
let mut scope_3153 = writer.prefix("MaxResults");
if let Some(var_3154) = &input.max_results {
scope_3153.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3154).into()),
);
}
#[allow(unused_mut)]
let mut scope_3155 = writer.prefix("NextToken");
if let Some(var_3156) = &input.next_token {
scope_3155.string(var_3156);
}
#[allow(unused_mut)]
let mut scope_3157 = writer.prefix("DryRun");
if let Some(var_3158) = &input.dry_run {
scope_3157.boolean(*var_3158);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_local_gateway_virtual_interface_groups(
input: &crate::input::DescribeLocalGatewayVirtualInterfaceGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeLocalGatewayVirtualInterfaceGroups",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3159 = writer.prefix("LocalGatewayVirtualInterfaceGroupId");
if let Some(var_3160) = &input.local_gateway_virtual_interface_group_ids {
let mut list_3162 = scope_3159.start_list(true, Some("item"));
for item_3161 in var_3160 {
#[allow(unused_mut)]
let mut entry_3163 = list_3162.entry();
entry_3163.string(item_3161);
}
list_3162.finish();
}
#[allow(unused_mut)]
let mut scope_3164 = writer.prefix("Filter");
if let Some(var_3165) = &input.filters {
let mut list_3167 = scope_3164.start_list(true, Some("Filter"));
for item_3166 in var_3165 {
#[allow(unused_mut)]
let mut entry_3168 = list_3167.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3168, item_3166)?;
}
list_3167.finish();
}
#[allow(unused_mut)]
let mut scope_3169 = writer.prefix("MaxResults");
if let Some(var_3170) = &input.max_results {
scope_3169.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3170).into()),
);
}
#[allow(unused_mut)]
let mut scope_3171 = writer.prefix("NextToken");
if let Some(var_3172) = &input.next_token {
scope_3171.string(var_3172);
}
#[allow(unused_mut)]
let mut scope_3173 = writer.prefix("DryRun");
if let Some(var_3174) = &input.dry_run {
scope_3173.boolean(*var_3174);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_local_gateway_virtual_interfaces(
input: &crate::input::DescribeLocalGatewayVirtualInterfacesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeLocalGatewayVirtualInterfaces",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3175 = writer.prefix("LocalGatewayVirtualInterfaceId");
if let Some(var_3176) = &input.local_gateway_virtual_interface_ids {
let mut list_3178 = scope_3175.start_list(true, Some("item"));
for item_3177 in var_3176 {
#[allow(unused_mut)]
let mut entry_3179 = list_3178.entry();
entry_3179.string(item_3177);
}
list_3178.finish();
}
#[allow(unused_mut)]
let mut scope_3180 = writer.prefix("Filter");
if let Some(var_3181) = &input.filters {
let mut list_3183 = scope_3180.start_list(true, Some("Filter"));
for item_3182 in var_3181 {
#[allow(unused_mut)]
let mut entry_3184 = list_3183.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3184, item_3182)?;
}
list_3183.finish();
}
#[allow(unused_mut)]
let mut scope_3185 = writer.prefix("MaxResults");
if let Some(var_3186) = &input.max_results {
scope_3185.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3186).into()),
);
}
#[allow(unused_mut)]
let mut scope_3187 = writer.prefix("NextToken");
if let Some(var_3188) = &input.next_token {
scope_3187.string(var_3188);
}
#[allow(unused_mut)]
let mut scope_3189 = writer.prefix("DryRun");
if let Some(var_3190) = &input.dry_run {
scope_3189.boolean(*var_3190);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_managed_prefix_lists(
input: &crate::input::DescribeManagedPrefixListsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeManagedPrefixLists", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3191 = writer.prefix("DryRun");
if let Some(var_3192) = &input.dry_run {
scope_3191.boolean(*var_3192);
}
#[allow(unused_mut)]
let mut scope_3193 = writer.prefix("Filter");
if let Some(var_3194) = &input.filters {
let mut list_3196 = scope_3193.start_list(true, Some("Filter"));
for item_3195 in var_3194 {
#[allow(unused_mut)]
let mut entry_3197 = list_3196.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3197, item_3195)?;
}
list_3196.finish();
}
#[allow(unused_mut)]
let mut scope_3198 = writer.prefix("MaxResults");
if let Some(var_3199) = &input.max_results {
scope_3198.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3199).into()),
);
}
#[allow(unused_mut)]
let mut scope_3200 = writer.prefix("NextToken");
if let Some(var_3201) = &input.next_token {
scope_3200.string(var_3201);
}
#[allow(unused_mut)]
let mut scope_3202 = writer.prefix("PrefixListId");
if let Some(var_3203) = &input.prefix_list_ids {
let mut list_3205 = scope_3202.start_list(true, Some("item"));
for item_3204 in var_3203 {
#[allow(unused_mut)]
let mut entry_3206 = list_3205.entry();
entry_3206.string(item_3204);
}
list_3205.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_moving_addresses(
input: &crate::input::DescribeMovingAddressesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeMovingAddresses", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3207 = writer.prefix("Filter");
if let Some(var_3208) = &input.filters {
let mut list_3210 = scope_3207.start_list(true, Some("Filter"));
for item_3209 in var_3208 {
#[allow(unused_mut)]
let mut entry_3211 = list_3210.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3211, item_3209)?;
}
list_3210.finish();
}
#[allow(unused_mut)]
let mut scope_3212 = writer.prefix("DryRun");
if let Some(var_3213) = &input.dry_run {
scope_3212.boolean(*var_3213);
}
#[allow(unused_mut)]
let mut scope_3214 = writer.prefix("MaxResults");
if let Some(var_3215) = &input.max_results {
scope_3214.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3215).into()),
);
}
#[allow(unused_mut)]
let mut scope_3216 = writer.prefix("NextToken");
if let Some(var_3217) = &input.next_token {
scope_3216.string(var_3217);
}
#[allow(unused_mut)]
let mut scope_3218 = writer.prefix("PublicIp");
if let Some(var_3219) = &input.public_ips {
let mut list_3221 = scope_3218.start_list(true, Some("item"));
for item_3220 in var_3219 {
#[allow(unused_mut)]
let mut entry_3222 = list_3221.entry();
entry_3222.string(item_3220);
}
list_3221.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_nat_gateways(
input: &crate::input::DescribeNatGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeNatGateways", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3223 = writer.prefix("DryRun");
if let Some(var_3224) = &input.dry_run {
scope_3223.boolean(*var_3224);
}
#[allow(unused_mut)]
let mut scope_3225 = writer.prefix("Filter");
if let Some(var_3226) = &input.filter {
let mut list_3228 = scope_3225.start_list(true, Some("Filter"));
for item_3227 in var_3226 {
#[allow(unused_mut)]
let mut entry_3229 = list_3228.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3229, item_3227)?;
}
list_3228.finish();
}
#[allow(unused_mut)]
let mut scope_3230 = writer.prefix("MaxResults");
if let Some(var_3231) = &input.max_results {
scope_3230.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3231).into()),
);
}
#[allow(unused_mut)]
let mut scope_3232 = writer.prefix("NatGatewayId");
if let Some(var_3233) = &input.nat_gateway_ids {
let mut list_3235 = scope_3232.start_list(true, Some("item"));
for item_3234 in var_3233 {
#[allow(unused_mut)]
let mut entry_3236 = list_3235.entry();
entry_3236.string(item_3234);
}
list_3235.finish();
}
#[allow(unused_mut)]
let mut scope_3237 = writer.prefix("NextToken");
if let Some(var_3238) = &input.next_token {
scope_3237.string(var_3238);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_network_acls(
input: &crate::input::DescribeNetworkAclsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeNetworkAcls", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3239 = writer.prefix("Filter");
if let Some(var_3240) = &input.filters {
let mut list_3242 = scope_3239.start_list(true, Some("Filter"));
for item_3241 in var_3240 {
#[allow(unused_mut)]
let mut entry_3243 = list_3242.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3243, item_3241)?;
}
list_3242.finish();
}
#[allow(unused_mut)]
let mut scope_3244 = writer.prefix("DryRun");
if let Some(var_3245) = &input.dry_run {
scope_3244.boolean(*var_3245);
}
#[allow(unused_mut)]
let mut scope_3246 = writer.prefix("NetworkAclId");
if let Some(var_3247) = &input.network_acl_ids {
let mut list_3249 = scope_3246.start_list(true, Some("item"));
for item_3248 in var_3247 {
#[allow(unused_mut)]
let mut entry_3250 = list_3249.entry();
entry_3250.string(item_3248);
}
list_3249.finish();
}
#[allow(unused_mut)]
let mut scope_3251 = writer.prefix("NextToken");
if let Some(var_3252) = &input.next_token {
scope_3251.string(var_3252);
}
#[allow(unused_mut)]
let mut scope_3253 = writer.prefix("MaxResults");
if let Some(var_3254) = &input.max_results {
scope_3253.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3254).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_network_insights_access_scope_analyses(
input: &crate::input::DescribeNetworkInsightsAccessScopeAnalysesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeNetworkInsightsAccessScopeAnalyses",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3255 = writer.prefix("NetworkInsightsAccessScopeAnalysisId");
if let Some(var_3256) = &input.network_insights_access_scope_analysis_ids {
let mut list_3258 = scope_3255.start_list(true, Some("item"));
for item_3257 in var_3256 {
#[allow(unused_mut)]
let mut entry_3259 = list_3258.entry();
entry_3259.string(item_3257);
}
list_3258.finish();
}
#[allow(unused_mut)]
let mut scope_3260 = writer.prefix("NetworkInsightsAccessScopeId");
if let Some(var_3261) = &input.network_insights_access_scope_id {
scope_3260.string(var_3261);
}
#[allow(unused_mut)]
let mut scope_3262 = writer.prefix("AnalysisStartTimeBegin");
if let Some(var_3263) = &input.analysis_start_time_begin {
scope_3262.date_time(var_3263, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_3264 = writer.prefix("AnalysisStartTimeEnd");
if let Some(var_3265) = &input.analysis_start_time_end {
scope_3264.date_time(var_3265, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_3266 = writer.prefix("Filter");
if let Some(var_3267) = &input.filters {
let mut list_3269 = scope_3266.start_list(true, Some("Filter"));
for item_3268 in var_3267 {
#[allow(unused_mut)]
let mut entry_3270 = list_3269.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3270, item_3268)?;
}
list_3269.finish();
}
#[allow(unused_mut)]
let mut scope_3271 = writer.prefix("MaxResults");
if let Some(var_3272) = &input.max_results {
scope_3271.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3272).into()),
);
}
#[allow(unused_mut)]
let mut scope_3273 = writer.prefix("DryRun");
if let Some(var_3274) = &input.dry_run {
scope_3273.boolean(*var_3274);
}
#[allow(unused_mut)]
let mut scope_3275 = writer.prefix("NextToken");
if let Some(var_3276) = &input.next_token {
scope_3275.string(var_3276);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_network_insights_access_scopes(
input: &crate::input::DescribeNetworkInsightsAccessScopesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeNetworkInsightsAccessScopes",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3277 = writer.prefix("NetworkInsightsAccessScopeId");
if let Some(var_3278) = &input.network_insights_access_scope_ids {
let mut list_3280 = scope_3277.start_list(true, Some("item"));
for item_3279 in var_3278 {
#[allow(unused_mut)]
let mut entry_3281 = list_3280.entry();
entry_3281.string(item_3279);
}
list_3280.finish();
}
#[allow(unused_mut)]
let mut scope_3282 = writer.prefix("Filter");
if let Some(var_3283) = &input.filters {
let mut list_3285 = scope_3282.start_list(true, Some("Filter"));
for item_3284 in var_3283 {
#[allow(unused_mut)]
let mut entry_3286 = list_3285.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3286, item_3284)?;
}
list_3285.finish();
}
#[allow(unused_mut)]
let mut scope_3287 = writer.prefix("MaxResults");
if let Some(var_3288) = &input.max_results {
scope_3287.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3288).into()),
);
}
#[allow(unused_mut)]
let mut scope_3289 = writer.prefix("DryRun");
if let Some(var_3290) = &input.dry_run {
scope_3289.boolean(*var_3290);
}
#[allow(unused_mut)]
let mut scope_3291 = writer.prefix("NextToken");
if let Some(var_3292) = &input.next_token {
scope_3291.string(var_3292);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_network_insights_analyses(
input: &crate::input::DescribeNetworkInsightsAnalysesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeNetworkInsightsAnalyses",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3293 = writer.prefix("NetworkInsightsAnalysisId");
if let Some(var_3294) = &input.network_insights_analysis_ids {
let mut list_3296 = scope_3293.start_list(true, Some("item"));
for item_3295 in var_3294 {
#[allow(unused_mut)]
let mut entry_3297 = list_3296.entry();
entry_3297.string(item_3295);
}
list_3296.finish();
}
#[allow(unused_mut)]
let mut scope_3298 = writer.prefix("NetworkInsightsPathId");
if let Some(var_3299) = &input.network_insights_path_id {
scope_3298.string(var_3299);
}
#[allow(unused_mut)]
let mut scope_3300 = writer.prefix("AnalysisStartTime");
if let Some(var_3301) = &input.analysis_start_time {
scope_3300.date_time(var_3301, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_3302 = writer.prefix("AnalysisEndTime");
if let Some(var_3303) = &input.analysis_end_time {
scope_3302.date_time(var_3303, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_3304 = writer.prefix("Filter");
if let Some(var_3305) = &input.filters {
let mut list_3307 = scope_3304.start_list(true, Some("Filter"));
for item_3306 in var_3305 {
#[allow(unused_mut)]
let mut entry_3308 = list_3307.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3308, item_3306)?;
}
list_3307.finish();
}
#[allow(unused_mut)]
let mut scope_3309 = writer.prefix("MaxResults");
if let Some(var_3310) = &input.max_results {
scope_3309.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3310).into()),
);
}
#[allow(unused_mut)]
let mut scope_3311 = writer.prefix("DryRun");
if let Some(var_3312) = &input.dry_run {
scope_3311.boolean(*var_3312);
}
#[allow(unused_mut)]
let mut scope_3313 = writer.prefix("NextToken");
if let Some(var_3314) = &input.next_token {
scope_3313.string(var_3314);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_network_insights_paths(
input: &crate::input::DescribeNetworkInsightsPathsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeNetworkInsightsPaths", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3315 = writer.prefix("NetworkInsightsPathId");
if let Some(var_3316) = &input.network_insights_path_ids {
let mut list_3318 = scope_3315.start_list(true, Some("item"));
for item_3317 in var_3316 {
#[allow(unused_mut)]
let mut entry_3319 = list_3318.entry();
entry_3319.string(item_3317);
}
list_3318.finish();
}
#[allow(unused_mut)]
let mut scope_3320 = writer.prefix("Filter");
if let Some(var_3321) = &input.filters {
let mut list_3323 = scope_3320.start_list(true, Some("Filter"));
for item_3322 in var_3321 {
#[allow(unused_mut)]
let mut entry_3324 = list_3323.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3324, item_3322)?;
}
list_3323.finish();
}
#[allow(unused_mut)]
let mut scope_3325 = writer.prefix("MaxResults");
if let Some(var_3326) = &input.max_results {
scope_3325.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3326).into()),
);
}
#[allow(unused_mut)]
let mut scope_3327 = writer.prefix("DryRun");
if let Some(var_3328) = &input.dry_run {
scope_3327.boolean(*var_3328);
}
#[allow(unused_mut)]
let mut scope_3329 = writer.prefix("NextToken");
if let Some(var_3330) = &input.next_token {
scope_3329.string(var_3330);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_network_interface_attribute(
input: &crate::input::DescribeNetworkInterfaceAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeNetworkInterfaceAttribute",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3331 = writer.prefix("Attribute");
if let Some(var_3332) = &input.attribute {
scope_3331.string(var_3332.as_str());
}
#[allow(unused_mut)]
let mut scope_3333 = writer.prefix("DryRun");
if let Some(var_3334) = &input.dry_run {
scope_3333.boolean(*var_3334);
}
#[allow(unused_mut)]
let mut scope_3335 = writer.prefix("NetworkInterfaceId");
if let Some(var_3336) = &input.network_interface_id {
scope_3335.string(var_3336);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_network_interface_permissions(
input: &crate::input::DescribeNetworkInterfacePermissionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeNetworkInterfacePermissions",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3337 = writer.prefix("NetworkInterfacePermissionId");
if let Some(var_3338) = &input.network_interface_permission_ids {
let mut list_3340 = scope_3337.start_list(true, None);
for item_3339 in var_3338 {
#[allow(unused_mut)]
let mut entry_3341 = list_3340.entry();
entry_3341.string(item_3339);
}
list_3340.finish();
}
#[allow(unused_mut)]
let mut scope_3342 = writer.prefix("Filter");
if let Some(var_3343) = &input.filters {
let mut list_3345 = scope_3342.start_list(true, Some("Filter"));
for item_3344 in var_3343 {
#[allow(unused_mut)]
let mut entry_3346 = list_3345.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3346, item_3344)?;
}
list_3345.finish();
}
#[allow(unused_mut)]
let mut scope_3347 = writer.prefix("NextToken");
if let Some(var_3348) = &input.next_token {
scope_3347.string(var_3348);
}
#[allow(unused_mut)]
let mut scope_3349 = writer.prefix("MaxResults");
if let Some(var_3350) = &input.max_results {
scope_3349.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3350).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_network_interfaces(
input: &crate::input::DescribeNetworkInterfacesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeNetworkInterfaces", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3351 = writer.prefix("Filter");
if let Some(var_3352) = &input.filters {
let mut list_3354 = scope_3351.start_list(true, Some("Filter"));
for item_3353 in var_3352 {
#[allow(unused_mut)]
let mut entry_3355 = list_3354.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3355, item_3353)?;
}
list_3354.finish();
}
#[allow(unused_mut)]
let mut scope_3356 = writer.prefix("DryRun");
if let Some(var_3357) = &input.dry_run {
scope_3356.boolean(*var_3357);
}
#[allow(unused_mut)]
let mut scope_3358 = writer.prefix("NetworkInterfaceId");
if let Some(var_3359) = &input.network_interface_ids {
let mut list_3361 = scope_3358.start_list(true, Some("item"));
for item_3360 in var_3359 {
#[allow(unused_mut)]
let mut entry_3362 = list_3361.entry();
entry_3362.string(item_3360);
}
list_3361.finish();
}
#[allow(unused_mut)]
let mut scope_3363 = writer.prefix("NextToken");
if let Some(var_3364) = &input.next_token {
scope_3363.string(var_3364);
}
#[allow(unused_mut)]
let mut scope_3365 = writer.prefix("MaxResults");
if let Some(var_3366) = &input.max_results {
scope_3365.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3366).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_placement_groups(
input: &crate::input::DescribePlacementGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribePlacementGroups", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3367 = writer.prefix("Filter");
if let Some(var_3368) = &input.filters {
let mut list_3370 = scope_3367.start_list(true, Some("Filter"));
for item_3369 in var_3368 {
#[allow(unused_mut)]
let mut entry_3371 = list_3370.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3371, item_3369)?;
}
list_3370.finish();
}
#[allow(unused_mut)]
let mut scope_3372 = writer.prefix("DryRun");
if let Some(var_3373) = &input.dry_run {
scope_3372.boolean(*var_3373);
}
#[allow(unused_mut)]
let mut scope_3374 = writer.prefix("GroupName");
if let Some(var_3375) = &input.group_names {
let mut list_3377 = scope_3374.start_list(true, None);
for item_3376 in var_3375 {
#[allow(unused_mut)]
let mut entry_3378 = list_3377.entry();
entry_3378.string(item_3376);
}
list_3377.finish();
}
#[allow(unused_mut)]
let mut scope_3379 = writer.prefix("GroupId");
if let Some(var_3380) = &input.group_ids {
let mut list_3382 = scope_3379.start_list(true, Some("GroupId"));
for item_3381 in var_3380 {
#[allow(unused_mut)]
let mut entry_3383 = list_3382.entry();
entry_3383.string(item_3381);
}
list_3382.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_prefix_lists(
input: &crate::input::DescribePrefixListsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribePrefixLists", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3384 = writer.prefix("DryRun");
if let Some(var_3385) = &input.dry_run {
scope_3384.boolean(*var_3385);
}
#[allow(unused_mut)]
let mut scope_3386 = writer.prefix("Filter");
if let Some(var_3387) = &input.filters {
let mut list_3389 = scope_3386.start_list(true, Some("Filter"));
for item_3388 in var_3387 {
#[allow(unused_mut)]
let mut entry_3390 = list_3389.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3390, item_3388)?;
}
list_3389.finish();
}
#[allow(unused_mut)]
let mut scope_3391 = writer.prefix("MaxResults");
if let Some(var_3392) = &input.max_results {
scope_3391.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3392).into()),
);
}
#[allow(unused_mut)]
let mut scope_3393 = writer.prefix("NextToken");
if let Some(var_3394) = &input.next_token {
scope_3393.string(var_3394);
}
#[allow(unused_mut)]
let mut scope_3395 = writer.prefix("PrefixListId");
if let Some(var_3396) = &input.prefix_list_ids {
let mut list_3398 = scope_3395.start_list(true, Some("item"));
for item_3397 in var_3396 {
#[allow(unused_mut)]
let mut entry_3399 = list_3398.entry();
entry_3399.string(item_3397);
}
list_3398.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_principal_id_format(
input: &crate::input::DescribePrincipalIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribePrincipalIdFormat", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3400 = writer.prefix("DryRun");
if let Some(var_3401) = &input.dry_run {
scope_3400.boolean(*var_3401);
}
#[allow(unused_mut)]
let mut scope_3402 = writer.prefix("Resource");
if let Some(var_3403) = &input.resources {
let mut list_3405 = scope_3402.start_list(true, Some("item"));
for item_3404 in var_3403 {
#[allow(unused_mut)]
let mut entry_3406 = list_3405.entry();
entry_3406.string(item_3404);
}
list_3405.finish();
}
#[allow(unused_mut)]
let mut scope_3407 = writer.prefix("MaxResults");
if let Some(var_3408) = &input.max_results {
scope_3407.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3408).into()),
);
}
#[allow(unused_mut)]
let mut scope_3409 = writer.prefix("NextToken");
if let Some(var_3410) = &input.next_token {
scope_3409.string(var_3410);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_public_ipv4_pools(
input: &crate::input::DescribePublicIpv4PoolsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribePublicIpv4Pools", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3411 = writer.prefix("PoolId");
if let Some(var_3412) = &input.pool_ids {
let mut list_3414 = scope_3411.start_list(true, Some("item"));
for item_3413 in var_3412 {
#[allow(unused_mut)]
let mut entry_3415 = list_3414.entry();
entry_3415.string(item_3413);
}
list_3414.finish();
}
#[allow(unused_mut)]
let mut scope_3416 = writer.prefix("NextToken");
if let Some(var_3417) = &input.next_token {
scope_3416.string(var_3417);
}
#[allow(unused_mut)]
let mut scope_3418 = writer.prefix("MaxResults");
if let Some(var_3419) = &input.max_results {
scope_3418.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3419).into()),
);
}
#[allow(unused_mut)]
let mut scope_3420 = writer.prefix("Filter");
if let Some(var_3421) = &input.filters {
let mut list_3423 = scope_3420.start_list(true, Some("Filter"));
for item_3422 in var_3421 {
#[allow(unused_mut)]
let mut entry_3424 = list_3423.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3424, item_3422)?;
}
list_3423.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_regions(
input: &crate::input::DescribeRegionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeRegions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3425 = writer.prefix("Filter");
if let Some(var_3426) = &input.filters {
let mut list_3428 = scope_3425.start_list(true, Some("Filter"));
for item_3427 in var_3426 {
#[allow(unused_mut)]
let mut entry_3429 = list_3428.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3429, item_3427)?;
}
list_3428.finish();
}
#[allow(unused_mut)]
let mut scope_3430 = writer.prefix("RegionName");
if let Some(var_3431) = &input.region_names {
let mut list_3433 = scope_3430.start_list(true, Some("RegionName"));
for item_3432 in var_3431 {
#[allow(unused_mut)]
let mut entry_3434 = list_3433.entry();
entry_3434.string(item_3432);
}
list_3433.finish();
}
#[allow(unused_mut)]
let mut scope_3435 = writer.prefix("DryRun");
if let Some(var_3436) = &input.dry_run {
scope_3435.boolean(*var_3436);
}
#[allow(unused_mut)]
let mut scope_3437 = writer.prefix("AllRegions");
if let Some(var_3438) = &input.all_regions {
scope_3437.boolean(*var_3438);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_replace_root_volume_tasks(
input: &crate::input::DescribeReplaceRootVolumeTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeReplaceRootVolumeTasks",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3439 = writer.prefix("ReplaceRootVolumeTaskId");
if let Some(var_3440) = &input.replace_root_volume_task_ids {
let mut list_3442 = scope_3439.start_list(true, Some("ReplaceRootVolumeTaskId"));
for item_3441 in var_3440 {
#[allow(unused_mut)]
let mut entry_3443 = list_3442.entry();
entry_3443.string(item_3441);
}
list_3442.finish();
}
#[allow(unused_mut)]
let mut scope_3444 = writer.prefix("Filter");
if let Some(var_3445) = &input.filters {
let mut list_3447 = scope_3444.start_list(true, Some("Filter"));
for item_3446 in var_3445 {
#[allow(unused_mut)]
let mut entry_3448 = list_3447.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3448, item_3446)?;
}
list_3447.finish();
}
#[allow(unused_mut)]
let mut scope_3449 = writer.prefix("MaxResults");
if let Some(var_3450) = &input.max_results {
scope_3449.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3450).into()),
);
}
#[allow(unused_mut)]
let mut scope_3451 = writer.prefix("NextToken");
if let Some(var_3452) = &input.next_token {
scope_3451.string(var_3452);
}
#[allow(unused_mut)]
let mut scope_3453 = writer.prefix("DryRun");
if let Some(var_3454) = &input.dry_run {
scope_3453.boolean(*var_3454);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_reserved_instances(
input: &crate::input::DescribeReservedInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeReservedInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3455 = writer.prefix("Filter");
if let Some(var_3456) = &input.filters {
let mut list_3458 = scope_3455.start_list(true, Some("Filter"));
for item_3457 in var_3456 {
#[allow(unused_mut)]
let mut entry_3459 = list_3458.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3459, item_3457)?;
}
list_3458.finish();
}
#[allow(unused_mut)]
let mut scope_3460 = writer.prefix("OfferingClass");
if let Some(var_3461) = &input.offering_class {
scope_3460.string(var_3461.as_str());
}
#[allow(unused_mut)]
let mut scope_3462 = writer.prefix("ReservedInstancesId");
if let Some(var_3463) = &input.reserved_instances_ids {
let mut list_3465 = scope_3462.start_list(true, Some("ReservedInstancesId"));
for item_3464 in var_3463 {
#[allow(unused_mut)]
let mut entry_3466 = list_3465.entry();
entry_3466.string(item_3464);
}
list_3465.finish();
}
#[allow(unused_mut)]
let mut scope_3467 = writer.prefix("DryRun");
if let Some(var_3468) = &input.dry_run {
scope_3467.boolean(*var_3468);
}
#[allow(unused_mut)]
let mut scope_3469 = writer.prefix("OfferingType");
if let Some(var_3470) = &input.offering_type {
scope_3469.string(var_3470.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_reserved_instances_listings(
input: &crate::input::DescribeReservedInstancesListingsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeReservedInstancesListings",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3471 = writer.prefix("Filter");
if let Some(var_3472) = &input.filters {
let mut list_3474 = scope_3471.start_list(true, Some("Filter"));
for item_3473 in var_3472 {
#[allow(unused_mut)]
let mut entry_3475 = list_3474.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3475, item_3473)?;
}
list_3474.finish();
}
#[allow(unused_mut)]
let mut scope_3476 = writer.prefix("ReservedInstancesId");
if let Some(var_3477) = &input.reserved_instances_id {
scope_3476.string(var_3477);
}
#[allow(unused_mut)]
let mut scope_3478 = writer.prefix("ReservedInstancesListingId");
if let Some(var_3479) = &input.reserved_instances_listing_id {
scope_3478.string(var_3479);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_reserved_instances_modifications(
input: &crate::input::DescribeReservedInstancesModificationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeReservedInstancesModifications",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3480 = writer.prefix("Filter");
if let Some(var_3481) = &input.filters {
let mut list_3483 = scope_3480.start_list(true, Some("Filter"));
for item_3482 in var_3481 {
#[allow(unused_mut)]
let mut entry_3484 = list_3483.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3484, item_3482)?;
}
list_3483.finish();
}
#[allow(unused_mut)]
let mut scope_3485 = writer.prefix("ReservedInstancesModificationId");
if let Some(var_3486) = &input.reserved_instances_modification_ids {
let mut list_3488 = scope_3485.start_list(true, Some("ReservedInstancesModificationId"));
for item_3487 in var_3486 {
#[allow(unused_mut)]
let mut entry_3489 = list_3488.entry();
entry_3489.string(item_3487);
}
list_3488.finish();
}
#[allow(unused_mut)]
let mut scope_3490 = writer.prefix("NextToken");
if let Some(var_3491) = &input.next_token {
scope_3490.string(var_3491);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_reserved_instances_offerings(
input: &crate::input::DescribeReservedInstancesOfferingsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeReservedInstancesOfferings",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3492 = writer.prefix("AvailabilityZone");
if let Some(var_3493) = &input.availability_zone {
scope_3492.string(var_3493);
}
#[allow(unused_mut)]
let mut scope_3494 = writer.prefix("Filter");
if let Some(var_3495) = &input.filters {
let mut list_3497 = scope_3494.start_list(true, Some("Filter"));
for item_3496 in var_3495 {
#[allow(unused_mut)]
let mut entry_3498 = list_3497.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3498, item_3496)?;
}
list_3497.finish();
}
#[allow(unused_mut)]
let mut scope_3499 = writer.prefix("IncludeMarketplace");
if let Some(var_3500) = &input.include_marketplace {
scope_3499.boolean(*var_3500);
}
#[allow(unused_mut)]
let mut scope_3501 = writer.prefix("InstanceType");
if let Some(var_3502) = &input.instance_type {
scope_3501.string(var_3502.as_str());
}
#[allow(unused_mut)]
let mut scope_3503 = writer.prefix("MaxDuration");
if let Some(var_3504) = &input.max_duration {
scope_3503.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3504).into()),
);
}
#[allow(unused_mut)]
let mut scope_3505 = writer.prefix("MaxInstanceCount");
if let Some(var_3506) = &input.max_instance_count {
scope_3505.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3506).into()),
);
}
#[allow(unused_mut)]
let mut scope_3507 = writer.prefix("MinDuration");
if let Some(var_3508) = &input.min_duration {
scope_3507.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3508).into()),
);
}
#[allow(unused_mut)]
let mut scope_3509 = writer.prefix("OfferingClass");
if let Some(var_3510) = &input.offering_class {
scope_3509.string(var_3510.as_str());
}
#[allow(unused_mut)]
let mut scope_3511 = writer.prefix("ProductDescription");
if let Some(var_3512) = &input.product_description {
scope_3511.string(var_3512.as_str());
}
#[allow(unused_mut)]
let mut scope_3513 = writer.prefix("ReservedInstancesOfferingId");
if let Some(var_3514) = &input.reserved_instances_offering_ids {
let mut list_3516 = scope_3513.start_list(true, None);
for item_3515 in var_3514 {
#[allow(unused_mut)]
let mut entry_3517 = list_3516.entry();
entry_3517.string(item_3515);
}
list_3516.finish();
}
#[allow(unused_mut)]
let mut scope_3518 = writer.prefix("DryRun");
if let Some(var_3519) = &input.dry_run {
scope_3518.boolean(*var_3519);
}
#[allow(unused_mut)]
let mut scope_3520 = writer.prefix("InstanceTenancy");
if let Some(var_3521) = &input.instance_tenancy {
scope_3520.string(var_3521.as_str());
}
#[allow(unused_mut)]
let mut scope_3522 = writer.prefix("MaxResults");
if let Some(var_3523) = &input.max_results {
scope_3522.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3523).into()),
);
}
#[allow(unused_mut)]
let mut scope_3524 = writer.prefix("NextToken");
if let Some(var_3525) = &input.next_token {
scope_3524.string(var_3525);
}
#[allow(unused_mut)]
let mut scope_3526 = writer.prefix("OfferingType");
if let Some(var_3527) = &input.offering_type {
scope_3526.string(var_3527.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_route_tables(
input: &crate::input::DescribeRouteTablesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeRouteTables", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3528 = writer.prefix("Filter");
if let Some(var_3529) = &input.filters {
let mut list_3531 = scope_3528.start_list(true, Some("Filter"));
for item_3530 in var_3529 {
#[allow(unused_mut)]
let mut entry_3532 = list_3531.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3532, item_3530)?;
}
list_3531.finish();
}
#[allow(unused_mut)]
let mut scope_3533 = writer.prefix("DryRun");
if let Some(var_3534) = &input.dry_run {
scope_3533.boolean(*var_3534);
}
#[allow(unused_mut)]
let mut scope_3535 = writer.prefix("RouteTableId");
if let Some(var_3536) = &input.route_table_ids {
let mut list_3538 = scope_3535.start_list(true, Some("item"));
for item_3537 in var_3536 {
#[allow(unused_mut)]
let mut entry_3539 = list_3538.entry();
entry_3539.string(item_3537);
}
list_3538.finish();
}
#[allow(unused_mut)]
let mut scope_3540 = writer.prefix("NextToken");
if let Some(var_3541) = &input.next_token {
scope_3540.string(var_3541);
}
#[allow(unused_mut)]
let mut scope_3542 = writer.prefix("MaxResults");
if let Some(var_3543) = &input.max_results {
scope_3542.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3543).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_scheduled_instance_availability(
input: &crate::input::DescribeScheduledInstanceAvailabilityInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeScheduledInstanceAvailability",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3544 = writer.prefix("DryRun");
if let Some(var_3545) = &input.dry_run {
scope_3544.boolean(*var_3545);
}
#[allow(unused_mut)]
let mut scope_3546 = writer.prefix("Filter");
if let Some(var_3547) = &input.filters {
let mut list_3549 = scope_3546.start_list(true, Some("Filter"));
for item_3548 in var_3547 {
#[allow(unused_mut)]
let mut entry_3550 = list_3549.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3550, item_3548)?;
}
list_3549.finish();
}
#[allow(unused_mut)]
let mut scope_3551 = writer.prefix("FirstSlotStartTimeRange");
if let Some(var_3552) = &input.first_slot_start_time_range {
crate::query_ser::serialize_structure_crate_model_slot_date_time_range_request(
scope_3551, var_3552,
)?;
}
#[allow(unused_mut)]
let mut scope_3553 = writer.prefix("MaxResults");
if let Some(var_3554) = &input.max_results {
scope_3553.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3554).into()),
);
}
#[allow(unused_mut)]
let mut scope_3555 = writer.prefix("MaxSlotDurationInHours");
if let Some(var_3556) = &input.max_slot_duration_in_hours {
scope_3555.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3556).into()),
);
}
#[allow(unused_mut)]
let mut scope_3557 = writer.prefix("MinSlotDurationInHours");
if let Some(var_3558) = &input.min_slot_duration_in_hours {
scope_3557.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3558).into()),
);
}
#[allow(unused_mut)]
let mut scope_3559 = writer.prefix("NextToken");
if let Some(var_3560) = &input.next_token {
scope_3559.string(var_3560);
}
#[allow(unused_mut)]
let mut scope_3561 = writer.prefix("Recurrence");
if let Some(var_3562) = &input.recurrence {
crate::query_ser::serialize_structure_crate_model_scheduled_instance_recurrence_request(
scope_3561, var_3562,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_scheduled_instances(
input: &crate::input::DescribeScheduledInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeScheduledInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3563 = writer.prefix("DryRun");
if let Some(var_3564) = &input.dry_run {
scope_3563.boolean(*var_3564);
}
#[allow(unused_mut)]
let mut scope_3565 = writer.prefix("Filter");
if let Some(var_3566) = &input.filters {
let mut list_3568 = scope_3565.start_list(true, Some("Filter"));
for item_3567 in var_3566 {
#[allow(unused_mut)]
let mut entry_3569 = list_3568.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3569, item_3567)?;
}
list_3568.finish();
}
#[allow(unused_mut)]
let mut scope_3570 = writer.prefix("MaxResults");
if let Some(var_3571) = &input.max_results {
scope_3570.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3571).into()),
);
}
#[allow(unused_mut)]
let mut scope_3572 = writer.prefix("NextToken");
if let Some(var_3573) = &input.next_token {
scope_3572.string(var_3573);
}
#[allow(unused_mut)]
let mut scope_3574 = writer.prefix("ScheduledInstanceId");
if let Some(var_3575) = &input.scheduled_instance_ids {
let mut list_3577 = scope_3574.start_list(true, Some("ScheduledInstanceId"));
for item_3576 in var_3575 {
#[allow(unused_mut)]
let mut entry_3578 = list_3577.entry();
entry_3578.string(item_3576);
}
list_3577.finish();
}
#[allow(unused_mut)]
let mut scope_3579 = writer.prefix("SlotStartTimeRange");
if let Some(var_3580) = &input.slot_start_time_range {
crate::query_ser::serialize_structure_crate_model_slot_start_time_range_request(
scope_3579, var_3580,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_security_group_references(
input: &crate::input::DescribeSecurityGroupReferencesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeSecurityGroupReferences",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3581 = writer.prefix("DryRun");
if let Some(var_3582) = &input.dry_run {
scope_3581.boolean(*var_3582);
}
#[allow(unused_mut)]
let mut scope_3583 = writer.prefix("GroupId");
if let Some(var_3584) = &input.group_id {
let mut list_3586 = scope_3583.start_list(true, Some("item"));
for item_3585 in var_3584 {
#[allow(unused_mut)]
let mut entry_3587 = list_3586.entry();
entry_3587.string(item_3585);
}
list_3586.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_security_group_rules(
input: &crate::input::DescribeSecurityGroupRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSecurityGroupRules", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3588 = writer.prefix("Filter");
if let Some(var_3589) = &input.filters {
let mut list_3591 = scope_3588.start_list(true, Some("Filter"));
for item_3590 in var_3589 {
#[allow(unused_mut)]
let mut entry_3592 = list_3591.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3592, item_3590)?;
}
list_3591.finish();
}
#[allow(unused_mut)]
let mut scope_3593 = writer.prefix("SecurityGroupRuleId");
if let Some(var_3594) = &input.security_group_rule_ids {
let mut list_3596 = scope_3593.start_list(true, Some("item"));
for item_3595 in var_3594 {
#[allow(unused_mut)]
let mut entry_3597 = list_3596.entry();
entry_3597.string(item_3595);
}
list_3596.finish();
}
#[allow(unused_mut)]
let mut scope_3598 = writer.prefix("DryRun");
if let Some(var_3599) = &input.dry_run {
scope_3598.boolean(*var_3599);
}
#[allow(unused_mut)]
let mut scope_3600 = writer.prefix("NextToken");
if let Some(var_3601) = &input.next_token {
scope_3600.string(var_3601);
}
#[allow(unused_mut)]
let mut scope_3602 = writer.prefix("MaxResults");
if let Some(var_3603) = &input.max_results {
scope_3602.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3603).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_security_groups(
input: &crate::input::DescribeSecurityGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSecurityGroups", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3604 = writer.prefix("Filter");
if let Some(var_3605) = &input.filters {
let mut list_3607 = scope_3604.start_list(true, Some("Filter"));
for item_3606 in var_3605 {
#[allow(unused_mut)]
let mut entry_3608 = list_3607.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3608, item_3606)?;
}
list_3607.finish();
}
#[allow(unused_mut)]
let mut scope_3609 = writer.prefix("GroupId");
if let Some(var_3610) = &input.group_ids {
let mut list_3612 = scope_3609.start_list(true, Some("groupId"));
for item_3611 in var_3610 {
#[allow(unused_mut)]
let mut entry_3613 = list_3612.entry();
entry_3613.string(item_3611);
}
list_3612.finish();
}
#[allow(unused_mut)]
let mut scope_3614 = writer.prefix("GroupName");
if let Some(var_3615) = &input.group_names {
let mut list_3617 = scope_3614.start_list(true, Some("GroupName"));
for item_3616 in var_3615 {
#[allow(unused_mut)]
let mut entry_3618 = list_3617.entry();
entry_3618.string(item_3616);
}
list_3617.finish();
}
#[allow(unused_mut)]
let mut scope_3619 = writer.prefix("DryRun");
if let Some(var_3620) = &input.dry_run {
scope_3619.boolean(*var_3620);
}
#[allow(unused_mut)]
let mut scope_3621 = writer.prefix("NextToken");
if let Some(var_3622) = &input.next_token {
scope_3621.string(var_3622);
}
#[allow(unused_mut)]
let mut scope_3623 = writer.prefix("MaxResults");
if let Some(var_3624) = &input.max_results {
scope_3623.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3624).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_snapshot_attribute(
input: &crate::input::DescribeSnapshotAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSnapshotAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3625 = writer.prefix("Attribute");
if let Some(var_3626) = &input.attribute {
scope_3625.string(var_3626.as_str());
}
#[allow(unused_mut)]
let mut scope_3627 = writer.prefix("SnapshotId");
if let Some(var_3628) = &input.snapshot_id {
scope_3627.string(var_3628);
}
#[allow(unused_mut)]
let mut scope_3629 = writer.prefix("DryRun");
if let Some(var_3630) = &input.dry_run {
scope_3629.boolean(*var_3630);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_snapshots(
input: &crate::input::DescribeSnapshotsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSnapshots", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3631 = writer.prefix("Filter");
if let Some(var_3632) = &input.filters {
let mut list_3634 = scope_3631.start_list(true, Some("Filter"));
for item_3633 in var_3632 {
#[allow(unused_mut)]
let mut entry_3635 = list_3634.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3635, item_3633)?;
}
list_3634.finish();
}
#[allow(unused_mut)]
let mut scope_3636 = writer.prefix("MaxResults");
if let Some(var_3637) = &input.max_results {
scope_3636.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3637).into()),
);
}
#[allow(unused_mut)]
let mut scope_3638 = writer.prefix("NextToken");
if let Some(var_3639) = &input.next_token {
scope_3638.string(var_3639);
}
#[allow(unused_mut)]
let mut scope_3640 = writer.prefix("Owner");
if let Some(var_3641) = &input.owner_ids {
let mut list_3643 = scope_3640.start_list(true, Some("Owner"));
for item_3642 in var_3641 {
#[allow(unused_mut)]
let mut entry_3644 = list_3643.entry();
entry_3644.string(item_3642);
}
list_3643.finish();
}
#[allow(unused_mut)]
let mut scope_3645 = writer.prefix("RestorableBy");
if let Some(var_3646) = &input.restorable_by_user_ids {
let mut list_3648 = scope_3645.start_list(true, None);
for item_3647 in var_3646 {
#[allow(unused_mut)]
let mut entry_3649 = list_3648.entry();
entry_3649.string(item_3647);
}
list_3648.finish();
}
#[allow(unused_mut)]
let mut scope_3650 = writer.prefix("SnapshotId");
if let Some(var_3651) = &input.snapshot_ids {
let mut list_3653 = scope_3650.start_list(true, Some("SnapshotId"));
for item_3652 in var_3651 {
#[allow(unused_mut)]
let mut entry_3654 = list_3653.entry();
entry_3654.string(item_3652);
}
list_3653.finish();
}
#[allow(unused_mut)]
let mut scope_3655 = writer.prefix("DryRun");
if let Some(var_3656) = &input.dry_run {
scope_3655.boolean(*var_3656);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_snapshot_tier_status(
input: &crate::input::DescribeSnapshotTierStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSnapshotTierStatus", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3657 = writer.prefix("Filter");
if let Some(var_3658) = &input.filters {
let mut list_3660 = scope_3657.start_list(true, Some("Filter"));
for item_3659 in var_3658 {
#[allow(unused_mut)]
let mut entry_3661 = list_3660.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3661, item_3659)?;
}
list_3660.finish();
}
#[allow(unused_mut)]
let mut scope_3662 = writer.prefix("DryRun");
if let Some(var_3663) = &input.dry_run {
scope_3662.boolean(*var_3663);
}
#[allow(unused_mut)]
let mut scope_3664 = writer.prefix("NextToken");
if let Some(var_3665) = &input.next_token {
scope_3664.string(var_3665);
}
#[allow(unused_mut)]
let mut scope_3666 = writer.prefix("MaxResults");
if let Some(var_3667) = &input.max_results {
scope_3666.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3667).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_spot_datafeed_subscription(
input: &crate::input::DescribeSpotDatafeedSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeSpotDatafeedSubscription",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3668 = writer.prefix("DryRun");
if let Some(var_3669) = &input.dry_run {
scope_3668.boolean(*var_3669);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_spot_fleet_instances(
input: &crate::input::DescribeSpotFleetInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSpotFleetInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3670 = writer.prefix("DryRun");
if let Some(var_3671) = &input.dry_run {
scope_3670.boolean(*var_3671);
}
#[allow(unused_mut)]
let mut scope_3672 = writer.prefix("MaxResults");
if let Some(var_3673) = &input.max_results {
scope_3672.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3673).into()),
);
}
#[allow(unused_mut)]
let mut scope_3674 = writer.prefix("NextToken");
if let Some(var_3675) = &input.next_token {
scope_3674.string(var_3675);
}
#[allow(unused_mut)]
let mut scope_3676 = writer.prefix("SpotFleetRequestId");
if let Some(var_3677) = &input.spot_fleet_request_id {
scope_3676.string(var_3677);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_spot_fleet_request_history(
input: &crate::input::DescribeSpotFleetRequestHistoryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeSpotFleetRequestHistory",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3678 = writer.prefix("DryRun");
if let Some(var_3679) = &input.dry_run {
scope_3678.boolean(*var_3679);
}
#[allow(unused_mut)]
let mut scope_3680 = writer.prefix("EventType");
if let Some(var_3681) = &input.event_type {
scope_3680.string(var_3681.as_str());
}
#[allow(unused_mut)]
let mut scope_3682 = writer.prefix("MaxResults");
if let Some(var_3683) = &input.max_results {
scope_3682.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3683).into()),
);
}
#[allow(unused_mut)]
let mut scope_3684 = writer.prefix("NextToken");
if let Some(var_3685) = &input.next_token {
scope_3684.string(var_3685);
}
#[allow(unused_mut)]
let mut scope_3686 = writer.prefix("SpotFleetRequestId");
if let Some(var_3687) = &input.spot_fleet_request_id {
scope_3686.string(var_3687);
}
#[allow(unused_mut)]
let mut scope_3688 = writer.prefix("StartTime");
if let Some(var_3689) = &input.start_time {
scope_3688.date_time(var_3689, aws_smithy_types::date_time::Format::DateTime)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_spot_fleet_requests(
input: &crate::input::DescribeSpotFleetRequestsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSpotFleetRequests", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3690 = writer.prefix("DryRun");
if let Some(var_3691) = &input.dry_run {
scope_3690.boolean(*var_3691);
}
#[allow(unused_mut)]
let mut scope_3692 = writer.prefix("MaxResults");
if let Some(var_3693) = &input.max_results {
scope_3692.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3693).into()),
);
}
#[allow(unused_mut)]
let mut scope_3694 = writer.prefix("NextToken");
if let Some(var_3695) = &input.next_token {
scope_3694.string(var_3695);
}
#[allow(unused_mut)]
let mut scope_3696 = writer.prefix("SpotFleetRequestId");
if let Some(var_3697) = &input.spot_fleet_request_ids {
let mut list_3699 = scope_3696.start_list(true, Some("item"));
for item_3698 in var_3697 {
#[allow(unused_mut)]
let mut entry_3700 = list_3699.entry();
entry_3700.string(item_3698);
}
list_3699.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_spot_instance_requests(
input: &crate::input::DescribeSpotInstanceRequestsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSpotInstanceRequests", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3701 = writer.prefix("Filter");
if let Some(var_3702) = &input.filters {
let mut list_3704 = scope_3701.start_list(true, Some("Filter"));
for item_3703 in var_3702 {
#[allow(unused_mut)]
let mut entry_3705 = list_3704.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3705, item_3703)?;
}
list_3704.finish();
}
#[allow(unused_mut)]
let mut scope_3706 = writer.prefix("DryRun");
if let Some(var_3707) = &input.dry_run {
scope_3706.boolean(*var_3707);
}
#[allow(unused_mut)]
let mut scope_3708 = writer.prefix("SpotInstanceRequestId");
if let Some(var_3709) = &input.spot_instance_request_ids {
let mut list_3711 = scope_3708.start_list(true, Some("SpotInstanceRequestId"));
for item_3710 in var_3709 {
#[allow(unused_mut)]
let mut entry_3712 = list_3711.entry();
entry_3712.string(item_3710);
}
list_3711.finish();
}
#[allow(unused_mut)]
let mut scope_3713 = writer.prefix("NextToken");
if let Some(var_3714) = &input.next_token {
scope_3713.string(var_3714);
}
#[allow(unused_mut)]
let mut scope_3715 = writer.prefix("MaxResults");
if let Some(var_3716) = &input.max_results {
scope_3715.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3716).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_spot_price_history(
input: &crate::input::DescribeSpotPriceHistoryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSpotPriceHistory", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3717 = writer.prefix("Filter");
if let Some(var_3718) = &input.filters {
let mut list_3720 = scope_3717.start_list(true, Some("Filter"));
for item_3719 in var_3718 {
#[allow(unused_mut)]
let mut entry_3721 = list_3720.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3721, item_3719)?;
}
list_3720.finish();
}
#[allow(unused_mut)]
let mut scope_3722 = writer.prefix("AvailabilityZone");
if let Some(var_3723) = &input.availability_zone {
scope_3722.string(var_3723);
}
#[allow(unused_mut)]
let mut scope_3724 = writer.prefix("DryRun");
if let Some(var_3725) = &input.dry_run {
scope_3724.boolean(*var_3725);
}
#[allow(unused_mut)]
let mut scope_3726 = writer.prefix("EndTime");
if let Some(var_3727) = &input.end_time {
scope_3726.date_time(var_3727, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_3728 = writer.prefix("InstanceType");
if let Some(var_3729) = &input.instance_types {
let mut list_3731 = scope_3728.start_list(true, None);
for item_3730 in var_3729 {
#[allow(unused_mut)]
let mut entry_3732 = list_3731.entry();
entry_3732.string(item_3730.as_str());
}
list_3731.finish();
}
#[allow(unused_mut)]
let mut scope_3733 = writer.prefix("MaxResults");
if let Some(var_3734) = &input.max_results {
scope_3733.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3734).into()),
);
}
#[allow(unused_mut)]
let mut scope_3735 = writer.prefix("NextToken");
if let Some(var_3736) = &input.next_token {
scope_3735.string(var_3736);
}
#[allow(unused_mut)]
let mut scope_3737 = writer.prefix("ProductDescription");
if let Some(var_3738) = &input.product_descriptions {
let mut list_3740 = scope_3737.start_list(true, None);
for item_3739 in var_3738 {
#[allow(unused_mut)]
let mut entry_3741 = list_3740.entry();
entry_3741.string(item_3739);
}
list_3740.finish();
}
#[allow(unused_mut)]
let mut scope_3742 = writer.prefix("StartTime");
if let Some(var_3743) = &input.start_time {
scope_3742.date_time(var_3743, aws_smithy_types::date_time::Format::DateTime)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_stale_security_groups(
input: &crate::input::DescribeStaleSecurityGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeStaleSecurityGroups", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3744 = writer.prefix("DryRun");
if let Some(var_3745) = &input.dry_run {
scope_3744.boolean(*var_3745);
}
#[allow(unused_mut)]
let mut scope_3746 = writer.prefix("MaxResults");
if let Some(var_3747) = &input.max_results {
scope_3746.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3747).into()),
);
}
#[allow(unused_mut)]
let mut scope_3748 = writer.prefix("NextToken");
if let Some(var_3749) = &input.next_token {
scope_3748.string(var_3749);
}
#[allow(unused_mut)]
let mut scope_3750 = writer.prefix("VpcId");
if let Some(var_3751) = &input.vpc_id {
scope_3750.string(var_3751);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_store_image_tasks(
input: &crate::input::DescribeStoreImageTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeStoreImageTasks", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3752 = writer.prefix("ImageId");
if let Some(var_3753) = &input.image_ids {
let mut list_3755 = scope_3752.start_list(true, Some("item"));
for item_3754 in var_3753 {
#[allow(unused_mut)]
let mut entry_3756 = list_3755.entry();
entry_3756.string(item_3754);
}
list_3755.finish();
}
#[allow(unused_mut)]
let mut scope_3757 = writer.prefix("DryRun");
if let Some(var_3758) = &input.dry_run {
scope_3757.boolean(*var_3758);
}
#[allow(unused_mut)]
let mut scope_3759 = writer.prefix("Filter");
if let Some(var_3760) = &input.filters {
let mut list_3762 = scope_3759.start_list(true, Some("Filter"));
for item_3761 in var_3760 {
#[allow(unused_mut)]
let mut entry_3763 = list_3762.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3763, item_3761)?;
}
list_3762.finish();
}
#[allow(unused_mut)]
let mut scope_3764 = writer.prefix("NextToken");
if let Some(var_3765) = &input.next_token {
scope_3764.string(var_3765);
}
#[allow(unused_mut)]
let mut scope_3766 = writer.prefix("MaxResults");
if let Some(var_3767) = &input.max_results {
scope_3766.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3767).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_subnets(
input: &crate::input::DescribeSubnetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeSubnets", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3768 = writer.prefix("Filter");
if let Some(var_3769) = &input.filters {
let mut list_3771 = scope_3768.start_list(true, Some("Filter"));
for item_3770 in var_3769 {
#[allow(unused_mut)]
let mut entry_3772 = list_3771.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3772, item_3770)?;
}
list_3771.finish();
}
#[allow(unused_mut)]
let mut scope_3773 = writer.prefix("SubnetId");
if let Some(var_3774) = &input.subnet_ids {
let mut list_3776 = scope_3773.start_list(true, Some("SubnetId"));
for item_3775 in var_3774 {
#[allow(unused_mut)]
let mut entry_3777 = list_3776.entry();
entry_3777.string(item_3775);
}
list_3776.finish();
}
#[allow(unused_mut)]
let mut scope_3778 = writer.prefix("DryRun");
if let Some(var_3779) = &input.dry_run {
scope_3778.boolean(*var_3779);
}
#[allow(unused_mut)]
let mut scope_3780 = writer.prefix("NextToken");
if let Some(var_3781) = &input.next_token {
scope_3780.string(var_3781);
}
#[allow(unused_mut)]
let mut scope_3782 = writer.prefix("MaxResults");
if let Some(var_3783) = &input.max_results {
scope_3782.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3783).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_tags(
input: &crate::input::DescribeTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeTags", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3784 = writer.prefix("DryRun");
if let Some(var_3785) = &input.dry_run {
scope_3784.boolean(*var_3785);
}
#[allow(unused_mut)]
let mut scope_3786 = writer.prefix("Filter");
if let Some(var_3787) = &input.filters {
let mut list_3789 = scope_3786.start_list(true, Some("Filter"));
for item_3788 in var_3787 {
#[allow(unused_mut)]
let mut entry_3790 = list_3789.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3790, item_3788)?;
}
list_3789.finish();
}
#[allow(unused_mut)]
let mut scope_3791 = writer.prefix("MaxResults");
if let Some(var_3792) = &input.max_results {
scope_3791.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3792).into()),
);
}
#[allow(unused_mut)]
let mut scope_3793 = writer.prefix("NextToken");
if let Some(var_3794) = &input.next_token {
scope_3793.string(var_3794);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_traffic_mirror_filters(
input: &crate::input::DescribeTrafficMirrorFiltersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeTrafficMirrorFilters", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3795 = writer.prefix("TrafficMirrorFilterId");
if let Some(var_3796) = &input.traffic_mirror_filter_ids {
let mut list_3798 = scope_3795.start_list(true, Some("item"));
for item_3797 in var_3796 {
#[allow(unused_mut)]
let mut entry_3799 = list_3798.entry();
entry_3799.string(item_3797);
}
list_3798.finish();
}
#[allow(unused_mut)]
let mut scope_3800 = writer.prefix("DryRun");
if let Some(var_3801) = &input.dry_run {
scope_3800.boolean(*var_3801);
}
#[allow(unused_mut)]
let mut scope_3802 = writer.prefix("Filter");
if let Some(var_3803) = &input.filters {
let mut list_3805 = scope_3802.start_list(true, Some("Filter"));
for item_3804 in var_3803 {
#[allow(unused_mut)]
let mut entry_3806 = list_3805.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3806, item_3804)?;
}
list_3805.finish();
}
#[allow(unused_mut)]
let mut scope_3807 = writer.prefix("MaxResults");
if let Some(var_3808) = &input.max_results {
scope_3807.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3808).into()),
);
}
#[allow(unused_mut)]
let mut scope_3809 = writer.prefix("NextToken");
if let Some(var_3810) = &input.next_token {
scope_3809.string(var_3810);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_traffic_mirror_sessions(
input: &crate::input::DescribeTrafficMirrorSessionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeTrafficMirrorSessions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3811 = writer.prefix("TrafficMirrorSessionId");
if let Some(var_3812) = &input.traffic_mirror_session_ids {
let mut list_3814 = scope_3811.start_list(true, Some("item"));
for item_3813 in var_3812 {
#[allow(unused_mut)]
let mut entry_3815 = list_3814.entry();
entry_3815.string(item_3813);
}
list_3814.finish();
}
#[allow(unused_mut)]
let mut scope_3816 = writer.prefix("DryRun");
if let Some(var_3817) = &input.dry_run {
scope_3816.boolean(*var_3817);
}
#[allow(unused_mut)]
let mut scope_3818 = writer.prefix("Filter");
if let Some(var_3819) = &input.filters {
let mut list_3821 = scope_3818.start_list(true, Some("Filter"));
for item_3820 in var_3819 {
#[allow(unused_mut)]
let mut entry_3822 = list_3821.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3822, item_3820)?;
}
list_3821.finish();
}
#[allow(unused_mut)]
let mut scope_3823 = writer.prefix("MaxResults");
if let Some(var_3824) = &input.max_results {
scope_3823.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3824).into()),
);
}
#[allow(unused_mut)]
let mut scope_3825 = writer.prefix("NextToken");
if let Some(var_3826) = &input.next_token {
scope_3825.string(var_3826);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_traffic_mirror_targets(
input: &crate::input::DescribeTrafficMirrorTargetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeTrafficMirrorTargets", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3827 = writer.prefix("TrafficMirrorTargetId");
if let Some(var_3828) = &input.traffic_mirror_target_ids {
let mut list_3830 = scope_3827.start_list(true, Some("item"));
for item_3829 in var_3828 {
#[allow(unused_mut)]
let mut entry_3831 = list_3830.entry();
entry_3831.string(item_3829);
}
list_3830.finish();
}
#[allow(unused_mut)]
let mut scope_3832 = writer.prefix("DryRun");
if let Some(var_3833) = &input.dry_run {
scope_3832.boolean(*var_3833);
}
#[allow(unused_mut)]
let mut scope_3834 = writer.prefix("Filter");
if let Some(var_3835) = &input.filters {
let mut list_3837 = scope_3834.start_list(true, Some("Filter"));
for item_3836 in var_3835 {
#[allow(unused_mut)]
let mut entry_3838 = list_3837.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3838, item_3836)?;
}
list_3837.finish();
}
#[allow(unused_mut)]
let mut scope_3839 = writer.prefix("MaxResults");
if let Some(var_3840) = &input.max_results {
scope_3839.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3840).into()),
);
}
#[allow(unused_mut)]
let mut scope_3841 = writer.prefix("NextToken");
if let Some(var_3842) = &input.next_token {
scope_3841.string(var_3842);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_transit_gateway_attachments(
input: &crate::input::DescribeTransitGatewayAttachmentsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTransitGatewayAttachments",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3843 = writer.prefix("TransitGatewayAttachmentIds");
if let Some(var_3844) = &input.transit_gateway_attachment_ids {
let mut list_3846 = scope_3843.start_list(true, None);
for item_3845 in var_3844 {
#[allow(unused_mut)]
let mut entry_3847 = list_3846.entry();
entry_3847.string(item_3845);
}
list_3846.finish();
}
#[allow(unused_mut)]
let mut scope_3848 = writer.prefix("Filter");
if let Some(var_3849) = &input.filters {
let mut list_3851 = scope_3848.start_list(true, Some("Filter"));
for item_3850 in var_3849 {
#[allow(unused_mut)]
let mut entry_3852 = list_3851.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3852, item_3850)?;
}
list_3851.finish();
}
#[allow(unused_mut)]
let mut scope_3853 = writer.prefix("MaxResults");
if let Some(var_3854) = &input.max_results {
scope_3853.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3854).into()),
);
}
#[allow(unused_mut)]
let mut scope_3855 = writer.prefix("NextToken");
if let Some(var_3856) = &input.next_token {
scope_3855.string(var_3856);
}
#[allow(unused_mut)]
let mut scope_3857 = writer.prefix("DryRun");
if let Some(var_3858) = &input.dry_run {
scope_3857.boolean(*var_3858);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_transit_gateway_connect_peers(
input: &crate::input::DescribeTransitGatewayConnectPeersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTransitGatewayConnectPeers",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3859 = writer.prefix("TransitGatewayConnectPeerIds");
if let Some(var_3860) = &input.transit_gateway_connect_peer_ids {
let mut list_3862 = scope_3859.start_list(true, Some("item"));
for item_3861 in var_3860 {
#[allow(unused_mut)]
let mut entry_3863 = list_3862.entry();
entry_3863.string(item_3861);
}
list_3862.finish();
}
#[allow(unused_mut)]
let mut scope_3864 = writer.prefix("Filter");
if let Some(var_3865) = &input.filters {
let mut list_3867 = scope_3864.start_list(true, Some("Filter"));
for item_3866 in var_3865 {
#[allow(unused_mut)]
let mut entry_3868 = list_3867.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3868, item_3866)?;
}
list_3867.finish();
}
#[allow(unused_mut)]
let mut scope_3869 = writer.prefix("MaxResults");
if let Some(var_3870) = &input.max_results {
scope_3869.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3870).into()),
);
}
#[allow(unused_mut)]
let mut scope_3871 = writer.prefix("NextToken");
if let Some(var_3872) = &input.next_token {
scope_3871.string(var_3872);
}
#[allow(unused_mut)]
let mut scope_3873 = writer.prefix("DryRun");
if let Some(var_3874) = &input.dry_run {
scope_3873.boolean(*var_3874);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_transit_gateway_connects(
input: &crate::input::DescribeTransitGatewayConnectsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTransitGatewayConnects",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3875 = writer.prefix("TransitGatewayAttachmentIds");
if let Some(var_3876) = &input.transit_gateway_attachment_ids {
let mut list_3878 = scope_3875.start_list(true, None);
for item_3877 in var_3876 {
#[allow(unused_mut)]
let mut entry_3879 = list_3878.entry();
entry_3879.string(item_3877);
}
list_3878.finish();
}
#[allow(unused_mut)]
let mut scope_3880 = writer.prefix("Filter");
if let Some(var_3881) = &input.filters {
let mut list_3883 = scope_3880.start_list(true, Some("Filter"));
for item_3882 in var_3881 {
#[allow(unused_mut)]
let mut entry_3884 = list_3883.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3884, item_3882)?;
}
list_3883.finish();
}
#[allow(unused_mut)]
let mut scope_3885 = writer.prefix("MaxResults");
if let Some(var_3886) = &input.max_results {
scope_3885.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3886).into()),
);
}
#[allow(unused_mut)]
let mut scope_3887 = writer.prefix("NextToken");
if let Some(var_3888) = &input.next_token {
scope_3887.string(var_3888);
}
#[allow(unused_mut)]
let mut scope_3889 = writer.prefix("DryRun");
if let Some(var_3890) = &input.dry_run {
scope_3889.boolean(*var_3890);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_transit_gateway_multicast_domains(
input: &crate::input::DescribeTransitGatewayMulticastDomainsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTransitGatewayMulticastDomains",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3891 = writer.prefix("TransitGatewayMulticastDomainIds");
if let Some(var_3892) = &input.transit_gateway_multicast_domain_ids {
let mut list_3894 = scope_3891.start_list(true, Some("item"));
for item_3893 in var_3892 {
#[allow(unused_mut)]
let mut entry_3895 = list_3894.entry();
entry_3895.string(item_3893);
}
list_3894.finish();
}
#[allow(unused_mut)]
let mut scope_3896 = writer.prefix("Filter");
if let Some(var_3897) = &input.filters {
let mut list_3899 = scope_3896.start_list(true, Some("Filter"));
for item_3898 in var_3897 {
#[allow(unused_mut)]
let mut entry_3900 = list_3899.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3900, item_3898)?;
}
list_3899.finish();
}
#[allow(unused_mut)]
let mut scope_3901 = writer.prefix("MaxResults");
if let Some(var_3902) = &input.max_results {
scope_3901.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3902).into()),
);
}
#[allow(unused_mut)]
let mut scope_3903 = writer.prefix("NextToken");
if let Some(var_3904) = &input.next_token {
scope_3903.string(var_3904);
}
#[allow(unused_mut)]
let mut scope_3905 = writer.prefix("DryRun");
if let Some(var_3906) = &input.dry_run {
scope_3905.boolean(*var_3906);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_transit_gateway_peering_attachments(
input: &crate::input::DescribeTransitGatewayPeeringAttachmentsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTransitGatewayPeeringAttachments",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3907 = writer.prefix("TransitGatewayAttachmentIds");
if let Some(var_3908) = &input.transit_gateway_attachment_ids {
let mut list_3910 = scope_3907.start_list(true, None);
for item_3909 in var_3908 {
#[allow(unused_mut)]
let mut entry_3911 = list_3910.entry();
entry_3911.string(item_3909);
}
list_3910.finish();
}
#[allow(unused_mut)]
let mut scope_3912 = writer.prefix("Filter");
if let Some(var_3913) = &input.filters {
let mut list_3915 = scope_3912.start_list(true, Some("Filter"));
for item_3914 in var_3913 {
#[allow(unused_mut)]
let mut entry_3916 = list_3915.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3916, item_3914)?;
}
list_3915.finish();
}
#[allow(unused_mut)]
let mut scope_3917 = writer.prefix("MaxResults");
if let Some(var_3918) = &input.max_results {
scope_3917.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3918).into()),
);
}
#[allow(unused_mut)]
let mut scope_3919 = writer.prefix("NextToken");
if let Some(var_3920) = &input.next_token {
scope_3919.string(var_3920);
}
#[allow(unused_mut)]
let mut scope_3921 = writer.prefix("DryRun");
if let Some(var_3922) = &input.dry_run {
scope_3921.boolean(*var_3922);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_transit_gateway_policy_tables(
input: &crate::input::DescribeTransitGatewayPolicyTablesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTransitGatewayPolicyTables",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3923 = writer.prefix("TransitGatewayPolicyTableIds");
if let Some(var_3924) = &input.transit_gateway_policy_table_ids {
let mut list_3926 = scope_3923.start_list(true, Some("item"));
for item_3925 in var_3924 {
#[allow(unused_mut)]
let mut entry_3927 = list_3926.entry();
entry_3927.string(item_3925);
}
list_3926.finish();
}
#[allow(unused_mut)]
let mut scope_3928 = writer.prefix("Filter");
if let Some(var_3929) = &input.filters {
let mut list_3931 = scope_3928.start_list(true, Some("Filter"));
for item_3930 in var_3929 {
#[allow(unused_mut)]
let mut entry_3932 = list_3931.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3932, item_3930)?;
}
list_3931.finish();
}
#[allow(unused_mut)]
let mut scope_3933 = writer.prefix("MaxResults");
if let Some(var_3934) = &input.max_results {
scope_3933.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3934).into()),
);
}
#[allow(unused_mut)]
let mut scope_3935 = writer.prefix("NextToken");
if let Some(var_3936) = &input.next_token {
scope_3935.string(var_3936);
}
#[allow(unused_mut)]
let mut scope_3937 = writer.prefix("DryRun");
if let Some(var_3938) = &input.dry_run {
scope_3937.boolean(*var_3938);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_transit_gateway_route_table_announcements(
input: &crate::input::DescribeTransitGatewayRouteTableAnnouncementsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTransitGatewayRouteTableAnnouncements",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3939 = writer.prefix("TransitGatewayRouteTableAnnouncementIds");
if let Some(var_3940) = &input.transit_gateway_route_table_announcement_ids {
let mut list_3942 = scope_3939.start_list(true, Some("item"));
for item_3941 in var_3940 {
#[allow(unused_mut)]
let mut entry_3943 = list_3942.entry();
entry_3943.string(item_3941);
}
list_3942.finish();
}
#[allow(unused_mut)]
let mut scope_3944 = writer.prefix("Filter");
if let Some(var_3945) = &input.filters {
let mut list_3947 = scope_3944.start_list(true, Some("Filter"));
for item_3946 in var_3945 {
#[allow(unused_mut)]
let mut entry_3948 = list_3947.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3948, item_3946)?;
}
list_3947.finish();
}
#[allow(unused_mut)]
let mut scope_3949 = writer.prefix("MaxResults");
if let Some(var_3950) = &input.max_results {
scope_3949.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3950).into()),
);
}
#[allow(unused_mut)]
let mut scope_3951 = writer.prefix("NextToken");
if let Some(var_3952) = &input.next_token {
scope_3951.string(var_3952);
}
#[allow(unused_mut)]
let mut scope_3953 = writer.prefix("DryRun");
if let Some(var_3954) = &input.dry_run {
scope_3953.boolean(*var_3954);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_transit_gateway_route_tables(
input: &crate::input::DescribeTransitGatewayRouteTablesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTransitGatewayRouteTables",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3955 = writer.prefix("TransitGatewayRouteTableIds");
if let Some(var_3956) = &input.transit_gateway_route_table_ids {
let mut list_3958 = scope_3955.start_list(true, Some("item"));
for item_3957 in var_3956 {
#[allow(unused_mut)]
let mut entry_3959 = list_3958.entry();
entry_3959.string(item_3957);
}
list_3958.finish();
}
#[allow(unused_mut)]
let mut scope_3960 = writer.prefix("Filter");
if let Some(var_3961) = &input.filters {
let mut list_3963 = scope_3960.start_list(true, Some("Filter"));
for item_3962 in var_3961 {
#[allow(unused_mut)]
let mut entry_3964 = list_3963.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3964, item_3962)?;
}
list_3963.finish();
}
#[allow(unused_mut)]
let mut scope_3965 = writer.prefix("MaxResults");
if let Some(var_3966) = &input.max_results {
scope_3965.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3966).into()),
);
}
#[allow(unused_mut)]
let mut scope_3967 = writer.prefix("NextToken");
if let Some(var_3968) = &input.next_token {
scope_3967.string(var_3968);
}
#[allow(unused_mut)]
let mut scope_3969 = writer.prefix("DryRun");
if let Some(var_3970) = &input.dry_run {
scope_3969.boolean(*var_3970);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_transit_gateways(
input: &crate::input::DescribeTransitGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeTransitGateways", "2016-11-15");
#[allow(unused_mut)]
let mut scope_3971 = writer.prefix("TransitGatewayIds");
if let Some(var_3972) = &input.transit_gateway_ids {
let mut list_3974 = scope_3971.start_list(true, Some("item"));
for item_3973 in var_3972 {
#[allow(unused_mut)]
let mut entry_3975 = list_3974.entry();
entry_3975.string(item_3973);
}
list_3974.finish();
}
#[allow(unused_mut)]
let mut scope_3976 = writer.prefix("Filter");
if let Some(var_3977) = &input.filters {
let mut list_3979 = scope_3976.start_list(true, Some("Filter"));
for item_3978 in var_3977 {
#[allow(unused_mut)]
let mut entry_3980 = list_3979.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3980, item_3978)?;
}
list_3979.finish();
}
#[allow(unused_mut)]
let mut scope_3981 = writer.prefix("MaxResults");
if let Some(var_3982) = &input.max_results {
scope_3981.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3982).into()),
);
}
#[allow(unused_mut)]
let mut scope_3983 = writer.prefix("NextToken");
if let Some(var_3984) = &input.next_token {
scope_3983.string(var_3984);
}
#[allow(unused_mut)]
let mut scope_3985 = writer.prefix("DryRun");
if let Some(var_3986) = &input.dry_run {
scope_3985.boolean(*var_3986);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_transit_gateway_vpc_attachments(
input: &crate::input::DescribeTransitGatewayVpcAttachmentsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTransitGatewayVpcAttachments",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_3987 = writer.prefix("TransitGatewayAttachmentIds");
if let Some(var_3988) = &input.transit_gateway_attachment_ids {
let mut list_3990 = scope_3987.start_list(true, None);
for item_3989 in var_3988 {
#[allow(unused_mut)]
let mut entry_3991 = list_3990.entry();
entry_3991.string(item_3989);
}
list_3990.finish();
}
#[allow(unused_mut)]
let mut scope_3992 = writer.prefix("Filter");
if let Some(var_3993) = &input.filters {
let mut list_3995 = scope_3992.start_list(true, Some("Filter"));
for item_3994 in var_3993 {
#[allow(unused_mut)]
let mut entry_3996 = list_3995.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_3996, item_3994)?;
}
list_3995.finish();
}
#[allow(unused_mut)]
let mut scope_3997 = writer.prefix("MaxResults");
if let Some(var_3998) = &input.max_results {
scope_3997.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3998).into()),
);
}
#[allow(unused_mut)]
let mut scope_3999 = writer.prefix("NextToken");
if let Some(var_4000) = &input.next_token {
scope_3999.string(var_4000);
}
#[allow(unused_mut)]
let mut scope_4001 = writer.prefix("DryRun");
if let Some(var_4002) = &input.dry_run {
scope_4001.boolean(*var_4002);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_trunk_interface_associations(
input: &crate::input::DescribeTrunkInterfaceAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTrunkInterfaceAssociations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4003 = writer.prefix("AssociationId");
if let Some(var_4004) = &input.association_ids {
let mut list_4006 = scope_4003.start_list(true, Some("item"));
for item_4005 in var_4004 {
#[allow(unused_mut)]
let mut entry_4007 = list_4006.entry();
entry_4007.string(item_4005);
}
list_4006.finish();
}
#[allow(unused_mut)]
let mut scope_4008 = writer.prefix("DryRun");
if let Some(var_4009) = &input.dry_run {
scope_4008.boolean(*var_4009);
}
#[allow(unused_mut)]
let mut scope_4010 = writer.prefix("Filter");
if let Some(var_4011) = &input.filters {
let mut list_4013 = scope_4010.start_list(true, Some("Filter"));
for item_4012 in var_4011 {
#[allow(unused_mut)]
let mut entry_4014 = list_4013.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4014, item_4012)?;
}
list_4013.finish();
}
#[allow(unused_mut)]
let mut scope_4015 = writer.prefix("NextToken");
if let Some(var_4016) = &input.next_token {
scope_4015.string(var_4016);
}
#[allow(unused_mut)]
let mut scope_4017 = writer.prefix("MaxResults");
if let Some(var_4018) = &input.max_results {
scope_4017.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4018).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_verified_access_endpoints(
input: &crate::input::DescribeVerifiedAccessEndpointsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeVerifiedAccessEndpoints",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4019 = writer.prefix("VerifiedAccessEndpointId");
if let Some(var_4020) = &input.verified_access_endpoint_ids {
let mut list_4022 = scope_4019.start_list(true, Some("item"));
for item_4021 in var_4020 {
#[allow(unused_mut)]
let mut entry_4023 = list_4022.entry();
entry_4023.string(item_4021);
}
list_4022.finish();
}
#[allow(unused_mut)]
let mut scope_4024 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_4025) = &input.verified_access_instance_id {
scope_4024.string(var_4025);
}
#[allow(unused_mut)]
let mut scope_4026 = writer.prefix("VerifiedAccessGroupId");
if let Some(var_4027) = &input.verified_access_group_id {
scope_4026.string(var_4027);
}
#[allow(unused_mut)]
let mut scope_4028 = writer.prefix("MaxResults");
if let Some(var_4029) = &input.max_results {
scope_4028.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4029).into()),
);
}
#[allow(unused_mut)]
let mut scope_4030 = writer.prefix("NextToken");
if let Some(var_4031) = &input.next_token {
scope_4030.string(var_4031);
}
#[allow(unused_mut)]
let mut scope_4032 = writer.prefix("Filter");
if let Some(var_4033) = &input.filters {
let mut list_4035 = scope_4032.start_list(true, Some("Filter"));
for item_4034 in var_4033 {
#[allow(unused_mut)]
let mut entry_4036 = list_4035.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4036, item_4034)?;
}
list_4035.finish();
}
#[allow(unused_mut)]
let mut scope_4037 = writer.prefix("DryRun");
if let Some(var_4038) = &input.dry_run {
scope_4037.boolean(*var_4038);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_verified_access_groups(
input: &crate::input::DescribeVerifiedAccessGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVerifiedAccessGroups", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4039 = writer.prefix("VerifiedAccessGroupId");
if let Some(var_4040) = &input.verified_access_group_ids {
let mut list_4042 = scope_4039.start_list(true, Some("item"));
for item_4041 in var_4040 {
#[allow(unused_mut)]
let mut entry_4043 = list_4042.entry();
entry_4043.string(item_4041);
}
list_4042.finish();
}
#[allow(unused_mut)]
let mut scope_4044 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_4045) = &input.verified_access_instance_id {
scope_4044.string(var_4045);
}
#[allow(unused_mut)]
let mut scope_4046 = writer.prefix("MaxResults");
if let Some(var_4047) = &input.max_results {
scope_4046.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4047).into()),
);
}
#[allow(unused_mut)]
let mut scope_4048 = writer.prefix("NextToken");
if let Some(var_4049) = &input.next_token {
scope_4048.string(var_4049);
}
#[allow(unused_mut)]
let mut scope_4050 = writer.prefix("Filter");
if let Some(var_4051) = &input.filters {
let mut list_4053 = scope_4050.start_list(true, Some("Filter"));
for item_4052 in var_4051 {
#[allow(unused_mut)]
let mut entry_4054 = list_4053.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4054, item_4052)?;
}
list_4053.finish();
}
#[allow(unused_mut)]
let mut scope_4055 = writer.prefix("DryRun");
if let Some(var_4056) = &input.dry_run {
scope_4055.boolean(*var_4056);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_verified_access_instance_logging_configurations(
input: &crate::input::DescribeVerifiedAccessInstanceLoggingConfigurationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeVerifiedAccessInstanceLoggingConfigurations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4057 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_4058) = &input.verified_access_instance_ids {
let mut list_4060 = scope_4057.start_list(true, Some("item"));
for item_4059 in var_4058 {
#[allow(unused_mut)]
let mut entry_4061 = list_4060.entry();
entry_4061.string(item_4059);
}
list_4060.finish();
}
#[allow(unused_mut)]
let mut scope_4062 = writer.prefix("MaxResults");
if let Some(var_4063) = &input.max_results {
scope_4062.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4063).into()),
);
}
#[allow(unused_mut)]
let mut scope_4064 = writer.prefix("NextToken");
if let Some(var_4065) = &input.next_token {
scope_4064.string(var_4065);
}
#[allow(unused_mut)]
let mut scope_4066 = writer.prefix("Filter");
if let Some(var_4067) = &input.filters {
let mut list_4069 = scope_4066.start_list(true, Some("Filter"));
for item_4068 in var_4067 {
#[allow(unused_mut)]
let mut entry_4070 = list_4069.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4070, item_4068)?;
}
list_4069.finish();
}
#[allow(unused_mut)]
let mut scope_4071 = writer.prefix("DryRun");
if let Some(var_4072) = &input.dry_run {
scope_4071.boolean(*var_4072);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_verified_access_instances(
input: &crate::input::DescribeVerifiedAccessInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeVerifiedAccessInstances",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4073 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_4074) = &input.verified_access_instance_ids {
let mut list_4076 = scope_4073.start_list(true, Some("item"));
for item_4075 in var_4074 {
#[allow(unused_mut)]
let mut entry_4077 = list_4076.entry();
entry_4077.string(item_4075);
}
list_4076.finish();
}
#[allow(unused_mut)]
let mut scope_4078 = writer.prefix("MaxResults");
if let Some(var_4079) = &input.max_results {
scope_4078.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4079).into()),
);
}
#[allow(unused_mut)]
let mut scope_4080 = writer.prefix("NextToken");
if let Some(var_4081) = &input.next_token {
scope_4080.string(var_4081);
}
#[allow(unused_mut)]
let mut scope_4082 = writer.prefix("Filter");
if let Some(var_4083) = &input.filters {
let mut list_4085 = scope_4082.start_list(true, Some("Filter"));
for item_4084 in var_4083 {
#[allow(unused_mut)]
let mut entry_4086 = list_4085.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4086, item_4084)?;
}
list_4085.finish();
}
#[allow(unused_mut)]
let mut scope_4087 = writer.prefix("DryRun");
if let Some(var_4088) = &input.dry_run {
scope_4087.boolean(*var_4088);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_verified_access_trust_providers(
input: &crate::input::DescribeVerifiedAccessTrustProvidersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeVerifiedAccessTrustProviders",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4089 = writer.prefix("VerifiedAccessTrustProviderId");
if let Some(var_4090) = &input.verified_access_trust_provider_ids {
let mut list_4092 = scope_4089.start_list(true, Some("item"));
for item_4091 in var_4090 {
#[allow(unused_mut)]
let mut entry_4093 = list_4092.entry();
entry_4093.string(item_4091);
}
list_4092.finish();
}
#[allow(unused_mut)]
let mut scope_4094 = writer.prefix("MaxResults");
if let Some(var_4095) = &input.max_results {
scope_4094.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4095).into()),
);
}
#[allow(unused_mut)]
let mut scope_4096 = writer.prefix("NextToken");
if let Some(var_4097) = &input.next_token {
scope_4096.string(var_4097);
}
#[allow(unused_mut)]
let mut scope_4098 = writer.prefix("Filter");
if let Some(var_4099) = &input.filters {
let mut list_4101 = scope_4098.start_list(true, Some("Filter"));
for item_4100 in var_4099 {
#[allow(unused_mut)]
let mut entry_4102 = list_4101.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4102, item_4100)?;
}
list_4101.finish();
}
#[allow(unused_mut)]
let mut scope_4103 = writer.prefix("DryRun");
if let Some(var_4104) = &input.dry_run {
scope_4103.boolean(*var_4104);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_volume_attribute(
input: &crate::input::DescribeVolumeAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVolumeAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4105 = writer.prefix("Attribute");
if let Some(var_4106) = &input.attribute {
scope_4105.string(var_4106.as_str());
}
#[allow(unused_mut)]
let mut scope_4107 = writer.prefix("VolumeId");
if let Some(var_4108) = &input.volume_id {
scope_4107.string(var_4108);
}
#[allow(unused_mut)]
let mut scope_4109 = writer.prefix("DryRun");
if let Some(var_4110) = &input.dry_run {
scope_4109.boolean(*var_4110);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_volumes(
input: &crate::input::DescribeVolumesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeVolumes", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4111 = writer.prefix("Filter");
if let Some(var_4112) = &input.filters {
let mut list_4114 = scope_4111.start_list(true, Some("Filter"));
for item_4113 in var_4112 {
#[allow(unused_mut)]
let mut entry_4115 = list_4114.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4115, item_4113)?;
}
list_4114.finish();
}
#[allow(unused_mut)]
let mut scope_4116 = writer.prefix("VolumeId");
if let Some(var_4117) = &input.volume_ids {
let mut list_4119 = scope_4116.start_list(true, Some("VolumeId"));
for item_4118 in var_4117 {
#[allow(unused_mut)]
let mut entry_4120 = list_4119.entry();
entry_4120.string(item_4118);
}
list_4119.finish();
}
#[allow(unused_mut)]
let mut scope_4121 = writer.prefix("DryRun");
if let Some(var_4122) = &input.dry_run {
scope_4121.boolean(*var_4122);
}
#[allow(unused_mut)]
let mut scope_4123 = writer.prefix("MaxResults");
if let Some(var_4124) = &input.max_results {
scope_4123.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4124).into()),
);
}
#[allow(unused_mut)]
let mut scope_4125 = writer.prefix("NextToken");
if let Some(var_4126) = &input.next_token {
scope_4125.string(var_4126);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_volumes_modifications(
input: &crate::input::DescribeVolumesModificationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVolumesModifications", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4127 = writer.prefix("DryRun");
if let Some(var_4128) = &input.dry_run {
scope_4127.boolean(*var_4128);
}
#[allow(unused_mut)]
let mut scope_4129 = writer.prefix("VolumeId");
if let Some(var_4130) = &input.volume_ids {
let mut list_4132 = scope_4129.start_list(true, Some("VolumeId"));
for item_4131 in var_4130 {
#[allow(unused_mut)]
let mut entry_4133 = list_4132.entry();
entry_4133.string(item_4131);
}
list_4132.finish();
}
#[allow(unused_mut)]
let mut scope_4134 = writer.prefix("Filter");
if let Some(var_4135) = &input.filters {
let mut list_4137 = scope_4134.start_list(true, Some("Filter"));
for item_4136 in var_4135 {
#[allow(unused_mut)]
let mut entry_4138 = list_4137.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4138, item_4136)?;
}
list_4137.finish();
}
#[allow(unused_mut)]
let mut scope_4139 = writer.prefix("NextToken");
if let Some(var_4140) = &input.next_token {
scope_4139.string(var_4140);
}
#[allow(unused_mut)]
let mut scope_4141 = writer.prefix("MaxResults");
if let Some(var_4142) = &input.max_results {
scope_4141.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4142).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_volume_status(
input: &crate::input::DescribeVolumeStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVolumeStatus", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4143 = writer.prefix("Filter");
if let Some(var_4144) = &input.filters {
let mut list_4146 = scope_4143.start_list(true, Some("Filter"));
for item_4145 in var_4144 {
#[allow(unused_mut)]
let mut entry_4147 = list_4146.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4147, item_4145)?;
}
list_4146.finish();
}
#[allow(unused_mut)]
let mut scope_4148 = writer.prefix("MaxResults");
if let Some(var_4149) = &input.max_results {
scope_4148.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4149).into()),
);
}
#[allow(unused_mut)]
let mut scope_4150 = writer.prefix("NextToken");
if let Some(var_4151) = &input.next_token {
scope_4150.string(var_4151);
}
#[allow(unused_mut)]
let mut scope_4152 = writer.prefix("VolumeId");
if let Some(var_4153) = &input.volume_ids {
let mut list_4155 = scope_4152.start_list(true, Some("VolumeId"));
for item_4154 in var_4153 {
#[allow(unused_mut)]
let mut entry_4156 = list_4155.entry();
entry_4156.string(item_4154);
}
list_4155.finish();
}
#[allow(unused_mut)]
let mut scope_4157 = writer.prefix("DryRun");
if let Some(var_4158) = &input.dry_run {
scope_4157.boolean(*var_4158);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpc_attribute(
input: &crate::input::DescribeVpcAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVpcAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4159 = writer.prefix("Attribute");
if let Some(var_4160) = &input.attribute {
scope_4159.string(var_4160.as_str());
}
#[allow(unused_mut)]
let mut scope_4161 = writer.prefix("VpcId");
if let Some(var_4162) = &input.vpc_id {
scope_4161.string(var_4162);
}
#[allow(unused_mut)]
let mut scope_4163 = writer.prefix("DryRun");
if let Some(var_4164) = &input.dry_run {
scope_4163.boolean(*var_4164);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpc_classic_link(
input: &crate::input::DescribeVpcClassicLinkInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVpcClassicLink", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4165 = writer.prefix("Filter");
if let Some(var_4166) = &input.filters {
let mut list_4168 = scope_4165.start_list(true, Some("Filter"));
for item_4167 in var_4166 {
#[allow(unused_mut)]
let mut entry_4169 = list_4168.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4169, item_4167)?;
}
list_4168.finish();
}
#[allow(unused_mut)]
let mut scope_4170 = writer.prefix("DryRun");
if let Some(var_4171) = &input.dry_run {
scope_4170.boolean(*var_4171);
}
#[allow(unused_mut)]
let mut scope_4172 = writer.prefix("VpcId");
if let Some(var_4173) = &input.vpc_ids {
let mut list_4175 = scope_4172.start_list(true, Some("VpcId"));
for item_4174 in var_4173 {
#[allow(unused_mut)]
let mut entry_4176 = list_4175.entry();
entry_4176.string(item_4174);
}
list_4175.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpc_classic_link_dns_support(
input: &crate::input::DescribeVpcClassicLinkDnsSupportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeVpcClassicLinkDnsSupport",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4177 = writer.prefix("MaxResults");
if let Some(var_4178) = &input.max_results {
scope_4177.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4178).into()),
);
}
#[allow(unused_mut)]
let mut scope_4179 = writer.prefix("NextToken");
if let Some(var_4180) = &input.next_token {
scope_4179.string(var_4180);
}
#[allow(unused_mut)]
let mut scope_4181 = writer.prefix("VpcIds");
if let Some(var_4182) = &input.vpc_ids {
let mut list_4184 = scope_4181.start_list(true, Some("VpcId"));
for item_4183 in var_4182 {
#[allow(unused_mut)]
let mut entry_4185 = list_4184.entry();
entry_4185.string(item_4183);
}
list_4184.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpc_endpoint_connection_notifications(
input: &crate::input::DescribeVpcEndpointConnectionNotificationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeVpcEndpointConnectionNotifications",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4186 = writer.prefix("DryRun");
if let Some(var_4187) = &input.dry_run {
scope_4186.boolean(*var_4187);
}
#[allow(unused_mut)]
let mut scope_4188 = writer.prefix("ConnectionNotificationId");
if let Some(var_4189) = &input.connection_notification_id {
scope_4188.string(var_4189);
}
#[allow(unused_mut)]
let mut scope_4190 = writer.prefix("Filter");
if let Some(var_4191) = &input.filters {
let mut list_4193 = scope_4190.start_list(true, Some("Filter"));
for item_4192 in var_4191 {
#[allow(unused_mut)]
let mut entry_4194 = list_4193.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4194, item_4192)?;
}
list_4193.finish();
}
#[allow(unused_mut)]
let mut scope_4195 = writer.prefix("MaxResults");
if let Some(var_4196) = &input.max_results {
scope_4195.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4196).into()),
);
}
#[allow(unused_mut)]
let mut scope_4197 = writer.prefix("NextToken");
if let Some(var_4198) = &input.next_token {
scope_4197.string(var_4198);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpc_endpoint_connections(
input: &crate::input::DescribeVpcEndpointConnectionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeVpcEndpointConnections",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4199 = writer.prefix("DryRun");
if let Some(var_4200) = &input.dry_run {
scope_4199.boolean(*var_4200);
}
#[allow(unused_mut)]
let mut scope_4201 = writer.prefix("Filter");
if let Some(var_4202) = &input.filters {
let mut list_4204 = scope_4201.start_list(true, Some("Filter"));
for item_4203 in var_4202 {
#[allow(unused_mut)]
let mut entry_4205 = list_4204.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4205, item_4203)?;
}
list_4204.finish();
}
#[allow(unused_mut)]
let mut scope_4206 = writer.prefix("MaxResults");
if let Some(var_4207) = &input.max_results {
scope_4206.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4207).into()),
);
}
#[allow(unused_mut)]
let mut scope_4208 = writer.prefix("NextToken");
if let Some(var_4209) = &input.next_token {
scope_4208.string(var_4209);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpc_endpoints(
input: &crate::input::DescribeVpcEndpointsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVpcEndpoints", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4210 = writer.prefix("DryRun");
if let Some(var_4211) = &input.dry_run {
scope_4210.boolean(*var_4211);
}
#[allow(unused_mut)]
let mut scope_4212 = writer.prefix("VpcEndpointId");
if let Some(var_4213) = &input.vpc_endpoint_ids {
let mut list_4215 = scope_4212.start_list(true, Some("item"));
for item_4214 in var_4213 {
#[allow(unused_mut)]
let mut entry_4216 = list_4215.entry();
entry_4216.string(item_4214);
}
list_4215.finish();
}
#[allow(unused_mut)]
let mut scope_4217 = writer.prefix("Filter");
if let Some(var_4218) = &input.filters {
let mut list_4220 = scope_4217.start_list(true, Some("Filter"));
for item_4219 in var_4218 {
#[allow(unused_mut)]
let mut entry_4221 = list_4220.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4221, item_4219)?;
}
list_4220.finish();
}
#[allow(unused_mut)]
let mut scope_4222 = writer.prefix("MaxResults");
if let Some(var_4223) = &input.max_results {
scope_4222.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4223).into()),
);
}
#[allow(unused_mut)]
let mut scope_4224 = writer.prefix("NextToken");
if let Some(var_4225) = &input.next_token {
scope_4224.string(var_4225);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpc_endpoint_service_configurations(
input: &crate::input::DescribeVpcEndpointServiceConfigurationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeVpcEndpointServiceConfigurations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4226 = writer.prefix("DryRun");
if let Some(var_4227) = &input.dry_run {
scope_4226.boolean(*var_4227);
}
#[allow(unused_mut)]
let mut scope_4228 = writer.prefix("ServiceId");
if let Some(var_4229) = &input.service_ids {
let mut list_4231 = scope_4228.start_list(true, Some("item"));
for item_4230 in var_4229 {
#[allow(unused_mut)]
let mut entry_4232 = list_4231.entry();
entry_4232.string(item_4230);
}
list_4231.finish();
}
#[allow(unused_mut)]
let mut scope_4233 = writer.prefix("Filter");
if let Some(var_4234) = &input.filters {
let mut list_4236 = scope_4233.start_list(true, Some("Filter"));
for item_4235 in var_4234 {
#[allow(unused_mut)]
let mut entry_4237 = list_4236.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4237, item_4235)?;
}
list_4236.finish();
}
#[allow(unused_mut)]
let mut scope_4238 = writer.prefix("MaxResults");
if let Some(var_4239) = &input.max_results {
scope_4238.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4239).into()),
);
}
#[allow(unused_mut)]
let mut scope_4240 = writer.prefix("NextToken");
if let Some(var_4241) = &input.next_token {
scope_4240.string(var_4241);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpc_endpoint_service_permissions(
input: &crate::input::DescribeVpcEndpointServicePermissionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeVpcEndpointServicePermissions",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4242 = writer.prefix("DryRun");
if let Some(var_4243) = &input.dry_run {
scope_4242.boolean(*var_4243);
}
#[allow(unused_mut)]
let mut scope_4244 = writer.prefix("ServiceId");
if let Some(var_4245) = &input.service_id {
scope_4244.string(var_4245);
}
#[allow(unused_mut)]
let mut scope_4246 = writer.prefix("Filter");
if let Some(var_4247) = &input.filters {
let mut list_4249 = scope_4246.start_list(true, Some("Filter"));
for item_4248 in var_4247 {
#[allow(unused_mut)]
let mut entry_4250 = list_4249.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4250, item_4248)?;
}
list_4249.finish();
}
#[allow(unused_mut)]
let mut scope_4251 = writer.prefix("MaxResults");
if let Some(var_4252) = &input.max_results {
scope_4251.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4252).into()),
);
}
#[allow(unused_mut)]
let mut scope_4253 = writer.prefix("NextToken");
if let Some(var_4254) = &input.next_token {
scope_4253.string(var_4254);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpc_endpoint_services(
input: &crate::input::DescribeVpcEndpointServicesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVpcEndpointServices", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4255 = writer.prefix("DryRun");
if let Some(var_4256) = &input.dry_run {
scope_4255.boolean(*var_4256);
}
#[allow(unused_mut)]
let mut scope_4257 = writer.prefix("ServiceName");
if let Some(var_4258) = &input.service_names {
let mut list_4260 = scope_4257.start_list(true, Some("item"));
for item_4259 in var_4258 {
#[allow(unused_mut)]
let mut entry_4261 = list_4260.entry();
entry_4261.string(item_4259);
}
list_4260.finish();
}
#[allow(unused_mut)]
let mut scope_4262 = writer.prefix("Filter");
if let Some(var_4263) = &input.filters {
let mut list_4265 = scope_4262.start_list(true, Some("Filter"));
for item_4264 in var_4263 {
#[allow(unused_mut)]
let mut entry_4266 = list_4265.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4266, item_4264)?;
}
list_4265.finish();
}
#[allow(unused_mut)]
let mut scope_4267 = writer.prefix("MaxResults");
if let Some(var_4268) = &input.max_results {
scope_4267.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4268).into()),
);
}
#[allow(unused_mut)]
let mut scope_4269 = writer.prefix("NextToken");
if let Some(var_4270) = &input.next_token {
scope_4269.string(var_4270);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpc_peering_connections(
input: &crate::input::DescribeVpcPeeringConnectionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVpcPeeringConnections", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4271 = writer.prefix("Filter");
if let Some(var_4272) = &input.filters {
let mut list_4274 = scope_4271.start_list(true, Some("Filter"));
for item_4273 in var_4272 {
#[allow(unused_mut)]
let mut entry_4275 = list_4274.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4275, item_4273)?;
}
list_4274.finish();
}
#[allow(unused_mut)]
let mut scope_4276 = writer.prefix("DryRun");
if let Some(var_4277) = &input.dry_run {
scope_4276.boolean(*var_4277);
}
#[allow(unused_mut)]
let mut scope_4278 = writer.prefix("VpcPeeringConnectionId");
if let Some(var_4279) = &input.vpc_peering_connection_ids {
let mut list_4281 = scope_4278.start_list(true, Some("item"));
for item_4280 in var_4279 {
#[allow(unused_mut)]
let mut entry_4282 = list_4281.entry();
entry_4282.string(item_4280);
}
list_4281.finish();
}
#[allow(unused_mut)]
let mut scope_4283 = writer.prefix("NextToken");
if let Some(var_4284) = &input.next_token {
scope_4283.string(var_4284);
}
#[allow(unused_mut)]
let mut scope_4285 = writer.prefix("MaxResults");
if let Some(var_4286) = &input.max_results {
scope_4285.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4286).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpcs(
input: &crate::input::DescribeVpcsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeVpcs", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4287 = writer.prefix("Filter");
if let Some(var_4288) = &input.filters {
let mut list_4290 = scope_4287.start_list(true, Some("Filter"));
for item_4289 in var_4288 {
#[allow(unused_mut)]
let mut entry_4291 = list_4290.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4291, item_4289)?;
}
list_4290.finish();
}
#[allow(unused_mut)]
let mut scope_4292 = writer.prefix("VpcId");
if let Some(var_4293) = &input.vpc_ids {
let mut list_4295 = scope_4292.start_list(true, Some("VpcId"));
for item_4294 in var_4293 {
#[allow(unused_mut)]
let mut entry_4296 = list_4295.entry();
entry_4296.string(item_4294);
}
list_4295.finish();
}
#[allow(unused_mut)]
let mut scope_4297 = writer.prefix("DryRun");
if let Some(var_4298) = &input.dry_run {
scope_4297.boolean(*var_4298);
}
#[allow(unused_mut)]
let mut scope_4299 = writer.prefix("NextToken");
if let Some(var_4300) = &input.next_token {
scope_4299.string(var_4300);
}
#[allow(unused_mut)]
let mut scope_4301 = writer.prefix("MaxResults");
if let Some(var_4302) = &input.max_results {
scope_4301.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4302).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpn_connections(
input: &crate::input::DescribeVpnConnectionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVpnConnections", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4303 = writer.prefix("Filter");
if let Some(var_4304) = &input.filters {
let mut list_4306 = scope_4303.start_list(true, Some("Filter"));
for item_4305 in var_4304 {
#[allow(unused_mut)]
let mut entry_4307 = list_4306.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4307, item_4305)?;
}
list_4306.finish();
}
#[allow(unused_mut)]
let mut scope_4308 = writer.prefix("VpnConnectionId");
if let Some(var_4309) = &input.vpn_connection_ids {
let mut list_4311 = scope_4308.start_list(true, Some("VpnConnectionId"));
for item_4310 in var_4309 {
#[allow(unused_mut)]
let mut entry_4312 = list_4311.entry();
entry_4312.string(item_4310);
}
list_4311.finish();
}
#[allow(unused_mut)]
let mut scope_4313 = writer.prefix("DryRun");
if let Some(var_4314) = &input.dry_run {
scope_4313.boolean(*var_4314);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_vpn_gateways(
input: &crate::input::DescribeVpnGatewaysInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeVpnGateways", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4315 = writer.prefix("Filter");
if let Some(var_4316) = &input.filters {
let mut list_4318 = scope_4315.start_list(true, Some("Filter"));
for item_4317 in var_4316 {
#[allow(unused_mut)]
let mut entry_4319 = list_4318.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4319, item_4317)?;
}
list_4318.finish();
}
#[allow(unused_mut)]
let mut scope_4320 = writer.prefix("VpnGatewayId");
if let Some(var_4321) = &input.vpn_gateway_ids {
let mut list_4323 = scope_4320.start_list(true, Some("VpnGatewayId"));
for item_4322 in var_4321 {
#[allow(unused_mut)]
let mut entry_4324 = list_4323.entry();
entry_4324.string(item_4322);
}
list_4323.finish();
}
#[allow(unused_mut)]
let mut scope_4325 = writer.prefix("DryRun");
if let Some(var_4326) = &input.dry_run {
scope_4325.boolean(*var_4326);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_classic_link_vpc(
input: &crate::input::DetachClassicLinkVpcInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DetachClassicLinkVpc", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4327 = writer.prefix("DryRun");
if let Some(var_4328) = &input.dry_run {
scope_4327.boolean(*var_4328);
}
#[allow(unused_mut)]
let mut scope_4329 = writer.prefix("InstanceId");
if let Some(var_4330) = &input.instance_id {
scope_4329.string(var_4330);
}
#[allow(unused_mut)]
let mut scope_4331 = writer.prefix("VpcId");
if let Some(var_4332) = &input.vpc_id {
scope_4331.string(var_4332);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_internet_gateway(
input: &crate::input::DetachInternetGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DetachInternetGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4333 = writer.prefix("DryRun");
if let Some(var_4334) = &input.dry_run {
scope_4333.boolean(*var_4334);
}
#[allow(unused_mut)]
let mut scope_4335 = writer.prefix("InternetGatewayId");
if let Some(var_4336) = &input.internet_gateway_id {
scope_4335.string(var_4336);
}
#[allow(unused_mut)]
let mut scope_4337 = writer.prefix("VpcId");
if let Some(var_4338) = &input.vpc_id {
scope_4337.string(var_4338);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_network_interface(
input: &crate::input::DetachNetworkInterfaceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DetachNetworkInterface", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4339 = writer.prefix("AttachmentId");
if let Some(var_4340) = &input.attachment_id {
scope_4339.string(var_4340);
}
#[allow(unused_mut)]
let mut scope_4341 = writer.prefix("DryRun");
if let Some(var_4342) = &input.dry_run {
scope_4341.boolean(*var_4342);
}
#[allow(unused_mut)]
let mut scope_4343 = writer.prefix("Force");
if let Some(var_4344) = &input.force {
scope_4343.boolean(*var_4344);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_verified_access_trust_provider(
input: &crate::input::DetachVerifiedAccessTrustProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DetachVerifiedAccessTrustProvider",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4345 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_4346) = &input.verified_access_instance_id {
scope_4345.string(var_4346);
}
#[allow(unused_mut)]
let mut scope_4347 = writer.prefix("VerifiedAccessTrustProviderId");
if let Some(var_4348) = &input.verified_access_trust_provider_id {
scope_4347.string(var_4348);
}
#[allow(unused_mut)]
let mut scope_4349 = writer.prefix("ClientToken");
if let Some(var_4350) = &input.client_token {
scope_4349.string(var_4350);
}
#[allow(unused_mut)]
let mut scope_4351 = writer.prefix("DryRun");
if let Some(var_4352) = &input.dry_run {
scope_4351.boolean(*var_4352);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_volume(
input: &crate::input::DetachVolumeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DetachVolume", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4353 = writer.prefix("Device");
if let Some(var_4354) = &input.device {
scope_4353.string(var_4354);
}
#[allow(unused_mut)]
let mut scope_4355 = writer.prefix("Force");
if let Some(var_4356) = &input.force {
scope_4355.boolean(*var_4356);
}
#[allow(unused_mut)]
let mut scope_4357 = writer.prefix("InstanceId");
if let Some(var_4358) = &input.instance_id {
scope_4357.string(var_4358);
}
#[allow(unused_mut)]
let mut scope_4359 = writer.prefix("VolumeId");
if let Some(var_4360) = &input.volume_id {
scope_4359.string(var_4360);
}
#[allow(unused_mut)]
let mut scope_4361 = writer.prefix("DryRun");
if let Some(var_4362) = &input.dry_run {
scope_4361.boolean(*var_4362);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_vpn_gateway(
input: &crate::input::DetachVpnGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DetachVpnGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4363 = writer.prefix("VpcId");
if let Some(var_4364) = &input.vpc_id {
scope_4363.string(var_4364);
}
#[allow(unused_mut)]
let mut scope_4365 = writer.prefix("VpnGatewayId");
if let Some(var_4366) = &input.vpn_gateway_id {
scope_4365.string(var_4366);
}
#[allow(unused_mut)]
let mut scope_4367 = writer.prefix("DryRun");
if let Some(var_4368) = &input.dry_run {
scope_4367.boolean(*var_4368);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_address_transfer(
input: &crate::input::DisableAddressTransferInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableAddressTransfer", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4369 = writer.prefix("AllocationId");
if let Some(var_4370) = &input.allocation_id {
scope_4369.string(var_4370);
}
#[allow(unused_mut)]
let mut scope_4371 = writer.prefix("DryRun");
if let Some(var_4372) = &input.dry_run {
scope_4371.boolean(*var_4372);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_aws_network_performance_metric_subscription(
input: &crate::input::DisableAwsNetworkPerformanceMetricSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisableAwsNetworkPerformanceMetricSubscription",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4373 = writer.prefix("Source");
if let Some(var_4374) = &input.source {
scope_4373.string(var_4374);
}
#[allow(unused_mut)]
let mut scope_4375 = writer.prefix("Destination");
if let Some(var_4376) = &input.destination {
scope_4375.string(var_4376);
}
#[allow(unused_mut)]
let mut scope_4377 = writer.prefix("Metric");
if let Some(var_4378) = &input.metric {
scope_4377.string(var_4378.as_str());
}
#[allow(unused_mut)]
let mut scope_4379 = writer.prefix("Statistic");
if let Some(var_4380) = &input.statistic {
scope_4379.string(var_4380.as_str());
}
#[allow(unused_mut)]
let mut scope_4381 = writer.prefix("DryRun");
if let Some(var_4382) = &input.dry_run {
scope_4381.boolean(*var_4382);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_ebs_encryption_by_default(
input: &crate::input::DisableEbsEncryptionByDefaultInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableEbsEncryptionByDefault", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4383 = writer.prefix("DryRun");
if let Some(var_4384) = &input.dry_run {
scope_4383.boolean(*var_4384);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_fast_launch(
input: &crate::input::DisableFastLaunchInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableFastLaunch", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4385 = writer.prefix("ImageId");
if let Some(var_4386) = &input.image_id {
scope_4385.string(var_4386);
}
#[allow(unused_mut)]
let mut scope_4387 = writer.prefix("Force");
if let Some(var_4388) = &input.force {
scope_4387.boolean(*var_4388);
}
#[allow(unused_mut)]
let mut scope_4389 = writer.prefix("DryRun");
if let Some(var_4390) = &input.dry_run {
scope_4389.boolean(*var_4390);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_fast_snapshot_restores(
input: &crate::input::DisableFastSnapshotRestoresInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableFastSnapshotRestores", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4391 = writer.prefix("AvailabilityZone");
if let Some(var_4392) = &input.availability_zones {
let mut list_4394 = scope_4391.start_list(true, Some("AvailabilityZone"));
for item_4393 in var_4392 {
#[allow(unused_mut)]
let mut entry_4395 = list_4394.entry();
entry_4395.string(item_4393);
}
list_4394.finish();
}
#[allow(unused_mut)]
let mut scope_4396 = writer.prefix("SourceSnapshotId");
if let Some(var_4397) = &input.source_snapshot_ids {
let mut list_4399 = scope_4396.start_list(true, Some("SnapshotId"));
for item_4398 in var_4397 {
#[allow(unused_mut)]
let mut entry_4400 = list_4399.entry();
entry_4400.string(item_4398);
}
list_4399.finish();
}
#[allow(unused_mut)]
let mut scope_4401 = writer.prefix("DryRun");
if let Some(var_4402) = &input.dry_run {
scope_4401.boolean(*var_4402);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_image_deprecation(
input: &crate::input::DisableImageDeprecationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableImageDeprecation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4403 = writer.prefix("ImageId");
if let Some(var_4404) = &input.image_id {
scope_4403.string(var_4404);
}
#[allow(unused_mut)]
let mut scope_4405 = writer.prefix("DryRun");
if let Some(var_4406) = &input.dry_run {
scope_4405.boolean(*var_4406);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_ipam_organization_admin_account(
input: &crate::input::DisableIpamOrganizationAdminAccountInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisableIpamOrganizationAdminAccount",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4407 = writer.prefix("DryRun");
if let Some(var_4408) = &input.dry_run {
scope_4407.boolean(*var_4408);
}
#[allow(unused_mut)]
let mut scope_4409 = writer.prefix("DelegatedAdminAccountId");
if let Some(var_4410) = &input.delegated_admin_account_id {
scope_4409.string(var_4410);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_serial_console_access(
input: &crate::input::DisableSerialConsoleAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableSerialConsoleAccess", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4411 = writer.prefix("DryRun");
if let Some(var_4412) = &input.dry_run {
scope_4411.boolean(*var_4412);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_transit_gateway_route_table_propagation(
input: &crate::input::DisableTransitGatewayRouteTablePropagationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisableTransitGatewayRouteTablePropagation",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4413 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_4414) = &input.transit_gateway_route_table_id {
scope_4413.string(var_4414);
}
#[allow(unused_mut)]
let mut scope_4415 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_4416) = &input.transit_gateway_attachment_id {
scope_4415.string(var_4416);
}
#[allow(unused_mut)]
let mut scope_4417 = writer.prefix("DryRun");
if let Some(var_4418) = &input.dry_run {
scope_4417.boolean(*var_4418);
}
#[allow(unused_mut)]
let mut scope_4419 = writer.prefix("TransitGatewayRouteTableAnnouncementId");
if let Some(var_4420) = &input.transit_gateway_route_table_announcement_id {
scope_4419.string(var_4420);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_vgw_route_propagation(
input: &crate::input::DisableVgwRoutePropagationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableVgwRoutePropagation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4421 = writer.prefix("GatewayId");
if let Some(var_4422) = &input.gateway_id {
scope_4421.string(var_4422);
}
#[allow(unused_mut)]
let mut scope_4423 = writer.prefix("RouteTableId");
if let Some(var_4424) = &input.route_table_id {
scope_4423.string(var_4424);
}
#[allow(unused_mut)]
let mut scope_4425 = writer.prefix("DryRun");
if let Some(var_4426) = &input.dry_run {
scope_4425.boolean(*var_4426);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_vpc_classic_link(
input: &crate::input::DisableVpcClassicLinkInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableVpcClassicLink", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4427 = writer.prefix("DryRun");
if let Some(var_4428) = &input.dry_run {
scope_4427.boolean(*var_4428);
}
#[allow(unused_mut)]
let mut scope_4429 = writer.prefix("VpcId");
if let Some(var_4430) = &input.vpc_id {
scope_4429.string(var_4430);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_vpc_classic_link_dns_support(
input: &crate::input::DisableVpcClassicLinkDnsSupportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisableVpcClassicLinkDnsSupport",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4431 = writer.prefix("VpcId");
if let Some(var_4432) = &input.vpc_id {
scope_4431.string(var_4432);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_address(
input: &crate::input::DisassociateAddressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisassociateAddress", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4433 = writer.prefix("AssociationId");
if let Some(var_4434) = &input.association_id {
scope_4433.string(var_4434);
}
#[allow(unused_mut)]
let mut scope_4435 = writer.prefix("PublicIp");
if let Some(var_4436) = &input.public_ip {
scope_4435.string(var_4436);
}
#[allow(unused_mut)]
let mut scope_4437 = writer.prefix("DryRun");
if let Some(var_4438) = &input.dry_run {
scope_4437.boolean(*var_4438);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_client_vpn_target_network(
input: &crate::input::DisassociateClientVpnTargetNetworkInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisassociateClientVpnTargetNetwork",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4439 = writer.prefix("ClientVpnEndpointId");
if let Some(var_4440) = &input.client_vpn_endpoint_id {
scope_4439.string(var_4440);
}
#[allow(unused_mut)]
let mut scope_4441 = writer.prefix("AssociationId");
if let Some(var_4442) = &input.association_id {
scope_4441.string(var_4442);
}
#[allow(unused_mut)]
let mut scope_4443 = writer.prefix("DryRun");
if let Some(var_4444) = &input.dry_run {
scope_4443.boolean(*var_4444);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_enclave_certificate_iam_role(
input: &crate::input::DisassociateEnclaveCertificateIamRoleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisassociateEnclaveCertificateIamRole",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4445 = writer.prefix("CertificateArn");
if let Some(var_4446) = &input.certificate_arn {
scope_4445.string(var_4446);
}
#[allow(unused_mut)]
let mut scope_4447 = writer.prefix("RoleArn");
if let Some(var_4448) = &input.role_arn {
scope_4447.string(var_4448);
}
#[allow(unused_mut)]
let mut scope_4449 = writer.prefix("DryRun");
if let Some(var_4450) = &input.dry_run {
scope_4449.boolean(*var_4450);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_iam_instance_profile(
input: &crate::input::DisassociateIamInstanceProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisassociateIamInstanceProfile",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4451 = writer.prefix("AssociationId");
if let Some(var_4452) = &input.association_id {
scope_4451.string(var_4452);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_instance_event_window(
input: &crate::input::DisassociateInstanceEventWindowInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisassociateInstanceEventWindow",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4453 = writer.prefix("DryRun");
if let Some(var_4454) = &input.dry_run {
scope_4453.boolean(*var_4454);
}
#[allow(unused_mut)]
let mut scope_4455 = writer.prefix("InstanceEventWindowId");
if let Some(var_4456) = &input.instance_event_window_id {
scope_4455.string(var_4456);
}
#[allow(unused_mut)]
let mut scope_4457 = writer.prefix("AssociationTarget");
if let Some(var_4458) = &input.association_target {
crate::query_ser::serialize_structure_crate_model_instance_event_window_disassociation_request(scope_4457, var_4458)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_route_table(
input: &crate::input::DisassociateRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisassociateRouteTable", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4459 = writer.prefix("AssociationId");
if let Some(var_4460) = &input.association_id {
scope_4459.string(var_4460);
}
#[allow(unused_mut)]
let mut scope_4461 = writer.prefix("DryRun");
if let Some(var_4462) = &input.dry_run {
scope_4461.boolean(*var_4462);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_subnet_cidr_block(
input: &crate::input::DisassociateSubnetCidrBlockInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisassociateSubnetCidrBlock", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4463 = writer.prefix("AssociationId");
if let Some(var_4464) = &input.association_id {
scope_4463.string(var_4464);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_transit_gateway_multicast_domain(
input: &crate::input::DisassociateTransitGatewayMulticastDomainInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisassociateTransitGatewayMulticastDomain",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4465 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_4466) = &input.transit_gateway_multicast_domain_id {
scope_4465.string(var_4466);
}
#[allow(unused_mut)]
let mut scope_4467 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_4468) = &input.transit_gateway_attachment_id {
scope_4467.string(var_4468);
}
#[allow(unused_mut)]
let mut scope_4469 = writer.prefix("SubnetIds");
if let Some(var_4470) = &input.subnet_ids {
let mut list_4472 = scope_4469.start_list(true, Some("item"));
for item_4471 in var_4470 {
#[allow(unused_mut)]
let mut entry_4473 = list_4472.entry();
entry_4473.string(item_4471);
}
list_4472.finish();
}
#[allow(unused_mut)]
let mut scope_4474 = writer.prefix("DryRun");
if let Some(var_4475) = &input.dry_run {
scope_4474.boolean(*var_4475);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_transit_gateway_policy_table(
input: &crate::input::DisassociateTransitGatewayPolicyTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisassociateTransitGatewayPolicyTable",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4476 = writer.prefix("TransitGatewayPolicyTableId");
if let Some(var_4477) = &input.transit_gateway_policy_table_id {
scope_4476.string(var_4477);
}
#[allow(unused_mut)]
let mut scope_4478 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_4479) = &input.transit_gateway_attachment_id {
scope_4478.string(var_4479);
}
#[allow(unused_mut)]
let mut scope_4480 = writer.prefix("DryRun");
if let Some(var_4481) = &input.dry_run {
scope_4480.boolean(*var_4481);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_transit_gateway_route_table(
input: &crate::input::DisassociateTransitGatewayRouteTableInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DisassociateTransitGatewayRouteTable",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4482 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_4483) = &input.transit_gateway_route_table_id {
scope_4482.string(var_4483);
}
#[allow(unused_mut)]
let mut scope_4484 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_4485) = &input.transit_gateway_attachment_id {
scope_4484.string(var_4485);
}
#[allow(unused_mut)]
let mut scope_4486 = writer.prefix("DryRun");
if let Some(var_4487) = &input.dry_run {
scope_4486.boolean(*var_4487);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_trunk_interface(
input: &crate::input::DisassociateTrunkInterfaceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisassociateTrunkInterface", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4488 = writer.prefix("AssociationId");
if let Some(var_4489) = &input.association_id {
scope_4488.string(var_4489);
}
#[allow(unused_mut)]
let mut scope_4490 = writer.prefix("ClientToken");
if let Some(var_4491) = &input.client_token {
scope_4490.string(var_4491);
}
#[allow(unused_mut)]
let mut scope_4492 = writer.prefix("DryRun");
if let Some(var_4493) = &input.dry_run {
scope_4492.boolean(*var_4493);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_vpc_cidr_block(
input: &crate::input::DisassociateVpcCidrBlockInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisassociateVpcCidrBlock", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4494 = writer.prefix("AssociationId");
if let Some(var_4495) = &input.association_id {
scope_4494.string(var_4495);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_address_transfer(
input: &crate::input::EnableAddressTransferInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableAddressTransfer", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4496 = writer.prefix("AllocationId");
if let Some(var_4497) = &input.allocation_id {
scope_4496.string(var_4497);
}
#[allow(unused_mut)]
let mut scope_4498 = writer.prefix("TransferAccountId");
if let Some(var_4499) = &input.transfer_account_id {
scope_4498.string(var_4499);
}
#[allow(unused_mut)]
let mut scope_4500 = writer.prefix("DryRun");
if let Some(var_4501) = &input.dry_run {
scope_4500.boolean(*var_4501);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_aws_network_performance_metric_subscription(
input: &crate::input::EnableAwsNetworkPerformanceMetricSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"EnableAwsNetworkPerformanceMetricSubscription",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4502 = writer.prefix("Source");
if let Some(var_4503) = &input.source {
scope_4502.string(var_4503);
}
#[allow(unused_mut)]
let mut scope_4504 = writer.prefix("Destination");
if let Some(var_4505) = &input.destination {
scope_4504.string(var_4505);
}
#[allow(unused_mut)]
let mut scope_4506 = writer.prefix("Metric");
if let Some(var_4507) = &input.metric {
scope_4506.string(var_4507.as_str());
}
#[allow(unused_mut)]
let mut scope_4508 = writer.prefix("Statistic");
if let Some(var_4509) = &input.statistic {
scope_4508.string(var_4509.as_str());
}
#[allow(unused_mut)]
let mut scope_4510 = writer.prefix("DryRun");
if let Some(var_4511) = &input.dry_run {
scope_4510.boolean(*var_4511);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_ebs_encryption_by_default(
input: &crate::input::EnableEbsEncryptionByDefaultInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableEbsEncryptionByDefault", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4512 = writer.prefix("DryRun");
if let Some(var_4513) = &input.dry_run {
scope_4512.boolean(*var_4513);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_fast_launch(
input: &crate::input::EnableFastLaunchInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "EnableFastLaunch", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4514 = writer.prefix("ImageId");
if let Some(var_4515) = &input.image_id {
scope_4514.string(var_4515);
}
#[allow(unused_mut)]
let mut scope_4516 = writer.prefix("ResourceType");
if let Some(var_4517) = &input.resource_type {
scope_4516.string(var_4517);
}
#[allow(unused_mut)]
let mut scope_4518 = writer.prefix("SnapshotConfiguration");
if let Some(var_4519) = &input.snapshot_configuration {
crate::query_ser::serialize_structure_crate_model_fast_launch_snapshot_configuration_request(scope_4518, var_4519)?;
}
#[allow(unused_mut)]
let mut scope_4520 = writer.prefix("LaunchTemplate");
if let Some(var_4521) = &input.launch_template {
crate::query_ser::serialize_structure_crate_model_fast_launch_launch_template_specification_request(scope_4520, var_4521)?;
}
#[allow(unused_mut)]
let mut scope_4522 = writer.prefix("MaxParallelLaunches");
if let Some(var_4523) = &input.max_parallel_launches {
scope_4522.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4523).into()),
);
}
#[allow(unused_mut)]
let mut scope_4524 = writer.prefix("DryRun");
if let Some(var_4525) = &input.dry_run {
scope_4524.boolean(*var_4525);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_fast_snapshot_restores(
input: &crate::input::EnableFastSnapshotRestoresInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableFastSnapshotRestores", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4526 = writer.prefix("AvailabilityZone");
if let Some(var_4527) = &input.availability_zones {
let mut list_4529 = scope_4526.start_list(true, Some("AvailabilityZone"));
for item_4528 in var_4527 {
#[allow(unused_mut)]
let mut entry_4530 = list_4529.entry();
entry_4530.string(item_4528);
}
list_4529.finish();
}
#[allow(unused_mut)]
let mut scope_4531 = writer.prefix("SourceSnapshotId");
if let Some(var_4532) = &input.source_snapshot_ids {
let mut list_4534 = scope_4531.start_list(true, Some("SnapshotId"));
for item_4533 in var_4532 {
#[allow(unused_mut)]
let mut entry_4535 = list_4534.entry();
entry_4535.string(item_4533);
}
list_4534.finish();
}
#[allow(unused_mut)]
let mut scope_4536 = writer.prefix("DryRun");
if let Some(var_4537) = &input.dry_run {
scope_4536.boolean(*var_4537);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_image_deprecation(
input: &crate::input::EnableImageDeprecationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableImageDeprecation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4538 = writer.prefix("ImageId");
if let Some(var_4539) = &input.image_id {
scope_4538.string(var_4539);
}
#[allow(unused_mut)]
let mut scope_4540 = writer.prefix("DeprecateAt");
if let Some(var_4541) = &input.deprecate_at {
scope_4540.date_time(var_4541, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_4542 = writer.prefix("DryRun");
if let Some(var_4543) = &input.dry_run {
scope_4542.boolean(*var_4543);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_ipam_organization_admin_account(
input: &crate::input::EnableIpamOrganizationAdminAccountInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"EnableIpamOrganizationAdminAccount",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4544 = writer.prefix("DryRun");
if let Some(var_4545) = &input.dry_run {
scope_4544.boolean(*var_4545);
}
#[allow(unused_mut)]
let mut scope_4546 = writer.prefix("DelegatedAdminAccountId");
if let Some(var_4547) = &input.delegated_admin_account_id {
scope_4546.string(var_4547);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_reachability_analyzer_organization_sharing(
input: &crate::input::EnableReachabilityAnalyzerOrganizationSharingInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"EnableReachabilityAnalyzerOrganizationSharing",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4548 = writer.prefix("DryRun");
if let Some(var_4549) = &input.dry_run {
scope_4548.boolean(*var_4549);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_serial_console_access(
input: &crate::input::EnableSerialConsoleAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableSerialConsoleAccess", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4550 = writer.prefix("DryRun");
if let Some(var_4551) = &input.dry_run {
scope_4550.boolean(*var_4551);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_transit_gateway_route_table_propagation(
input: &crate::input::EnableTransitGatewayRouteTablePropagationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"EnableTransitGatewayRouteTablePropagation",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4552 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_4553) = &input.transit_gateway_route_table_id {
scope_4552.string(var_4553);
}
#[allow(unused_mut)]
let mut scope_4554 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_4555) = &input.transit_gateway_attachment_id {
scope_4554.string(var_4555);
}
#[allow(unused_mut)]
let mut scope_4556 = writer.prefix("DryRun");
if let Some(var_4557) = &input.dry_run {
scope_4556.boolean(*var_4557);
}
#[allow(unused_mut)]
let mut scope_4558 = writer.prefix("TransitGatewayRouteTableAnnouncementId");
if let Some(var_4559) = &input.transit_gateway_route_table_announcement_id {
scope_4558.string(var_4559);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_vgw_route_propagation(
input: &crate::input::EnableVgwRoutePropagationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableVgwRoutePropagation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4560 = writer.prefix("GatewayId");
if let Some(var_4561) = &input.gateway_id {
scope_4560.string(var_4561);
}
#[allow(unused_mut)]
let mut scope_4562 = writer.prefix("RouteTableId");
if let Some(var_4563) = &input.route_table_id {
scope_4562.string(var_4563);
}
#[allow(unused_mut)]
let mut scope_4564 = writer.prefix("DryRun");
if let Some(var_4565) = &input.dry_run {
scope_4564.boolean(*var_4565);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_volume_io(
input: &crate::input::EnableVolumeIoInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "EnableVolumeIO", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4566 = writer.prefix("DryRun");
if let Some(var_4567) = &input.dry_run {
scope_4566.boolean(*var_4567);
}
#[allow(unused_mut)]
let mut scope_4568 = writer.prefix("VolumeId");
if let Some(var_4569) = &input.volume_id {
scope_4568.string(var_4569);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_vpc_classic_link(
input: &crate::input::EnableVpcClassicLinkInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableVpcClassicLink", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4570 = writer.prefix("DryRun");
if let Some(var_4571) = &input.dry_run {
scope_4570.boolean(*var_4571);
}
#[allow(unused_mut)]
let mut scope_4572 = writer.prefix("VpcId");
if let Some(var_4573) = &input.vpc_id {
scope_4572.string(var_4573);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_vpc_classic_link_dns_support(
input: &crate::input::EnableVpcClassicLinkDnsSupportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"EnableVpcClassicLinkDnsSupport",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4574 = writer.prefix("VpcId");
if let Some(var_4575) = &input.vpc_id {
scope_4574.string(var_4575);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_export_client_vpn_client_certificate_revocation_list(
input: &crate::input::ExportClientVpnClientCertificateRevocationListInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ExportClientVpnClientCertificateRevocationList",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4576 = writer.prefix("ClientVpnEndpointId");
if let Some(var_4577) = &input.client_vpn_endpoint_id {
scope_4576.string(var_4577);
}
#[allow(unused_mut)]
let mut scope_4578 = writer.prefix("DryRun");
if let Some(var_4579) = &input.dry_run {
scope_4578.boolean(*var_4579);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_export_client_vpn_client_configuration(
input: &crate::input::ExportClientVpnClientConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ExportClientVpnClientConfiguration",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4580 = writer.prefix("ClientVpnEndpointId");
if let Some(var_4581) = &input.client_vpn_endpoint_id {
scope_4580.string(var_4581);
}
#[allow(unused_mut)]
let mut scope_4582 = writer.prefix("DryRun");
if let Some(var_4583) = &input.dry_run {
scope_4582.boolean(*var_4583);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_export_image(
input: &crate::input::ExportImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ExportImage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4584 = writer.prefix("ClientToken");
if let Some(var_4585) = &input.client_token {
scope_4584.string(var_4585);
}
#[allow(unused_mut)]
let mut scope_4586 = writer.prefix("Description");
if let Some(var_4587) = &input.description {
scope_4586.string(var_4587);
}
#[allow(unused_mut)]
let mut scope_4588 = writer.prefix("DiskImageFormat");
if let Some(var_4589) = &input.disk_image_format {
scope_4588.string(var_4589.as_str());
}
#[allow(unused_mut)]
let mut scope_4590 = writer.prefix("DryRun");
if let Some(var_4591) = &input.dry_run {
scope_4590.boolean(*var_4591);
}
#[allow(unused_mut)]
let mut scope_4592 = writer.prefix("ImageId");
if let Some(var_4593) = &input.image_id {
scope_4592.string(var_4593);
}
#[allow(unused_mut)]
let mut scope_4594 = writer.prefix("S3ExportLocation");
if let Some(var_4595) = &input.s3_export_location {
crate::query_ser::serialize_structure_crate_model_export_task_s3_location_request(
scope_4594, var_4595,
)?;
}
#[allow(unused_mut)]
let mut scope_4596 = writer.prefix("RoleName");
if let Some(var_4597) = &input.role_name {
scope_4596.string(var_4597);
}
#[allow(unused_mut)]
let mut scope_4598 = writer.prefix("TagSpecification");
if let Some(var_4599) = &input.tag_specifications {
let mut list_4601 = scope_4598.start_list(true, Some("item"));
for item_4600 in var_4599 {
#[allow(unused_mut)]
let mut entry_4602 = list_4601.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_4602, item_4600,
)?;
}
list_4601.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_export_transit_gateway_routes(
input: &crate::input::ExportTransitGatewayRoutesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ExportTransitGatewayRoutes", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4603 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_4604) = &input.transit_gateway_route_table_id {
scope_4603.string(var_4604);
}
#[allow(unused_mut)]
let mut scope_4605 = writer.prefix("Filter");
if let Some(var_4606) = &input.filters {
let mut list_4608 = scope_4605.start_list(true, Some("Filter"));
for item_4607 in var_4606 {
#[allow(unused_mut)]
let mut entry_4609 = list_4608.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4609, item_4607)?;
}
list_4608.finish();
}
#[allow(unused_mut)]
let mut scope_4610 = writer.prefix("S3Bucket");
if let Some(var_4611) = &input.s3_bucket {
scope_4610.string(var_4611);
}
#[allow(unused_mut)]
let mut scope_4612 = writer.prefix("DryRun");
if let Some(var_4613) = &input.dry_run {
scope_4612.boolean(*var_4613);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_associated_enclave_certificate_iam_roles(
input: &crate::input::GetAssociatedEnclaveCertificateIamRolesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetAssociatedEnclaveCertificateIamRoles",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4614 = writer.prefix("CertificateArn");
if let Some(var_4615) = &input.certificate_arn {
scope_4614.string(var_4615);
}
#[allow(unused_mut)]
let mut scope_4616 = writer.prefix("DryRun");
if let Some(var_4617) = &input.dry_run {
scope_4616.boolean(*var_4617);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_associated_ipv6_pool_cidrs(
input: &crate::input::GetAssociatedIpv6PoolCidrsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetAssociatedIpv6PoolCidrs", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4618 = writer.prefix("PoolId");
if let Some(var_4619) = &input.pool_id {
scope_4618.string(var_4619);
}
#[allow(unused_mut)]
let mut scope_4620 = writer.prefix("NextToken");
if let Some(var_4621) = &input.next_token {
scope_4620.string(var_4621);
}
#[allow(unused_mut)]
let mut scope_4622 = writer.prefix("MaxResults");
if let Some(var_4623) = &input.max_results {
scope_4622.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4623).into()),
);
}
#[allow(unused_mut)]
let mut scope_4624 = writer.prefix("DryRun");
if let Some(var_4625) = &input.dry_run {
scope_4624.boolean(*var_4625);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_aws_network_performance_data(
input: &crate::input::GetAwsNetworkPerformanceDataInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetAwsNetworkPerformanceData", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4626 = writer.prefix("DataQuery");
if let Some(var_4627) = &input.data_queries {
let mut list_4629 = scope_4626.start_list(true, None);
for item_4628 in var_4627 {
#[allow(unused_mut)]
let mut entry_4630 = list_4629.entry();
crate::query_ser::serialize_structure_crate_model_data_query(entry_4630, item_4628)?;
}
list_4629.finish();
}
#[allow(unused_mut)]
let mut scope_4631 = writer.prefix("StartTime");
if let Some(var_4632) = &input.start_time {
scope_4631.date_time(var_4632, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_4633 = writer.prefix("EndTime");
if let Some(var_4634) = &input.end_time {
scope_4633.date_time(var_4634, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_4635 = writer.prefix("MaxResults");
if let Some(var_4636) = &input.max_results {
scope_4635.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4636).into()),
);
}
#[allow(unused_mut)]
let mut scope_4637 = writer.prefix("NextToken");
if let Some(var_4638) = &input.next_token {
scope_4637.string(var_4638);
}
#[allow(unused_mut)]
let mut scope_4639 = writer.prefix("DryRun");
if let Some(var_4640) = &input.dry_run {
scope_4639.boolean(*var_4640);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_capacity_reservation_usage(
input: &crate::input::GetCapacityReservationUsageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetCapacityReservationUsage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4641 = writer.prefix("CapacityReservationId");
if let Some(var_4642) = &input.capacity_reservation_id {
scope_4641.string(var_4642);
}
#[allow(unused_mut)]
let mut scope_4643 = writer.prefix("NextToken");
if let Some(var_4644) = &input.next_token {
scope_4643.string(var_4644);
}
#[allow(unused_mut)]
let mut scope_4645 = writer.prefix("MaxResults");
if let Some(var_4646) = &input.max_results {
scope_4645.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4646).into()),
);
}
#[allow(unused_mut)]
let mut scope_4647 = writer.prefix("DryRun");
if let Some(var_4648) = &input.dry_run {
scope_4647.boolean(*var_4648);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_coip_pool_usage(
input: &crate::input::GetCoipPoolUsageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetCoipPoolUsage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4649 = writer.prefix("PoolId");
if let Some(var_4650) = &input.pool_id {
scope_4649.string(var_4650);
}
#[allow(unused_mut)]
let mut scope_4651 = writer.prefix("Filter");
if let Some(var_4652) = &input.filters {
let mut list_4654 = scope_4651.start_list(true, Some("Filter"));
for item_4653 in var_4652 {
#[allow(unused_mut)]
let mut entry_4655 = list_4654.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4655, item_4653)?;
}
list_4654.finish();
}
#[allow(unused_mut)]
let mut scope_4656 = writer.prefix("MaxResults");
if let Some(var_4657) = &input.max_results {
scope_4656.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4657).into()),
);
}
#[allow(unused_mut)]
let mut scope_4658 = writer.prefix("NextToken");
if let Some(var_4659) = &input.next_token {
scope_4658.string(var_4659);
}
#[allow(unused_mut)]
let mut scope_4660 = writer.prefix("DryRun");
if let Some(var_4661) = &input.dry_run {
scope_4660.boolean(*var_4661);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_console_output(
input: &crate::input::GetConsoleOutputInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetConsoleOutput", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4662 = writer.prefix("InstanceId");
if let Some(var_4663) = &input.instance_id {
scope_4662.string(var_4663);
}
#[allow(unused_mut)]
let mut scope_4664 = writer.prefix("DryRun");
if let Some(var_4665) = &input.dry_run {
scope_4664.boolean(*var_4665);
}
#[allow(unused_mut)]
let mut scope_4666 = writer.prefix("Latest");
if let Some(var_4667) = &input.latest {
scope_4666.boolean(*var_4667);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_console_screenshot(
input: &crate::input::GetConsoleScreenshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetConsoleScreenshot", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4668 = writer.prefix("DryRun");
if let Some(var_4669) = &input.dry_run {
scope_4668.boolean(*var_4669);
}
#[allow(unused_mut)]
let mut scope_4670 = writer.prefix("InstanceId");
if let Some(var_4671) = &input.instance_id {
scope_4670.string(var_4671);
}
#[allow(unused_mut)]
let mut scope_4672 = writer.prefix("WakeUp");
if let Some(var_4673) = &input.wake_up {
scope_4672.boolean(*var_4673);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_default_credit_specification(
input: &crate::input::GetDefaultCreditSpecificationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetDefaultCreditSpecification", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4674 = writer.prefix("DryRun");
if let Some(var_4675) = &input.dry_run {
scope_4674.boolean(*var_4675);
}
#[allow(unused_mut)]
let mut scope_4676 = writer.prefix("InstanceFamily");
if let Some(var_4677) = &input.instance_family {
scope_4676.string(var_4677.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_ebs_default_kms_key_id(
input: &crate::input::GetEbsDefaultKmsKeyIdInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetEbsDefaultKmsKeyId", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4678 = writer.prefix("DryRun");
if let Some(var_4679) = &input.dry_run {
scope_4678.boolean(*var_4679);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_ebs_encryption_by_default(
input: &crate::input::GetEbsEncryptionByDefaultInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetEbsEncryptionByDefault", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4680 = writer.prefix("DryRun");
if let Some(var_4681) = &input.dry_run {
scope_4680.boolean(*var_4681);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_flow_logs_integration_template(
input: &crate::input::GetFlowLogsIntegrationTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetFlowLogsIntegrationTemplate",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4682 = writer.prefix("DryRun");
if let Some(var_4683) = &input.dry_run {
scope_4682.boolean(*var_4683);
}
#[allow(unused_mut)]
let mut scope_4684 = writer.prefix("FlowLogId");
if let Some(var_4685) = &input.flow_log_id {
scope_4684.string(var_4685);
}
#[allow(unused_mut)]
let mut scope_4686 = writer.prefix("ConfigDeliveryS3DestinationArn");
if let Some(var_4687) = &input.config_delivery_s3_destination_arn {
scope_4686.string(var_4687);
}
#[allow(unused_mut)]
let mut scope_4688 = writer.prefix("IntegrateService");
if let Some(var_4689) = &input.integrate_services {
crate::query_ser::serialize_structure_crate_model_integrate_services(scope_4688, var_4689)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_groups_for_capacity_reservation(
input: &crate::input::GetGroupsForCapacityReservationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetGroupsForCapacityReservation",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4690 = writer.prefix("CapacityReservationId");
if let Some(var_4691) = &input.capacity_reservation_id {
scope_4690.string(var_4691);
}
#[allow(unused_mut)]
let mut scope_4692 = writer.prefix("NextToken");
if let Some(var_4693) = &input.next_token {
scope_4692.string(var_4693);
}
#[allow(unused_mut)]
let mut scope_4694 = writer.prefix("MaxResults");
if let Some(var_4695) = &input.max_results {
scope_4694.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4695).into()),
);
}
#[allow(unused_mut)]
let mut scope_4696 = writer.prefix("DryRun");
if let Some(var_4697) = &input.dry_run {
scope_4696.boolean(*var_4697);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_host_reservation_purchase_preview(
input: &crate::input::GetHostReservationPurchasePreviewInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetHostReservationPurchasePreview",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4698 = writer.prefix("HostIdSet");
if let Some(var_4699) = &input.host_id_set {
let mut list_4701 = scope_4698.start_list(true, Some("item"));
for item_4700 in var_4699 {
#[allow(unused_mut)]
let mut entry_4702 = list_4701.entry();
entry_4702.string(item_4700);
}
list_4701.finish();
}
#[allow(unused_mut)]
let mut scope_4703 = writer.prefix("OfferingId");
if let Some(var_4704) = &input.offering_id {
scope_4703.string(var_4704);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_instance_types_from_instance_requirements(
input: &crate::input::GetInstanceTypesFromInstanceRequirementsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetInstanceTypesFromInstanceRequirements",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4705 = writer.prefix("DryRun");
if let Some(var_4706) = &input.dry_run {
scope_4705.boolean(*var_4706);
}
#[allow(unused_mut)]
let mut scope_4707 = writer.prefix("ArchitectureType");
if let Some(var_4708) = &input.architecture_types {
let mut list_4710 = scope_4707.start_list(true, Some("item"));
for item_4709 in var_4708 {
#[allow(unused_mut)]
let mut entry_4711 = list_4710.entry();
entry_4711.string(item_4709.as_str());
}
list_4710.finish();
}
#[allow(unused_mut)]
let mut scope_4712 = writer.prefix("VirtualizationType");
if let Some(var_4713) = &input.virtualization_types {
let mut list_4715 = scope_4712.start_list(true, Some("item"));
for item_4714 in var_4713 {
#[allow(unused_mut)]
let mut entry_4716 = list_4715.entry();
entry_4716.string(item_4714.as_str());
}
list_4715.finish();
}
#[allow(unused_mut)]
let mut scope_4717 = writer.prefix("InstanceRequirements");
if let Some(var_4718) = &input.instance_requirements {
crate::query_ser::serialize_structure_crate_model_instance_requirements_request(
scope_4717, var_4718,
)?;
}
#[allow(unused_mut)]
let mut scope_4719 = writer.prefix("MaxResults");
if let Some(var_4720) = &input.max_results {
scope_4719.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4720).into()),
);
}
#[allow(unused_mut)]
let mut scope_4721 = writer.prefix("NextToken");
if let Some(var_4722) = &input.next_token {
scope_4721.string(var_4722);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_instance_uefi_data(
input: &crate::input::GetInstanceUefiDataInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetInstanceUefiData", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4723 = writer.prefix("InstanceId");
if let Some(var_4724) = &input.instance_id {
scope_4723.string(var_4724);
}
#[allow(unused_mut)]
let mut scope_4725 = writer.prefix("DryRun");
if let Some(var_4726) = &input.dry_run {
scope_4725.boolean(*var_4726);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_ipam_address_history(
input: &crate::input::GetIpamAddressHistoryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetIpamAddressHistory", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4727 = writer.prefix("DryRun");
if let Some(var_4728) = &input.dry_run {
scope_4727.boolean(*var_4728);
}
#[allow(unused_mut)]
let mut scope_4729 = writer.prefix("Cidr");
if let Some(var_4730) = &input.cidr {
scope_4729.string(var_4730);
}
#[allow(unused_mut)]
let mut scope_4731 = writer.prefix("IpamScopeId");
if let Some(var_4732) = &input.ipam_scope_id {
scope_4731.string(var_4732);
}
#[allow(unused_mut)]
let mut scope_4733 = writer.prefix("VpcId");
if let Some(var_4734) = &input.vpc_id {
scope_4733.string(var_4734);
}
#[allow(unused_mut)]
let mut scope_4735 = writer.prefix("StartTime");
if let Some(var_4736) = &input.start_time {
scope_4735.date_time(var_4736, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_4737 = writer.prefix("EndTime");
if let Some(var_4738) = &input.end_time {
scope_4737.date_time(var_4738, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_4739 = writer.prefix("MaxResults");
if let Some(var_4740) = &input.max_results {
scope_4739.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4740).into()),
);
}
#[allow(unused_mut)]
let mut scope_4741 = writer.prefix("NextToken");
if let Some(var_4742) = &input.next_token {
scope_4741.string(var_4742);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_ipam_pool_allocations(
input: &crate::input::GetIpamPoolAllocationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetIpamPoolAllocations", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4743 = writer.prefix("DryRun");
if let Some(var_4744) = &input.dry_run {
scope_4743.boolean(*var_4744);
}
#[allow(unused_mut)]
let mut scope_4745 = writer.prefix("IpamPoolId");
if let Some(var_4746) = &input.ipam_pool_id {
scope_4745.string(var_4746);
}
#[allow(unused_mut)]
let mut scope_4747 = writer.prefix("IpamPoolAllocationId");
if let Some(var_4748) = &input.ipam_pool_allocation_id {
scope_4747.string(var_4748);
}
#[allow(unused_mut)]
let mut scope_4749 = writer.prefix("Filter");
if let Some(var_4750) = &input.filters {
let mut list_4752 = scope_4749.start_list(true, Some("Filter"));
for item_4751 in var_4750 {
#[allow(unused_mut)]
let mut entry_4753 = list_4752.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4753, item_4751)?;
}
list_4752.finish();
}
#[allow(unused_mut)]
let mut scope_4754 = writer.prefix("MaxResults");
if let Some(var_4755) = &input.max_results {
scope_4754.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4755).into()),
);
}
#[allow(unused_mut)]
let mut scope_4756 = writer.prefix("NextToken");
if let Some(var_4757) = &input.next_token {
scope_4756.string(var_4757);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_ipam_pool_cidrs(
input: &crate::input::GetIpamPoolCidrsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetIpamPoolCidrs", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4758 = writer.prefix("DryRun");
if let Some(var_4759) = &input.dry_run {
scope_4758.boolean(*var_4759);
}
#[allow(unused_mut)]
let mut scope_4760 = writer.prefix("IpamPoolId");
if let Some(var_4761) = &input.ipam_pool_id {
scope_4760.string(var_4761);
}
#[allow(unused_mut)]
let mut scope_4762 = writer.prefix("Filter");
if let Some(var_4763) = &input.filters {
let mut list_4765 = scope_4762.start_list(true, Some("Filter"));
for item_4764 in var_4763 {
#[allow(unused_mut)]
let mut entry_4766 = list_4765.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4766, item_4764)?;
}
list_4765.finish();
}
#[allow(unused_mut)]
let mut scope_4767 = writer.prefix("MaxResults");
if let Some(var_4768) = &input.max_results {
scope_4767.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4768).into()),
);
}
#[allow(unused_mut)]
let mut scope_4769 = writer.prefix("NextToken");
if let Some(var_4770) = &input.next_token {
scope_4769.string(var_4770);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_ipam_resource_cidrs(
input: &crate::input::GetIpamResourceCidrsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetIpamResourceCidrs", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4771 = writer.prefix("DryRun");
if let Some(var_4772) = &input.dry_run {
scope_4771.boolean(*var_4772);
}
#[allow(unused_mut)]
let mut scope_4773 = writer.prefix("Filter");
if let Some(var_4774) = &input.filters {
let mut list_4776 = scope_4773.start_list(true, Some("Filter"));
for item_4775 in var_4774 {
#[allow(unused_mut)]
let mut entry_4777 = list_4776.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4777, item_4775)?;
}
list_4776.finish();
}
#[allow(unused_mut)]
let mut scope_4778 = writer.prefix("MaxResults");
if let Some(var_4779) = &input.max_results {
scope_4778.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4779).into()),
);
}
#[allow(unused_mut)]
let mut scope_4780 = writer.prefix("NextToken");
if let Some(var_4781) = &input.next_token {
scope_4780.string(var_4781);
}
#[allow(unused_mut)]
let mut scope_4782 = writer.prefix("IpamScopeId");
if let Some(var_4783) = &input.ipam_scope_id {
scope_4782.string(var_4783);
}
#[allow(unused_mut)]
let mut scope_4784 = writer.prefix("IpamPoolId");
if let Some(var_4785) = &input.ipam_pool_id {
scope_4784.string(var_4785);
}
#[allow(unused_mut)]
let mut scope_4786 = writer.prefix("ResourceId");
if let Some(var_4787) = &input.resource_id {
scope_4786.string(var_4787);
}
#[allow(unused_mut)]
let mut scope_4788 = writer.prefix("ResourceType");
if let Some(var_4789) = &input.resource_type {
scope_4788.string(var_4789.as_str());
}
#[allow(unused_mut)]
let mut scope_4790 = writer.prefix("ResourceTag");
if let Some(var_4791) = &input.resource_tag {
crate::query_ser::serialize_structure_crate_model_request_ipam_resource_tag(
scope_4790, var_4791,
)?;
}
#[allow(unused_mut)]
let mut scope_4792 = writer.prefix("ResourceOwner");
if let Some(var_4793) = &input.resource_owner {
scope_4792.string(var_4793);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_launch_template_data(
input: &crate::input::GetLaunchTemplateDataInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetLaunchTemplateData", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4794 = writer.prefix("DryRun");
if let Some(var_4795) = &input.dry_run {
scope_4794.boolean(*var_4795);
}
#[allow(unused_mut)]
let mut scope_4796 = writer.prefix("InstanceId");
if let Some(var_4797) = &input.instance_id {
scope_4796.string(var_4797);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_managed_prefix_list_associations(
input: &crate::input::GetManagedPrefixListAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetManagedPrefixListAssociations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4798 = writer.prefix("DryRun");
if let Some(var_4799) = &input.dry_run {
scope_4798.boolean(*var_4799);
}
#[allow(unused_mut)]
let mut scope_4800 = writer.prefix("PrefixListId");
if let Some(var_4801) = &input.prefix_list_id {
scope_4800.string(var_4801);
}
#[allow(unused_mut)]
let mut scope_4802 = writer.prefix("MaxResults");
if let Some(var_4803) = &input.max_results {
scope_4802.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4803).into()),
);
}
#[allow(unused_mut)]
let mut scope_4804 = writer.prefix("NextToken");
if let Some(var_4805) = &input.next_token {
scope_4804.string(var_4805);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_managed_prefix_list_entries(
input: &crate::input::GetManagedPrefixListEntriesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetManagedPrefixListEntries", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4806 = writer.prefix("DryRun");
if let Some(var_4807) = &input.dry_run {
scope_4806.boolean(*var_4807);
}
#[allow(unused_mut)]
let mut scope_4808 = writer.prefix("PrefixListId");
if let Some(var_4809) = &input.prefix_list_id {
scope_4808.string(var_4809);
}
#[allow(unused_mut)]
let mut scope_4810 = writer.prefix("TargetVersion");
if let Some(var_4811) = &input.target_version {
scope_4810.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4811).into()),
);
}
#[allow(unused_mut)]
let mut scope_4812 = writer.prefix("MaxResults");
if let Some(var_4813) = &input.max_results {
scope_4812.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4813).into()),
);
}
#[allow(unused_mut)]
let mut scope_4814 = writer.prefix("NextToken");
if let Some(var_4815) = &input.next_token {
scope_4814.string(var_4815);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_network_insights_access_scope_analysis_findings(
input: &crate::input::GetNetworkInsightsAccessScopeAnalysisFindingsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetNetworkInsightsAccessScopeAnalysisFindings",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4816 = writer.prefix("NetworkInsightsAccessScopeAnalysisId");
if let Some(var_4817) = &input.network_insights_access_scope_analysis_id {
scope_4816.string(var_4817);
}
#[allow(unused_mut)]
let mut scope_4818 = writer.prefix("MaxResults");
if let Some(var_4819) = &input.max_results {
scope_4818.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4819).into()),
);
}
#[allow(unused_mut)]
let mut scope_4820 = writer.prefix("NextToken");
if let Some(var_4821) = &input.next_token {
scope_4820.string(var_4821);
}
#[allow(unused_mut)]
let mut scope_4822 = writer.prefix("DryRun");
if let Some(var_4823) = &input.dry_run {
scope_4822.boolean(*var_4823);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_network_insights_access_scope_content(
input: &crate::input::GetNetworkInsightsAccessScopeContentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetNetworkInsightsAccessScopeContent",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4824 = writer.prefix("NetworkInsightsAccessScopeId");
if let Some(var_4825) = &input.network_insights_access_scope_id {
scope_4824.string(var_4825);
}
#[allow(unused_mut)]
let mut scope_4826 = writer.prefix("DryRun");
if let Some(var_4827) = &input.dry_run {
scope_4826.boolean(*var_4827);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_password_data(
input: &crate::input::GetPasswordDataInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetPasswordData", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4828 = writer.prefix("InstanceId");
if let Some(var_4829) = &input.instance_id {
scope_4828.string(var_4829);
}
#[allow(unused_mut)]
let mut scope_4830 = writer.prefix("DryRun");
if let Some(var_4831) = &input.dry_run {
scope_4830.boolean(*var_4831);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_reserved_instances_exchange_quote(
input: &crate::input::GetReservedInstancesExchangeQuoteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetReservedInstancesExchangeQuote",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4832 = writer.prefix("DryRun");
if let Some(var_4833) = &input.dry_run {
scope_4832.boolean(*var_4833);
}
#[allow(unused_mut)]
let mut scope_4834 = writer.prefix("ReservedInstanceId");
if let Some(var_4835) = &input.reserved_instance_ids {
let mut list_4837 = scope_4834.start_list(true, Some("ReservedInstanceId"));
for item_4836 in var_4835 {
#[allow(unused_mut)]
let mut entry_4838 = list_4837.entry();
entry_4838.string(item_4836);
}
list_4837.finish();
}
#[allow(unused_mut)]
let mut scope_4839 = writer.prefix("TargetConfiguration");
if let Some(var_4840) = &input.target_configurations {
let mut list_4842 = scope_4839.start_list(true, Some("TargetConfigurationRequest"));
for item_4841 in var_4840 {
#[allow(unused_mut)]
let mut entry_4843 = list_4842.entry();
crate::query_ser::serialize_structure_crate_model_target_configuration_request(
entry_4843, item_4841,
)?;
}
list_4842.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_serial_console_access_status(
input: &crate::input::GetSerialConsoleAccessStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetSerialConsoleAccessStatus", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4844 = writer.prefix("DryRun");
if let Some(var_4845) = &input.dry_run {
scope_4844.boolean(*var_4845);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_spot_placement_scores(
input: &crate::input::GetSpotPlacementScoresInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetSpotPlacementScores", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4846 = writer.prefix("InstanceType");
if let Some(var_4847) = &input.instance_types {
let mut list_4849 = scope_4846.start_list(true, None);
for item_4848 in var_4847 {
#[allow(unused_mut)]
let mut entry_4850 = list_4849.entry();
entry_4850.string(item_4848);
}
list_4849.finish();
}
#[allow(unused_mut)]
let mut scope_4851 = writer.prefix("TargetCapacity");
if let Some(var_4852) = &input.target_capacity {
scope_4851.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4852).into()),
);
}
#[allow(unused_mut)]
let mut scope_4853 = writer.prefix("TargetCapacityUnitType");
if let Some(var_4854) = &input.target_capacity_unit_type {
scope_4853.string(var_4854.as_str());
}
#[allow(unused_mut)]
let mut scope_4855 = writer.prefix("SingleAvailabilityZone");
if let Some(var_4856) = &input.single_availability_zone {
scope_4855.boolean(*var_4856);
}
#[allow(unused_mut)]
let mut scope_4857 = writer.prefix("RegionName");
if let Some(var_4858) = &input.region_names {
let mut list_4860 = scope_4857.start_list(true, None);
for item_4859 in var_4858 {
#[allow(unused_mut)]
let mut entry_4861 = list_4860.entry();
entry_4861.string(item_4859);
}
list_4860.finish();
}
#[allow(unused_mut)]
let mut scope_4862 = writer.prefix("InstanceRequirementsWithMetadata");
if let Some(var_4863) = &input.instance_requirements_with_metadata {
crate::query_ser::serialize_structure_crate_model_instance_requirements_with_metadata_request(scope_4862, var_4863)?;
}
#[allow(unused_mut)]
let mut scope_4864 = writer.prefix("DryRun");
if let Some(var_4865) = &input.dry_run {
scope_4864.boolean(*var_4865);
}
#[allow(unused_mut)]
let mut scope_4866 = writer.prefix("MaxResults");
if let Some(var_4867) = &input.max_results {
scope_4866.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4867).into()),
);
}
#[allow(unused_mut)]
let mut scope_4868 = writer.prefix("NextToken");
if let Some(var_4869) = &input.next_token {
scope_4868.string(var_4869);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_subnet_cidr_reservations(
input: &crate::input::GetSubnetCidrReservationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetSubnetCidrReservations", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4870 = writer.prefix("Filter");
if let Some(var_4871) = &input.filters {
let mut list_4873 = scope_4870.start_list(true, Some("Filter"));
for item_4872 in var_4871 {
#[allow(unused_mut)]
let mut entry_4874 = list_4873.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4874, item_4872)?;
}
list_4873.finish();
}
#[allow(unused_mut)]
let mut scope_4875 = writer.prefix("SubnetId");
if let Some(var_4876) = &input.subnet_id {
scope_4875.string(var_4876);
}
#[allow(unused_mut)]
let mut scope_4877 = writer.prefix("DryRun");
if let Some(var_4878) = &input.dry_run {
scope_4877.boolean(*var_4878);
}
#[allow(unused_mut)]
let mut scope_4879 = writer.prefix("NextToken");
if let Some(var_4880) = &input.next_token {
scope_4879.string(var_4880);
}
#[allow(unused_mut)]
let mut scope_4881 = writer.prefix("MaxResults");
if let Some(var_4882) = &input.max_results {
scope_4881.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4882).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_transit_gateway_attachment_propagations(
input: &crate::input::GetTransitGatewayAttachmentPropagationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetTransitGatewayAttachmentPropagations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4883 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_4884) = &input.transit_gateway_attachment_id {
scope_4883.string(var_4884);
}
#[allow(unused_mut)]
let mut scope_4885 = writer.prefix("Filter");
if let Some(var_4886) = &input.filters {
let mut list_4888 = scope_4885.start_list(true, Some("Filter"));
for item_4887 in var_4886 {
#[allow(unused_mut)]
let mut entry_4889 = list_4888.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4889, item_4887)?;
}
list_4888.finish();
}
#[allow(unused_mut)]
let mut scope_4890 = writer.prefix("MaxResults");
if let Some(var_4891) = &input.max_results {
scope_4890.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4891).into()),
);
}
#[allow(unused_mut)]
let mut scope_4892 = writer.prefix("NextToken");
if let Some(var_4893) = &input.next_token {
scope_4892.string(var_4893);
}
#[allow(unused_mut)]
let mut scope_4894 = writer.prefix("DryRun");
if let Some(var_4895) = &input.dry_run {
scope_4894.boolean(*var_4895);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_transit_gateway_multicast_domain_associations(
input: &crate::input::GetTransitGatewayMulticastDomainAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetTransitGatewayMulticastDomainAssociations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4896 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_4897) = &input.transit_gateway_multicast_domain_id {
scope_4896.string(var_4897);
}
#[allow(unused_mut)]
let mut scope_4898 = writer.prefix("Filter");
if let Some(var_4899) = &input.filters {
let mut list_4901 = scope_4898.start_list(true, Some("Filter"));
for item_4900 in var_4899 {
#[allow(unused_mut)]
let mut entry_4902 = list_4901.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4902, item_4900)?;
}
list_4901.finish();
}
#[allow(unused_mut)]
let mut scope_4903 = writer.prefix("MaxResults");
if let Some(var_4904) = &input.max_results {
scope_4903.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4904).into()),
);
}
#[allow(unused_mut)]
let mut scope_4905 = writer.prefix("NextToken");
if let Some(var_4906) = &input.next_token {
scope_4905.string(var_4906);
}
#[allow(unused_mut)]
let mut scope_4907 = writer.prefix("DryRun");
if let Some(var_4908) = &input.dry_run {
scope_4907.boolean(*var_4908);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_transit_gateway_policy_table_associations(
input: &crate::input::GetTransitGatewayPolicyTableAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetTransitGatewayPolicyTableAssociations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4909 = writer.prefix("TransitGatewayPolicyTableId");
if let Some(var_4910) = &input.transit_gateway_policy_table_id {
scope_4909.string(var_4910);
}
#[allow(unused_mut)]
let mut scope_4911 = writer.prefix("Filter");
if let Some(var_4912) = &input.filters {
let mut list_4914 = scope_4911.start_list(true, Some("Filter"));
for item_4913 in var_4912 {
#[allow(unused_mut)]
let mut entry_4915 = list_4914.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4915, item_4913)?;
}
list_4914.finish();
}
#[allow(unused_mut)]
let mut scope_4916 = writer.prefix("MaxResults");
if let Some(var_4917) = &input.max_results {
scope_4916.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4917).into()),
);
}
#[allow(unused_mut)]
let mut scope_4918 = writer.prefix("NextToken");
if let Some(var_4919) = &input.next_token {
scope_4918.string(var_4919);
}
#[allow(unused_mut)]
let mut scope_4920 = writer.prefix("DryRun");
if let Some(var_4921) = &input.dry_run {
scope_4920.boolean(*var_4921);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_transit_gateway_policy_table_entries(
input: &crate::input::GetTransitGatewayPolicyTableEntriesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetTransitGatewayPolicyTableEntries",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4922 = writer.prefix("TransitGatewayPolicyTableId");
if let Some(var_4923) = &input.transit_gateway_policy_table_id {
scope_4922.string(var_4923);
}
#[allow(unused_mut)]
let mut scope_4924 = writer.prefix("Filter");
if let Some(var_4925) = &input.filters {
let mut list_4927 = scope_4924.start_list(true, Some("Filter"));
for item_4926 in var_4925 {
#[allow(unused_mut)]
let mut entry_4928 = list_4927.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4928, item_4926)?;
}
list_4927.finish();
}
#[allow(unused_mut)]
let mut scope_4929 = writer.prefix("MaxResults");
if let Some(var_4930) = &input.max_results {
scope_4929.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4930).into()),
);
}
#[allow(unused_mut)]
let mut scope_4931 = writer.prefix("NextToken");
if let Some(var_4932) = &input.next_token {
scope_4931.string(var_4932);
}
#[allow(unused_mut)]
let mut scope_4933 = writer.prefix("DryRun");
if let Some(var_4934) = &input.dry_run {
scope_4933.boolean(*var_4934);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_transit_gateway_prefix_list_references(
input: &crate::input::GetTransitGatewayPrefixListReferencesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetTransitGatewayPrefixListReferences",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4935 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_4936) = &input.transit_gateway_route_table_id {
scope_4935.string(var_4936);
}
#[allow(unused_mut)]
let mut scope_4937 = writer.prefix("Filter");
if let Some(var_4938) = &input.filters {
let mut list_4940 = scope_4937.start_list(true, Some("Filter"));
for item_4939 in var_4938 {
#[allow(unused_mut)]
let mut entry_4941 = list_4940.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4941, item_4939)?;
}
list_4940.finish();
}
#[allow(unused_mut)]
let mut scope_4942 = writer.prefix("MaxResults");
if let Some(var_4943) = &input.max_results {
scope_4942.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4943).into()),
);
}
#[allow(unused_mut)]
let mut scope_4944 = writer.prefix("NextToken");
if let Some(var_4945) = &input.next_token {
scope_4944.string(var_4945);
}
#[allow(unused_mut)]
let mut scope_4946 = writer.prefix("DryRun");
if let Some(var_4947) = &input.dry_run {
scope_4946.boolean(*var_4947);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_transit_gateway_route_table_associations(
input: &crate::input::GetTransitGatewayRouteTableAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetTransitGatewayRouteTableAssociations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4948 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_4949) = &input.transit_gateway_route_table_id {
scope_4948.string(var_4949);
}
#[allow(unused_mut)]
let mut scope_4950 = writer.prefix("Filter");
if let Some(var_4951) = &input.filters {
let mut list_4953 = scope_4950.start_list(true, Some("Filter"));
for item_4952 in var_4951 {
#[allow(unused_mut)]
let mut entry_4954 = list_4953.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4954, item_4952)?;
}
list_4953.finish();
}
#[allow(unused_mut)]
let mut scope_4955 = writer.prefix("MaxResults");
if let Some(var_4956) = &input.max_results {
scope_4955.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4956).into()),
);
}
#[allow(unused_mut)]
let mut scope_4957 = writer.prefix("NextToken");
if let Some(var_4958) = &input.next_token {
scope_4957.string(var_4958);
}
#[allow(unused_mut)]
let mut scope_4959 = writer.prefix("DryRun");
if let Some(var_4960) = &input.dry_run {
scope_4959.boolean(*var_4960);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_transit_gateway_route_table_propagations(
input: &crate::input::GetTransitGatewayRouteTablePropagationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetTransitGatewayRouteTablePropagations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4961 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_4962) = &input.transit_gateway_route_table_id {
scope_4961.string(var_4962);
}
#[allow(unused_mut)]
let mut scope_4963 = writer.prefix("Filter");
if let Some(var_4964) = &input.filters {
let mut list_4966 = scope_4963.start_list(true, Some("Filter"));
for item_4965 in var_4964 {
#[allow(unused_mut)]
let mut entry_4967 = list_4966.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_4967, item_4965)?;
}
list_4966.finish();
}
#[allow(unused_mut)]
let mut scope_4968 = writer.prefix("MaxResults");
if let Some(var_4969) = &input.max_results {
scope_4968.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4969).into()),
);
}
#[allow(unused_mut)]
let mut scope_4970 = writer.prefix("NextToken");
if let Some(var_4971) = &input.next_token {
scope_4970.string(var_4971);
}
#[allow(unused_mut)]
let mut scope_4972 = writer.prefix("DryRun");
if let Some(var_4973) = &input.dry_run {
scope_4972.boolean(*var_4973);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_verified_access_endpoint_policy(
input: &crate::input::GetVerifiedAccessEndpointPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetVerifiedAccessEndpointPolicy",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4974 = writer.prefix("VerifiedAccessEndpointId");
if let Some(var_4975) = &input.verified_access_endpoint_id {
scope_4974.string(var_4975);
}
#[allow(unused_mut)]
let mut scope_4976 = writer.prefix("DryRun");
if let Some(var_4977) = &input.dry_run {
scope_4976.boolean(*var_4977);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_verified_access_group_policy(
input: &crate::input::GetVerifiedAccessGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetVerifiedAccessGroupPolicy", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4978 = writer.prefix("VerifiedAccessGroupId");
if let Some(var_4979) = &input.verified_access_group_id {
scope_4978.string(var_4979);
}
#[allow(unused_mut)]
let mut scope_4980 = writer.prefix("DryRun");
if let Some(var_4981) = &input.dry_run {
scope_4980.boolean(*var_4981);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_vpn_connection_device_sample_configuration(
input: &crate::input::GetVpnConnectionDeviceSampleConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetVpnConnectionDeviceSampleConfiguration",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4982 = writer.prefix("VpnConnectionId");
if let Some(var_4983) = &input.vpn_connection_id {
scope_4982.string(var_4983);
}
#[allow(unused_mut)]
let mut scope_4984 = writer.prefix("VpnConnectionDeviceTypeId");
if let Some(var_4985) = &input.vpn_connection_device_type_id {
scope_4984.string(var_4985);
}
#[allow(unused_mut)]
let mut scope_4986 = writer.prefix("InternetKeyExchangeVersion");
if let Some(var_4987) = &input.internet_key_exchange_version {
scope_4986.string(var_4987);
}
#[allow(unused_mut)]
let mut scope_4988 = writer.prefix("DryRun");
if let Some(var_4989) = &input.dry_run {
scope_4988.boolean(*var_4989);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_vpn_connection_device_types(
input: &crate::input::GetVpnConnectionDeviceTypesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetVpnConnectionDeviceTypes", "2016-11-15");
#[allow(unused_mut)]
let mut scope_4990 = writer.prefix("MaxResults");
if let Some(var_4991) = &input.max_results {
scope_4990.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4991).into()),
);
}
#[allow(unused_mut)]
let mut scope_4992 = writer.prefix("NextToken");
if let Some(var_4993) = &input.next_token {
scope_4992.string(var_4993);
}
#[allow(unused_mut)]
let mut scope_4994 = writer.prefix("DryRun");
if let Some(var_4995) = &input.dry_run {
scope_4994.boolean(*var_4995);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_import_client_vpn_client_certificate_revocation_list(
input: &crate::input::ImportClientVpnClientCertificateRevocationListInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ImportClientVpnClientCertificateRevocationList",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_4996 = writer.prefix("ClientVpnEndpointId");
if let Some(var_4997) = &input.client_vpn_endpoint_id {
scope_4996.string(var_4997);
}
#[allow(unused_mut)]
let mut scope_4998 = writer.prefix("CertificateRevocationList");
if let Some(var_4999) = &input.certificate_revocation_list {
scope_4998.string(var_4999);
}
#[allow(unused_mut)]
let mut scope_5000 = writer.prefix("DryRun");
if let Some(var_5001) = &input.dry_run {
scope_5000.boolean(*var_5001);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_import_image(
input: &crate::input::ImportImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ImportImage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5002 = writer.prefix("Architecture");
if let Some(var_5003) = &input.architecture {
scope_5002.string(var_5003);
}
#[allow(unused_mut)]
let mut scope_5004 = writer.prefix("ClientData");
if let Some(var_5005) = &input.client_data {
crate::query_ser::serialize_structure_crate_model_client_data(scope_5004, var_5005)?;
}
#[allow(unused_mut)]
let mut scope_5006 = writer.prefix("ClientToken");
if let Some(var_5007) = &input.client_token {
scope_5006.string(var_5007);
}
#[allow(unused_mut)]
let mut scope_5008 = writer.prefix("Description");
if let Some(var_5009) = &input.description {
scope_5008.string(var_5009);
}
#[allow(unused_mut)]
let mut scope_5010 = writer.prefix("DiskContainer");
if let Some(var_5011) = &input.disk_containers {
let mut list_5013 = scope_5010.start_list(true, Some("item"));
for item_5012 in var_5011 {
#[allow(unused_mut)]
let mut entry_5014 = list_5013.entry();
crate::query_ser::serialize_structure_crate_model_image_disk_container(
entry_5014, item_5012,
)?;
}
list_5013.finish();
}
#[allow(unused_mut)]
let mut scope_5015 = writer.prefix("DryRun");
if let Some(var_5016) = &input.dry_run {
scope_5015.boolean(*var_5016);
}
#[allow(unused_mut)]
let mut scope_5017 = writer.prefix("Encrypted");
if let Some(var_5018) = &input.encrypted {
scope_5017.boolean(*var_5018);
}
#[allow(unused_mut)]
let mut scope_5019 = writer.prefix("Hypervisor");
if let Some(var_5020) = &input.hypervisor {
scope_5019.string(var_5020);
}
#[allow(unused_mut)]
let mut scope_5021 = writer.prefix("KmsKeyId");
if let Some(var_5022) = &input.kms_key_id {
scope_5021.string(var_5022);
}
#[allow(unused_mut)]
let mut scope_5023 = writer.prefix("LicenseType");
if let Some(var_5024) = &input.license_type {
scope_5023.string(var_5024);
}
#[allow(unused_mut)]
let mut scope_5025 = writer.prefix("Platform");
if let Some(var_5026) = &input.platform {
scope_5025.string(var_5026);
}
#[allow(unused_mut)]
let mut scope_5027 = writer.prefix("RoleName");
if let Some(var_5028) = &input.role_name {
scope_5027.string(var_5028);
}
#[allow(unused_mut)]
let mut scope_5029 = writer.prefix("LicenseSpecifications");
if let Some(var_5030) = &input.license_specifications {
let mut list_5032 = scope_5029.start_list(true, Some("item"));
for item_5031 in var_5030 {
#[allow(unused_mut)]
let mut entry_5033 = list_5032.entry();
crate::query_ser::serialize_structure_crate_model_import_image_license_configuration_request(entry_5033, item_5031)?;
}
list_5032.finish();
}
#[allow(unused_mut)]
let mut scope_5034 = writer.prefix("TagSpecification");
if let Some(var_5035) = &input.tag_specifications {
let mut list_5037 = scope_5034.start_list(true, Some("item"));
for item_5036 in var_5035 {
#[allow(unused_mut)]
let mut entry_5038 = list_5037.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_5038, item_5036,
)?;
}
list_5037.finish();
}
#[allow(unused_mut)]
let mut scope_5039 = writer.prefix("UsageOperation");
if let Some(var_5040) = &input.usage_operation {
scope_5039.string(var_5040);
}
#[allow(unused_mut)]
let mut scope_5041 = writer.prefix("BootMode");
if let Some(var_5042) = &input.boot_mode {
scope_5041.string(var_5042.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_import_instance(
input: &crate::input::ImportInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ImportInstance", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5043 = writer.prefix("Description");
if let Some(var_5044) = &input.description {
scope_5043.string(var_5044);
}
#[allow(unused_mut)]
let mut scope_5045 = writer.prefix("DiskImage");
if let Some(var_5046) = &input.disk_images {
let mut list_5048 = scope_5045.start_list(true, None);
for item_5047 in var_5046 {
#[allow(unused_mut)]
let mut entry_5049 = list_5048.entry();
crate::query_ser::serialize_structure_crate_model_disk_image(entry_5049, item_5047)?;
}
list_5048.finish();
}
#[allow(unused_mut)]
let mut scope_5050 = writer.prefix("DryRun");
if let Some(var_5051) = &input.dry_run {
scope_5050.boolean(*var_5051);
}
#[allow(unused_mut)]
let mut scope_5052 = writer.prefix("LaunchSpecification");
if let Some(var_5053) = &input.launch_specification {
crate::query_ser::serialize_structure_crate_model_import_instance_launch_specification(
scope_5052, var_5053,
)?;
}
#[allow(unused_mut)]
let mut scope_5054 = writer.prefix("Platform");
if let Some(var_5055) = &input.platform {
scope_5054.string(var_5055.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_import_key_pair(
input: &crate::input::ImportKeyPairInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ImportKeyPair", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5056 = writer.prefix("DryRun");
if let Some(var_5057) = &input.dry_run {
scope_5056.boolean(*var_5057);
}
#[allow(unused_mut)]
let mut scope_5058 = writer.prefix("KeyName");
if let Some(var_5059) = &input.key_name {
scope_5058.string(var_5059);
}
#[allow(unused_mut)]
let mut scope_5060 = writer.prefix("PublicKeyMaterial");
if let Some(var_5061) = &input.public_key_material {
scope_5060.string(&aws_smithy_types::base64::encode(var_5061));
}
#[allow(unused_mut)]
let mut scope_5062 = writer.prefix("TagSpecification");
if let Some(var_5063) = &input.tag_specifications {
let mut list_5065 = scope_5062.start_list(true, Some("item"));
for item_5064 in var_5063 {
#[allow(unused_mut)]
let mut entry_5066 = list_5065.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_5066, item_5064,
)?;
}
list_5065.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_import_snapshot(
input: &crate::input::ImportSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ImportSnapshot", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5067 = writer.prefix("ClientData");
if let Some(var_5068) = &input.client_data {
crate::query_ser::serialize_structure_crate_model_client_data(scope_5067, var_5068)?;
}
#[allow(unused_mut)]
let mut scope_5069 = writer.prefix("ClientToken");
if let Some(var_5070) = &input.client_token {
scope_5069.string(var_5070);
}
#[allow(unused_mut)]
let mut scope_5071 = writer.prefix("Description");
if let Some(var_5072) = &input.description {
scope_5071.string(var_5072);
}
#[allow(unused_mut)]
let mut scope_5073 = writer.prefix("DiskContainer");
if let Some(var_5074) = &input.disk_container {
crate::query_ser::serialize_structure_crate_model_snapshot_disk_container(
scope_5073, var_5074,
)?;
}
#[allow(unused_mut)]
let mut scope_5075 = writer.prefix("DryRun");
if let Some(var_5076) = &input.dry_run {
scope_5075.boolean(*var_5076);
}
#[allow(unused_mut)]
let mut scope_5077 = writer.prefix("Encrypted");
if let Some(var_5078) = &input.encrypted {
scope_5077.boolean(*var_5078);
}
#[allow(unused_mut)]
let mut scope_5079 = writer.prefix("KmsKeyId");
if let Some(var_5080) = &input.kms_key_id {
scope_5079.string(var_5080);
}
#[allow(unused_mut)]
let mut scope_5081 = writer.prefix("RoleName");
if let Some(var_5082) = &input.role_name {
scope_5081.string(var_5082);
}
#[allow(unused_mut)]
let mut scope_5083 = writer.prefix("TagSpecification");
if let Some(var_5084) = &input.tag_specifications {
let mut list_5086 = scope_5083.start_list(true, Some("item"));
for item_5085 in var_5084 {
#[allow(unused_mut)]
let mut entry_5087 = list_5086.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_5087, item_5085,
)?;
}
list_5086.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_import_volume(
input: &crate::input::ImportVolumeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ImportVolume", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5088 = writer.prefix("AvailabilityZone");
if let Some(var_5089) = &input.availability_zone {
scope_5088.string(var_5089);
}
#[allow(unused_mut)]
let mut scope_5090 = writer.prefix("Description");
if let Some(var_5091) = &input.description {
scope_5090.string(var_5091);
}
#[allow(unused_mut)]
let mut scope_5092 = writer.prefix("DryRun");
if let Some(var_5093) = &input.dry_run {
scope_5092.boolean(*var_5093);
}
#[allow(unused_mut)]
let mut scope_5094 = writer.prefix("Image");
if let Some(var_5095) = &input.image {
crate::query_ser::serialize_structure_crate_model_disk_image_detail(scope_5094, var_5095)?;
}
#[allow(unused_mut)]
let mut scope_5096 = writer.prefix("Volume");
if let Some(var_5097) = &input.volume {
crate::query_ser::serialize_structure_crate_model_volume_detail(scope_5096, var_5097)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_images_in_recycle_bin(
input: &crate::input::ListImagesInRecycleBinInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListImagesInRecycleBin", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5098 = writer.prefix("ImageId");
if let Some(var_5099) = &input.image_ids {
let mut list_5101 = scope_5098.start_list(true, Some("ImageId"));
for item_5100 in var_5099 {
#[allow(unused_mut)]
let mut entry_5102 = list_5101.entry();
entry_5102.string(item_5100);
}
list_5101.finish();
}
#[allow(unused_mut)]
let mut scope_5103 = writer.prefix("NextToken");
if let Some(var_5104) = &input.next_token {
scope_5103.string(var_5104);
}
#[allow(unused_mut)]
let mut scope_5105 = writer.prefix("MaxResults");
if let Some(var_5106) = &input.max_results {
scope_5105.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5106).into()),
);
}
#[allow(unused_mut)]
let mut scope_5107 = writer.prefix("DryRun");
if let Some(var_5108) = &input.dry_run {
scope_5107.boolean(*var_5108);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_snapshots_in_recycle_bin(
input: &crate::input::ListSnapshotsInRecycleBinInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListSnapshotsInRecycleBin", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5109 = writer.prefix("MaxResults");
if let Some(var_5110) = &input.max_results {
scope_5109.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5110).into()),
);
}
#[allow(unused_mut)]
let mut scope_5111 = writer.prefix("NextToken");
if let Some(var_5112) = &input.next_token {
scope_5111.string(var_5112);
}
#[allow(unused_mut)]
let mut scope_5113 = writer.prefix("SnapshotId");
if let Some(var_5114) = &input.snapshot_ids {
let mut list_5116 = scope_5113.start_list(true, Some("SnapshotId"));
for item_5115 in var_5114 {
#[allow(unused_mut)]
let mut entry_5117 = list_5116.entry();
entry_5117.string(item_5115);
}
list_5116.finish();
}
#[allow(unused_mut)]
let mut scope_5118 = writer.prefix("DryRun");
if let Some(var_5119) = &input.dry_run {
scope_5118.boolean(*var_5119);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_address_attribute(
input: &crate::input::ModifyAddressAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyAddressAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5120 = writer.prefix("AllocationId");
if let Some(var_5121) = &input.allocation_id {
scope_5120.string(var_5121);
}
#[allow(unused_mut)]
let mut scope_5122 = writer.prefix("DomainName");
if let Some(var_5123) = &input.domain_name {
scope_5122.string(var_5123);
}
#[allow(unused_mut)]
let mut scope_5124 = writer.prefix("DryRun");
if let Some(var_5125) = &input.dry_run {
scope_5124.boolean(*var_5125);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_availability_zone_group(
input: &crate::input::ModifyAvailabilityZoneGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyAvailabilityZoneGroup", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5126 = writer.prefix("GroupName");
if let Some(var_5127) = &input.group_name {
scope_5126.string(var_5127);
}
#[allow(unused_mut)]
let mut scope_5128 = writer.prefix("OptInStatus");
if let Some(var_5129) = &input.opt_in_status {
scope_5128.string(var_5129.as_str());
}
#[allow(unused_mut)]
let mut scope_5130 = writer.prefix("DryRun");
if let Some(var_5131) = &input.dry_run {
scope_5130.boolean(*var_5131);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_capacity_reservation(
input: &crate::input::ModifyCapacityReservationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyCapacityReservation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5132 = writer.prefix("CapacityReservationId");
if let Some(var_5133) = &input.capacity_reservation_id {
scope_5132.string(var_5133);
}
#[allow(unused_mut)]
let mut scope_5134 = writer.prefix("InstanceCount");
if let Some(var_5135) = &input.instance_count {
scope_5134.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5135).into()),
);
}
#[allow(unused_mut)]
let mut scope_5136 = writer.prefix("EndDate");
if let Some(var_5137) = &input.end_date {
scope_5136.date_time(var_5137, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_5138 = writer.prefix("EndDateType");
if let Some(var_5139) = &input.end_date_type {
scope_5138.string(var_5139.as_str());
}
#[allow(unused_mut)]
let mut scope_5140 = writer.prefix("Accept");
if let Some(var_5141) = &input.accept {
scope_5140.boolean(*var_5141);
}
#[allow(unused_mut)]
let mut scope_5142 = writer.prefix("DryRun");
if let Some(var_5143) = &input.dry_run {
scope_5142.boolean(*var_5143);
}
#[allow(unused_mut)]
let mut scope_5144 = writer.prefix("AdditionalInfo");
if let Some(var_5145) = &input.additional_info {
scope_5144.string(var_5145);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_capacity_reservation_fleet(
input: &crate::input::ModifyCapacityReservationFleetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyCapacityReservationFleet",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5146 = writer.prefix("CapacityReservationFleetId");
if let Some(var_5147) = &input.capacity_reservation_fleet_id {
scope_5146.string(var_5147);
}
#[allow(unused_mut)]
let mut scope_5148 = writer.prefix("TotalTargetCapacity");
if let Some(var_5149) = &input.total_target_capacity {
scope_5148.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5149).into()),
);
}
#[allow(unused_mut)]
let mut scope_5150 = writer.prefix("EndDate");
if let Some(var_5151) = &input.end_date {
scope_5150.date_time(var_5151, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_5152 = writer.prefix("DryRun");
if let Some(var_5153) = &input.dry_run {
scope_5152.boolean(*var_5153);
}
#[allow(unused_mut)]
let mut scope_5154 = writer.prefix("RemoveEndDate");
if let Some(var_5155) = &input.remove_end_date {
scope_5154.boolean(*var_5155);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_client_vpn_endpoint(
input: &crate::input::ModifyClientVpnEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyClientVpnEndpoint", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5156 = writer.prefix("ClientVpnEndpointId");
if let Some(var_5157) = &input.client_vpn_endpoint_id {
scope_5156.string(var_5157);
}
#[allow(unused_mut)]
let mut scope_5158 = writer.prefix("ServerCertificateArn");
if let Some(var_5159) = &input.server_certificate_arn {
scope_5158.string(var_5159);
}
#[allow(unused_mut)]
let mut scope_5160 = writer.prefix("ConnectionLogOptions");
if let Some(var_5161) = &input.connection_log_options {
crate::query_ser::serialize_structure_crate_model_connection_log_options(
scope_5160, var_5161,
)?;
}
#[allow(unused_mut)]
let mut scope_5162 = writer.prefix("DnsServers");
if let Some(var_5163) = &input.dns_servers {
crate::query_ser::serialize_structure_crate_model_dns_servers_options_modify_structure(
scope_5162, var_5163,
)?;
}
#[allow(unused_mut)]
let mut scope_5164 = writer.prefix("VpnPort");
if let Some(var_5165) = &input.vpn_port {
scope_5164.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5165).into()),
);
}
#[allow(unused_mut)]
let mut scope_5166 = writer.prefix("Description");
if let Some(var_5167) = &input.description {
scope_5166.string(var_5167);
}
#[allow(unused_mut)]
let mut scope_5168 = writer.prefix("SplitTunnel");
if let Some(var_5169) = &input.split_tunnel {
scope_5168.boolean(*var_5169);
}
#[allow(unused_mut)]
let mut scope_5170 = writer.prefix("DryRun");
if let Some(var_5171) = &input.dry_run {
scope_5170.boolean(*var_5171);
}
#[allow(unused_mut)]
let mut scope_5172 = writer.prefix("SecurityGroupId");
if let Some(var_5173) = &input.security_group_ids {
let mut list_5175 = scope_5172.start_list(true, Some("item"));
for item_5174 in var_5173 {
#[allow(unused_mut)]
let mut entry_5176 = list_5175.entry();
entry_5176.string(item_5174);
}
list_5175.finish();
}
#[allow(unused_mut)]
let mut scope_5177 = writer.prefix("VpcId");
if let Some(var_5178) = &input.vpc_id {
scope_5177.string(var_5178);
}
#[allow(unused_mut)]
let mut scope_5179 = writer.prefix("SelfServicePortal");
if let Some(var_5180) = &input.self_service_portal {
scope_5179.string(var_5180.as_str());
}
#[allow(unused_mut)]
let mut scope_5181 = writer.prefix("ClientConnectOptions");
if let Some(var_5182) = &input.client_connect_options {
crate::query_ser::serialize_structure_crate_model_client_connect_options(
scope_5181, var_5182,
)?;
}
#[allow(unused_mut)]
let mut scope_5183 = writer.prefix("SessionTimeoutHours");
if let Some(var_5184) = &input.session_timeout_hours {
scope_5183.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5184).into()),
);
}
#[allow(unused_mut)]
let mut scope_5185 = writer.prefix("ClientLoginBannerOptions");
if let Some(var_5186) = &input.client_login_banner_options {
crate::query_ser::serialize_structure_crate_model_client_login_banner_options(
scope_5185, var_5186,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_default_credit_specification(
input: &crate::input::ModifyDefaultCreditSpecificationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyDefaultCreditSpecification",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5187 = writer.prefix("DryRun");
if let Some(var_5188) = &input.dry_run {
scope_5187.boolean(*var_5188);
}
#[allow(unused_mut)]
let mut scope_5189 = writer.prefix("InstanceFamily");
if let Some(var_5190) = &input.instance_family {
scope_5189.string(var_5190.as_str());
}
#[allow(unused_mut)]
let mut scope_5191 = writer.prefix("CpuCredits");
if let Some(var_5192) = &input.cpu_credits {
scope_5191.string(var_5192);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_ebs_default_kms_key_id(
input: &crate::input::ModifyEbsDefaultKmsKeyIdInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyEbsDefaultKmsKeyId", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5193 = writer.prefix("KmsKeyId");
if let Some(var_5194) = &input.kms_key_id {
scope_5193.string(var_5194);
}
#[allow(unused_mut)]
let mut scope_5195 = writer.prefix("DryRun");
if let Some(var_5196) = &input.dry_run {
scope_5195.boolean(*var_5196);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_fleet(
input: &crate::input::ModifyFleetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyFleet", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5197 = writer.prefix("DryRun");
if let Some(var_5198) = &input.dry_run {
scope_5197.boolean(*var_5198);
}
#[allow(unused_mut)]
let mut scope_5199 = writer.prefix("ExcessCapacityTerminationPolicy");
if let Some(var_5200) = &input.excess_capacity_termination_policy {
scope_5199.string(var_5200.as_str());
}
#[allow(unused_mut)]
let mut scope_5201 = writer.prefix("LaunchTemplateConfig");
if let Some(var_5202) = &input.launch_template_configs {
let mut list_5204 = scope_5201.start_list(true, Some("item"));
for item_5203 in var_5202 {
#[allow(unused_mut)]
let mut entry_5205 = list_5204.entry();
crate::query_ser::serialize_structure_crate_model_fleet_launch_template_config_request(
entry_5205, item_5203,
)?;
}
list_5204.finish();
}
#[allow(unused_mut)]
let mut scope_5206 = writer.prefix("FleetId");
if let Some(var_5207) = &input.fleet_id {
scope_5206.string(var_5207);
}
#[allow(unused_mut)]
let mut scope_5208 = writer.prefix("TargetCapacitySpecification");
if let Some(var_5209) = &input.target_capacity_specification {
crate::query_ser::serialize_structure_crate_model_target_capacity_specification_request(
scope_5208, var_5209,
)?;
}
#[allow(unused_mut)]
let mut scope_5210 = writer.prefix("Context");
if let Some(var_5211) = &input.context {
scope_5210.string(var_5211);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_fpga_image_attribute(
input: &crate::input::ModifyFpgaImageAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyFpgaImageAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5212 = writer.prefix("DryRun");
if let Some(var_5213) = &input.dry_run {
scope_5212.boolean(*var_5213);
}
#[allow(unused_mut)]
let mut scope_5214 = writer.prefix("FpgaImageId");
if let Some(var_5215) = &input.fpga_image_id {
scope_5214.string(var_5215);
}
#[allow(unused_mut)]
let mut scope_5216 = writer.prefix("Attribute");
if let Some(var_5217) = &input.attribute {
scope_5216.string(var_5217.as_str());
}
#[allow(unused_mut)]
let mut scope_5218 = writer.prefix("OperationType");
if let Some(var_5219) = &input.operation_type {
scope_5218.string(var_5219.as_str());
}
#[allow(unused_mut)]
let mut scope_5220 = writer.prefix("UserId");
if let Some(var_5221) = &input.user_ids {
let mut list_5223 = scope_5220.start_list(true, Some("UserId"));
for item_5222 in var_5221 {
#[allow(unused_mut)]
let mut entry_5224 = list_5223.entry();
entry_5224.string(item_5222);
}
list_5223.finish();
}
#[allow(unused_mut)]
let mut scope_5225 = writer.prefix("UserGroup");
if let Some(var_5226) = &input.user_groups {
let mut list_5228 = scope_5225.start_list(true, Some("UserGroup"));
for item_5227 in var_5226 {
#[allow(unused_mut)]
let mut entry_5229 = list_5228.entry();
entry_5229.string(item_5227);
}
list_5228.finish();
}
#[allow(unused_mut)]
let mut scope_5230 = writer.prefix("ProductCode");
if let Some(var_5231) = &input.product_codes {
let mut list_5233 = scope_5230.start_list(true, Some("ProductCode"));
for item_5232 in var_5231 {
#[allow(unused_mut)]
let mut entry_5234 = list_5233.entry();
entry_5234.string(item_5232);
}
list_5233.finish();
}
#[allow(unused_mut)]
let mut scope_5235 = writer.prefix("LoadPermission");
if let Some(var_5236) = &input.load_permission {
crate::query_ser::serialize_structure_crate_model_load_permission_modifications(
scope_5235, var_5236,
)?;
}
#[allow(unused_mut)]
let mut scope_5237 = writer.prefix("Description");
if let Some(var_5238) = &input.description {
scope_5237.string(var_5238);
}
#[allow(unused_mut)]
let mut scope_5239 = writer.prefix("Name");
if let Some(var_5240) = &input.name {
scope_5239.string(var_5240);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_hosts(
input: &crate::input::ModifyHostsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyHosts", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5241 = writer.prefix("AutoPlacement");
if let Some(var_5242) = &input.auto_placement {
scope_5241.string(var_5242.as_str());
}
#[allow(unused_mut)]
let mut scope_5243 = writer.prefix("HostId");
if let Some(var_5244) = &input.host_ids {
let mut list_5246 = scope_5243.start_list(true, Some("item"));
for item_5245 in var_5244 {
#[allow(unused_mut)]
let mut entry_5247 = list_5246.entry();
entry_5247.string(item_5245);
}
list_5246.finish();
}
#[allow(unused_mut)]
let mut scope_5248 = writer.prefix("HostRecovery");
if let Some(var_5249) = &input.host_recovery {
scope_5248.string(var_5249.as_str());
}
#[allow(unused_mut)]
let mut scope_5250 = writer.prefix("InstanceType");
if let Some(var_5251) = &input.instance_type {
scope_5250.string(var_5251);
}
#[allow(unused_mut)]
let mut scope_5252 = writer.prefix("InstanceFamily");
if let Some(var_5253) = &input.instance_family {
scope_5252.string(var_5253);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_identity_id_format(
input: &crate::input::ModifyIdentityIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyIdentityIdFormat", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5254 = writer.prefix("PrincipalArn");
if let Some(var_5255) = &input.principal_arn {
scope_5254.string(var_5255);
}
#[allow(unused_mut)]
let mut scope_5256 = writer.prefix("Resource");
if let Some(var_5257) = &input.resource {
scope_5256.string(var_5257);
}
#[allow(unused_mut)]
let mut scope_5258 = writer.prefix("UseLongIds");
if let Some(var_5259) = &input.use_long_ids {
scope_5258.boolean(*var_5259);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_id_format(
input: &crate::input::ModifyIdFormatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyIdFormat", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5260 = writer.prefix("Resource");
if let Some(var_5261) = &input.resource {
scope_5260.string(var_5261);
}
#[allow(unused_mut)]
let mut scope_5262 = writer.prefix("UseLongIds");
if let Some(var_5263) = &input.use_long_ids {
scope_5262.boolean(*var_5263);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_image_attribute(
input: &crate::input::ModifyImageAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyImageAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5264 = writer.prefix("Attribute");
if let Some(var_5265) = &input.attribute {
scope_5264.string(var_5265);
}
#[allow(unused_mut)]
let mut scope_5266 = writer.prefix("Description");
if let Some(var_5267) = &input.description {
crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5266, var_5267)?;
}
#[allow(unused_mut)]
let mut scope_5268 = writer.prefix("ImageId");
if let Some(var_5269) = &input.image_id {
scope_5268.string(var_5269);
}
#[allow(unused_mut)]
let mut scope_5270 = writer.prefix("LaunchPermission");
if let Some(var_5271) = &input.launch_permission {
crate::query_ser::serialize_structure_crate_model_launch_permission_modifications(
scope_5270, var_5271,
)?;
}
#[allow(unused_mut)]
let mut scope_5272 = writer.prefix("OperationType");
if let Some(var_5273) = &input.operation_type {
scope_5272.string(var_5273.as_str());
}
#[allow(unused_mut)]
let mut scope_5274 = writer.prefix("ProductCode");
if let Some(var_5275) = &input.product_codes {
let mut list_5277 = scope_5274.start_list(true, Some("ProductCode"));
for item_5276 in var_5275 {
#[allow(unused_mut)]
let mut entry_5278 = list_5277.entry();
entry_5278.string(item_5276);
}
list_5277.finish();
}
#[allow(unused_mut)]
let mut scope_5279 = writer.prefix("UserGroup");
if let Some(var_5280) = &input.user_groups {
let mut list_5282 = scope_5279.start_list(true, Some("UserGroup"));
for item_5281 in var_5280 {
#[allow(unused_mut)]
let mut entry_5283 = list_5282.entry();
entry_5283.string(item_5281);
}
list_5282.finish();
}
#[allow(unused_mut)]
let mut scope_5284 = writer.prefix("UserId");
if let Some(var_5285) = &input.user_ids {
let mut list_5287 = scope_5284.start_list(true, Some("UserId"));
for item_5286 in var_5285 {
#[allow(unused_mut)]
let mut entry_5288 = list_5287.entry();
entry_5288.string(item_5286);
}
list_5287.finish();
}
#[allow(unused_mut)]
let mut scope_5289 = writer.prefix("Value");
if let Some(var_5290) = &input.value {
scope_5289.string(var_5290);
}
#[allow(unused_mut)]
let mut scope_5291 = writer.prefix("DryRun");
if let Some(var_5292) = &input.dry_run {
scope_5291.boolean(*var_5292);
}
#[allow(unused_mut)]
let mut scope_5293 = writer.prefix("OrganizationArn");
if let Some(var_5294) = &input.organization_arns {
let mut list_5296 = scope_5293.start_list(true, Some("OrganizationArn"));
for item_5295 in var_5294 {
#[allow(unused_mut)]
let mut entry_5297 = list_5296.entry();
entry_5297.string(item_5295);
}
list_5296.finish();
}
#[allow(unused_mut)]
let mut scope_5298 = writer.prefix("OrganizationalUnitArn");
if let Some(var_5299) = &input.organizational_unit_arns {
let mut list_5301 = scope_5298.start_list(true, Some("OrganizationalUnitArn"));
for item_5300 in var_5299 {
#[allow(unused_mut)]
let mut entry_5302 = list_5301.entry();
entry_5302.string(item_5300);
}
list_5301.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_instance_attribute(
input: &crate::input::ModifyInstanceAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyInstanceAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5303 = writer.prefix("SourceDestCheck");
if let Some(var_5304) = &input.source_dest_check {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5303, var_5304,
)?;
}
#[allow(unused_mut)]
let mut scope_5305 = writer.prefix("Attribute");
if let Some(var_5306) = &input.attribute {
scope_5305.string(var_5306.as_str());
}
#[allow(unused_mut)]
let mut scope_5307 = writer.prefix("BlockDeviceMapping");
if let Some(var_5308) = &input.block_device_mappings {
let mut list_5310 = scope_5307.start_list(true, Some("item"));
for item_5309 in var_5308 {
#[allow(unused_mut)]
let mut entry_5311 = list_5310.entry();
crate::query_ser::serialize_structure_crate_model_instance_block_device_mapping_specification(entry_5311, item_5309)?;
}
list_5310.finish();
}
#[allow(unused_mut)]
let mut scope_5312 = writer.prefix("DisableApiTermination");
if let Some(var_5313) = &input.disable_api_termination {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5312, var_5313,
)?;
}
#[allow(unused_mut)]
let mut scope_5314 = writer.prefix("DryRun");
if let Some(var_5315) = &input.dry_run {
scope_5314.boolean(*var_5315);
}
#[allow(unused_mut)]
let mut scope_5316 = writer.prefix("EbsOptimized");
if let Some(var_5317) = &input.ebs_optimized {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5316, var_5317,
)?;
}
#[allow(unused_mut)]
let mut scope_5318 = writer.prefix("EnaSupport");
if let Some(var_5319) = &input.ena_support {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5318, var_5319,
)?;
}
#[allow(unused_mut)]
let mut scope_5320 = writer.prefix("GroupId");
if let Some(var_5321) = &input.groups {
let mut list_5323 = scope_5320.start_list(true, Some("groupId"));
for item_5322 in var_5321 {
#[allow(unused_mut)]
let mut entry_5324 = list_5323.entry();
entry_5324.string(item_5322);
}
list_5323.finish();
}
#[allow(unused_mut)]
let mut scope_5325 = writer.prefix("InstanceId");
if let Some(var_5326) = &input.instance_id {
scope_5325.string(var_5326);
}
#[allow(unused_mut)]
let mut scope_5327 = writer.prefix("InstanceInitiatedShutdownBehavior");
if let Some(var_5328) = &input.instance_initiated_shutdown_behavior {
crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5327, var_5328)?;
}
#[allow(unused_mut)]
let mut scope_5329 = writer.prefix("InstanceType");
if let Some(var_5330) = &input.instance_type {
crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5329, var_5330)?;
}
#[allow(unused_mut)]
let mut scope_5331 = writer.prefix("Kernel");
if let Some(var_5332) = &input.kernel {
crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5331, var_5332)?;
}
#[allow(unused_mut)]
let mut scope_5333 = writer.prefix("Ramdisk");
if let Some(var_5334) = &input.ramdisk {
crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5333, var_5334)?;
}
#[allow(unused_mut)]
let mut scope_5335 = writer.prefix("SriovNetSupport");
if let Some(var_5336) = &input.sriov_net_support {
crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5335, var_5336)?;
}
#[allow(unused_mut)]
let mut scope_5337 = writer.prefix("UserData");
if let Some(var_5338) = &input.user_data {
crate::query_ser::serialize_structure_crate_model_blob_attribute_value(
scope_5337, var_5338,
)?;
}
#[allow(unused_mut)]
let mut scope_5339 = writer.prefix("Value");
if let Some(var_5340) = &input.value {
scope_5339.string(var_5340);
}
#[allow(unused_mut)]
let mut scope_5341 = writer.prefix("DisableApiStop");
if let Some(var_5342) = &input.disable_api_stop {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5341, var_5342,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_instance_capacity_reservation_attributes(
input: &crate::input::ModifyInstanceCapacityReservationAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyInstanceCapacityReservationAttributes",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5343 = writer.prefix("InstanceId");
if let Some(var_5344) = &input.instance_id {
scope_5343.string(var_5344);
}
#[allow(unused_mut)]
let mut scope_5345 = writer.prefix("CapacityReservationSpecification");
if let Some(var_5346) = &input.capacity_reservation_specification {
crate::query_ser::serialize_structure_crate_model_capacity_reservation_specification(
scope_5345, var_5346,
)?;
}
#[allow(unused_mut)]
let mut scope_5347 = writer.prefix("DryRun");
if let Some(var_5348) = &input.dry_run {
scope_5347.boolean(*var_5348);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_instance_credit_specification(
input: &crate::input::ModifyInstanceCreditSpecificationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyInstanceCreditSpecification",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5349 = writer.prefix("DryRun");
if let Some(var_5350) = &input.dry_run {
scope_5349.boolean(*var_5350);
}
#[allow(unused_mut)]
let mut scope_5351 = writer.prefix("ClientToken");
if let Some(var_5352) = &input.client_token {
scope_5351.string(var_5352);
}
#[allow(unused_mut)]
let mut scope_5353 = writer.prefix("InstanceCreditSpecification");
if let Some(var_5354) = &input.instance_credit_specifications {
let mut list_5356 = scope_5353.start_list(true, Some("item"));
for item_5355 in var_5354 {
#[allow(unused_mut)]
let mut entry_5357 = list_5356.entry();
crate::query_ser::serialize_structure_crate_model_instance_credit_specification_request(entry_5357, item_5355)?;
}
list_5356.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_instance_event_start_time(
input: &crate::input::ModifyInstanceEventStartTimeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyInstanceEventStartTime", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5358 = writer.prefix("DryRun");
if let Some(var_5359) = &input.dry_run {
scope_5358.boolean(*var_5359);
}
#[allow(unused_mut)]
let mut scope_5360 = writer.prefix("InstanceId");
if let Some(var_5361) = &input.instance_id {
scope_5360.string(var_5361);
}
#[allow(unused_mut)]
let mut scope_5362 = writer.prefix("InstanceEventId");
if let Some(var_5363) = &input.instance_event_id {
scope_5362.string(var_5363);
}
#[allow(unused_mut)]
let mut scope_5364 = writer.prefix("NotBefore");
if let Some(var_5365) = &input.not_before {
scope_5364.date_time(var_5365, aws_smithy_types::date_time::Format::DateTime)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_instance_event_window(
input: &crate::input::ModifyInstanceEventWindowInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyInstanceEventWindow", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5366 = writer.prefix("DryRun");
if let Some(var_5367) = &input.dry_run {
scope_5366.boolean(*var_5367);
}
#[allow(unused_mut)]
let mut scope_5368 = writer.prefix("Name");
if let Some(var_5369) = &input.name {
scope_5368.string(var_5369);
}
#[allow(unused_mut)]
let mut scope_5370 = writer.prefix("InstanceEventWindowId");
if let Some(var_5371) = &input.instance_event_window_id {
scope_5370.string(var_5371);
}
#[allow(unused_mut)]
let mut scope_5372 = writer.prefix("TimeRange");
if let Some(var_5373) = &input.time_ranges {
let mut list_5375 = scope_5372.start_list(true, None);
for item_5374 in var_5373 {
#[allow(unused_mut)]
let mut entry_5376 = list_5375.entry();
crate::query_ser::serialize_structure_crate_model_instance_event_window_time_range_request(entry_5376, item_5374)?;
}
list_5375.finish();
}
#[allow(unused_mut)]
let mut scope_5377 = writer.prefix("CronExpression");
if let Some(var_5378) = &input.cron_expression {
scope_5377.string(var_5378);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_instance_maintenance_options(
input: &crate::input::ModifyInstanceMaintenanceOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyInstanceMaintenanceOptions",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5379 = writer.prefix("InstanceId");
if let Some(var_5380) = &input.instance_id {
scope_5379.string(var_5380);
}
#[allow(unused_mut)]
let mut scope_5381 = writer.prefix("AutoRecovery");
if let Some(var_5382) = &input.auto_recovery {
scope_5381.string(var_5382.as_str());
}
#[allow(unused_mut)]
let mut scope_5383 = writer.prefix("DryRun");
if let Some(var_5384) = &input.dry_run {
scope_5383.boolean(*var_5384);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_instance_metadata_options(
input: &crate::input::ModifyInstanceMetadataOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyInstanceMetadataOptions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5385 = writer.prefix("InstanceId");
if let Some(var_5386) = &input.instance_id {
scope_5385.string(var_5386);
}
#[allow(unused_mut)]
let mut scope_5387 = writer.prefix("HttpTokens");
if let Some(var_5388) = &input.http_tokens {
scope_5387.string(var_5388.as_str());
}
#[allow(unused_mut)]
let mut scope_5389 = writer.prefix("HttpPutResponseHopLimit");
if let Some(var_5390) = &input.http_put_response_hop_limit {
scope_5389.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5390).into()),
);
}
#[allow(unused_mut)]
let mut scope_5391 = writer.prefix("HttpEndpoint");
if let Some(var_5392) = &input.http_endpoint {
scope_5391.string(var_5392.as_str());
}
#[allow(unused_mut)]
let mut scope_5393 = writer.prefix("DryRun");
if let Some(var_5394) = &input.dry_run {
scope_5393.boolean(*var_5394);
}
#[allow(unused_mut)]
let mut scope_5395 = writer.prefix("HttpProtocolIpv6");
if let Some(var_5396) = &input.http_protocol_ipv6 {
scope_5395.string(var_5396.as_str());
}
#[allow(unused_mut)]
let mut scope_5397 = writer.prefix("InstanceMetadataTags");
if let Some(var_5398) = &input.instance_metadata_tags {
scope_5397.string(var_5398.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_instance_placement(
input: &crate::input::ModifyInstancePlacementInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyInstancePlacement", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5399 = writer.prefix("Affinity");
if let Some(var_5400) = &input.affinity {
scope_5399.string(var_5400.as_str());
}
#[allow(unused_mut)]
let mut scope_5401 = writer.prefix("GroupName");
if let Some(var_5402) = &input.group_name {
scope_5401.string(var_5402);
}
#[allow(unused_mut)]
let mut scope_5403 = writer.prefix("HostId");
if let Some(var_5404) = &input.host_id {
scope_5403.string(var_5404);
}
#[allow(unused_mut)]
let mut scope_5405 = writer.prefix("InstanceId");
if let Some(var_5406) = &input.instance_id {
scope_5405.string(var_5406);
}
#[allow(unused_mut)]
let mut scope_5407 = writer.prefix("Tenancy");
if let Some(var_5408) = &input.tenancy {
scope_5407.string(var_5408.as_str());
}
#[allow(unused_mut)]
let mut scope_5409 = writer.prefix("PartitionNumber");
if let Some(var_5410) = &input.partition_number {
scope_5409.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5410).into()),
);
}
#[allow(unused_mut)]
let mut scope_5411 = writer.prefix("HostResourceGroupArn");
if let Some(var_5412) = &input.host_resource_group_arn {
scope_5411.string(var_5412);
}
#[allow(unused_mut)]
let mut scope_5413 = writer.prefix("GroupId");
if let Some(var_5414) = &input.group_id {
scope_5413.string(var_5414);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_ipam(
input: &crate::input::ModifyIpamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyIpam", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5415 = writer.prefix("DryRun");
if let Some(var_5416) = &input.dry_run {
scope_5415.boolean(*var_5416);
}
#[allow(unused_mut)]
let mut scope_5417 = writer.prefix("IpamId");
if let Some(var_5418) = &input.ipam_id {
scope_5417.string(var_5418);
}
#[allow(unused_mut)]
let mut scope_5419 = writer.prefix("Description");
if let Some(var_5420) = &input.description {
scope_5419.string(var_5420);
}
#[allow(unused_mut)]
let mut scope_5421 = writer.prefix("AddOperatingRegion");
if let Some(var_5422) = &input.add_operating_regions {
let mut list_5424 = scope_5421.start_list(true, None);
for item_5423 in var_5422 {
#[allow(unused_mut)]
let mut entry_5425 = list_5424.entry();
crate::query_ser::serialize_structure_crate_model_add_ipam_operating_region(
entry_5425, item_5423,
)?;
}
list_5424.finish();
}
#[allow(unused_mut)]
let mut scope_5426 = writer.prefix("RemoveOperatingRegion");
if let Some(var_5427) = &input.remove_operating_regions {
let mut list_5429 = scope_5426.start_list(true, None);
for item_5428 in var_5427 {
#[allow(unused_mut)]
let mut entry_5430 = list_5429.entry();
crate::query_ser::serialize_structure_crate_model_remove_ipam_operating_region(
entry_5430, item_5428,
)?;
}
list_5429.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_ipam_pool(
input: &crate::input::ModifyIpamPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyIpamPool", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5431 = writer.prefix("DryRun");
if let Some(var_5432) = &input.dry_run {
scope_5431.boolean(*var_5432);
}
#[allow(unused_mut)]
let mut scope_5433 = writer.prefix("IpamPoolId");
if let Some(var_5434) = &input.ipam_pool_id {
scope_5433.string(var_5434);
}
#[allow(unused_mut)]
let mut scope_5435 = writer.prefix("Description");
if let Some(var_5436) = &input.description {
scope_5435.string(var_5436);
}
#[allow(unused_mut)]
let mut scope_5437 = writer.prefix("AutoImport");
if let Some(var_5438) = &input.auto_import {
scope_5437.boolean(*var_5438);
}
#[allow(unused_mut)]
let mut scope_5439 = writer.prefix("AllocationMinNetmaskLength");
if let Some(var_5440) = &input.allocation_min_netmask_length {
scope_5439.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5440).into()),
);
}
#[allow(unused_mut)]
let mut scope_5441 = writer.prefix("AllocationMaxNetmaskLength");
if let Some(var_5442) = &input.allocation_max_netmask_length {
scope_5441.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5442).into()),
);
}
#[allow(unused_mut)]
let mut scope_5443 = writer.prefix("AllocationDefaultNetmaskLength");
if let Some(var_5444) = &input.allocation_default_netmask_length {
scope_5443.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5444).into()),
);
}
#[allow(unused_mut)]
let mut scope_5445 = writer.prefix("ClearAllocationDefaultNetmaskLength");
if let Some(var_5446) = &input.clear_allocation_default_netmask_length {
scope_5445.boolean(*var_5446);
}
#[allow(unused_mut)]
let mut scope_5447 = writer.prefix("AddAllocationResourceTag");
if let Some(var_5448) = &input.add_allocation_resource_tags {
let mut list_5450 = scope_5447.start_list(true, Some("item"));
for item_5449 in var_5448 {
#[allow(unused_mut)]
let mut entry_5451 = list_5450.entry();
crate::query_ser::serialize_structure_crate_model_request_ipam_resource_tag(
entry_5451, item_5449,
)?;
}
list_5450.finish();
}
#[allow(unused_mut)]
let mut scope_5452 = writer.prefix("RemoveAllocationResourceTag");
if let Some(var_5453) = &input.remove_allocation_resource_tags {
let mut list_5455 = scope_5452.start_list(true, Some("item"));
for item_5454 in var_5453 {
#[allow(unused_mut)]
let mut entry_5456 = list_5455.entry();
crate::query_ser::serialize_structure_crate_model_request_ipam_resource_tag(
entry_5456, item_5454,
)?;
}
list_5455.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_ipam_resource_cidr(
input: &crate::input::ModifyIpamResourceCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyIpamResourceCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5457 = writer.prefix("DryRun");
if let Some(var_5458) = &input.dry_run {
scope_5457.boolean(*var_5458);
}
#[allow(unused_mut)]
let mut scope_5459 = writer.prefix("ResourceId");
if let Some(var_5460) = &input.resource_id {
scope_5459.string(var_5460);
}
#[allow(unused_mut)]
let mut scope_5461 = writer.prefix("ResourceCidr");
if let Some(var_5462) = &input.resource_cidr {
scope_5461.string(var_5462);
}
#[allow(unused_mut)]
let mut scope_5463 = writer.prefix("ResourceRegion");
if let Some(var_5464) = &input.resource_region {
scope_5463.string(var_5464);
}
#[allow(unused_mut)]
let mut scope_5465 = writer.prefix("CurrentIpamScopeId");
if let Some(var_5466) = &input.current_ipam_scope_id {
scope_5465.string(var_5466);
}
#[allow(unused_mut)]
let mut scope_5467 = writer.prefix("DestinationIpamScopeId");
if let Some(var_5468) = &input.destination_ipam_scope_id {
scope_5467.string(var_5468);
}
#[allow(unused_mut)]
let mut scope_5469 = writer.prefix("Monitored");
if let Some(var_5470) = &input.monitored {
scope_5469.boolean(*var_5470);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_ipam_scope(
input: &crate::input::ModifyIpamScopeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyIpamScope", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5471 = writer.prefix("DryRun");
if let Some(var_5472) = &input.dry_run {
scope_5471.boolean(*var_5472);
}
#[allow(unused_mut)]
let mut scope_5473 = writer.prefix("IpamScopeId");
if let Some(var_5474) = &input.ipam_scope_id {
scope_5473.string(var_5474);
}
#[allow(unused_mut)]
let mut scope_5475 = writer.prefix("Description");
if let Some(var_5476) = &input.description {
scope_5475.string(var_5476);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_launch_template(
input: &crate::input::ModifyLaunchTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyLaunchTemplate", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5477 = writer.prefix("DryRun");
if let Some(var_5478) = &input.dry_run {
scope_5477.boolean(*var_5478);
}
#[allow(unused_mut)]
let mut scope_5479 = writer.prefix("ClientToken");
if let Some(var_5480) = &input.client_token {
scope_5479.string(var_5480);
}
#[allow(unused_mut)]
let mut scope_5481 = writer.prefix("LaunchTemplateId");
if let Some(var_5482) = &input.launch_template_id {
scope_5481.string(var_5482);
}
#[allow(unused_mut)]
let mut scope_5483 = writer.prefix("LaunchTemplateName");
if let Some(var_5484) = &input.launch_template_name {
scope_5483.string(var_5484);
}
#[allow(unused_mut)]
let mut scope_5485 = writer.prefix("SetDefaultVersion");
if let Some(var_5486) = &input.default_version {
scope_5485.string(var_5486);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_local_gateway_route(
input: &crate::input::ModifyLocalGatewayRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyLocalGatewayRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5487 = writer.prefix("DestinationCidrBlock");
if let Some(var_5488) = &input.destination_cidr_block {
scope_5487.string(var_5488);
}
#[allow(unused_mut)]
let mut scope_5489 = writer.prefix("LocalGatewayRouteTableId");
if let Some(var_5490) = &input.local_gateway_route_table_id {
scope_5489.string(var_5490);
}
#[allow(unused_mut)]
let mut scope_5491 = writer.prefix("LocalGatewayVirtualInterfaceGroupId");
if let Some(var_5492) = &input.local_gateway_virtual_interface_group_id {
scope_5491.string(var_5492);
}
#[allow(unused_mut)]
let mut scope_5493 = writer.prefix("NetworkInterfaceId");
if let Some(var_5494) = &input.network_interface_id {
scope_5493.string(var_5494);
}
#[allow(unused_mut)]
let mut scope_5495 = writer.prefix("DryRun");
if let Some(var_5496) = &input.dry_run {
scope_5495.boolean(*var_5496);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_managed_prefix_list(
input: &crate::input::ModifyManagedPrefixListInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyManagedPrefixList", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5497 = writer.prefix("DryRun");
if let Some(var_5498) = &input.dry_run {
scope_5497.boolean(*var_5498);
}
#[allow(unused_mut)]
let mut scope_5499 = writer.prefix("PrefixListId");
if let Some(var_5500) = &input.prefix_list_id {
scope_5499.string(var_5500);
}
#[allow(unused_mut)]
let mut scope_5501 = writer.prefix("CurrentVersion");
if let Some(var_5502) = &input.current_version {
scope_5501.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5502).into()),
);
}
#[allow(unused_mut)]
let mut scope_5503 = writer.prefix("PrefixListName");
if let Some(var_5504) = &input.prefix_list_name {
scope_5503.string(var_5504);
}
#[allow(unused_mut)]
let mut scope_5505 = writer.prefix("AddEntry");
if let Some(var_5506) = &input.add_entries {
let mut list_5508 = scope_5505.start_list(true, None);
for item_5507 in var_5506 {
#[allow(unused_mut)]
let mut entry_5509 = list_5508.entry();
crate::query_ser::serialize_structure_crate_model_add_prefix_list_entry(
entry_5509, item_5507,
)?;
}
list_5508.finish();
}
#[allow(unused_mut)]
let mut scope_5510 = writer.prefix("RemoveEntry");
if let Some(var_5511) = &input.remove_entries {
let mut list_5513 = scope_5510.start_list(true, None);
for item_5512 in var_5511 {
#[allow(unused_mut)]
let mut entry_5514 = list_5513.entry();
crate::query_ser::serialize_structure_crate_model_remove_prefix_list_entry(
entry_5514, item_5512,
)?;
}
list_5513.finish();
}
#[allow(unused_mut)]
let mut scope_5515 = writer.prefix("MaxEntries");
if let Some(var_5516) = &input.max_entries {
scope_5515.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5516).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_network_interface_attribute(
input: &crate::input::ModifyNetworkInterfaceAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyNetworkInterfaceAttribute",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5517 = writer.prefix("Attachment");
if let Some(var_5518) = &input.attachment {
crate::query_ser::serialize_structure_crate_model_network_interface_attachment_changes(
scope_5517, var_5518,
)?;
}
#[allow(unused_mut)]
let mut scope_5519 = writer.prefix("Description");
if let Some(var_5520) = &input.description {
crate::query_ser::serialize_structure_crate_model_attribute_value(scope_5519, var_5520)?;
}
#[allow(unused_mut)]
let mut scope_5521 = writer.prefix("DryRun");
if let Some(var_5522) = &input.dry_run {
scope_5521.boolean(*var_5522);
}
#[allow(unused_mut)]
let mut scope_5523 = writer.prefix("SecurityGroupId");
if let Some(var_5524) = &input.groups {
let mut list_5526 = scope_5523.start_list(true, Some("SecurityGroupId"));
for item_5525 in var_5524 {
#[allow(unused_mut)]
let mut entry_5527 = list_5526.entry();
entry_5527.string(item_5525);
}
list_5526.finish();
}
#[allow(unused_mut)]
let mut scope_5528 = writer.prefix("NetworkInterfaceId");
if let Some(var_5529) = &input.network_interface_id {
scope_5528.string(var_5529);
}
#[allow(unused_mut)]
let mut scope_5530 = writer.prefix("SourceDestCheck");
if let Some(var_5531) = &input.source_dest_check {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5530, var_5531,
)?;
}
#[allow(unused_mut)]
let mut scope_5532 = writer.prefix("EnaSrdSpecification");
if let Some(var_5533) = &input.ena_srd_specification {
crate::query_ser::serialize_structure_crate_model_ena_srd_specification(
scope_5532, var_5533,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_private_dns_name_options(
input: &crate::input::ModifyPrivateDnsNameOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyPrivateDnsNameOptions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5534 = writer.prefix("DryRun");
if let Some(var_5535) = &input.dry_run {
scope_5534.boolean(*var_5535);
}
#[allow(unused_mut)]
let mut scope_5536 = writer.prefix("InstanceId");
if let Some(var_5537) = &input.instance_id {
scope_5536.string(var_5537);
}
#[allow(unused_mut)]
let mut scope_5538 = writer.prefix("PrivateDnsHostnameType");
if let Some(var_5539) = &input.private_dns_hostname_type {
scope_5538.string(var_5539.as_str());
}
#[allow(unused_mut)]
let mut scope_5540 = writer.prefix("EnableResourceNameDnsARecord");
if let Some(var_5541) = &input.enable_resource_name_dns_a_record {
scope_5540.boolean(*var_5541);
}
#[allow(unused_mut)]
let mut scope_5542 = writer.prefix("EnableResourceNameDnsAAAARecord");
if let Some(var_5543) = &input.enable_resource_name_dns_aaaa_record {
scope_5542.boolean(*var_5543);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_reserved_instances(
input: &crate::input::ModifyReservedInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyReservedInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5544 = writer.prefix("ReservedInstancesId");
if let Some(var_5545) = &input.reserved_instances_ids {
let mut list_5547 = scope_5544.start_list(true, Some("ReservedInstancesId"));
for item_5546 in var_5545 {
#[allow(unused_mut)]
let mut entry_5548 = list_5547.entry();
entry_5548.string(item_5546);
}
list_5547.finish();
}
#[allow(unused_mut)]
let mut scope_5549 = writer.prefix("ClientToken");
if let Some(var_5550) = &input.client_token {
scope_5549.string(var_5550);
}
#[allow(unused_mut)]
let mut scope_5551 = writer.prefix("ReservedInstancesConfigurationSetItemType");
if let Some(var_5552) = &input.target_configurations {
let mut list_5554 = scope_5551.start_list(true, Some("item"));
for item_5553 in var_5552 {
#[allow(unused_mut)]
let mut entry_5555 = list_5554.entry();
crate::query_ser::serialize_structure_crate_model_reserved_instances_configuration(
entry_5555, item_5553,
)?;
}
list_5554.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_security_group_rules(
input: &crate::input::ModifySecurityGroupRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifySecurityGroupRules", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5556 = writer.prefix("GroupId");
if let Some(var_5557) = &input.group_id {
scope_5556.string(var_5557);
}
#[allow(unused_mut)]
let mut scope_5558 = writer.prefix("SecurityGroupRule");
if let Some(var_5559) = &input.security_group_rules {
let mut list_5561 = scope_5558.start_list(true, Some("item"));
for item_5560 in var_5559 {
#[allow(unused_mut)]
let mut entry_5562 = list_5561.entry();
crate::query_ser::serialize_structure_crate_model_security_group_rule_update(
entry_5562, item_5560,
)?;
}
list_5561.finish();
}
#[allow(unused_mut)]
let mut scope_5563 = writer.prefix("DryRun");
if let Some(var_5564) = &input.dry_run {
scope_5563.boolean(*var_5564);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_snapshot_attribute(
input: &crate::input::ModifySnapshotAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifySnapshotAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5565 = writer.prefix("Attribute");
if let Some(var_5566) = &input.attribute {
scope_5565.string(var_5566.as_str());
}
#[allow(unused_mut)]
let mut scope_5567 = writer.prefix("CreateVolumePermission");
if let Some(var_5568) = &input.create_volume_permission {
crate::query_ser::serialize_structure_crate_model_create_volume_permission_modifications(
scope_5567, var_5568,
)?;
}
#[allow(unused_mut)]
let mut scope_5569 = writer.prefix("UserGroup");
if let Some(var_5570) = &input.group_names {
let mut list_5572 = scope_5569.start_list(true, Some("GroupName"));
for item_5571 in var_5570 {
#[allow(unused_mut)]
let mut entry_5573 = list_5572.entry();
entry_5573.string(item_5571);
}
list_5572.finish();
}
#[allow(unused_mut)]
let mut scope_5574 = writer.prefix("OperationType");
if let Some(var_5575) = &input.operation_type {
scope_5574.string(var_5575.as_str());
}
#[allow(unused_mut)]
let mut scope_5576 = writer.prefix("SnapshotId");
if let Some(var_5577) = &input.snapshot_id {
scope_5576.string(var_5577);
}
#[allow(unused_mut)]
let mut scope_5578 = writer.prefix("UserId");
if let Some(var_5579) = &input.user_ids {
let mut list_5581 = scope_5578.start_list(true, Some("UserId"));
for item_5580 in var_5579 {
#[allow(unused_mut)]
let mut entry_5582 = list_5581.entry();
entry_5582.string(item_5580);
}
list_5581.finish();
}
#[allow(unused_mut)]
let mut scope_5583 = writer.prefix("DryRun");
if let Some(var_5584) = &input.dry_run {
scope_5583.boolean(*var_5584);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_snapshot_tier(
input: &crate::input::ModifySnapshotTierInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifySnapshotTier", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5585 = writer.prefix("SnapshotId");
if let Some(var_5586) = &input.snapshot_id {
scope_5585.string(var_5586);
}
#[allow(unused_mut)]
let mut scope_5587 = writer.prefix("StorageTier");
if let Some(var_5588) = &input.storage_tier {
scope_5587.string(var_5588.as_str());
}
#[allow(unused_mut)]
let mut scope_5589 = writer.prefix("DryRun");
if let Some(var_5590) = &input.dry_run {
scope_5589.boolean(*var_5590);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_spot_fleet_request(
input: &crate::input::ModifySpotFleetRequestInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifySpotFleetRequest", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5591 = writer.prefix("ExcessCapacityTerminationPolicy");
if let Some(var_5592) = &input.excess_capacity_termination_policy {
scope_5591.string(var_5592.as_str());
}
#[allow(unused_mut)]
let mut scope_5593 = writer.prefix("LaunchTemplateConfig");
if let Some(var_5594) = &input.launch_template_configs {
let mut list_5596 = scope_5593.start_list(true, Some("item"));
for item_5595 in var_5594 {
#[allow(unused_mut)]
let mut entry_5597 = list_5596.entry();
crate::query_ser::serialize_structure_crate_model_launch_template_config(
entry_5597, item_5595,
)?;
}
list_5596.finish();
}
#[allow(unused_mut)]
let mut scope_5598 = writer.prefix("SpotFleetRequestId");
if let Some(var_5599) = &input.spot_fleet_request_id {
scope_5598.string(var_5599);
}
#[allow(unused_mut)]
let mut scope_5600 = writer.prefix("TargetCapacity");
if let Some(var_5601) = &input.target_capacity {
scope_5600.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5601).into()),
);
}
#[allow(unused_mut)]
let mut scope_5602 = writer.prefix("OnDemandTargetCapacity");
if let Some(var_5603) = &input.on_demand_target_capacity {
scope_5602.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5603).into()),
);
}
#[allow(unused_mut)]
let mut scope_5604 = writer.prefix("Context");
if let Some(var_5605) = &input.context {
scope_5604.string(var_5605);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_subnet_attribute(
input: &crate::input::ModifySubnetAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifySubnetAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5606 = writer.prefix("AssignIpv6AddressOnCreation");
if let Some(var_5607) = &input.assign_ipv6_address_on_creation {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5606, var_5607,
)?;
}
#[allow(unused_mut)]
let mut scope_5608 = writer.prefix("MapPublicIpOnLaunch");
if let Some(var_5609) = &input.map_public_ip_on_launch {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5608, var_5609,
)?;
}
#[allow(unused_mut)]
let mut scope_5610 = writer.prefix("SubnetId");
if let Some(var_5611) = &input.subnet_id {
scope_5610.string(var_5611);
}
#[allow(unused_mut)]
let mut scope_5612 = writer.prefix("MapCustomerOwnedIpOnLaunch");
if let Some(var_5613) = &input.map_customer_owned_ip_on_launch {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5612, var_5613,
)?;
}
#[allow(unused_mut)]
let mut scope_5614 = writer.prefix("CustomerOwnedIpv4Pool");
if let Some(var_5615) = &input.customer_owned_ipv4_pool {
scope_5614.string(var_5615);
}
#[allow(unused_mut)]
let mut scope_5616 = writer.prefix("EnableDns64");
if let Some(var_5617) = &input.enable_dns64 {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5616, var_5617,
)?;
}
#[allow(unused_mut)]
let mut scope_5618 = writer.prefix("PrivateDnsHostnameTypeOnLaunch");
if let Some(var_5619) = &input.private_dns_hostname_type_on_launch {
scope_5618.string(var_5619.as_str());
}
#[allow(unused_mut)]
let mut scope_5620 = writer.prefix("EnableResourceNameDnsARecordOnLaunch");
if let Some(var_5621) = &input.enable_resource_name_dns_a_record_on_launch {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5620, var_5621,
)?;
}
#[allow(unused_mut)]
let mut scope_5622 = writer.prefix("EnableResourceNameDnsAAAARecordOnLaunch");
if let Some(var_5623) = &input.enable_resource_name_dns_aaaa_record_on_launch {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5622, var_5623,
)?;
}
#[allow(unused_mut)]
let mut scope_5624 = writer.prefix("EnableLniAtDeviceIndex");
if let Some(var_5625) = &input.enable_lni_at_device_index {
scope_5624.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5625).into()),
);
}
#[allow(unused_mut)]
let mut scope_5626 = writer.prefix("DisableLniAtDeviceIndex");
if let Some(var_5627) = &input.disable_lni_at_device_index {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5626, var_5627,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_traffic_mirror_filter_network_services(
input: &crate::input::ModifyTrafficMirrorFilterNetworkServicesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyTrafficMirrorFilterNetworkServices",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5628 = writer.prefix("TrafficMirrorFilterId");
if let Some(var_5629) = &input.traffic_mirror_filter_id {
scope_5628.string(var_5629);
}
#[allow(unused_mut)]
let mut scope_5630 = writer.prefix("AddNetworkService");
if let Some(var_5631) = &input.add_network_services {
let mut list_5633 = scope_5630.start_list(true, Some("item"));
for item_5632 in var_5631 {
#[allow(unused_mut)]
let mut entry_5634 = list_5633.entry();
entry_5634.string(item_5632.as_str());
}
list_5633.finish();
}
#[allow(unused_mut)]
let mut scope_5635 = writer.prefix("RemoveNetworkService");
if let Some(var_5636) = &input.remove_network_services {
let mut list_5638 = scope_5635.start_list(true, Some("item"));
for item_5637 in var_5636 {
#[allow(unused_mut)]
let mut entry_5639 = list_5638.entry();
entry_5639.string(item_5637.as_str());
}
list_5638.finish();
}
#[allow(unused_mut)]
let mut scope_5640 = writer.prefix("DryRun");
if let Some(var_5641) = &input.dry_run {
scope_5640.boolean(*var_5641);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_traffic_mirror_filter_rule(
input: &crate::input::ModifyTrafficMirrorFilterRuleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyTrafficMirrorFilterRule", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5642 = writer.prefix("TrafficMirrorFilterRuleId");
if let Some(var_5643) = &input.traffic_mirror_filter_rule_id {
scope_5642.string(var_5643);
}
#[allow(unused_mut)]
let mut scope_5644 = writer.prefix("TrafficDirection");
if let Some(var_5645) = &input.traffic_direction {
scope_5644.string(var_5645.as_str());
}
#[allow(unused_mut)]
let mut scope_5646 = writer.prefix("RuleNumber");
if let Some(var_5647) = &input.rule_number {
scope_5646.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5647).into()),
);
}
#[allow(unused_mut)]
let mut scope_5648 = writer.prefix("RuleAction");
if let Some(var_5649) = &input.rule_action {
scope_5648.string(var_5649.as_str());
}
#[allow(unused_mut)]
let mut scope_5650 = writer.prefix("DestinationPortRange");
if let Some(var_5651) = &input.destination_port_range {
crate::query_ser::serialize_structure_crate_model_traffic_mirror_port_range_request(
scope_5650, var_5651,
)?;
}
#[allow(unused_mut)]
let mut scope_5652 = writer.prefix("SourcePortRange");
if let Some(var_5653) = &input.source_port_range {
crate::query_ser::serialize_structure_crate_model_traffic_mirror_port_range_request(
scope_5652, var_5653,
)?;
}
#[allow(unused_mut)]
let mut scope_5654 = writer.prefix("Protocol");
if let Some(var_5655) = &input.protocol {
scope_5654.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5655).into()),
);
}
#[allow(unused_mut)]
let mut scope_5656 = writer.prefix("DestinationCidrBlock");
if let Some(var_5657) = &input.destination_cidr_block {
scope_5656.string(var_5657);
}
#[allow(unused_mut)]
let mut scope_5658 = writer.prefix("SourceCidrBlock");
if let Some(var_5659) = &input.source_cidr_block {
scope_5658.string(var_5659);
}
#[allow(unused_mut)]
let mut scope_5660 = writer.prefix("Description");
if let Some(var_5661) = &input.description {
scope_5660.string(var_5661);
}
#[allow(unused_mut)]
let mut scope_5662 = writer.prefix("RemoveField");
if let Some(var_5663) = &input.remove_fields {
let mut list_5665 = scope_5662.start_list(true, None);
for item_5664 in var_5663 {
#[allow(unused_mut)]
let mut entry_5666 = list_5665.entry();
entry_5666.string(item_5664.as_str());
}
list_5665.finish();
}
#[allow(unused_mut)]
let mut scope_5667 = writer.prefix("DryRun");
if let Some(var_5668) = &input.dry_run {
scope_5667.boolean(*var_5668);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_traffic_mirror_session(
input: &crate::input::ModifyTrafficMirrorSessionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyTrafficMirrorSession", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5669 = writer.prefix("TrafficMirrorSessionId");
if let Some(var_5670) = &input.traffic_mirror_session_id {
scope_5669.string(var_5670);
}
#[allow(unused_mut)]
let mut scope_5671 = writer.prefix("TrafficMirrorTargetId");
if let Some(var_5672) = &input.traffic_mirror_target_id {
scope_5671.string(var_5672);
}
#[allow(unused_mut)]
let mut scope_5673 = writer.prefix("TrafficMirrorFilterId");
if let Some(var_5674) = &input.traffic_mirror_filter_id {
scope_5673.string(var_5674);
}
#[allow(unused_mut)]
let mut scope_5675 = writer.prefix("PacketLength");
if let Some(var_5676) = &input.packet_length {
scope_5675.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5676).into()),
);
}
#[allow(unused_mut)]
let mut scope_5677 = writer.prefix("SessionNumber");
if let Some(var_5678) = &input.session_number {
scope_5677.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5678).into()),
);
}
#[allow(unused_mut)]
let mut scope_5679 = writer.prefix("VirtualNetworkId");
if let Some(var_5680) = &input.virtual_network_id {
scope_5679.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5680).into()),
);
}
#[allow(unused_mut)]
let mut scope_5681 = writer.prefix("Description");
if let Some(var_5682) = &input.description {
scope_5681.string(var_5682);
}
#[allow(unused_mut)]
let mut scope_5683 = writer.prefix("RemoveField");
if let Some(var_5684) = &input.remove_fields {
let mut list_5686 = scope_5683.start_list(true, None);
for item_5685 in var_5684 {
#[allow(unused_mut)]
let mut entry_5687 = list_5686.entry();
entry_5687.string(item_5685.as_str());
}
list_5686.finish();
}
#[allow(unused_mut)]
let mut scope_5688 = writer.prefix("DryRun");
if let Some(var_5689) = &input.dry_run {
scope_5688.boolean(*var_5689);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_transit_gateway(
input: &crate::input::ModifyTransitGatewayInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyTransitGateway", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5690 = writer.prefix("TransitGatewayId");
if let Some(var_5691) = &input.transit_gateway_id {
scope_5690.string(var_5691);
}
#[allow(unused_mut)]
let mut scope_5692 = writer.prefix("Description");
if let Some(var_5693) = &input.description {
scope_5692.string(var_5693);
}
#[allow(unused_mut)]
let mut scope_5694 = writer.prefix("Options");
if let Some(var_5695) = &input.options {
crate::query_ser::serialize_structure_crate_model_modify_transit_gateway_options(
scope_5694, var_5695,
)?;
}
#[allow(unused_mut)]
let mut scope_5696 = writer.prefix("DryRun");
if let Some(var_5697) = &input.dry_run {
scope_5696.boolean(*var_5697);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_transit_gateway_prefix_list_reference(
input: &crate::input::ModifyTransitGatewayPrefixListReferenceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyTransitGatewayPrefixListReference",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5698 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_5699) = &input.transit_gateway_route_table_id {
scope_5698.string(var_5699);
}
#[allow(unused_mut)]
let mut scope_5700 = writer.prefix("PrefixListId");
if let Some(var_5701) = &input.prefix_list_id {
scope_5700.string(var_5701);
}
#[allow(unused_mut)]
let mut scope_5702 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_5703) = &input.transit_gateway_attachment_id {
scope_5702.string(var_5703);
}
#[allow(unused_mut)]
let mut scope_5704 = writer.prefix("Blackhole");
if let Some(var_5705) = &input.blackhole {
scope_5704.boolean(*var_5705);
}
#[allow(unused_mut)]
let mut scope_5706 = writer.prefix("DryRun");
if let Some(var_5707) = &input.dry_run {
scope_5706.boolean(*var_5707);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_transit_gateway_vpc_attachment(
input: &crate::input::ModifyTransitGatewayVpcAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyTransitGatewayVpcAttachment",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5708 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_5709) = &input.transit_gateway_attachment_id {
scope_5708.string(var_5709);
}
#[allow(unused_mut)]
let mut scope_5710 = writer.prefix("AddSubnetIds");
if let Some(var_5711) = &input.add_subnet_ids {
let mut list_5713 = scope_5710.start_list(true, Some("item"));
for item_5712 in var_5711 {
#[allow(unused_mut)]
let mut entry_5714 = list_5713.entry();
entry_5714.string(item_5712);
}
list_5713.finish();
}
#[allow(unused_mut)]
let mut scope_5715 = writer.prefix("RemoveSubnetIds");
if let Some(var_5716) = &input.remove_subnet_ids {
let mut list_5718 = scope_5715.start_list(true, Some("item"));
for item_5717 in var_5716 {
#[allow(unused_mut)]
let mut entry_5719 = list_5718.entry();
entry_5719.string(item_5717);
}
list_5718.finish();
}
#[allow(unused_mut)]
let mut scope_5720 = writer.prefix("Options");
if let Some(var_5721) = &input.options {
crate::query_ser::serialize_structure_crate_model_modify_transit_gateway_vpc_attachment_request_options(scope_5720, var_5721)?;
}
#[allow(unused_mut)]
let mut scope_5722 = writer.prefix("DryRun");
if let Some(var_5723) = &input.dry_run {
scope_5722.boolean(*var_5723);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_verified_access_endpoint(
input: &crate::input::ModifyVerifiedAccessEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyVerifiedAccessEndpoint", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5724 = writer.prefix("VerifiedAccessEndpointId");
if let Some(var_5725) = &input.verified_access_endpoint_id {
scope_5724.string(var_5725);
}
#[allow(unused_mut)]
let mut scope_5726 = writer.prefix("VerifiedAccessGroupId");
if let Some(var_5727) = &input.verified_access_group_id {
scope_5726.string(var_5727);
}
#[allow(unused_mut)]
let mut scope_5728 = writer.prefix("LoadBalancerOptions");
if let Some(var_5729) = &input.load_balancer_options {
crate::query_ser::serialize_structure_crate_model_modify_verified_access_endpoint_load_balancer_options(scope_5728, var_5729)?;
}
#[allow(unused_mut)]
let mut scope_5730 = writer.prefix("NetworkInterfaceOptions");
if let Some(var_5731) = &input.network_interface_options {
crate::query_ser::serialize_structure_crate_model_modify_verified_access_endpoint_eni_options(scope_5730, var_5731)?;
}
#[allow(unused_mut)]
let mut scope_5732 = writer.prefix("Description");
if let Some(var_5733) = &input.description {
scope_5732.string(var_5733);
}
#[allow(unused_mut)]
let mut scope_5734 = writer.prefix("ClientToken");
if let Some(var_5735) = &input.client_token {
scope_5734.string(var_5735);
}
#[allow(unused_mut)]
let mut scope_5736 = writer.prefix("DryRun");
if let Some(var_5737) = &input.dry_run {
scope_5736.boolean(*var_5737);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_verified_access_endpoint_policy(
input: &crate::input::ModifyVerifiedAccessEndpointPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyVerifiedAccessEndpointPolicy",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5738 = writer.prefix("VerifiedAccessEndpointId");
if let Some(var_5739) = &input.verified_access_endpoint_id {
scope_5738.string(var_5739);
}
#[allow(unused_mut)]
let mut scope_5740 = writer.prefix("PolicyEnabled");
if let Some(var_5741) = &input.policy_enabled {
scope_5740.boolean(*var_5741);
}
#[allow(unused_mut)]
let mut scope_5742 = writer.prefix("PolicyDocument");
if let Some(var_5743) = &input.policy_document {
scope_5742.string(var_5743);
}
#[allow(unused_mut)]
let mut scope_5744 = writer.prefix("ClientToken");
if let Some(var_5745) = &input.client_token {
scope_5744.string(var_5745);
}
#[allow(unused_mut)]
let mut scope_5746 = writer.prefix("DryRun");
if let Some(var_5747) = &input.dry_run {
scope_5746.boolean(*var_5747);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_verified_access_group(
input: &crate::input::ModifyVerifiedAccessGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyVerifiedAccessGroup", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5748 = writer.prefix("VerifiedAccessGroupId");
if let Some(var_5749) = &input.verified_access_group_id {
scope_5748.string(var_5749);
}
#[allow(unused_mut)]
let mut scope_5750 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_5751) = &input.verified_access_instance_id {
scope_5750.string(var_5751);
}
#[allow(unused_mut)]
let mut scope_5752 = writer.prefix("Description");
if let Some(var_5753) = &input.description {
scope_5752.string(var_5753);
}
#[allow(unused_mut)]
let mut scope_5754 = writer.prefix("ClientToken");
if let Some(var_5755) = &input.client_token {
scope_5754.string(var_5755);
}
#[allow(unused_mut)]
let mut scope_5756 = writer.prefix("DryRun");
if let Some(var_5757) = &input.dry_run {
scope_5756.boolean(*var_5757);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_verified_access_group_policy(
input: &crate::input::ModifyVerifiedAccessGroupPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyVerifiedAccessGroupPolicy",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5758 = writer.prefix("VerifiedAccessGroupId");
if let Some(var_5759) = &input.verified_access_group_id {
scope_5758.string(var_5759);
}
#[allow(unused_mut)]
let mut scope_5760 = writer.prefix("PolicyEnabled");
if let Some(var_5761) = &input.policy_enabled {
scope_5760.boolean(*var_5761);
}
#[allow(unused_mut)]
let mut scope_5762 = writer.prefix("PolicyDocument");
if let Some(var_5763) = &input.policy_document {
scope_5762.string(var_5763);
}
#[allow(unused_mut)]
let mut scope_5764 = writer.prefix("ClientToken");
if let Some(var_5765) = &input.client_token {
scope_5764.string(var_5765);
}
#[allow(unused_mut)]
let mut scope_5766 = writer.prefix("DryRun");
if let Some(var_5767) = &input.dry_run {
scope_5766.boolean(*var_5767);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_verified_access_instance(
input: &crate::input::ModifyVerifiedAccessInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyVerifiedAccessInstance", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5768 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_5769) = &input.verified_access_instance_id {
scope_5768.string(var_5769);
}
#[allow(unused_mut)]
let mut scope_5770 = writer.prefix("Description");
if let Some(var_5771) = &input.description {
scope_5770.string(var_5771);
}
#[allow(unused_mut)]
let mut scope_5772 = writer.prefix("DryRun");
if let Some(var_5773) = &input.dry_run {
scope_5772.boolean(*var_5773);
}
#[allow(unused_mut)]
let mut scope_5774 = writer.prefix("ClientToken");
if let Some(var_5775) = &input.client_token {
scope_5774.string(var_5775);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_verified_access_instance_logging_configuration(
input: &crate::input::ModifyVerifiedAccessInstanceLoggingConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyVerifiedAccessInstanceLoggingConfiguration",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5776 = writer.prefix("VerifiedAccessInstanceId");
if let Some(var_5777) = &input.verified_access_instance_id {
scope_5776.string(var_5777);
}
#[allow(unused_mut)]
let mut scope_5778 = writer.prefix("AccessLogs");
if let Some(var_5779) = &input.access_logs {
crate::query_ser::serialize_structure_crate_model_verified_access_log_options(
scope_5778, var_5779,
)?;
}
#[allow(unused_mut)]
let mut scope_5780 = writer.prefix("DryRun");
if let Some(var_5781) = &input.dry_run {
scope_5780.boolean(*var_5781);
}
#[allow(unused_mut)]
let mut scope_5782 = writer.prefix("ClientToken");
if let Some(var_5783) = &input.client_token {
scope_5782.string(var_5783);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_verified_access_trust_provider(
input: &crate::input::ModifyVerifiedAccessTrustProviderInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyVerifiedAccessTrustProvider",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5784 = writer.prefix("VerifiedAccessTrustProviderId");
if let Some(var_5785) = &input.verified_access_trust_provider_id {
scope_5784.string(var_5785);
}
#[allow(unused_mut)]
let mut scope_5786 = writer.prefix("OidcOptions");
if let Some(var_5787) = &input.oidc_options {
crate::query_ser::serialize_structure_crate_model_modify_verified_access_trust_provider_oidc_options(scope_5786, var_5787)?;
}
#[allow(unused_mut)]
let mut scope_5788 = writer.prefix("Description");
if let Some(var_5789) = &input.description {
scope_5788.string(var_5789);
}
#[allow(unused_mut)]
let mut scope_5790 = writer.prefix("DryRun");
if let Some(var_5791) = &input.dry_run {
scope_5790.boolean(*var_5791);
}
#[allow(unused_mut)]
let mut scope_5792 = writer.prefix("ClientToken");
if let Some(var_5793) = &input.client_token {
scope_5792.string(var_5793);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_volume(
input: &crate::input::ModifyVolumeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyVolume", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5794 = writer.prefix("DryRun");
if let Some(var_5795) = &input.dry_run {
scope_5794.boolean(*var_5795);
}
#[allow(unused_mut)]
let mut scope_5796 = writer.prefix("VolumeId");
if let Some(var_5797) = &input.volume_id {
scope_5796.string(var_5797);
}
#[allow(unused_mut)]
let mut scope_5798 = writer.prefix("Size");
if let Some(var_5799) = &input.size {
scope_5798.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5799).into()),
);
}
#[allow(unused_mut)]
let mut scope_5800 = writer.prefix("VolumeType");
if let Some(var_5801) = &input.volume_type {
scope_5800.string(var_5801.as_str());
}
#[allow(unused_mut)]
let mut scope_5802 = writer.prefix("Iops");
if let Some(var_5803) = &input.iops {
scope_5802.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5803).into()),
);
}
#[allow(unused_mut)]
let mut scope_5804 = writer.prefix("Throughput");
if let Some(var_5805) = &input.throughput {
scope_5804.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5805).into()),
);
}
#[allow(unused_mut)]
let mut scope_5806 = writer.prefix("MultiAttachEnabled");
if let Some(var_5807) = &input.multi_attach_enabled {
scope_5806.boolean(*var_5807);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_volume_attribute(
input: &crate::input::ModifyVolumeAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyVolumeAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5808 = writer.prefix("AutoEnableIO");
if let Some(var_5809) = &input.auto_enable_io {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5808, var_5809,
)?;
}
#[allow(unused_mut)]
let mut scope_5810 = writer.prefix("VolumeId");
if let Some(var_5811) = &input.volume_id {
scope_5810.string(var_5811);
}
#[allow(unused_mut)]
let mut scope_5812 = writer.prefix("DryRun");
if let Some(var_5813) = &input.dry_run {
scope_5812.boolean(*var_5813);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpc_attribute(
input: &crate::input::ModifyVpcAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpcAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5814 = writer.prefix("EnableDnsHostnames");
if let Some(var_5815) = &input.enable_dns_hostnames {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5814, var_5815,
)?;
}
#[allow(unused_mut)]
let mut scope_5816 = writer.prefix("EnableDnsSupport");
if let Some(var_5817) = &input.enable_dns_support {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5816, var_5817,
)?;
}
#[allow(unused_mut)]
let mut scope_5818 = writer.prefix("VpcId");
if let Some(var_5819) = &input.vpc_id {
scope_5818.string(var_5819);
}
#[allow(unused_mut)]
let mut scope_5820 = writer.prefix("EnableNetworkAddressUsageMetrics");
if let Some(var_5821) = &input.enable_network_address_usage_metrics {
crate::query_ser::serialize_structure_crate_model_attribute_boolean_value(
scope_5820, var_5821,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpc_endpoint(
input: &crate::input::ModifyVpcEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpcEndpoint", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5822 = writer.prefix("DryRun");
if let Some(var_5823) = &input.dry_run {
scope_5822.boolean(*var_5823);
}
#[allow(unused_mut)]
let mut scope_5824 = writer.prefix("VpcEndpointId");
if let Some(var_5825) = &input.vpc_endpoint_id {
scope_5824.string(var_5825);
}
#[allow(unused_mut)]
let mut scope_5826 = writer.prefix("ResetPolicy");
if let Some(var_5827) = &input.reset_policy {
scope_5826.boolean(*var_5827);
}
#[allow(unused_mut)]
let mut scope_5828 = writer.prefix("PolicyDocument");
if let Some(var_5829) = &input.policy_document {
scope_5828.string(var_5829);
}
#[allow(unused_mut)]
let mut scope_5830 = writer.prefix("AddRouteTableId");
if let Some(var_5831) = &input.add_route_table_ids {
let mut list_5833 = scope_5830.start_list(true, Some("item"));
for item_5832 in var_5831 {
#[allow(unused_mut)]
let mut entry_5834 = list_5833.entry();
entry_5834.string(item_5832);
}
list_5833.finish();
}
#[allow(unused_mut)]
let mut scope_5835 = writer.prefix("RemoveRouteTableId");
if let Some(var_5836) = &input.remove_route_table_ids {
let mut list_5838 = scope_5835.start_list(true, Some("item"));
for item_5837 in var_5836 {
#[allow(unused_mut)]
let mut entry_5839 = list_5838.entry();
entry_5839.string(item_5837);
}
list_5838.finish();
}
#[allow(unused_mut)]
let mut scope_5840 = writer.prefix("AddSubnetId");
if let Some(var_5841) = &input.add_subnet_ids {
let mut list_5843 = scope_5840.start_list(true, Some("item"));
for item_5842 in var_5841 {
#[allow(unused_mut)]
let mut entry_5844 = list_5843.entry();
entry_5844.string(item_5842);
}
list_5843.finish();
}
#[allow(unused_mut)]
let mut scope_5845 = writer.prefix("RemoveSubnetId");
if let Some(var_5846) = &input.remove_subnet_ids {
let mut list_5848 = scope_5845.start_list(true, Some("item"));
for item_5847 in var_5846 {
#[allow(unused_mut)]
let mut entry_5849 = list_5848.entry();
entry_5849.string(item_5847);
}
list_5848.finish();
}
#[allow(unused_mut)]
let mut scope_5850 = writer.prefix("AddSecurityGroupId");
if let Some(var_5851) = &input.add_security_group_ids {
let mut list_5853 = scope_5850.start_list(true, Some("item"));
for item_5852 in var_5851 {
#[allow(unused_mut)]
let mut entry_5854 = list_5853.entry();
entry_5854.string(item_5852);
}
list_5853.finish();
}
#[allow(unused_mut)]
let mut scope_5855 = writer.prefix("RemoveSecurityGroupId");
if let Some(var_5856) = &input.remove_security_group_ids {
let mut list_5858 = scope_5855.start_list(true, Some("item"));
for item_5857 in var_5856 {
#[allow(unused_mut)]
let mut entry_5859 = list_5858.entry();
entry_5859.string(item_5857);
}
list_5858.finish();
}
#[allow(unused_mut)]
let mut scope_5860 = writer.prefix("IpAddressType");
if let Some(var_5861) = &input.ip_address_type {
scope_5860.string(var_5861.as_str());
}
#[allow(unused_mut)]
let mut scope_5862 = writer.prefix("DnsOptions");
if let Some(var_5863) = &input.dns_options {
crate::query_ser::serialize_structure_crate_model_dns_options_specification(
scope_5862, var_5863,
)?;
}
#[allow(unused_mut)]
let mut scope_5864 = writer.prefix("PrivateDnsEnabled");
if let Some(var_5865) = &input.private_dns_enabled {
scope_5864.boolean(*var_5865);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpc_endpoint_connection_notification(
input: &crate::input::ModifyVpcEndpointConnectionNotificationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyVpcEndpointConnectionNotification",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5866 = writer.prefix("DryRun");
if let Some(var_5867) = &input.dry_run {
scope_5866.boolean(*var_5867);
}
#[allow(unused_mut)]
let mut scope_5868 = writer.prefix("ConnectionNotificationId");
if let Some(var_5869) = &input.connection_notification_id {
scope_5868.string(var_5869);
}
#[allow(unused_mut)]
let mut scope_5870 = writer.prefix("ConnectionNotificationArn");
if let Some(var_5871) = &input.connection_notification_arn {
scope_5870.string(var_5871);
}
#[allow(unused_mut)]
let mut scope_5872 = writer.prefix("ConnectionEvents");
if let Some(var_5873) = &input.connection_events {
let mut list_5875 = scope_5872.start_list(true, Some("item"));
for item_5874 in var_5873 {
#[allow(unused_mut)]
let mut entry_5876 = list_5875.entry();
entry_5876.string(item_5874);
}
list_5875.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpc_endpoint_service_configuration(
input: &crate::input::ModifyVpcEndpointServiceConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyVpcEndpointServiceConfiguration",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5877 = writer.prefix("DryRun");
if let Some(var_5878) = &input.dry_run {
scope_5877.boolean(*var_5878);
}
#[allow(unused_mut)]
let mut scope_5879 = writer.prefix("ServiceId");
if let Some(var_5880) = &input.service_id {
scope_5879.string(var_5880);
}
#[allow(unused_mut)]
let mut scope_5881 = writer.prefix("PrivateDnsName");
if let Some(var_5882) = &input.private_dns_name {
scope_5881.string(var_5882);
}
#[allow(unused_mut)]
let mut scope_5883 = writer.prefix("RemovePrivateDnsName");
if let Some(var_5884) = &input.remove_private_dns_name {
scope_5883.boolean(*var_5884);
}
#[allow(unused_mut)]
let mut scope_5885 = writer.prefix("AcceptanceRequired");
if let Some(var_5886) = &input.acceptance_required {
scope_5885.boolean(*var_5886);
}
#[allow(unused_mut)]
let mut scope_5887 = writer.prefix("AddNetworkLoadBalancerArn");
if let Some(var_5888) = &input.add_network_load_balancer_arns {
let mut list_5890 = scope_5887.start_list(true, Some("item"));
for item_5889 in var_5888 {
#[allow(unused_mut)]
let mut entry_5891 = list_5890.entry();
entry_5891.string(item_5889);
}
list_5890.finish();
}
#[allow(unused_mut)]
let mut scope_5892 = writer.prefix("RemoveNetworkLoadBalancerArn");
if let Some(var_5893) = &input.remove_network_load_balancer_arns {
let mut list_5895 = scope_5892.start_list(true, Some("item"));
for item_5894 in var_5893 {
#[allow(unused_mut)]
let mut entry_5896 = list_5895.entry();
entry_5896.string(item_5894);
}
list_5895.finish();
}
#[allow(unused_mut)]
let mut scope_5897 = writer.prefix("AddGatewayLoadBalancerArn");
if let Some(var_5898) = &input.add_gateway_load_balancer_arns {
let mut list_5900 = scope_5897.start_list(true, Some("item"));
for item_5899 in var_5898 {
#[allow(unused_mut)]
let mut entry_5901 = list_5900.entry();
entry_5901.string(item_5899);
}
list_5900.finish();
}
#[allow(unused_mut)]
let mut scope_5902 = writer.prefix("RemoveGatewayLoadBalancerArn");
if let Some(var_5903) = &input.remove_gateway_load_balancer_arns {
let mut list_5905 = scope_5902.start_list(true, Some("item"));
for item_5904 in var_5903 {
#[allow(unused_mut)]
let mut entry_5906 = list_5905.entry();
entry_5906.string(item_5904);
}
list_5905.finish();
}
#[allow(unused_mut)]
let mut scope_5907 = writer.prefix("AddSupportedIpAddressType");
if let Some(var_5908) = &input.add_supported_ip_address_types {
let mut list_5910 = scope_5907.start_list(true, Some("item"));
for item_5909 in var_5908 {
#[allow(unused_mut)]
let mut entry_5911 = list_5910.entry();
entry_5911.string(item_5909);
}
list_5910.finish();
}
#[allow(unused_mut)]
let mut scope_5912 = writer.prefix("RemoveSupportedIpAddressType");
if let Some(var_5913) = &input.remove_supported_ip_address_types {
let mut list_5915 = scope_5912.start_list(true, Some("item"));
for item_5914 in var_5913 {
#[allow(unused_mut)]
let mut entry_5916 = list_5915.entry();
entry_5916.string(item_5914);
}
list_5915.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpc_endpoint_service_payer_responsibility(
input: &crate::input::ModifyVpcEndpointServicePayerResponsibilityInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyVpcEndpointServicePayerResponsibility",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5917 = writer.prefix("DryRun");
if let Some(var_5918) = &input.dry_run {
scope_5917.boolean(*var_5918);
}
#[allow(unused_mut)]
let mut scope_5919 = writer.prefix("ServiceId");
if let Some(var_5920) = &input.service_id {
scope_5919.string(var_5920);
}
#[allow(unused_mut)]
let mut scope_5921 = writer.prefix("PayerResponsibility");
if let Some(var_5922) = &input.payer_responsibility {
scope_5921.string(var_5922.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpc_endpoint_service_permissions(
input: &crate::input::ModifyVpcEndpointServicePermissionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyVpcEndpointServicePermissions",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5923 = writer.prefix("DryRun");
if let Some(var_5924) = &input.dry_run {
scope_5923.boolean(*var_5924);
}
#[allow(unused_mut)]
let mut scope_5925 = writer.prefix("ServiceId");
if let Some(var_5926) = &input.service_id {
scope_5925.string(var_5926);
}
#[allow(unused_mut)]
let mut scope_5927 = writer.prefix("AddAllowedPrincipals");
if let Some(var_5928) = &input.add_allowed_principals {
let mut list_5930 = scope_5927.start_list(true, Some("item"));
for item_5929 in var_5928 {
#[allow(unused_mut)]
let mut entry_5931 = list_5930.entry();
entry_5931.string(item_5929);
}
list_5930.finish();
}
#[allow(unused_mut)]
let mut scope_5932 = writer.prefix("RemoveAllowedPrincipals");
if let Some(var_5933) = &input.remove_allowed_principals {
let mut list_5935 = scope_5932.start_list(true, Some("item"));
for item_5934 in var_5933 {
#[allow(unused_mut)]
let mut entry_5936 = list_5935.entry();
entry_5936.string(item_5934);
}
list_5935.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpc_peering_connection_options(
input: &crate::input::ModifyVpcPeeringConnectionOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyVpcPeeringConnectionOptions",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_5937 = writer.prefix("AccepterPeeringConnectionOptions");
if let Some(var_5938) = &input.accepter_peering_connection_options {
crate::query_ser::serialize_structure_crate_model_peering_connection_options_request(
scope_5937, var_5938,
)?;
}
#[allow(unused_mut)]
let mut scope_5939 = writer.prefix("DryRun");
if let Some(var_5940) = &input.dry_run {
scope_5939.boolean(*var_5940);
}
#[allow(unused_mut)]
let mut scope_5941 = writer.prefix("RequesterPeeringConnectionOptions");
if let Some(var_5942) = &input.requester_peering_connection_options {
crate::query_ser::serialize_structure_crate_model_peering_connection_options_request(
scope_5941, var_5942,
)?;
}
#[allow(unused_mut)]
let mut scope_5943 = writer.prefix("VpcPeeringConnectionId");
if let Some(var_5944) = &input.vpc_peering_connection_id {
scope_5943.string(var_5944);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpc_tenancy(
input: &crate::input::ModifyVpcTenancyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpcTenancy", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5945 = writer.prefix("VpcId");
if let Some(var_5946) = &input.vpc_id {
scope_5945.string(var_5946);
}
#[allow(unused_mut)]
let mut scope_5947 = writer.prefix("InstanceTenancy");
if let Some(var_5948) = &input.instance_tenancy {
scope_5947.string(var_5948.as_str());
}
#[allow(unused_mut)]
let mut scope_5949 = writer.prefix("DryRun");
if let Some(var_5950) = &input.dry_run {
scope_5949.boolean(*var_5950);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpn_connection(
input: &crate::input::ModifyVpnConnectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpnConnection", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5951 = writer.prefix("VpnConnectionId");
if let Some(var_5952) = &input.vpn_connection_id {
scope_5951.string(var_5952);
}
#[allow(unused_mut)]
let mut scope_5953 = writer.prefix("TransitGatewayId");
if let Some(var_5954) = &input.transit_gateway_id {
scope_5953.string(var_5954);
}
#[allow(unused_mut)]
let mut scope_5955 = writer.prefix("CustomerGatewayId");
if let Some(var_5956) = &input.customer_gateway_id {
scope_5955.string(var_5956);
}
#[allow(unused_mut)]
let mut scope_5957 = writer.prefix("VpnGatewayId");
if let Some(var_5958) = &input.vpn_gateway_id {
scope_5957.string(var_5958);
}
#[allow(unused_mut)]
let mut scope_5959 = writer.prefix("DryRun");
if let Some(var_5960) = &input.dry_run {
scope_5959.boolean(*var_5960);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpn_connection_options(
input: &crate::input::ModifyVpnConnectionOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpnConnectionOptions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5961 = writer.prefix("VpnConnectionId");
if let Some(var_5962) = &input.vpn_connection_id {
scope_5961.string(var_5962);
}
#[allow(unused_mut)]
let mut scope_5963 = writer.prefix("LocalIpv4NetworkCidr");
if let Some(var_5964) = &input.local_ipv4_network_cidr {
scope_5963.string(var_5964);
}
#[allow(unused_mut)]
let mut scope_5965 = writer.prefix("RemoteIpv4NetworkCidr");
if let Some(var_5966) = &input.remote_ipv4_network_cidr {
scope_5965.string(var_5966);
}
#[allow(unused_mut)]
let mut scope_5967 = writer.prefix("LocalIpv6NetworkCidr");
if let Some(var_5968) = &input.local_ipv6_network_cidr {
scope_5967.string(var_5968);
}
#[allow(unused_mut)]
let mut scope_5969 = writer.prefix("RemoteIpv6NetworkCidr");
if let Some(var_5970) = &input.remote_ipv6_network_cidr {
scope_5969.string(var_5970);
}
#[allow(unused_mut)]
let mut scope_5971 = writer.prefix("DryRun");
if let Some(var_5972) = &input.dry_run {
scope_5971.boolean(*var_5972);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpn_tunnel_certificate(
input: &crate::input::ModifyVpnTunnelCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpnTunnelCertificate", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5973 = writer.prefix("VpnConnectionId");
if let Some(var_5974) = &input.vpn_connection_id {
scope_5973.string(var_5974);
}
#[allow(unused_mut)]
let mut scope_5975 = writer.prefix("VpnTunnelOutsideIpAddress");
if let Some(var_5976) = &input.vpn_tunnel_outside_ip_address {
scope_5975.string(var_5976);
}
#[allow(unused_mut)]
let mut scope_5977 = writer.prefix("DryRun");
if let Some(var_5978) = &input.dry_run {
scope_5977.boolean(*var_5978);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_vpn_tunnel_options(
input: &crate::input::ModifyVpnTunnelOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyVpnTunnelOptions", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5979 = writer.prefix("VpnConnectionId");
if let Some(var_5980) = &input.vpn_connection_id {
scope_5979.string(var_5980);
}
#[allow(unused_mut)]
let mut scope_5981 = writer.prefix("VpnTunnelOutsideIpAddress");
if let Some(var_5982) = &input.vpn_tunnel_outside_ip_address {
scope_5981.string(var_5982);
}
#[allow(unused_mut)]
let mut scope_5983 = writer.prefix("TunnelOptions");
if let Some(var_5984) = &input.tunnel_options {
crate::query_ser::serialize_structure_crate_model_modify_vpn_tunnel_options_specification(
scope_5983, var_5984,
)?;
}
#[allow(unused_mut)]
let mut scope_5985 = writer.prefix("DryRun");
if let Some(var_5986) = &input.dry_run {
scope_5985.boolean(*var_5986);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_monitor_instances(
input: &crate::input::MonitorInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "MonitorInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5987 = writer.prefix("InstanceId");
if let Some(var_5988) = &input.instance_ids {
let mut list_5990 = scope_5987.start_list(true, Some("InstanceId"));
for item_5989 in var_5988 {
#[allow(unused_mut)]
let mut entry_5991 = list_5990.entry();
entry_5991.string(item_5989);
}
list_5990.finish();
}
#[allow(unused_mut)]
let mut scope_5992 = writer.prefix("DryRun");
if let Some(var_5993) = &input.dry_run {
scope_5992.boolean(*var_5993);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_move_address_to_vpc(
input: &crate::input::MoveAddressToVpcInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "MoveAddressToVpc", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5994 = writer.prefix("DryRun");
if let Some(var_5995) = &input.dry_run {
scope_5994.boolean(*var_5995);
}
#[allow(unused_mut)]
let mut scope_5996 = writer.prefix("PublicIp");
if let Some(var_5997) = &input.public_ip {
scope_5996.string(var_5997);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_move_byoip_cidr_to_ipam(
input: &crate::input::MoveByoipCidrToIpamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "MoveByoipCidrToIpam", "2016-11-15");
#[allow(unused_mut)]
let mut scope_5998 = writer.prefix("DryRun");
if let Some(var_5999) = &input.dry_run {
scope_5998.boolean(*var_5999);
}
#[allow(unused_mut)]
let mut scope_6000 = writer.prefix("Cidr");
if let Some(var_6001) = &input.cidr {
scope_6000.string(var_6001);
}
#[allow(unused_mut)]
let mut scope_6002 = writer.prefix("IpamPoolId");
if let Some(var_6003) = &input.ipam_pool_id {
scope_6002.string(var_6003);
}
#[allow(unused_mut)]
let mut scope_6004 = writer.prefix("IpamPoolOwner");
if let Some(var_6005) = &input.ipam_pool_owner {
scope_6004.string(var_6005);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_provision_byoip_cidr(
input: &crate::input::ProvisionByoipCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ProvisionByoipCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6006 = writer.prefix("Cidr");
if let Some(var_6007) = &input.cidr {
scope_6006.string(var_6007);
}
#[allow(unused_mut)]
let mut scope_6008 = writer.prefix("CidrAuthorizationContext");
if let Some(var_6009) = &input.cidr_authorization_context {
crate::query_ser::serialize_structure_crate_model_cidr_authorization_context(
scope_6008, var_6009,
)?;
}
#[allow(unused_mut)]
let mut scope_6010 = writer.prefix("PubliclyAdvertisable");
if let Some(var_6011) = &input.publicly_advertisable {
scope_6010.boolean(*var_6011);
}
#[allow(unused_mut)]
let mut scope_6012 = writer.prefix("Description");
if let Some(var_6013) = &input.description {
scope_6012.string(var_6013);
}
#[allow(unused_mut)]
let mut scope_6014 = writer.prefix("DryRun");
if let Some(var_6015) = &input.dry_run {
scope_6014.boolean(*var_6015);
}
#[allow(unused_mut)]
let mut scope_6016 = writer.prefix("PoolTagSpecification");
if let Some(var_6017) = &input.pool_tag_specifications {
let mut list_6019 = scope_6016.start_list(true, Some("item"));
for item_6018 in var_6017 {
#[allow(unused_mut)]
let mut entry_6020 = list_6019.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_6020, item_6018,
)?;
}
list_6019.finish();
}
#[allow(unused_mut)]
let mut scope_6021 = writer.prefix("MultiRegion");
if let Some(var_6022) = &input.multi_region {
scope_6021.boolean(*var_6022);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_provision_ipam_pool_cidr(
input: &crate::input::ProvisionIpamPoolCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ProvisionIpamPoolCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6023 = writer.prefix("DryRun");
if let Some(var_6024) = &input.dry_run {
scope_6023.boolean(*var_6024);
}
#[allow(unused_mut)]
let mut scope_6025 = writer.prefix("IpamPoolId");
if let Some(var_6026) = &input.ipam_pool_id {
scope_6025.string(var_6026);
}
#[allow(unused_mut)]
let mut scope_6027 = writer.prefix("Cidr");
if let Some(var_6028) = &input.cidr {
scope_6027.string(var_6028);
}
#[allow(unused_mut)]
let mut scope_6029 = writer.prefix("CidrAuthorizationContext");
if let Some(var_6030) = &input.cidr_authorization_context {
crate::query_ser::serialize_structure_crate_model_ipam_cidr_authorization_context(
scope_6029, var_6030,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_provision_public_ipv4_pool_cidr(
input: &crate::input::ProvisionPublicIpv4PoolCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ProvisionPublicIpv4PoolCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6031 = writer.prefix("DryRun");
if let Some(var_6032) = &input.dry_run {
scope_6031.boolean(*var_6032);
}
#[allow(unused_mut)]
let mut scope_6033 = writer.prefix("IpamPoolId");
if let Some(var_6034) = &input.ipam_pool_id {
scope_6033.string(var_6034);
}
#[allow(unused_mut)]
let mut scope_6035 = writer.prefix("PoolId");
if let Some(var_6036) = &input.pool_id {
scope_6035.string(var_6036);
}
#[allow(unused_mut)]
let mut scope_6037 = writer.prefix("NetmaskLength");
if let Some(var_6038) = &input.netmask_length {
scope_6037.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6038).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_purchase_host_reservation(
input: &crate::input::PurchaseHostReservationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PurchaseHostReservation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6039 = writer.prefix("ClientToken");
if let Some(var_6040) = &input.client_token {
scope_6039.string(var_6040);
}
#[allow(unused_mut)]
let mut scope_6041 = writer.prefix("CurrencyCode");
if let Some(var_6042) = &input.currency_code {
scope_6041.string(var_6042.as_str());
}
#[allow(unused_mut)]
let mut scope_6043 = writer.prefix("HostIdSet");
if let Some(var_6044) = &input.host_id_set {
let mut list_6046 = scope_6043.start_list(true, Some("item"));
for item_6045 in var_6044 {
#[allow(unused_mut)]
let mut entry_6047 = list_6046.entry();
entry_6047.string(item_6045);
}
list_6046.finish();
}
#[allow(unused_mut)]
let mut scope_6048 = writer.prefix("LimitPrice");
if let Some(var_6049) = &input.limit_price {
scope_6048.string(var_6049);
}
#[allow(unused_mut)]
let mut scope_6050 = writer.prefix("OfferingId");
if let Some(var_6051) = &input.offering_id {
scope_6050.string(var_6051);
}
#[allow(unused_mut)]
let mut scope_6052 = writer.prefix("TagSpecification");
if let Some(var_6053) = &input.tag_specifications {
let mut list_6055 = scope_6052.start_list(true, Some("item"));
for item_6054 in var_6053 {
#[allow(unused_mut)]
let mut entry_6056 = list_6055.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_6056, item_6054,
)?;
}
list_6055.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_purchase_reserved_instances_offering(
input: &crate::input::PurchaseReservedInstancesOfferingInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"PurchaseReservedInstancesOffering",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6057 = writer.prefix("InstanceCount");
if let Some(var_6058) = &input.instance_count {
scope_6057.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6058).into()),
);
}
#[allow(unused_mut)]
let mut scope_6059 = writer.prefix("ReservedInstancesOfferingId");
if let Some(var_6060) = &input.reserved_instances_offering_id {
scope_6059.string(var_6060);
}
#[allow(unused_mut)]
let mut scope_6061 = writer.prefix("DryRun");
if let Some(var_6062) = &input.dry_run {
scope_6061.boolean(*var_6062);
}
#[allow(unused_mut)]
let mut scope_6063 = writer.prefix("LimitPrice");
if let Some(var_6064) = &input.limit_price {
crate::query_ser::serialize_structure_crate_model_reserved_instance_limit_price(
scope_6063, var_6064,
)?;
}
#[allow(unused_mut)]
let mut scope_6065 = writer.prefix("PurchaseTime");
if let Some(var_6066) = &input.purchase_time {
scope_6065.date_time(var_6066, aws_smithy_types::date_time::Format::DateTime)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_purchase_scheduled_instances(
input: &crate::input::PurchaseScheduledInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PurchaseScheduledInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6067 = writer.prefix("ClientToken");
if let Some(var_6068) = &input.client_token {
scope_6067.string(var_6068);
}
#[allow(unused_mut)]
let mut scope_6069 = writer.prefix("DryRun");
if let Some(var_6070) = &input.dry_run {
scope_6069.boolean(*var_6070);
}
#[allow(unused_mut)]
let mut scope_6071 = writer.prefix("PurchaseRequest");
if let Some(var_6072) = &input.purchase_requests {
let mut list_6074 = scope_6071.start_list(true, Some("PurchaseRequest"));
for item_6073 in var_6072 {
#[allow(unused_mut)]
let mut entry_6075 = list_6074.entry();
crate::query_ser::serialize_structure_crate_model_purchase_request(
entry_6075, item_6073,
)?;
}
list_6074.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reboot_instances(
input: &crate::input::RebootInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RebootInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6076 = writer.prefix("InstanceId");
if let Some(var_6077) = &input.instance_ids {
let mut list_6079 = scope_6076.start_list(true, Some("InstanceId"));
for item_6078 in var_6077 {
#[allow(unused_mut)]
let mut entry_6080 = list_6079.entry();
entry_6080.string(item_6078);
}
list_6079.finish();
}
#[allow(unused_mut)]
let mut scope_6081 = writer.prefix("DryRun");
if let Some(var_6082) = &input.dry_run {
scope_6081.boolean(*var_6082);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_register_image(
input: &crate::input::RegisterImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RegisterImage", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6083 = writer.prefix("ImageLocation");
if let Some(var_6084) = &input.image_location {
scope_6083.string(var_6084);
}
#[allow(unused_mut)]
let mut scope_6085 = writer.prefix("Architecture");
if let Some(var_6086) = &input.architecture {
scope_6085.string(var_6086.as_str());
}
#[allow(unused_mut)]
let mut scope_6087 = writer.prefix("BlockDeviceMapping");
if let Some(var_6088) = &input.block_device_mappings {
let mut list_6090 = scope_6087.start_list(true, Some("BlockDeviceMapping"));
for item_6089 in var_6088 {
#[allow(unused_mut)]
let mut entry_6091 = list_6090.entry();
crate::query_ser::serialize_structure_crate_model_block_device_mapping(
entry_6091, item_6089,
)?;
}
list_6090.finish();
}
#[allow(unused_mut)]
let mut scope_6092 = writer.prefix("Description");
if let Some(var_6093) = &input.description {
scope_6092.string(var_6093);
}
#[allow(unused_mut)]
let mut scope_6094 = writer.prefix("DryRun");
if let Some(var_6095) = &input.dry_run {
scope_6094.boolean(*var_6095);
}
#[allow(unused_mut)]
let mut scope_6096 = writer.prefix("EnaSupport");
if let Some(var_6097) = &input.ena_support {
scope_6096.boolean(*var_6097);
}
#[allow(unused_mut)]
let mut scope_6098 = writer.prefix("KernelId");
if let Some(var_6099) = &input.kernel_id {
scope_6098.string(var_6099);
}
#[allow(unused_mut)]
let mut scope_6100 = writer.prefix("Name");
if let Some(var_6101) = &input.name {
scope_6100.string(var_6101);
}
#[allow(unused_mut)]
let mut scope_6102 = writer.prefix("BillingProduct");
if let Some(var_6103) = &input.billing_products {
let mut list_6105 = scope_6102.start_list(true, Some("item"));
for item_6104 in var_6103 {
#[allow(unused_mut)]
let mut entry_6106 = list_6105.entry();
entry_6106.string(item_6104);
}
list_6105.finish();
}
#[allow(unused_mut)]
let mut scope_6107 = writer.prefix("RamdiskId");
if let Some(var_6108) = &input.ramdisk_id {
scope_6107.string(var_6108);
}
#[allow(unused_mut)]
let mut scope_6109 = writer.prefix("RootDeviceName");
if let Some(var_6110) = &input.root_device_name {
scope_6109.string(var_6110);
}
#[allow(unused_mut)]
let mut scope_6111 = writer.prefix("SriovNetSupport");
if let Some(var_6112) = &input.sriov_net_support {
scope_6111.string(var_6112);
}
#[allow(unused_mut)]
let mut scope_6113 = writer.prefix("VirtualizationType");
if let Some(var_6114) = &input.virtualization_type {
scope_6113.string(var_6114);
}
#[allow(unused_mut)]
let mut scope_6115 = writer.prefix("BootMode");
if let Some(var_6116) = &input.boot_mode {
scope_6115.string(var_6116.as_str());
}
#[allow(unused_mut)]
let mut scope_6117 = writer.prefix("TpmSupport");
if let Some(var_6118) = &input.tpm_support {
scope_6117.string(var_6118.as_str());
}
#[allow(unused_mut)]
let mut scope_6119 = writer.prefix("UefiData");
if let Some(var_6120) = &input.uefi_data {
scope_6119.string(var_6120);
}
#[allow(unused_mut)]
let mut scope_6121 = writer.prefix("ImdsSupport");
if let Some(var_6122) = &input.imds_support {
scope_6121.string(var_6122.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_register_instance_event_notification_attributes(
input: &crate::input::RegisterInstanceEventNotificationAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RegisterInstanceEventNotificationAttributes",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6123 = writer.prefix("DryRun");
if let Some(var_6124) = &input.dry_run {
scope_6123.boolean(*var_6124);
}
#[allow(unused_mut)]
let mut scope_6125 = writer.prefix("InstanceTagAttribute");
if let Some(var_6126) = &input.instance_tag_attribute {
crate::query_ser::serialize_structure_crate_model_register_instance_tag_attribute_request(
scope_6125, var_6126,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_register_transit_gateway_multicast_group_members(
input: &crate::input::RegisterTransitGatewayMulticastGroupMembersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RegisterTransitGatewayMulticastGroupMembers",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6127 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_6128) = &input.transit_gateway_multicast_domain_id {
scope_6127.string(var_6128);
}
#[allow(unused_mut)]
let mut scope_6129 = writer.prefix("GroupIpAddress");
if let Some(var_6130) = &input.group_ip_address {
scope_6129.string(var_6130);
}
#[allow(unused_mut)]
let mut scope_6131 = writer.prefix("NetworkInterfaceIds");
if let Some(var_6132) = &input.network_interface_ids {
let mut list_6134 = scope_6131.start_list(true, Some("item"));
for item_6133 in var_6132 {
#[allow(unused_mut)]
let mut entry_6135 = list_6134.entry();
entry_6135.string(item_6133);
}
list_6134.finish();
}
#[allow(unused_mut)]
let mut scope_6136 = writer.prefix("DryRun");
if let Some(var_6137) = &input.dry_run {
scope_6136.boolean(*var_6137);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_register_transit_gateway_multicast_group_sources(
input: &crate::input::RegisterTransitGatewayMulticastGroupSourcesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RegisterTransitGatewayMulticastGroupSources",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6138 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_6139) = &input.transit_gateway_multicast_domain_id {
scope_6138.string(var_6139);
}
#[allow(unused_mut)]
let mut scope_6140 = writer.prefix("GroupIpAddress");
if let Some(var_6141) = &input.group_ip_address {
scope_6140.string(var_6141);
}
#[allow(unused_mut)]
let mut scope_6142 = writer.prefix("NetworkInterfaceIds");
if let Some(var_6143) = &input.network_interface_ids {
let mut list_6145 = scope_6142.start_list(true, Some("item"));
for item_6144 in var_6143 {
#[allow(unused_mut)]
let mut entry_6146 = list_6145.entry();
entry_6146.string(item_6144);
}
list_6145.finish();
}
#[allow(unused_mut)]
let mut scope_6147 = writer.prefix("DryRun");
if let Some(var_6148) = &input.dry_run {
scope_6147.boolean(*var_6148);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reject_transit_gateway_multicast_domain_associations(
input: &crate::input::RejectTransitGatewayMulticastDomainAssociationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RejectTransitGatewayMulticastDomainAssociations",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6149 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_6150) = &input.transit_gateway_multicast_domain_id {
scope_6149.string(var_6150);
}
#[allow(unused_mut)]
let mut scope_6151 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_6152) = &input.transit_gateway_attachment_id {
scope_6151.string(var_6152);
}
#[allow(unused_mut)]
let mut scope_6153 = writer.prefix("SubnetIds");
if let Some(var_6154) = &input.subnet_ids {
let mut list_6156 = scope_6153.start_list(true, Some("item"));
for item_6155 in var_6154 {
#[allow(unused_mut)]
let mut entry_6157 = list_6156.entry();
entry_6157.string(item_6155);
}
list_6156.finish();
}
#[allow(unused_mut)]
let mut scope_6158 = writer.prefix("DryRun");
if let Some(var_6159) = &input.dry_run {
scope_6158.boolean(*var_6159);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reject_transit_gateway_peering_attachment(
input: &crate::input::RejectTransitGatewayPeeringAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RejectTransitGatewayPeeringAttachment",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6160 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_6161) = &input.transit_gateway_attachment_id {
scope_6160.string(var_6161);
}
#[allow(unused_mut)]
let mut scope_6162 = writer.prefix("DryRun");
if let Some(var_6163) = &input.dry_run {
scope_6162.boolean(*var_6163);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reject_transit_gateway_vpc_attachment(
input: &crate::input::RejectTransitGatewayVpcAttachmentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RejectTransitGatewayVpcAttachment",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6164 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_6165) = &input.transit_gateway_attachment_id {
scope_6164.string(var_6165);
}
#[allow(unused_mut)]
let mut scope_6166 = writer.prefix("DryRun");
if let Some(var_6167) = &input.dry_run {
scope_6166.boolean(*var_6167);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reject_vpc_endpoint_connections(
input: &crate::input::RejectVpcEndpointConnectionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RejectVpcEndpointConnections", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6168 = writer.prefix("DryRun");
if let Some(var_6169) = &input.dry_run {
scope_6168.boolean(*var_6169);
}
#[allow(unused_mut)]
let mut scope_6170 = writer.prefix("ServiceId");
if let Some(var_6171) = &input.service_id {
scope_6170.string(var_6171);
}
#[allow(unused_mut)]
let mut scope_6172 = writer.prefix("VpcEndpointId");
if let Some(var_6173) = &input.vpc_endpoint_ids {
let mut list_6175 = scope_6172.start_list(true, Some("item"));
for item_6174 in var_6173 {
#[allow(unused_mut)]
let mut entry_6176 = list_6175.entry();
entry_6176.string(item_6174);
}
list_6175.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reject_vpc_peering_connection(
input: &crate::input::RejectVpcPeeringConnectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RejectVpcPeeringConnection", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6177 = writer.prefix("DryRun");
if let Some(var_6178) = &input.dry_run {
scope_6177.boolean(*var_6178);
}
#[allow(unused_mut)]
let mut scope_6179 = writer.prefix("VpcPeeringConnectionId");
if let Some(var_6180) = &input.vpc_peering_connection_id {
scope_6179.string(var_6180);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_release_address(
input: &crate::input::ReleaseAddressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ReleaseAddress", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6181 = writer.prefix("AllocationId");
if let Some(var_6182) = &input.allocation_id {
scope_6181.string(var_6182);
}
#[allow(unused_mut)]
let mut scope_6183 = writer.prefix("PublicIp");
if let Some(var_6184) = &input.public_ip {
scope_6183.string(var_6184);
}
#[allow(unused_mut)]
let mut scope_6185 = writer.prefix("NetworkBorderGroup");
if let Some(var_6186) = &input.network_border_group {
scope_6185.string(var_6186);
}
#[allow(unused_mut)]
let mut scope_6187 = writer.prefix("DryRun");
if let Some(var_6188) = &input.dry_run {
scope_6187.boolean(*var_6188);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_release_hosts(
input: &crate::input::ReleaseHostsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ReleaseHosts", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6189 = writer.prefix("HostId");
if let Some(var_6190) = &input.host_ids {
let mut list_6192 = scope_6189.start_list(true, Some("item"));
for item_6191 in var_6190 {
#[allow(unused_mut)]
let mut entry_6193 = list_6192.entry();
entry_6193.string(item_6191);
}
list_6192.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_release_ipam_pool_allocation(
input: &crate::input::ReleaseIpamPoolAllocationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ReleaseIpamPoolAllocation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6194 = writer.prefix("DryRun");
if let Some(var_6195) = &input.dry_run {
scope_6194.boolean(*var_6195);
}
#[allow(unused_mut)]
let mut scope_6196 = writer.prefix("IpamPoolId");
if let Some(var_6197) = &input.ipam_pool_id {
scope_6196.string(var_6197);
}
#[allow(unused_mut)]
let mut scope_6198 = writer.prefix("Cidr");
if let Some(var_6199) = &input.cidr {
scope_6198.string(var_6199);
}
#[allow(unused_mut)]
let mut scope_6200 = writer.prefix("IpamPoolAllocationId");
if let Some(var_6201) = &input.ipam_pool_allocation_id {
scope_6200.string(var_6201);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_replace_iam_instance_profile_association(
input: &crate::input::ReplaceIamInstanceProfileAssociationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ReplaceIamInstanceProfileAssociation",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6202 = writer.prefix("IamInstanceProfile");
if let Some(var_6203) = &input.iam_instance_profile {
crate::query_ser::serialize_structure_crate_model_iam_instance_profile_specification(
scope_6202, var_6203,
)?;
}
#[allow(unused_mut)]
let mut scope_6204 = writer.prefix("AssociationId");
if let Some(var_6205) = &input.association_id {
scope_6204.string(var_6205);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_replace_network_acl_association(
input: &crate::input::ReplaceNetworkAclAssociationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ReplaceNetworkAclAssociation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6206 = writer.prefix("AssociationId");
if let Some(var_6207) = &input.association_id {
scope_6206.string(var_6207);
}
#[allow(unused_mut)]
let mut scope_6208 = writer.prefix("DryRun");
if let Some(var_6209) = &input.dry_run {
scope_6208.boolean(*var_6209);
}
#[allow(unused_mut)]
let mut scope_6210 = writer.prefix("NetworkAclId");
if let Some(var_6211) = &input.network_acl_id {
scope_6210.string(var_6211);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_replace_network_acl_entry(
input: &crate::input::ReplaceNetworkAclEntryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ReplaceNetworkAclEntry", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6212 = writer.prefix("CidrBlock");
if let Some(var_6213) = &input.cidr_block {
scope_6212.string(var_6213);
}
#[allow(unused_mut)]
let mut scope_6214 = writer.prefix("DryRun");
if let Some(var_6215) = &input.dry_run {
scope_6214.boolean(*var_6215);
}
#[allow(unused_mut)]
let mut scope_6216 = writer.prefix("Egress");
if let Some(var_6217) = &input.egress {
scope_6216.boolean(*var_6217);
}
#[allow(unused_mut)]
let mut scope_6218 = writer.prefix("Icmp");
if let Some(var_6219) = &input.icmp_type_code {
crate::query_ser::serialize_structure_crate_model_icmp_type_code(scope_6218, var_6219)?;
}
#[allow(unused_mut)]
let mut scope_6220 = writer.prefix("Ipv6CidrBlock");
if let Some(var_6221) = &input.ipv6_cidr_block {
scope_6220.string(var_6221);
}
#[allow(unused_mut)]
let mut scope_6222 = writer.prefix("NetworkAclId");
if let Some(var_6223) = &input.network_acl_id {
scope_6222.string(var_6223);
}
#[allow(unused_mut)]
let mut scope_6224 = writer.prefix("PortRange");
if let Some(var_6225) = &input.port_range {
crate::query_ser::serialize_structure_crate_model_port_range(scope_6224, var_6225)?;
}
#[allow(unused_mut)]
let mut scope_6226 = writer.prefix("Protocol");
if let Some(var_6227) = &input.protocol {
scope_6226.string(var_6227);
}
#[allow(unused_mut)]
let mut scope_6228 = writer.prefix("RuleAction");
if let Some(var_6229) = &input.rule_action {
scope_6228.string(var_6229.as_str());
}
#[allow(unused_mut)]
let mut scope_6230 = writer.prefix("RuleNumber");
if let Some(var_6231) = &input.rule_number {
scope_6230.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6231).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_replace_route(
input: &crate::input::ReplaceRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ReplaceRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6232 = writer.prefix("DestinationCidrBlock");
if let Some(var_6233) = &input.destination_cidr_block {
scope_6232.string(var_6233);
}
#[allow(unused_mut)]
let mut scope_6234 = writer.prefix("DestinationIpv6CidrBlock");
if let Some(var_6235) = &input.destination_ipv6_cidr_block {
scope_6234.string(var_6235);
}
#[allow(unused_mut)]
let mut scope_6236 = writer.prefix("DestinationPrefixListId");
if let Some(var_6237) = &input.destination_prefix_list_id {
scope_6236.string(var_6237);
}
#[allow(unused_mut)]
let mut scope_6238 = writer.prefix("DryRun");
if let Some(var_6239) = &input.dry_run {
scope_6238.boolean(*var_6239);
}
#[allow(unused_mut)]
let mut scope_6240 = writer.prefix("VpcEndpointId");
if let Some(var_6241) = &input.vpc_endpoint_id {
scope_6240.string(var_6241);
}
#[allow(unused_mut)]
let mut scope_6242 = writer.prefix("EgressOnlyInternetGatewayId");
if let Some(var_6243) = &input.egress_only_internet_gateway_id {
scope_6242.string(var_6243);
}
#[allow(unused_mut)]
let mut scope_6244 = writer.prefix("GatewayId");
if let Some(var_6245) = &input.gateway_id {
scope_6244.string(var_6245);
}
#[allow(unused_mut)]
let mut scope_6246 = writer.prefix("InstanceId");
if let Some(var_6247) = &input.instance_id {
scope_6246.string(var_6247);
}
#[allow(unused_mut)]
let mut scope_6248 = writer.prefix("LocalTarget");
if let Some(var_6249) = &input.local_target {
scope_6248.boolean(*var_6249);
}
#[allow(unused_mut)]
let mut scope_6250 = writer.prefix("NatGatewayId");
if let Some(var_6251) = &input.nat_gateway_id {
scope_6250.string(var_6251);
}
#[allow(unused_mut)]
let mut scope_6252 = writer.prefix("TransitGatewayId");
if let Some(var_6253) = &input.transit_gateway_id {
scope_6252.string(var_6253);
}
#[allow(unused_mut)]
let mut scope_6254 = writer.prefix("LocalGatewayId");
if let Some(var_6255) = &input.local_gateway_id {
scope_6254.string(var_6255);
}
#[allow(unused_mut)]
let mut scope_6256 = writer.prefix("CarrierGatewayId");
if let Some(var_6257) = &input.carrier_gateway_id {
scope_6256.string(var_6257);
}
#[allow(unused_mut)]
let mut scope_6258 = writer.prefix("NetworkInterfaceId");
if let Some(var_6259) = &input.network_interface_id {
scope_6258.string(var_6259);
}
#[allow(unused_mut)]
let mut scope_6260 = writer.prefix("RouteTableId");
if let Some(var_6261) = &input.route_table_id {
scope_6260.string(var_6261);
}
#[allow(unused_mut)]
let mut scope_6262 = writer.prefix("VpcPeeringConnectionId");
if let Some(var_6263) = &input.vpc_peering_connection_id {
scope_6262.string(var_6263);
}
#[allow(unused_mut)]
let mut scope_6264 = writer.prefix("CoreNetworkArn");
if let Some(var_6265) = &input.core_network_arn {
scope_6264.string(var_6265);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_replace_route_table_association(
input: &crate::input::ReplaceRouteTableAssociationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ReplaceRouteTableAssociation", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6266 = writer.prefix("AssociationId");
if let Some(var_6267) = &input.association_id {
scope_6266.string(var_6267);
}
#[allow(unused_mut)]
let mut scope_6268 = writer.prefix("DryRun");
if let Some(var_6269) = &input.dry_run {
scope_6268.boolean(*var_6269);
}
#[allow(unused_mut)]
let mut scope_6270 = writer.prefix("RouteTableId");
if let Some(var_6271) = &input.route_table_id {
scope_6270.string(var_6271);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_replace_transit_gateway_route(
input: &crate::input::ReplaceTransitGatewayRouteInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ReplaceTransitGatewayRoute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6272 = writer.prefix("DestinationCidrBlock");
if let Some(var_6273) = &input.destination_cidr_block {
scope_6272.string(var_6273);
}
#[allow(unused_mut)]
let mut scope_6274 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_6275) = &input.transit_gateway_route_table_id {
scope_6274.string(var_6275);
}
#[allow(unused_mut)]
let mut scope_6276 = writer.prefix("TransitGatewayAttachmentId");
if let Some(var_6277) = &input.transit_gateway_attachment_id {
scope_6276.string(var_6277);
}
#[allow(unused_mut)]
let mut scope_6278 = writer.prefix("Blackhole");
if let Some(var_6279) = &input.blackhole {
scope_6278.boolean(*var_6279);
}
#[allow(unused_mut)]
let mut scope_6280 = writer.prefix("DryRun");
if let Some(var_6281) = &input.dry_run {
scope_6280.boolean(*var_6281);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_report_instance_status(
input: &crate::input::ReportInstanceStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ReportInstanceStatus", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6282 = writer.prefix("Description");
if let Some(var_6283) = &input.description {
scope_6282.string(var_6283);
}
#[allow(unused_mut)]
let mut scope_6284 = writer.prefix("DryRun");
if let Some(var_6285) = &input.dry_run {
scope_6284.boolean(*var_6285);
}
#[allow(unused_mut)]
let mut scope_6286 = writer.prefix("EndTime");
if let Some(var_6287) = &input.end_time {
scope_6286.date_time(var_6287, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_6288 = writer.prefix("InstanceId");
if let Some(var_6289) = &input.instances {
let mut list_6291 = scope_6288.start_list(true, Some("InstanceId"));
for item_6290 in var_6289 {
#[allow(unused_mut)]
let mut entry_6292 = list_6291.entry();
entry_6292.string(item_6290);
}
list_6291.finish();
}
#[allow(unused_mut)]
let mut scope_6293 = writer.prefix("ReasonCode");
if let Some(var_6294) = &input.reason_codes {
let mut list_6296 = scope_6293.start_list(true, Some("item"));
for item_6295 in var_6294 {
#[allow(unused_mut)]
let mut entry_6297 = list_6296.entry();
entry_6297.string(item_6295.as_str());
}
list_6296.finish();
}
#[allow(unused_mut)]
let mut scope_6298 = writer.prefix("StartTime");
if let Some(var_6299) = &input.start_time {
scope_6298.date_time(var_6299, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_6300 = writer.prefix("Status");
if let Some(var_6301) = &input.status {
scope_6300.string(var_6301.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_request_spot_fleet(
input: &crate::input::RequestSpotFleetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RequestSpotFleet", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6302 = writer.prefix("DryRun");
if let Some(var_6303) = &input.dry_run {
scope_6302.boolean(*var_6303);
}
#[allow(unused_mut)]
let mut scope_6304 = writer.prefix("SpotFleetRequestConfig");
if let Some(var_6305) = &input.spot_fleet_request_config {
crate::query_ser::serialize_structure_crate_model_spot_fleet_request_config_data(
scope_6304, var_6305,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_request_spot_instances(
input: &crate::input::RequestSpotInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RequestSpotInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6306 = writer.prefix("AvailabilityZoneGroup");
if let Some(var_6307) = &input.availability_zone_group {
scope_6306.string(var_6307);
}
#[allow(unused_mut)]
let mut scope_6308 = writer.prefix("BlockDurationMinutes");
if let Some(var_6309) = &input.block_duration_minutes {
scope_6308.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6309).into()),
);
}
#[allow(unused_mut)]
let mut scope_6310 = writer.prefix("ClientToken");
if let Some(var_6311) = &input.client_token {
scope_6310.string(var_6311);
}
#[allow(unused_mut)]
let mut scope_6312 = writer.prefix("DryRun");
if let Some(var_6313) = &input.dry_run {
scope_6312.boolean(*var_6313);
}
#[allow(unused_mut)]
let mut scope_6314 = writer.prefix("InstanceCount");
if let Some(var_6315) = &input.instance_count {
scope_6314.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6315).into()),
);
}
#[allow(unused_mut)]
let mut scope_6316 = writer.prefix("LaunchGroup");
if let Some(var_6317) = &input.launch_group {
scope_6316.string(var_6317);
}
#[allow(unused_mut)]
let mut scope_6318 = writer.prefix("LaunchSpecification");
if let Some(var_6319) = &input.launch_specification {
crate::query_ser::serialize_structure_crate_model_request_spot_launch_specification(
scope_6318, var_6319,
)?;
}
#[allow(unused_mut)]
let mut scope_6320 = writer.prefix("SpotPrice");
if let Some(var_6321) = &input.spot_price {
scope_6320.string(var_6321);
}
#[allow(unused_mut)]
let mut scope_6322 = writer.prefix("Type");
if let Some(var_6323) = &input.r#type {
scope_6322.string(var_6323.as_str());
}
#[allow(unused_mut)]
let mut scope_6324 = writer.prefix("ValidFrom");
if let Some(var_6325) = &input.valid_from {
scope_6324.date_time(var_6325, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_6326 = writer.prefix("ValidUntil");
if let Some(var_6327) = &input.valid_until {
scope_6326.date_time(var_6327, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_6328 = writer.prefix("TagSpecification");
if let Some(var_6329) = &input.tag_specifications {
let mut list_6331 = scope_6328.start_list(true, Some("item"));
for item_6330 in var_6329 {
#[allow(unused_mut)]
let mut entry_6332 = list_6331.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_6332, item_6330,
)?;
}
list_6331.finish();
}
#[allow(unused_mut)]
let mut scope_6333 = writer.prefix("InstanceInterruptionBehavior");
if let Some(var_6334) = &input.instance_interruption_behavior {
scope_6333.string(var_6334.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_address_attribute(
input: &crate::input::ResetAddressAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ResetAddressAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6335 = writer.prefix("AllocationId");
if let Some(var_6336) = &input.allocation_id {
scope_6335.string(var_6336);
}
#[allow(unused_mut)]
let mut scope_6337 = writer.prefix("Attribute");
if let Some(var_6338) = &input.attribute {
scope_6337.string(var_6338.as_str());
}
#[allow(unused_mut)]
let mut scope_6339 = writer.prefix("DryRun");
if let Some(var_6340) = &input.dry_run {
scope_6339.boolean(*var_6340);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_ebs_default_kms_key_id(
input: &crate::input::ResetEbsDefaultKmsKeyIdInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ResetEbsDefaultKmsKeyId", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6341 = writer.prefix("DryRun");
if let Some(var_6342) = &input.dry_run {
scope_6341.boolean(*var_6342);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_fpga_image_attribute(
input: &crate::input::ResetFpgaImageAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ResetFpgaImageAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6343 = writer.prefix("DryRun");
if let Some(var_6344) = &input.dry_run {
scope_6343.boolean(*var_6344);
}
#[allow(unused_mut)]
let mut scope_6345 = writer.prefix("FpgaImageId");
if let Some(var_6346) = &input.fpga_image_id {
scope_6345.string(var_6346);
}
#[allow(unused_mut)]
let mut scope_6347 = writer.prefix("Attribute");
if let Some(var_6348) = &input.attribute {
scope_6347.string(var_6348.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_image_attribute(
input: &crate::input::ResetImageAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ResetImageAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6349 = writer.prefix("Attribute");
if let Some(var_6350) = &input.attribute {
scope_6349.string(var_6350.as_str());
}
#[allow(unused_mut)]
let mut scope_6351 = writer.prefix("ImageId");
if let Some(var_6352) = &input.image_id {
scope_6351.string(var_6352);
}
#[allow(unused_mut)]
let mut scope_6353 = writer.prefix("DryRun");
if let Some(var_6354) = &input.dry_run {
scope_6353.boolean(*var_6354);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_instance_attribute(
input: &crate::input::ResetInstanceAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ResetInstanceAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6355 = writer.prefix("Attribute");
if let Some(var_6356) = &input.attribute {
scope_6355.string(var_6356.as_str());
}
#[allow(unused_mut)]
let mut scope_6357 = writer.prefix("DryRun");
if let Some(var_6358) = &input.dry_run {
scope_6357.boolean(*var_6358);
}
#[allow(unused_mut)]
let mut scope_6359 = writer.prefix("InstanceId");
if let Some(var_6360) = &input.instance_id {
scope_6359.string(var_6360);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_network_interface_attribute(
input: &crate::input::ResetNetworkInterfaceAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ResetNetworkInterfaceAttribute",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6361 = writer.prefix("DryRun");
if let Some(var_6362) = &input.dry_run {
scope_6361.boolean(*var_6362);
}
#[allow(unused_mut)]
let mut scope_6363 = writer.prefix("NetworkInterfaceId");
if let Some(var_6364) = &input.network_interface_id {
scope_6363.string(var_6364);
}
#[allow(unused_mut)]
let mut scope_6365 = writer.prefix("SourceDestCheck");
if let Some(var_6366) = &input.source_dest_check {
scope_6365.string(var_6366);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_snapshot_attribute(
input: &crate::input::ResetSnapshotAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ResetSnapshotAttribute", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6367 = writer.prefix("Attribute");
if let Some(var_6368) = &input.attribute {
scope_6367.string(var_6368.as_str());
}
#[allow(unused_mut)]
let mut scope_6369 = writer.prefix("SnapshotId");
if let Some(var_6370) = &input.snapshot_id {
scope_6369.string(var_6370);
}
#[allow(unused_mut)]
let mut scope_6371 = writer.prefix("DryRun");
if let Some(var_6372) = &input.dry_run {
scope_6371.boolean(*var_6372);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_address_to_classic(
input: &crate::input::RestoreAddressToClassicInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RestoreAddressToClassic", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6373 = writer.prefix("DryRun");
if let Some(var_6374) = &input.dry_run {
scope_6373.boolean(*var_6374);
}
#[allow(unused_mut)]
let mut scope_6375 = writer.prefix("PublicIp");
if let Some(var_6376) = &input.public_ip {
scope_6375.string(var_6376);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_image_from_recycle_bin(
input: &crate::input::RestoreImageFromRecycleBinInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RestoreImageFromRecycleBin", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6377 = writer.prefix("ImageId");
if let Some(var_6378) = &input.image_id {
scope_6377.string(var_6378);
}
#[allow(unused_mut)]
let mut scope_6379 = writer.prefix("DryRun");
if let Some(var_6380) = &input.dry_run {
scope_6379.boolean(*var_6380);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_managed_prefix_list_version(
input: &crate::input::RestoreManagedPrefixListVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RestoreManagedPrefixListVersion",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6381 = writer.prefix("DryRun");
if let Some(var_6382) = &input.dry_run {
scope_6381.boolean(*var_6382);
}
#[allow(unused_mut)]
let mut scope_6383 = writer.prefix("PrefixListId");
if let Some(var_6384) = &input.prefix_list_id {
scope_6383.string(var_6384);
}
#[allow(unused_mut)]
let mut scope_6385 = writer.prefix("PreviousVersion");
if let Some(var_6386) = &input.previous_version {
scope_6385.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6386).into()),
);
}
#[allow(unused_mut)]
let mut scope_6387 = writer.prefix("CurrentVersion");
if let Some(var_6388) = &input.current_version {
scope_6387.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6388).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_snapshot_from_recycle_bin(
input: &crate::input::RestoreSnapshotFromRecycleBinInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RestoreSnapshotFromRecycleBin", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6389 = writer.prefix("SnapshotId");
if let Some(var_6390) = &input.snapshot_id {
scope_6389.string(var_6390);
}
#[allow(unused_mut)]
let mut scope_6391 = writer.prefix("DryRun");
if let Some(var_6392) = &input.dry_run {
scope_6391.boolean(*var_6392);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_snapshot_tier(
input: &crate::input::RestoreSnapshotTierInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RestoreSnapshotTier", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6393 = writer.prefix("SnapshotId");
if let Some(var_6394) = &input.snapshot_id {
scope_6393.string(var_6394);
}
#[allow(unused_mut)]
let mut scope_6395 = writer.prefix("TemporaryRestoreDays");
if let Some(var_6396) = &input.temporary_restore_days {
scope_6395.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6396).into()),
);
}
#[allow(unused_mut)]
let mut scope_6397 = writer.prefix("PermanentRestore");
if let Some(var_6398) = &input.permanent_restore {
scope_6397.boolean(*var_6398);
}
#[allow(unused_mut)]
let mut scope_6399 = writer.prefix("DryRun");
if let Some(var_6400) = &input.dry_run {
scope_6399.boolean(*var_6400);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_revoke_client_vpn_ingress(
input: &crate::input::RevokeClientVpnIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RevokeClientVpnIngress", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6401 = writer.prefix("ClientVpnEndpointId");
if let Some(var_6402) = &input.client_vpn_endpoint_id {
scope_6401.string(var_6402);
}
#[allow(unused_mut)]
let mut scope_6403 = writer.prefix("TargetNetworkCidr");
if let Some(var_6404) = &input.target_network_cidr {
scope_6403.string(var_6404);
}
#[allow(unused_mut)]
let mut scope_6405 = writer.prefix("AccessGroupId");
if let Some(var_6406) = &input.access_group_id {
scope_6405.string(var_6406);
}
#[allow(unused_mut)]
let mut scope_6407 = writer.prefix("RevokeAllGroups");
if let Some(var_6408) = &input.revoke_all_groups {
scope_6407.boolean(*var_6408);
}
#[allow(unused_mut)]
let mut scope_6409 = writer.prefix("DryRun");
if let Some(var_6410) = &input.dry_run {
scope_6409.boolean(*var_6410);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_revoke_security_group_egress(
input: &crate::input::RevokeSecurityGroupEgressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RevokeSecurityGroupEgress", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6411 = writer.prefix("DryRun");
if let Some(var_6412) = &input.dry_run {
scope_6411.boolean(*var_6412);
}
#[allow(unused_mut)]
let mut scope_6413 = writer.prefix("GroupId");
if let Some(var_6414) = &input.group_id {
scope_6413.string(var_6414);
}
#[allow(unused_mut)]
let mut scope_6415 = writer.prefix("IpPermissions");
if let Some(var_6416) = &input.ip_permissions {
let mut list_6418 = scope_6415.start_list(true, Some("item"));
for item_6417 in var_6416 {
#[allow(unused_mut)]
let mut entry_6419 = list_6418.entry();
crate::query_ser::serialize_structure_crate_model_ip_permission(entry_6419, item_6417)?;
}
list_6418.finish();
}
#[allow(unused_mut)]
let mut scope_6420 = writer.prefix("SecurityGroupRuleId");
if let Some(var_6421) = &input.security_group_rule_ids {
let mut list_6423 = scope_6420.start_list(true, Some("item"));
for item_6422 in var_6421 {
#[allow(unused_mut)]
let mut entry_6424 = list_6423.entry();
entry_6424.string(item_6422);
}
list_6423.finish();
}
#[allow(unused_mut)]
let mut scope_6425 = writer.prefix("CidrIp");
if let Some(var_6426) = &input.cidr_ip {
scope_6425.string(var_6426);
}
#[allow(unused_mut)]
let mut scope_6427 = writer.prefix("FromPort");
if let Some(var_6428) = &input.from_port {
scope_6427.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6428).into()),
);
}
#[allow(unused_mut)]
let mut scope_6429 = writer.prefix("IpProtocol");
if let Some(var_6430) = &input.ip_protocol {
scope_6429.string(var_6430);
}
#[allow(unused_mut)]
let mut scope_6431 = writer.prefix("ToPort");
if let Some(var_6432) = &input.to_port {
scope_6431.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6432).into()),
);
}
#[allow(unused_mut)]
let mut scope_6433 = writer.prefix("SourceSecurityGroupName");
if let Some(var_6434) = &input.source_security_group_name {
scope_6433.string(var_6434);
}
#[allow(unused_mut)]
let mut scope_6435 = writer.prefix("SourceSecurityGroupOwnerId");
if let Some(var_6436) = &input.source_security_group_owner_id {
scope_6435.string(var_6436);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_revoke_security_group_ingress(
input: &crate::input::RevokeSecurityGroupIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RevokeSecurityGroupIngress", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6437 = writer.prefix("CidrIp");
if let Some(var_6438) = &input.cidr_ip {
scope_6437.string(var_6438);
}
#[allow(unused_mut)]
let mut scope_6439 = writer.prefix("FromPort");
if let Some(var_6440) = &input.from_port {
scope_6439.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6440).into()),
);
}
#[allow(unused_mut)]
let mut scope_6441 = writer.prefix("GroupId");
if let Some(var_6442) = &input.group_id {
scope_6441.string(var_6442);
}
#[allow(unused_mut)]
let mut scope_6443 = writer.prefix("GroupName");
if let Some(var_6444) = &input.group_name {
scope_6443.string(var_6444);
}
#[allow(unused_mut)]
let mut scope_6445 = writer.prefix("IpPermissions");
if let Some(var_6446) = &input.ip_permissions {
let mut list_6448 = scope_6445.start_list(true, Some("item"));
for item_6447 in var_6446 {
#[allow(unused_mut)]
let mut entry_6449 = list_6448.entry();
crate::query_ser::serialize_structure_crate_model_ip_permission(entry_6449, item_6447)?;
}
list_6448.finish();
}
#[allow(unused_mut)]
let mut scope_6450 = writer.prefix("IpProtocol");
if let Some(var_6451) = &input.ip_protocol {
scope_6450.string(var_6451);
}
#[allow(unused_mut)]
let mut scope_6452 = writer.prefix("SourceSecurityGroupName");
if let Some(var_6453) = &input.source_security_group_name {
scope_6452.string(var_6453);
}
#[allow(unused_mut)]
let mut scope_6454 = writer.prefix("SourceSecurityGroupOwnerId");
if let Some(var_6455) = &input.source_security_group_owner_id {
scope_6454.string(var_6455);
}
#[allow(unused_mut)]
let mut scope_6456 = writer.prefix("ToPort");
if let Some(var_6457) = &input.to_port {
scope_6456.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6457).into()),
);
}
#[allow(unused_mut)]
let mut scope_6458 = writer.prefix("DryRun");
if let Some(var_6459) = &input.dry_run {
scope_6458.boolean(*var_6459);
}
#[allow(unused_mut)]
let mut scope_6460 = writer.prefix("SecurityGroupRuleId");
if let Some(var_6461) = &input.security_group_rule_ids {
let mut list_6463 = scope_6460.start_list(true, Some("item"));
for item_6462 in var_6461 {
#[allow(unused_mut)]
let mut entry_6464 = list_6463.entry();
entry_6464.string(item_6462);
}
list_6463.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_run_instances(
input: &crate::input::RunInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RunInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6465 = writer.prefix("BlockDeviceMapping");
if let Some(var_6466) = &input.block_device_mappings {
let mut list_6468 = scope_6465.start_list(true, Some("BlockDeviceMapping"));
for item_6467 in var_6466 {
#[allow(unused_mut)]
let mut entry_6469 = list_6468.entry();
crate::query_ser::serialize_structure_crate_model_block_device_mapping(
entry_6469, item_6467,
)?;
}
list_6468.finish();
}
#[allow(unused_mut)]
let mut scope_6470 = writer.prefix("ImageId");
if let Some(var_6471) = &input.image_id {
scope_6470.string(var_6471);
}
#[allow(unused_mut)]
let mut scope_6472 = writer.prefix("InstanceType");
if let Some(var_6473) = &input.instance_type {
scope_6472.string(var_6473.as_str());
}
#[allow(unused_mut)]
let mut scope_6474 = writer.prefix("Ipv6AddressCount");
if let Some(var_6475) = &input.ipv6_address_count {
scope_6474.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6475).into()),
);
}
#[allow(unused_mut)]
let mut scope_6476 = writer.prefix("Ipv6Address");
if let Some(var_6477) = &input.ipv6_addresses {
let mut list_6479 = scope_6476.start_list(true, Some("item"));
for item_6478 in var_6477 {
#[allow(unused_mut)]
let mut entry_6480 = list_6479.entry();
crate::query_ser::serialize_structure_crate_model_instance_ipv6_address(
entry_6480, item_6478,
)?;
}
list_6479.finish();
}
#[allow(unused_mut)]
let mut scope_6481 = writer.prefix("KernelId");
if let Some(var_6482) = &input.kernel_id {
scope_6481.string(var_6482);
}
#[allow(unused_mut)]
let mut scope_6483 = writer.prefix("KeyName");
if let Some(var_6484) = &input.key_name {
scope_6483.string(var_6484);
}
#[allow(unused_mut)]
let mut scope_6485 = writer.prefix("MaxCount");
if let Some(var_6486) = &input.max_count {
scope_6485.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6486).into()),
);
}
#[allow(unused_mut)]
let mut scope_6487 = writer.prefix("MinCount");
if let Some(var_6488) = &input.min_count {
scope_6487.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6488).into()),
);
}
#[allow(unused_mut)]
let mut scope_6489 = writer.prefix("Monitoring");
if let Some(var_6490) = &input.monitoring {
crate::query_ser::serialize_structure_crate_model_run_instances_monitoring_enabled(
scope_6489, var_6490,
)?;
}
#[allow(unused_mut)]
let mut scope_6491 = writer.prefix("Placement");
if let Some(var_6492) = &input.placement {
crate::query_ser::serialize_structure_crate_model_placement(scope_6491, var_6492)?;
}
#[allow(unused_mut)]
let mut scope_6493 = writer.prefix("RamdiskId");
if let Some(var_6494) = &input.ramdisk_id {
scope_6493.string(var_6494);
}
#[allow(unused_mut)]
let mut scope_6495 = writer.prefix("SecurityGroupId");
if let Some(var_6496) = &input.security_group_ids {
let mut list_6498 = scope_6495.start_list(true, Some("SecurityGroupId"));
for item_6497 in var_6496 {
#[allow(unused_mut)]
let mut entry_6499 = list_6498.entry();
entry_6499.string(item_6497);
}
list_6498.finish();
}
#[allow(unused_mut)]
let mut scope_6500 = writer.prefix("SecurityGroup");
if let Some(var_6501) = &input.security_groups {
let mut list_6503 = scope_6500.start_list(true, Some("SecurityGroup"));
for item_6502 in var_6501 {
#[allow(unused_mut)]
let mut entry_6504 = list_6503.entry();
entry_6504.string(item_6502);
}
list_6503.finish();
}
#[allow(unused_mut)]
let mut scope_6505 = writer.prefix("SubnetId");
if let Some(var_6506) = &input.subnet_id {
scope_6505.string(var_6506);
}
#[allow(unused_mut)]
let mut scope_6507 = writer.prefix("UserData");
if let Some(var_6508) = &input.user_data {
scope_6507.string(var_6508);
}
#[allow(unused_mut)]
let mut scope_6509 = writer.prefix("AdditionalInfo");
if let Some(var_6510) = &input.additional_info {
scope_6509.string(var_6510);
}
#[allow(unused_mut)]
let mut scope_6511 = writer.prefix("ClientToken");
if let Some(var_6512) = &input.client_token {
scope_6511.string(var_6512);
}
#[allow(unused_mut)]
let mut scope_6513 = writer.prefix("DisableApiTermination");
if let Some(var_6514) = &input.disable_api_termination {
scope_6513.boolean(*var_6514);
}
#[allow(unused_mut)]
let mut scope_6515 = writer.prefix("DryRun");
if let Some(var_6516) = &input.dry_run {
scope_6515.boolean(*var_6516);
}
#[allow(unused_mut)]
let mut scope_6517 = writer.prefix("EbsOptimized");
if let Some(var_6518) = &input.ebs_optimized {
scope_6517.boolean(*var_6518);
}
#[allow(unused_mut)]
let mut scope_6519 = writer.prefix("IamInstanceProfile");
if let Some(var_6520) = &input.iam_instance_profile {
crate::query_ser::serialize_structure_crate_model_iam_instance_profile_specification(
scope_6519, var_6520,
)?;
}
#[allow(unused_mut)]
let mut scope_6521 = writer.prefix("InstanceInitiatedShutdownBehavior");
if let Some(var_6522) = &input.instance_initiated_shutdown_behavior {
scope_6521.string(var_6522.as_str());
}
#[allow(unused_mut)]
let mut scope_6523 = writer.prefix("NetworkInterface");
if let Some(var_6524) = &input.network_interfaces {
let mut list_6526 = scope_6523.start_list(true, Some("item"));
for item_6525 in var_6524 {
#[allow(unused_mut)]
let mut entry_6527 = list_6526.entry();
crate::query_ser::serialize_structure_crate_model_instance_network_interface_specification(entry_6527, item_6525)?;
}
list_6526.finish();
}
#[allow(unused_mut)]
let mut scope_6528 = writer.prefix("PrivateIpAddress");
if let Some(var_6529) = &input.private_ip_address {
scope_6528.string(var_6529);
}
#[allow(unused_mut)]
let mut scope_6530 = writer.prefix("ElasticGpuSpecification");
if let Some(var_6531) = &input.elastic_gpu_specification {
let mut list_6533 = scope_6530.start_list(true, Some("item"));
for item_6532 in var_6531 {
#[allow(unused_mut)]
let mut entry_6534 = list_6533.entry();
crate::query_ser::serialize_structure_crate_model_elastic_gpu_specification(
entry_6534, item_6532,
)?;
}
list_6533.finish();
}
#[allow(unused_mut)]
let mut scope_6535 = writer.prefix("ElasticInferenceAccelerator");
if let Some(var_6536) = &input.elastic_inference_accelerators {
let mut list_6538 = scope_6535.start_list(true, Some("item"));
for item_6537 in var_6536 {
#[allow(unused_mut)]
let mut entry_6539 = list_6538.entry();
crate::query_ser::serialize_structure_crate_model_elastic_inference_accelerator(
entry_6539, item_6537,
)?;
}
list_6538.finish();
}
#[allow(unused_mut)]
let mut scope_6540 = writer.prefix("TagSpecification");
if let Some(var_6541) = &input.tag_specifications {
let mut list_6543 = scope_6540.start_list(true, Some("item"));
for item_6542 in var_6541 {
#[allow(unused_mut)]
let mut entry_6544 = list_6543.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_6544, item_6542,
)?;
}
list_6543.finish();
}
#[allow(unused_mut)]
let mut scope_6545 = writer.prefix("LaunchTemplate");
if let Some(var_6546) = &input.launch_template {
crate::query_ser::serialize_structure_crate_model_launch_template_specification(
scope_6545, var_6546,
)?;
}
#[allow(unused_mut)]
let mut scope_6547 = writer.prefix("InstanceMarketOptions");
if let Some(var_6548) = &input.instance_market_options {
crate::query_ser::serialize_structure_crate_model_instance_market_options_request(
scope_6547, var_6548,
)?;
}
#[allow(unused_mut)]
let mut scope_6549 = writer.prefix("CreditSpecification");
if let Some(var_6550) = &input.credit_specification {
crate::query_ser::serialize_structure_crate_model_credit_specification_request(
scope_6549, var_6550,
)?;
}
#[allow(unused_mut)]
let mut scope_6551 = writer.prefix("CpuOptions");
if let Some(var_6552) = &input.cpu_options {
crate::query_ser::serialize_structure_crate_model_cpu_options_request(
scope_6551, var_6552,
)?;
}
#[allow(unused_mut)]
let mut scope_6553 = writer.prefix("CapacityReservationSpecification");
if let Some(var_6554) = &input.capacity_reservation_specification {
crate::query_ser::serialize_structure_crate_model_capacity_reservation_specification(
scope_6553, var_6554,
)?;
}
#[allow(unused_mut)]
let mut scope_6555 = writer.prefix("HibernationOptions");
if let Some(var_6556) = &input.hibernation_options {
crate::query_ser::serialize_structure_crate_model_hibernation_options_request(
scope_6555, var_6556,
)?;
}
#[allow(unused_mut)]
let mut scope_6557 = writer.prefix("LicenseSpecification");
if let Some(var_6558) = &input.license_specifications {
let mut list_6560 = scope_6557.start_list(true, Some("item"));
for item_6559 in var_6558 {
#[allow(unused_mut)]
let mut entry_6561 = list_6560.entry();
crate::query_ser::serialize_structure_crate_model_license_configuration_request(
entry_6561, item_6559,
)?;
}
list_6560.finish();
}
#[allow(unused_mut)]
let mut scope_6562 = writer.prefix("MetadataOptions");
if let Some(var_6563) = &input.metadata_options {
crate::query_ser::serialize_structure_crate_model_instance_metadata_options_request(
scope_6562, var_6563,
)?;
}
#[allow(unused_mut)]
let mut scope_6564 = writer.prefix("EnclaveOptions");
if let Some(var_6565) = &input.enclave_options {
crate::query_ser::serialize_structure_crate_model_enclave_options_request(
scope_6564, var_6565,
)?;
}
#[allow(unused_mut)]
let mut scope_6566 = writer.prefix("PrivateDnsNameOptions");
if let Some(var_6567) = &input.private_dns_name_options {
crate::query_ser::serialize_structure_crate_model_private_dns_name_options_request(
scope_6566, var_6567,
)?;
}
#[allow(unused_mut)]
let mut scope_6568 = writer.prefix("MaintenanceOptions");
if let Some(var_6569) = &input.maintenance_options {
crate::query_ser::serialize_structure_crate_model_instance_maintenance_options_request(
scope_6568, var_6569,
)?;
}
#[allow(unused_mut)]
let mut scope_6570 = writer.prefix("DisableApiStop");
if let Some(var_6571) = &input.disable_api_stop {
scope_6570.boolean(*var_6571);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_run_scheduled_instances(
input: &crate::input::RunScheduledInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RunScheduledInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6572 = writer.prefix("ClientToken");
if let Some(var_6573) = &input.client_token {
scope_6572.string(var_6573);
}
#[allow(unused_mut)]
let mut scope_6574 = writer.prefix("DryRun");
if let Some(var_6575) = &input.dry_run {
scope_6574.boolean(*var_6575);
}
#[allow(unused_mut)]
let mut scope_6576 = writer.prefix("InstanceCount");
if let Some(var_6577) = &input.instance_count {
scope_6576.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6577).into()),
);
}
#[allow(unused_mut)]
let mut scope_6578 = writer.prefix("LaunchSpecification");
if let Some(var_6579) = &input.launch_specification {
crate::query_ser::serialize_structure_crate_model_scheduled_instances_launch_specification(
scope_6578, var_6579,
)?;
}
#[allow(unused_mut)]
let mut scope_6580 = writer.prefix("ScheduledInstanceId");
if let Some(var_6581) = &input.scheduled_instance_id {
scope_6580.string(var_6581);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_search_local_gateway_routes(
input: &crate::input::SearchLocalGatewayRoutesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SearchLocalGatewayRoutes", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6582 = writer.prefix("LocalGatewayRouteTableId");
if let Some(var_6583) = &input.local_gateway_route_table_id {
scope_6582.string(var_6583);
}
#[allow(unused_mut)]
let mut scope_6584 = writer.prefix("Filter");
if let Some(var_6585) = &input.filters {
let mut list_6587 = scope_6584.start_list(true, Some("Filter"));
for item_6586 in var_6585 {
#[allow(unused_mut)]
let mut entry_6588 = list_6587.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_6588, item_6586)?;
}
list_6587.finish();
}
#[allow(unused_mut)]
let mut scope_6589 = writer.prefix("MaxResults");
if let Some(var_6590) = &input.max_results {
scope_6589.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6590).into()),
);
}
#[allow(unused_mut)]
let mut scope_6591 = writer.prefix("NextToken");
if let Some(var_6592) = &input.next_token {
scope_6591.string(var_6592);
}
#[allow(unused_mut)]
let mut scope_6593 = writer.prefix("DryRun");
if let Some(var_6594) = &input.dry_run {
scope_6593.boolean(*var_6594);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_search_transit_gateway_multicast_groups(
input: &crate::input::SearchTransitGatewayMulticastGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"SearchTransitGatewayMulticastGroups",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6595 = writer.prefix("TransitGatewayMulticastDomainId");
if let Some(var_6596) = &input.transit_gateway_multicast_domain_id {
scope_6595.string(var_6596);
}
#[allow(unused_mut)]
let mut scope_6597 = writer.prefix("Filter");
if let Some(var_6598) = &input.filters {
let mut list_6600 = scope_6597.start_list(true, Some("Filter"));
for item_6599 in var_6598 {
#[allow(unused_mut)]
let mut entry_6601 = list_6600.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_6601, item_6599)?;
}
list_6600.finish();
}
#[allow(unused_mut)]
let mut scope_6602 = writer.prefix("MaxResults");
if let Some(var_6603) = &input.max_results {
scope_6602.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6603).into()),
);
}
#[allow(unused_mut)]
let mut scope_6604 = writer.prefix("NextToken");
if let Some(var_6605) = &input.next_token {
scope_6604.string(var_6605);
}
#[allow(unused_mut)]
let mut scope_6606 = writer.prefix("DryRun");
if let Some(var_6607) = &input.dry_run {
scope_6606.boolean(*var_6607);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_search_transit_gateway_routes(
input: &crate::input::SearchTransitGatewayRoutesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SearchTransitGatewayRoutes", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6608 = writer.prefix("TransitGatewayRouteTableId");
if let Some(var_6609) = &input.transit_gateway_route_table_id {
scope_6608.string(var_6609);
}
#[allow(unused_mut)]
let mut scope_6610 = writer.prefix("Filter");
if let Some(var_6611) = &input.filters {
let mut list_6613 = scope_6610.start_list(true, Some("Filter"));
for item_6612 in var_6611 {
#[allow(unused_mut)]
let mut entry_6614 = list_6613.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_6614, item_6612)?;
}
list_6613.finish();
}
#[allow(unused_mut)]
let mut scope_6615 = writer.prefix("MaxResults");
if let Some(var_6616) = &input.max_results {
scope_6615.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6616).into()),
);
}
#[allow(unused_mut)]
let mut scope_6617 = writer.prefix("DryRun");
if let Some(var_6618) = &input.dry_run {
scope_6617.boolean(*var_6618);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_send_diagnostic_interrupt(
input: &crate::input::SendDiagnosticInterruptInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SendDiagnosticInterrupt", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6619 = writer.prefix("InstanceId");
if let Some(var_6620) = &input.instance_id {
scope_6619.string(var_6620);
}
#[allow(unused_mut)]
let mut scope_6621 = writer.prefix("DryRun");
if let Some(var_6622) = &input.dry_run {
scope_6621.boolean(*var_6622);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_instances(
input: &crate::input::StartInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "StartInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6623 = writer.prefix("InstanceId");
if let Some(var_6624) = &input.instance_ids {
let mut list_6626 = scope_6623.start_list(true, Some("InstanceId"));
for item_6625 in var_6624 {
#[allow(unused_mut)]
let mut entry_6627 = list_6626.entry();
entry_6627.string(item_6625);
}
list_6626.finish();
}
#[allow(unused_mut)]
let mut scope_6628 = writer.prefix("AdditionalInfo");
if let Some(var_6629) = &input.additional_info {
scope_6628.string(var_6629);
}
#[allow(unused_mut)]
let mut scope_6630 = writer.prefix("DryRun");
if let Some(var_6631) = &input.dry_run {
scope_6630.boolean(*var_6631);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_network_insights_access_scope_analysis(
input: &crate::input::StartNetworkInsightsAccessScopeAnalysisInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"StartNetworkInsightsAccessScopeAnalysis",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6632 = writer.prefix("NetworkInsightsAccessScopeId");
if let Some(var_6633) = &input.network_insights_access_scope_id {
scope_6632.string(var_6633);
}
#[allow(unused_mut)]
let mut scope_6634 = writer.prefix("DryRun");
if let Some(var_6635) = &input.dry_run {
scope_6634.boolean(*var_6635);
}
#[allow(unused_mut)]
let mut scope_6636 = writer.prefix("TagSpecification");
if let Some(var_6637) = &input.tag_specifications {
let mut list_6639 = scope_6636.start_list(true, Some("item"));
for item_6638 in var_6637 {
#[allow(unused_mut)]
let mut entry_6640 = list_6639.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_6640, item_6638,
)?;
}
list_6639.finish();
}
#[allow(unused_mut)]
let mut scope_6641 = writer.prefix("ClientToken");
if let Some(var_6642) = &input.client_token {
scope_6641.string(var_6642);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_network_insights_analysis(
input: &crate::input::StartNetworkInsightsAnalysisInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "StartNetworkInsightsAnalysis", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6643 = writer.prefix("NetworkInsightsPathId");
if let Some(var_6644) = &input.network_insights_path_id {
scope_6643.string(var_6644);
}
#[allow(unused_mut)]
let mut scope_6645 = writer.prefix("AdditionalAccount");
if let Some(var_6646) = &input.additional_accounts {
let mut list_6648 = scope_6645.start_list(true, Some("item"));
for item_6647 in var_6646 {
#[allow(unused_mut)]
let mut entry_6649 = list_6648.entry();
entry_6649.string(item_6647);
}
list_6648.finish();
}
#[allow(unused_mut)]
let mut scope_6650 = writer.prefix("FilterInArn");
if let Some(var_6651) = &input.filter_in_arns {
let mut list_6653 = scope_6650.start_list(true, Some("item"));
for item_6652 in var_6651 {
#[allow(unused_mut)]
let mut entry_6654 = list_6653.entry();
entry_6654.string(item_6652);
}
list_6653.finish();
}
#[allow(unused_mut)]
let mut scope_6655 = writer.prefix("DryRun");
if let Some(var_6656) = &input.dry_run {
scope_6655.boolean(*var_6656);
}
#[allow(unused_mut)]
let mut scope_6657 = writer.prefix("TagSpecification");
if let Some(var_6658) = &input.tag_specifications {
let mut list_6660 = scope_6657.start_list(true, Some("item"));
for item_6659 in var_6658 {
#[allow(unused_mut)]
let mut entry_6661 = list_6660.entry();
crate::query_ser::serialize_structure_crate_model_tag_specification(
entry_6661, item_6659,
)?;
}
list_6660.finish();
}
#[allow(unused_mut)]
let mut scope_6662 = writer.prefix("ClientToken");
if let Some(var_6663) = &input.client_token {
scope_6662.string(var_6663);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_vpc_endpoint_service_private_dns_verification(
input: &crate::input::StartVpcEndpointServicePrivateDnsVerificationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"StartVpcEndpointServicePrivateDnsVerification",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6664 = writer.prefix("DryRun");
if let Some(var_6665) = &input.dry_run {
scope_6664.boolean(*var_6665);
}
#[allow(unused_mut)]
let mut scope_6666 = writer.prefix("ServiceId");
if let Some(var_6667) = &input.service_id {
scope_6666.string(var_6667);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_stop_instances(
input: &crate::input::StopInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "StopInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6668 = writer.prefix("InstanceId");
if let Some(var_6669) = &input.instance_ids {
let mut list_6671 = scope_6668.start_list(true, Some("InstanceId"));
for item_6670 in var_6669 {
#[allow(unused_mut)]
let mut entry_6672 = list_6671.entry();
entry_6672.string(item_6670);
}
list_6671.finish();
}
#[allow(unused_mut)]
let mut scope_6673 = writer.prefix("Hibernate");
if let Some(var_6674) = &input.hibernate {
scope_6673.boolean(*var_6674);
}
#[allow(unused_mut)]
let mut scope_6675 = writer.prefix("DryRun");
if let Some(var_6676) = &input.dry_run {
scope_6675.boolean(*var_6676);
}
#[allow(unused_mut)]
let mut scope_6677 = writer.prefix("Force");
if let Some(var_6678) = &input.force {
scope_6677.boolean(*var_6678);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_terminate_client_vpn_connections(
input: &crate::input::TerminateClientVpnConnectionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "TerminateClientVpnConnections", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6679 = writer.prefix("ClientVpnEndpointId");
if let Some(var_6680) = &input.client_vpn_endpoint_id {
scope_6679.string(var_6680);
}
#[allow(unused_mut)]
let mut scope_6681 = writer.prefix("ConnectionId");
if let Some(var_6682) = &input.connection_id {
scope_6681.string(var_6682);
}
#[allow(unused_mut)]
let mut scope_6683 = writer.prefix("Username");
if let Some(var_6684) = &input.username {
scope_6683.string(var_6684);
}
#[allow(unused_mut)]
let mut scope_6685 = writer.prefix("DryRun");
if let Some(var_6686) = &input.dry_run {
scope_6685.boolean(*var_6686);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_terminate_instances(
input: &crate::input::TerminateInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "TerminateInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6687 = writer.prefix("InstanceId");
if let Some(var_6688) = &input.instance_ids {
let mut list_6690 = scope_6687.start_list(true, Some("InstanceId"));
for item_6689 in var_6688 {
#[allow(unused_mut)]
let mut entry_6691 = list_6690.entry();
entry_6691.string(item_6689);
}
list_6690.finish();
}
#[allow(unused_mut)]
let mut scope_6692 = writer.prefix("DryRun");
if let Some(var_6693) = &input.dry_run {
scope_6692.boolean(*var_6693);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_unassign_ipv6_addresses(
input: &crate::input::UnassignIpv6AddressesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UnassignIpv6Addresses", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6694 = writer.prefix("Ipv6Addresses");
if let Some(var_6695) = &input.ipv6_addresses {
let mut list_6697 = scope_6694.start_list(true, Some("item"));
for item_6696 in var_6695 {
#[allow(unused_mut)]
let mut entry_6698 = list_6697.entry();
entry_6698.string(item_6696);
}
list_6697.finish();
}
#[allow(unused_mut)]
let mut scope_6699 = writer.prefix("Ipv6Prefix");
if let Some(var_6700) = &input.ipv6_prefixes {
let mut list_6702 = scope_6699.start_list(true, Some("item"));
for item_6701 in var_6700 {
#[allow(unused_mut)]
let mut entry_6703 = list_6702.entry();
entry_6703.string(item_6701);
}
list_6702.finish();
}
#[allow(unused_mut)]
let mut scope_6704 = writer.prefix("NetworkInterfaceId");
if let Some(var_6705) = &input.network_interface_id {
scope_6704.string(var_6705);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_unassign_private_ip_addresses(
input: &crate::input::UnassignPrivateIpAddressesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UnassignPrivateIpAddresses", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6706 = writer.prefix("NetworkInterfaceId");
if let Some(var_6707) = &input.network_interface_id {
scope_6706.string(var_6707);
}
#[allow(unused_mut)]
let mut scope_6708 = writer.prefix("PrivateIpAddress");
if let Some(var_6709) = &input.private_ip_addresses {
let mut list_6711 = scope_6708.start_list(true, Some("PrivateIpAddress"));
for item_6710 in var_6709 {
#[allow(unused_mut)]
let mut entry_6712 = list_6711.entry();
entry_6712.string(item_6710);
}
list_6711.finish();
}
#[allow(unused_mut)]
let mut scope_6713 = writer.prefix("Ipv4Prefix");
if let Some(var_6714) = &input.ipv4_prefixes {
let mut list_6716 = scope_6713.start_list(true, Some("item"));
for item_6715 in var_6714 {
#[allow(unused_mut)]
let mut entry_6717 = list_6716.entry();
entry_6717.string(item_6715);
}
list_6716.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_unmonitor_instances(
input: &crate::input::UnmonitorInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UnmonitorInstances", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6718 = writer.prefix("InstanceId");
if let Some(var_6719) = &input.instance_ids {
let mut list_6721 = scope_6718.start_list(true, Some("InstanceId"));
for item_6720 in var_6719 {
#[allow(unused_mut)]
let mut entry_6722 = list_6721.entry();
entry_6722.string(item_6720);
}
list_6721.finish();
}
#[allow(unused_mut)]
let mut scope_6723 = writer.prefix("DryRun");
if let Some(var_6724) = &input.dry_run {
scope_6723.boolean(*var_6724);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_security_group_rule_descriptions_egress(
input: &crate::input::UpdateSecurityGroupRuleDescriptionsEgressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"UpdateSecurityGroupRuleDescriptionsEgress",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6725 = writer.prefix("DryRun");
if let Some(var_6726) = &input.dry_run {
scope_6725.boolean(*var_6726);
}
#[allow(unused_mut)]
let mut scope_6727 = writer.prefix("GroupId");
if let Some(var_6728) = &input.group_id {
scope_6727.string(var_6728);
}
#[allow(unused_mut)]
let mut scope_6729 = writer.prefix("GroupName");
if let Some(var_6730) = &input.group_name {
scope_6729.string(var_6730);
}
#[allow(unused_mut)]
let mut scope_6731 = writer.prefix("IpPermissions");
if let Some(var_6732) = &input.ip_permissions {
let mut list_6734 = scope_6731.start_list(true, Some("item"));
for item_6733 in var_6732 {
#[allow(unused_mut)]
let mut entry_6735 = list_6734.entry();
crate::query_ser::serialize_structure_crate_model_ip_permission(entry_6735, item_6733)?;
}
list_6734.finish();
}
#[allow(unused_mut)]
let mut scope_6736 = writer.prefix("SecurityGroupRuleDescription");
if let Some(var_6737) = &input.security_group_rule_descriptions {
let mut list_6739 = scope_6736.start_list(true, Some("item"));
for item_6738 in var_6737 {
#[allow(unused_mut)]
let mut entry_6740 = list_6739.entry();
crate::query_ser::serialize_structure_crate_model_security_group_rule_description(
entry_6740, item_6738,
)?;
}
list_6739.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_security_group_rule_descriptions_ingress(
input: &crate::input::UpdateSecurityGroupRuleDescriptionsIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"UpdateSecurityGroupRuleDescriptionsIngress",
"2016-11-15",
);
#[allow(unused_mut)]
let mut scope_6741 = writer.prefix("DryRun");
if let Some(var_6742) = &input.dry_run {
scope_6741.boolean(*var_6742);
}
#[allow(unused_mut)]
let mut scope_6743 = writer.prefix("GroupId");
if let Some(var_6744) = &input.group_id {
scope_6743.string(var_6744);
}
#[allow(unused_mut)]
let mut scope_6745 = writer.prefix("GroupName");
if let Some(var_6746) = &input.group_name {
scope_6745.string(var_6746);
}
#[allow(unused_mut)]
let mut scope_6747 = writer.prefix("IpPermissions");
if let Some(var_6748) = &input.ip_permissions {
let mut list_6750 = scope_6747.start_list(true, Some("item"));
for item_6749 in var_6748 {
#[allow(unused_mut)]
let mut entry_6751 = list_6750.entry();
crate::query_ser::serialize_structure_crate_model_ip_permission(entry_6751, item_6749)?;
}
list_6750.finish();
}
#[allow(unused_mut)]
let mut scope_6752 = writer.prefix("SecurityGroupRuleDescription");
if let Some(var_6753) = &input.security_group_rule_descriptions {
let mut list_6755 = scope_6752.start_list(true, Some("item"));
for item_6754 in var_6753 {
#[allow(unused_mut)]
let mut entry_6756 = list_6755.entry();
crate::query_ser::serialize_structure_crate_model_security_group_rule_description(
entry_6756, item_6754,
)?;
}
list_6755.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_withdraw_byoip_cidr(
input: &crate::input::WithdrawByoipCidrInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "WithdrawByoipCidr", "2016-11-15");
#[allow(unused_mut)]
let mut scope_6757 = writer.prefix("Cidr");
if let Some(var_6758) = &input.cidr {
scope_6757.string(var_6758);
}
#[allow(unused_mut)]
let mut scope_6759 = writer.prefix("DryRun");
if let Some(var_6760) = &input.dry_run {
scope_6759.boolean(*var_6760);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}