pub fn serialize_operation_crate_operation_attach_instances(
input: &crate::input::AttachInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AttachInstances", "2011-01-01");
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("InstanceIds");
if let Some(var_2) = &input.instance_ids {
let mut list_4 = scope_1.start_list(false, None);
for item_3 in var_2 {
#[allow(unused_mut)]
let mut entry_5 = list_4.entry();
entry_5.string(item_3);
}
list_4.finish();
}
#[allow(unused_mut)]
let mut scope_6 = writer.prefix("AutoScalingGroupName");
if let Some(var_7) = &input.auto_scaling_group_name {
scope_6.string(var_7);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_load_balancers(
input: &crate::input::AttachLoadBalancersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AttachLoadBalancers", "2011-01-01");
#[allow(unused_mut)]
let mut scope_8 = writer.prefix("AutoScalingGroupName");
if let Some(var_9) = &input.auto_scaling_group_name {
scope_8.string(var_9);
}
#[allow(unused_mut)]
let mut scope_10 = writer.prefix("LoadBalancerNames");
if let Some(var_11) = &input.load_balancer_names {
let mut list_13 = scope_10.start_list(false, None);
for item_12 in var_11 {
#[allow(unused_mut)]
let mut entry_14 = list_13.entry();
entry_14.string(item_12);
}
list_13.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_load_balancer_target_groups(
input: &crate::input::AttachLoadBalancerTargetGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AttachLoadBalancerTargetGroups",
"2011-01-01",
);
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("AutoScalingGroupName");
if let Some(var_16) = &input.auto_scaling_group_name {
scope_15.string(var_16);
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("TargetGroupARNs");
if let Some(var_18) = &input.target_group_ar_ns {
let mut list_20 = scope_17.start_list(false, None);
for item_19 in var_18 {
#[allow(unused_mut)]
let mut entry_21 = list_20.entry();
entry_21.string(item_19);
}
list_20.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_attach_traffic_sources(
input: &crate::input::AttachTrafficSourcesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AttachTrafficSources", "2011-01-01");
#[allow(unused_mut)]
let mut scope_22 = writer.prefix("AutoScalingGroupName");
if let Some(var_23) = &input.auto_scaling_group_name {
scope_22.string(var_23);
}
#[allow(unused_mut)]
let mut scope_24 = writer.prefix("TrafficSources");
if let Some(var_25) = &input.traffic_sources {
let mut list_27 = scope_24.start_list(false, None);
for item_26 in var_25 {
#[allow(unused_mut)]
let mut entry_28 = list_27.entry();
crate::query_ser::serialize_structure_crate_model_traffic_source_identifier(
entry_28, item_26,
)?;
}
list_27.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_batch_delete_scheduled_action(
input: &crate::input::BatchDeleteScheduledActionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "BatchDeleteScheduledAction", "2011-01-01");
#[allow(unused_mut)]
let mut scope_29 = writer.prefix("AutoScalingGroupName");
if let Some(var_30) = &input.auto_scaling_group_name {
scope_29.string(var_30);
}
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("ScheduledActionNames");
if let Some(var_32) = &input.scheduled_action_names {
let mut list_34 = scope_31.start_list(false, None);
for item_33 in var_32 {
#[allow(unused_mut)]
let mut entry_35 = list_34.entry();
entry_35.string(item_33);
}
list_34.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_batch_put_scheduled_update_group_action(
input: &crate::input::BatchPutScheduledUpdateGroupActionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"BatchPutScheduledUpdateGroupAction",
"2011-01-01",
);
#[allow(unused_mut)]
let mut scope_36 = writer.prefix("AutoScalingGroupName");
if let Some(var_37) = &input.auto_scaling_group_name {
scope_36.string(var_37);
}
#[allow(unused_mut)]
let mut scope_38 = writer.prefix("ScheduledUpdateGroupActions");
if let Some(var_39) = &input.scheduled_update_group_actions {
let mut list_41 = scope_38.start_list(false, None);
for item_40 in var_39 {
#[allow(unused_mut)]
let mut entry_42 = list_41.entry();
crate::query_ser::serialize_structure_crate_model_scheduled_update_group_action_request(entry_42, item_40)?;
}
list_41.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_instance_refresh(
input: &crate::input::CancelInstanceRefreshInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CancelInstanceRefresh", "2011-01-01");
#[allow(unused_mut)]
let mut scope_43 = writer.prefix("AutoScalingGroupName");
if let Some(var_44) = &input.auto_scaling_group_name {
scope_43.string(var_44);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_complete_lifecycle_action(
input: &crate::input::CompleteLifecycleActionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CompleteLifecycleAction", "2011-01-01");
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("LifecycleHookName");
if let Some(var_46) = &input.lifecycle_hook_name {
scope_45.string(var_46);
}
#[allow(unused_mut)]
let mut scope_47 = writer.prefix("AutoScalingGroupName");
if let Some(var_48) = &input.auto_scaling_group_name {
scope_47.string(var_48);
}
#[allow(unused_mut)]
let mut scope_49 = writer.prefix("LifecycleActionToken");
if let Some(var_50) = &input.lifecycle_action_token {
scope_49.string(var_50);
}
#[allow(unused_mut)]
let mut scope_51 = writer.prefix("LifecycleActionResult");
if let Some(var_52) = &input.lifecycle_action_result {
scope_51.string(var_52);
}
#[allow(unused_mut)]
let mut scope_53 = writer.prefix("InstanceId");
if let Some(var_54) = &input.instance_id {
scope_53.string(var_54);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_auto_scaling_group(
input: &crate::input::CreateAutoScalingGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateAutoScalingGroup", "2011-01-01");
#[allow(unused_mut)]
let mut scope_55 = writer.prefix("AutoScalingGroupName");
if let Some(var_56) = &input.auto_scaling_group_name {
scope_55.string(var_56);
}
#[allow(unused_mut)]
let mut scope_57 = writer.prefix("LaunchConfigurationName");
if let Some(var_58) = &input.launch_configuration_name {
scope_57.string(var_58);
}
#[allow(unused_mut)]
let mut scope_59 = writer.prefix("LaunchTemplate");
if let Some(var_60) = &input.launch_template {
crate::query_ser::serialize_structure_crate_model_launch_template_specification(
scope_59, var_60,
)?;
}
#[allow(unused_mut)]
let mut scope_61 = writer.prefix("MixedInstancesPolicy");
if let Some(var_62) = &input.mixed_instances_policy {
crate::query_ser::serialize_structure_crate_model_mixed_instances_policy(scope_61, var_62)?;
}
#[allow(unused_mut)]
let mut scope_63 = writer.prefix("InstanceId");
if let Some(var_64) = &input.instance_id {
scope_63.string(var_64);
}
#[allow(unused_mut)]
let mut scope_65 = writer.prefix("MinSize");
if let Some(var_66) = &input.min_size {
scope_65.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_66).into()),
);
}
#[allow(unused_mut)]
let mut scope_67 = writer.prefix("MaxSize");
if let Some(var_68) = &input.max_size {
scope_67.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
#[allow(unused_mut)]
let mut scope_69 = writer.prefix("DesiredCapacity");
if let Some(var_70) = &input.desired_capacity {
scope_69.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_70).into()),
);
}
#[allow(unused_mut)]
let mut scope_71 = writer.prefix("DefaultCooldown");
if let Some(var_72) = &input.default_cooldown {
scope_71.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
#[allow(unused_mut)]
let mut scope_73 = writer.prefix("AvailabilityZones");
if let Some(var_74) = &input.availability_zones {
let mut list_76 = scope_73.start_list(false, None);
for item_75 in var_74 {
#[allow(unused_mut)]
let mut entry_77 = list_76.entry();
entry_77.string(item_75);
}
list_76.finish();
}
#[allow(unused_mut)]
let mut scope_78 = writer.prefix("LoadBalancerNames");
if let Some(var_79) = &input.load_balancer_names {
let mut list_81 = scope_78.start_list(false, None);
for item_80 in var_79 {
#[allow(unused_mut)]
let mut entry_82 = list_81.entry();
entry_82.string(item_80);
}
list_81.finish();
}
#[allow(unused_mut)]
let mut scope_83 = writer.prefix("TargetGroupARNs");
if let Some(var_84) = &input.target_group_ar_ns {
let mut list_86 = scope_83.start_list(false, None);
for item_85 in var_84 {
#[allow(unused_mut)]
let mut entry_87 = list_86.entry();
entry_87.string(item_85);
}
list_86.finish();
}
#[allow(unused_mut)]
let mut scope_88 = writer.prefix("HealthCheckType");
if let Some(var_89) = &input.health_check_type {
scope_88.string(var_89);
}
#[allow(unused_mut)]
let mut scope_90 = writer.prefix("HealthCheckGracePeriod");
if let Some(var_91) = &input.health_check_grace_period {
scope_90.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_91).into()),
);
}
#[allow(unused_mut)]
let mut scope_92 = writer.prefix("PlacementGroup");
if let Some(var_93) = &input.placement_group {
scope_92.string(var_93);
}
#[allow(unused_mut)]
let mut scope_94 = writer.prefix("VPCZoneIdentifier");
if let Some(var_95) = &input.vpc_zone_identifier {
scope_94.string(var_95);
}
#[allow(unused_mut)]
let mut scope_96 = writer.prefix("TerminationPolicies");
if let Some(var_97) = &input.termination_policies {
let mut list_99 = scope_96.start_list(false, None);
for item_98 in var_97 {
#[allow(unused_mut)]
let mut entry_100 = list_99.entry();
entry_100.string(item_98);
}
list_99.finish();
}
#[allow(unused_mut)]
let mut scope_101 = writer.prefix("NewInstancesProtectedFromScaleIn");
if let Some(var_102) = &input.new_instances_protected_from_scale_in {
scope_101.boolean(*var_102);
}
#[allow(unused_mut)]
let mut scope_103 = writer.prefix("CapacityRebalance");
if let Some(var_104) = &input.capacity_rebalance {
scope_103.boolean(*var_104);
}
#[allow(unused_mut)]
let mut scope_105 = writer.prefix("LifecycleHookSpecificationList");
if let Some(var_106) = &input.lifecycle_hook_specification_list {
let mut list_108 = scope_105.start_list(false, None);
for item_107 in var_106 {
#[allow(unused_mut)]
let mut entry_109 = list_108.entry();
crate::query_ser::serialize_structure_crate_model_lifecycle_hook_specification(
entry_109, item_107,
)?;
}
list_108.finish();
}
#[allow(unused_mut)]
let mut scope_110 = writer.prefix("Tags");
if let Some(var_111) = &input.tags {
let mut list_113 = scope_110.start_list(false, None);
for item_112 in var_111 {
#[allow(unused_mut)]
let mut entry_114 = list_113.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_114, item_112)?;
}
list_113.finish();
}
#[allow(unused_mut)]
let mut scope_115 = writer.prefix("ServiceLinkedRoleARN");
if let Some(var_116) = &input.service_linked_role_arn {
scope_115.string(var_116);
}
#[allow(unused_mut)]
let mut scope_117 = writer.prefix("MaxInstanceLifetime");
if let Some(var_118) = &input.max_instance_lifetime {
scope_117.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_118).into()),
);
}
#[allow(unused_mut)]
let mut scope_119 = writer.prefix("Context");
if let Some(var_120) = &input.context {
scope_119.string(var_120);
}
#[allow(unused_mut)]
let mut scope_121 = writer.prefix("DesiredCapacityType");
if let Some(var_122) = &input.desired_capacity_type {
scope_121.string(var_122);
}
#[allow(unused_mut)]
let mut scope_123 = writer.prefix("DefaultInstanceWarmup");
if let Some(var_124) = &input.default_instance_warmup {
scope_123.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
#[allow(unused_mut)]
let mut scope_125 = writer.prefix("TrafficSources");
if let Some(var_126) = &input.traffic_sources {
let mut list_128 = scope_125.start_list(false, None);
for item_127 in var_126 {
#[allow(unused_mut)]
let mut entry_129 = list_128.entry();
crate::query_ser::serialize_structure_crate_model_traffic_source_identifier(
entry_129, item_127,
)?;
}
list_128.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_launch_configuration(
input: &crate::input::CreateLaunchConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateLaunchConfiguration", "2011-01-01");
#[allow(unused_mut)]
let mut scope_130 = writer.prefix("LaunchConfigurationName");
if let Some(var_131) = &input.launch_configuration_name {
scope_130.string(var_131);
}
#[allow(unused_mut)]
let mut scope_132 = writer.prefix("ImageId");
if let Some(var_133) = &input.image_id {
scope_132.string(var_133);
}
#[allow(unused_mut)]
let mut scope_134 = writer.prefix("KeyName");
if let Some(var_135) = &input.key_name {
scope_134.string(var_135);
}
#[allow(unused_mut)]
let mut scope_136 = writer.prefix("SecurityGroups");
if let Some(var_137) = &input.security_groups {
let mut list_139 = scope_136.start_list(false, None);
for item_138 in var_137 {
#[allow(unused_mut)]
let mut entry_140 = list_139.entry();
entry_140.string(item_138);
}
list_139.finish();
}
#[allow(unused_mut)]
let mut scope_141 = writer.prefix("ClassicLinkVPCId");
if let Some(var_142) = &input.classic_link_vpc_id {
scope_141.string(var_142);
}
#[allow(unused_mut)]
let mut scope_143 = writer.prefix("ClassicLinkVPCSecurityGroups");
if let Some(var_144) = &input.classic_link_vpc_security_groups {
let mut list_146 = scope_143.start_list(false, None);
for item_145 in var_144 {
#[allow(unused_mut)]
let mut entry_147 = list_146.entry();
entry_147.string(item_145);
}
list_146.finish();
}
#[allow(unused_mut)]
let mut scope_148 = writer.prefix("UserData");
if let Some(var_149) = &input.user_data {
scope_148.string(var_149);
}
#[allow(unused_mut)]
let mut scope_150 = writer.prefix("InstanceId");
if let Some(var_151) = &input.instance_id {
scope_150.string(var_151);
}
#[allow(unused_mut)]
let mut scope_152 = writer.prefix("InstanceType");
if let Some(var_153) = &input.instance_type {
scope_152.string(var_153);
}
#[allow(unused_mut)]
let mut scope_154 = writer.prefix("KernelId");
if let Some(var_155) = &input.kernel_id {
scope_154.string(var_155);
}
#[allow(unused_mut)]
let mut scope_156 = writer.prefix("RamdiskId");
if let Some(var_157) = &input.ramdisk_id {
scope_156.string(var_157);
}
#[allow(unused_mut)]
let mut scope_158 = writer.prefix("BlockDeviceMappings");
if let Some(var_159) = &input.block_device_mappings {
let mut list_161 = scope_158.start_list(false, None);
for item_160 in var_159 {
#[allow(unused_mut)]
let mut entry_162 = list_161.entry();
crate::query_ser::serialize_structure_crate_model_block_device_mapping(
entry_162, item_160,
)?;
}
list_161.finish();
}
#[allow(unused_mut)]
let mut scope_163 = writer.prefix("InstanceMonitoring");
if let Some(var_164) = &input.instance_monitoring {
crate::query_ser::serialize_structure_crate_model_instance_monitoring(scope_163, var_164)?;
}
#[allow(unused_mut)]
let mut scope_165 = writer.prefix("SpotPrice");
if let Some(var_166) = &input.spot_price {
scope_165.string(var_166);
}
#[allow(unused_mut)]
let mut scope_167 = writer.prefix("IamInstanceProfile");
if let Some(var_168) = &input.iam_instance_profile {
scope_167.string(var_168);
}
#[allow(unused_mut)]
let mut scope_169 = writer.prefix("EbsOptimized");
if let Some(var_170) = &input.ebs_optimized {
scope_169.boolean(*var_170);
}
#[allow(unused_mut)]
let mut scope_171 = writer.prefix("AssociatePublicIpAddress");
if let Some(var_172) = &input.associate_public_ip_address {
scope_171.boolean(*var_172);
}
#[allow(unused_mut)]
let mut scope_173 = writer.prefix("PlacementTenancy");
if let Some(var_174) = &input.placement_tenancy {
scope_173.string(var_174);
}
#[allow(unused_mut)]
let mut scope_175 = writer.prefix("MetadataOptions");
if let Some(var_176) = &input.metadata_options {
crate::query_ser::serialize_structure_crate_model_instance_metadata_options(
scope_175, var_176,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_or_update_tags(
input: &crate::input::CreateOrUpdateTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateOrUpdateTags", "2011-01-01");
#[allow(unused_mut)]
let mut scope_177 = writer.prefix("Tags");
if let Some(var_178) = &input.tags {
let mut list_180 = scope_177.start_list(false, None);
for item_179 in var_178 {
#[allow(unused_mut)]
let mut entry_181 = list_180.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_181, item_179)?;
}
list_180.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_auto_scaling_group(
input: &crate::input::DeleteAutoScalingGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteAutoScalingGroup", "2011-01-01");
#[allow(unused_mut)]
let mut scope_182 = writer.prefix("AutoScalingGroupName");
if let Some(var_183) = &input.auto_scaling_group_name {
scope_182.string(var_183);
}
#[allow(unused_mut)]
let mut scope_184 = writer.prefix("ForceDelete");
if let Some(var_185) = &input.force_delete {
scope_184.boolean(*var_185);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_launch_configuration(
input: &crate::input::DeleteLaunchConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteLaunchConfiguration", "2011-01-01");
#[allow(unused_mut)]
let mut scope_186 = writer.prefix("LaunchConfigurationName");
if let Some(var_187) = &input.launch_configuration_name {
scope_186.string(var_187);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_lifecycle_hook(
input: &crate::input::DeleteLifecycleHookInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteLifecycleHook", "2011-01-01");
#[allow(unused_mut)]
let mut scope_188 = writer.prefix("LifecycleHookName");
if let Some(var_189) = &input.lifecycle_hook_name {
scope_188.string(var_189);
}
#[allow(unused_mut)]
let mut scope_190 = writer.prefix("AutoScalingGroupName");
if let Some(var_191) = &input.auto_scaling_group_name {
scope_190.string(var_191);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_notification_configuration(
input: &crate::input::DeleteNotificationConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteNotificationConfiguration",
"2011-01-01",
);
#[allow(unused_mut)]
let mut scope_192 = writer.prefix("AutoScalingGroupName");
if let Some(var_193) = &input.auto_scaling_group_name {
scope_192.string(var_193);
}
#[allow(unused_mut)]
let mut scope_194 = writer.prefix("TopicARN");
if let Some(var_195) = &input.topic_arn {
scope_194.string(var_195);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_policy(
input: &crate::input::DeletePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeletePolicy", "2011-01-01");
#[allow(unused_mut)]
let mut scope_196 = writer.prefix("AutoScalingGroupName");
if let Some(var_197) = &input.auto_scaling_group_name {
scope_196.string(var_197);
}
#[allow(unused_mut)]
let mut scope_198 = writer.prefix("PolicyName");
if let Some(var_199) = &input.policy_name {
scope_198.string(var_199);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_scheduled_action(
input: &crate::input::DeleteScheduledActionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteScheduledAction", "2011-01-01");
#[allow(unused_mut)]
let mut scope_200 = writer.prefix("AutoScalingGroupName");
if let Some(var_201) = &input.auto_scaling_group_name {
scope_200.string(var_201);
}
#[allow(unused_mut)]
let mut scope_202 = writer.prefix("ScheduledActionName");
if let Some(var_203) = &input.scheduled_action_name {
scope_202.string(var_203);
}
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", "2011-01-01");
#[allow(unused_mut)]
let mut scope_204 = writer.prefix("Tags");
if let Some(var_205) = &input.tags {
let mut list_207 = scope_204.start_list(false, None);
for item_206 in var_205 {
#[allow(unused_mut)]
let mut entry_208 = list_207.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_208, item_206)?;
}
list_207.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_warm_pool(
input: &crate::input::DeleteWarmPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteWarmPool", "2011-01-01");
#[allow(unused_mut)]
let mut scope_209 = writer.prefix("AutoScalingGroupName");
if let Some(var_210) = &input.auto_scaling_group_name {
scope_209.string(var_210);
}
#[allow(unused_mut)]
let mut scope_211 = writer.prefix("ForceDelete");
if let Some(var_212) = &input.force_delete {
scope_211.boolean(*var_212);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_account_limits(
input: &crate::input::DescribeAccountLimitsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAccountLimits", "2011-01-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_adjustment_types(
input: &crate::input::DescribeAdjustmentTypesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAdjustmentTypes", "2011-01-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_auto_scaling_groups(
input: &crate::input::DescribeAutoScalingGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAutoScalingGroups", "2011-01-01");
#[allow(unused_mut)]
let mut scope_213 = writer.prefix("AutoScalingGroupNames");
if let Some(var_214) = &input.auto_scaling_group_names {
let mut list_216 = scope_213.start_list(false, None);
for item_215 in var_214 {
#[allow(unused_mut)]
let mut entry_217 = list_216.entry();
entry_217.string(item_215);
}
list_216.finish();
}
#[allow(unused_mut)]
let mut scope_218 = writer.prefix("NextToken");
if let Some(var_219) = &input.next_token {
scope_218.string(var_219);
}
#[allow(unused_mut)]
let mut scope_220 = writer.prefix("MaxRecords");
if let Some(var_221) = &input.max_records {
scope_220.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_221).into()),
);
}
#[allow(unused_mut)]
let mut scope_222 = writer.prefix("Filters");
if let Some(var_223) = &input.filters {
let mut list_225 = scope_222.start_list(false, None);
for item_224 in var_223 {
#[allow(unused_mut)]
let mut entry_226 = list_225.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_226, item_224)?;
}
list_225.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_auto_scaling_instances(
input: &crate::input::DescribeAutoScalingInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAutoScalingInstances", "2011-01-01");
#[allow(unused_mut)]
let mut scope_227 = writer.prefix("InstanceIds");
if let Some(var_228) = &input.instance_ids {
let mut list_230 = scope_227.start_list(false, None);
for item_229 in var_228 {
#[allow(unused_mut)]
let mut entry_231 = list_230.entry();
entry_231.string(item_229);
}
list_230.finish();
}
#[allow(unused_mut)]
let mut scope_232 = writer.prefix("MaxRecords");
if let Some(var_233) = &input.max_records {
scope_232.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_233).into()),
);
}
#[allow(unused_mut)]
let mut scope_234 = writer.prefix("NextToken");
if let Some(var_235) = &input.next_token {
scope_234.string(var_235);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_auto_scaling_notification_types(
input: &crate::input::DescribeAutoScalingNotificationTypesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeAutoScalingNotificationTypes",
"2011-01-01",
);
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_instance_refreshes(
input: &crate::input::DescribeInstanceRefreshesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeInstanceRefreshes", "2011-01-01");
#[allow(unused_mut)]
let mut scope_236 = writer.prefix("AutoScalingGroupName");
if let Some(var_237) = &input.auto_scaling_group_name {
scope_236.string(var_237);
}
#[allow(unused_mut)]
let mut scope_238 = writer.prefix("InstanceRefreshIds");
if let Some(var_239) = &input.instance_refresh_ids {
let mut list_241 = scope_238.start_list(false, None);
for item_240 in var_239 {
#[allow(unused_mut)]
let mut entry_242 = list_241.entry();
entry_242.string(item_240);
}
list_241.finish();
}
#[allow(unused_mut)]
let mut scope_243 = writer.prefix("NextToken");
if let Some(var_244) = &input.next_token {
scope_243.string(var_244);
}
#[allow(unused_mut)]
let mut scope_245 = writer.prefix("MaxRecords");
if let Some(var_246) = &input.max_records {
scope_245.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_246).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_launch_configurations(
input: &crate::input::DescribeLaunchConfigurationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeLaunchConfigurations", "2011-01-01");
#[allow(unused_mut)]
let mut scope_247 = writer.prefix("LaunchConfigurationNames");
if let Some(var_248) = &input.launch_configuration_names {
let mut list_250 = scope_247.start_list(false, None);
for item_249 in var_248 {
#[allow(unused_mut)]
let mut entry_251 = list_250.entry();
entry_251.string(item_249);
}
list_250.finish();
}
#[allow(unused_mut)]
let mut scope_252 = writer.prefix("NextToken");
if let Some(var_253) = &input.next_token {
scope_252.string(var_253);
}
#[allow(unused_mut)]
let mut scope_254 = writer.prefix("MaxRecords");
if let Some(var_255) = &input.max_records {
scope_254.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_255).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_lifecycle_hooks(
input: &crate::input::DescribeLifecycleHooksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeLifecycleHooks", "2011-01-01");
#[allow(unused_mut)]
let mut scope_256 = writer.prefix("AutoScalingGroupName");
if let Some(var_257) = &input.auto_scaling_group_name {
scope_256.string(var_257);
}
#[allow(unused_mut)]
let mut scope_258 = writer.prefix("LifecycleHookNames");
if let Some(var_259) = &input.lifecycle_hook_names {
let mut list_261 = scope_258.start_list(false, None);
for item_260 in var_259 {
#[allow(unused_mut)]
let mut entry_262 = list_261.entry();
entry_262.string(item_260);
}
list_261.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_lifecycle_hook_types(
input: &crate::input::DescribeLifecycleHookTypesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeLifecycleHookTypes", "2011-01-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_load_balancers(
input: &crate::input::DescribeLoadBalancersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeLoadBalancers", "2011-01-01");
#[allow(unused_mut)]
let mut scope_263 = writer.prefix("AutoScalingGroupName");
if let Some(var_264) = &input.auto_scaling_group_name {
scope_263.string(var_264);
}
#[allow(unused_mut)]
let mut scope_265 = writer.prefix("NextToken");
if let Some(var_266) = &input.next_token {
scope_265.string(var_266);
}
#[allow(unused_mut)]
let mut scope_267 = writer.prefix("MaxRecords");
if let Some(var_268) = &input.max_records {
scope_267.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_268).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_load_balancer_target_groups(
input: &crate::input::DescribeLoadBalancerTargetGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeLoadBalancerTargetGroups",
"2011-01-01",
);
#[allow(unused_mut)]
let mut scope_269 = writer.prefix("AutoScalingGroupName");
if let Some(var_270) = &input.auto_scaling_group_name {
scope_269.string(var_270);
}
#[allow(unused_mut)]
let mut scope_271 = writer.prefix("NextToken");
if let Some(var_272) = &input.next_token {
scope_271.string(var_272);
}
#[allow(unused_mut)]
let mut scope_273 = writer.prefix("MaxRecords");
if let Some(var_274) = &input.max_records {
scope_273.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_274).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_metric_collection_types(
input: &crate::input::DescribeMetricCollectionTypesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeMetricCollectionTypes", "2011-01-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_notification_configurations(
input: &crate::input::DescribeNotificationConfigurationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeNotificationConfigurations",
"2011-01-01",
);
#[allow(unused_mut)]
let mut scope_275 = writer.prefix("AutoScalingGroupNames");
if let Some(var_276) = &input.auto_scaling_group_names {
let mut list_278 = scope_275.start_list(false, None);
for item_277 in var_276 {
#[allow(unused_mut)]
let mut entry_279 = list_278.entry();
entry_279.string(item_277);
}
list_278.finish();
}
#[allow(unused_mut)]
let mut scope_280 = writer.prefix("NextToken");
if let Some(var_281) = &input.next_token {
scope_280.string(var_281);
}
#[allow(unused_mut)]
let mut scope_282 = writer.prefix("MaxRecords");
if let Some(var_283) = &input.max_records {
scope_282.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_283).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_policies(
input: &crate::input::DescribePoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribePolicies", "2011-01-01");
#[allow(unused_mut)]
let mut scope_284 = writer.prefix("AutoScalingGroupName");
if let Some(var_285) = &input.auto_scaling_group_name {
scope_284.string(var_285);
}
#[allow(unused_mut)]
let mut scope_286 = writer.prefix("PolicyNames");
if let Some(var_287) = &input.policy_names {
let mut list_289 = scope_286.start_list(false, None);
for item_288 in var_287 {
#[allow(unused_mut)]
let mut entry_290 = list_289.entry();
entry_290.string(item_288);
}
list_289.finish();
}
#[allow(unused_mut)]
let mut scope_291 = writer.prefix("PolicyTypes");
if let Some(var_292) = &input.policy_types {
let mut list_294 = scope_291.start_list(false, None);
for item_293 in var_292 {
#[allow(unused_mut)]
let mut entry_295 = list_294.entry();
entry_295.string(item_293);
}
list_294.finish();
}
#[allow(unused_mut)]
let mut scope_296 = writer.prefix("NextToken");
if let Some(var_297) = &input.next_token {
scope_296.string(var_297);
}
#[allow(unused_mut)]
let mut scope_298 = writer.prefix("MaxRecords");
if let Some(var_299) = &input.max_records {
scope_298.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_299).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_scaling_activities(
input: &crate::input::DescribeScalingActivitiesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeScalingActivities", "2011-01-01");
#[allow(unused_mut)]
let mut scope_300 = writer.prefix("ActivityIds");
if let Some(var_301) = &input.activity_ids {
let mut list_303 = scope_300.start_list(false, None);
for item_302 in var_301 {
#[allow(unused_mut)]
let mut entry_304 = list_303.entry();
entry_304.string(item_302);
}
list_303.finish();
}
#[allow(unused_mut)]
let mut scope_305 = writer.prefix("AutoScalingGroupName");
if let Some(var_306) = &input.auto_scaling_group_name {
scope_305.string(var_306);
}
#[allow(unused_mut)]
let mut scope_307 = writer.prefix("IncludeDeletedGroups");
if let Some(var_308) = &input.include_deleted_groups {
scope_307.boolean(*var_308);
}
#[allow(unused_mut)]
let mut scope_309 = writer.prefix("MaxRecords");
if let Some(var_310) = &input.max_records {
scope_309.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_310).into()),
);
}
#[allow(unused_mut)]
let mut scope_311 = writer.prefix("NextToken");
if let Some(var_312) = &input.next_token {
scope_311.string(var_312);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_scaling_process_types(
input: &crate::input::DescribeScalingProcessTypesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeScalingProcessTypes", "2011-01-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_scheduled_actions(
input: &crate::input::DescribeScheduledActionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeScheduledActions", "2011-01-01");
#[allow(unused_mut)]
let mut scope_313 = writer.prefix("AutoScalingGroupName");
if let Some(var_314) = &input.auto_scaling_group_name {
scope_313.string(var_314);
}
#[allow(unused_mut)]
let mut scope_315 = writer.prefix("ScheduledActionNames");
if let Some(var_316) = &input.scheduled_action_names {
let mut list_318 = scope_315.start_list(false, None);
for item_317 in var_316 {
#[allow(unused_mut)]
let mut entry_319 = list_318.entry();
entry_319.string(item_317);
}
list_318.finish();
}
#[allow(unused_mut)]
let mut scope_320 = writer.prefix("StartTime");
if let Some(var_321) = &input.start_time {
scope_320.date_time(var_321, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_322 = writer.prefix("EndTime");
if let Some(var_323) = &input.end_time {
scope_322.date_time(var_323, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_324 = writer.prefix("NextToken");
if let Some(var_325) = &input.next_token {
scope_324.string(var_325);
}
#[allow(unused_mut)]
let mut scope_326 = writer.prefix("MaxRecords");
if let Some(var_327) = &input.max_records {
scope_326.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_327).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", "2011-01-01");
#[allow(unused_mut)]
let mut scope_328 = writer.prefix("Filters");
if let Some(var_329) = &input.filters {
let mut list_331 = scope_328.start_list(false, None);
for item_330 in var_329 {
#[allow(unused_mut)]
let mut entry_332 = list_331.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_332, item_330)?;
}
list_331.finish();
}
#[allow(unused_mut)]
let mut scope_333 = writer.prefix("NextToken");
if let Some(var_334) = &input.next_token {
scope_333.string(var_334);
}
#[allow(unused_mut)]
let mut scope_335 = writer.prefix("MaxRecords");
if let Some(var_336) = &input.max_records {
scope_335.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_336).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_termination_policy_types(
input: &crate::input::DescribeTerminationPolicyTypesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeTerminationPolicyTypes",
"2011-01-01",
);
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_traffic_sources(
input: &crate::input::DescribeTrafficSourcesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeTrafficSources", "2011-01-01");
#[allow(unused_mut)]
let mut scope_337 = writer.prefix("AutoScalingGroupName");
if let Some(var_338) = &input.auto_scaling_group_name {
scope_337.string(var_338);
}
#[allow(unused_mut)]
let mut scope_339 = writer.prefix("TrafficSourceType");
if let Some(var_340) = &input.traffic_source_type {
scope_339.string(var_340);
}
#[allow(unused_mut)]
let mut scope_341 = writer.prefix("NextToken");
if let Some(var_342) = &input.next_token {
scope_341.string(var_342);
}
#[allow(unused_mut)]
let mut scope_343 = writer.prefix("MaxRecords");
if let Some(var_344) = &input.max_records {
scope_343.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_344).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_warm_pool(
input: &crate::input::DescribeWarmPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeWarmPool", "2011-01-01");
#[allow(unused_mut)]
let mut scope_345 = writer.prefix("AutoScalingGroupName");
if let Some(var_346) = &input.auto_scaling_group_name {
scope_345.string(var_346);
}
#[allow(unused_mut)]
let mut scope_347 = writer.prefix("MaxRecords");
if let Some(var_348) = &input.max_records {
scope_347.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_348).into()),
);
}
#[allow(unused_mut)]
let mut scope_349 = writer.prefix("NextToken");
if let Some(var_350) = &input.next_token {
scope_349.string(var_350);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_instances(
input: &crate::input::DetachInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DetachInstances", "2011-01-01");
#[allow(unused_mut)]
let mut scope_351 = writer.prefix("InstanceIds");
if let Some(var_352) = &input.instance_ids {
let mut list_354 = scope_351.start_list(false, None);
for item_353 in var_352 {
#[allow(unused_mut)]
let mut entry_355 = list_354.entry();
entry_355.string(item_353);
}
list_354.finish();
}
#[allow(unused_mut)]
let mut scope_356 = writer.prefix("AutoScalingGroupName");
if let Some(var_357) = &input.auto_scaling_group_name {
scope_356.string(var_357);
}
#[allow(unused_mut)]
let mut scope_358 = writer.prefix("ShouldDecrementDesiredCapacity");
if let Some(var_359) = &input.should_decrement_desired_capacity {
scope_358.boolean(*var_359);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_load_balancers(
input: &crate::input::DetachLoadBalancersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DetachLoadBalancers", "2011-01-01");
#[allow(unused_mut)]
let mut scope_360 = writer.prefix("AutoScalingGroupName");
if let Some(var_361) = &input.auto_scaling_group_name {
scope_360.string(var_361);
}
#[allow(unused_mut)]
let mut scope_362 = writer.prefix("LoadBalancerNames");
if let Some(var_363) = &input.load_balancer_names {
let mut list_365 = scope_362.start_list(false, None);
for item_364 in var_363 {
#[allow(unused_mut)]
let mut entry_366 = list_365.entry();
entry_366.string(item_364);
}
list_365.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_load_balancer_target_groups(
input: &crate::input::DetachLoadBalancerTargetGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DetachLoadBalancerTargetGroups",
"2011-01-01",
);
#[allow(unused_mut)]
let mut scope_367 = writer.prefix("AutoScalingGroupName");
if let Some(var_368) = &input.auto_scaling_group_name {
scope_367.string(var_368);
}
#[allow(unused_mut)]
let mut scope_369 = writer.prefix("TargetGroupARNs");
if let Some(var_370) = &input.target_group_ar_ns {
let mut list_372 = scope_369.start_list(false, None);
for item_371 in var_370 {
#[allow(unused_mut)]
let mut entry_373 = list_372.entry();
entry_373.string(item_371);
}
list_372.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_detach_traffic_sources(
input: &crate::input::DetachTrafficSourcesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DetachTrafficSources", "2011-01-01");
#[allow(unused_mut)]
let mut scope_374 = writer.prefix("AutoScalingGroupName");
if let Some(var_375) = &input.auto_scaling_group_name {
scope_374.string(var_375);
}
#[allow(unused_mut)]
let mut scope_376 = writer.prefix("TrafficSources");
if let Some(var_377) = &input.traffic_sources {
let mut list_379 = scope_376.start_list(false, None);
for item_378 in var_377 {
#[allow(unused_mut)]
let mut entry_380 = list_379.entry();
crate::query_ser::serialize_structure_crate_model_traffic_source_identifier(
entry_380, item_378,
)?;
}
list_379.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_metrics_collection(
input: &crate::input::DisableMetricsCollectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableMetricsCollection", "2011-01-01");
#[allow(unused_mut)]
let mut scope_381 = writer.prefix("AutoScalingGroupName");
if let Some(var_382) = &input.auto_scaling_group_name {
scope_381.string(var_382);
}
#[allow(unused_mut)]
let mut scope_383 = writer.prefix("Metrics");
if let Some(var_384) = &input.metrics {
let mut list_386 = scope_383.start_list(false, None);
for item_385 in var_384 {
#[allow(unused_mut)]
let mut entry_387 = list_386.entry();
entry_387.string(item_385);
}
list_386.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_metrics_collection(
input: &crate::input::EnableMetricsCollectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableMetricsCollection", "2011-01-01");
#[allow(unused_mut)]
let mut scope_388 = writer.prefix("AutoScalingGroupName");
if let Some(var_389) = &input.auto_scaling_group_name {
scope_388.string(var_389);
}
#[allow(unused_mut)]
let mut scope_390 = writer.prefix("Metrics");
if let Some(var_391) = &input.metrics {
let mut list_393 = scope_390.start_list(false, None);
for item_392 in var_391 {
#[allow(unused_mut)]
let mut entry_394 = list_393.entry();
entry_394.string(item_392);
}
list_393.finish();
}
#[allow(unused_mut)]
let mut scope_395 = writer.prefix("Granularity");
if let Some(var_396) = &input.granularity {
scope_395.string(var_396);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enter_standby(
input: &crate::input::EnterStandbyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "EnterStandby", "2011-01-01");
#[allow(unused_mut)]
let mut scope_397 = writer.prefix("InstanceIds");
if let Some(var_398) = &input.instance_ids {
let mut list_400 = scope_397.start_list(false, None);
for item_399 in var_398 {
#[allow(unused_mut)]
let mut entry_401 = list_400.entry();
entry_401.string(item_399);
}
list_400.finish();
}
#[allow(unused_mut)]
let mut scope_402 = writer.prefix("AutoScalingGroupName");
if let Some(var_403) = &input.auto_scaling_group_name {
scope_402.string(var_403);
}
#[allow(unused_mut)]
let mut scope_404 = writer.prefix("ShouldDecrementDesiredCapacity");
if let Some(var_405) = &input.should_decrement_desired_capacity {
scope_404.boolean(*var_405);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_execute_policy(
input: &crate::input::ExecutePolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ExecutePolicy", "2011-01-01");
#[allow(unused_mut)]
let mut scope_406 = writer.prefix("AutoScalingGroupName");
if let Some(var_407) = &input.auto_scaling_group_name {
scope_406.string(var_407);
}
#[allow(unused_mut)]
let mut scope_408 = writer.prefix("PolicyName");
if let Some(var_409) = &input.policy_name {
scope_408.string(var_409);
}
#[allow(unused_mut)]
let mut scope_410 = writer.prefix("HonorCooldown");
if let Some(var_411) = &input.honor_cooldown {
scope_410.boolean(*var_411);
}
#[allow(unused_mut)]
let mut scope_412 = writer.prefix("MetricValue");
if let Some(var_413) = &input.metric_value {
scope_412.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_413).into()),
);
}
#[allow(unused_mut)]
let mut scope_414 = writer.prefix("BreachThreshold");
if let Some(var_415) = &input.breach_threshold {
scope_414.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_415).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_exit_standby(
input: &crate::input::ExitStandbyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ExitStandby", "2011-01-01");
#[allow(unused_mut)]
let mut scope_416 = writer.prefix("InstanceIds");
if let Some(var_417) = &input.instance_ids {
let mut list_419 = scope_416.start_list(false, None);
for item_418 in var_417 {
#[allow(unused_mut)]
let mut entry_420 = list_419.entry();
entry_420.string(item_418);
}
list_419.finish();
}
#[allow(unused_mut)]
let mut scope_421 = writer.prefix("AutoScalingGroupName");
if let Some(var_422) = &input.auto_scaling_group_name {
scope_421.string(var_422);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_predictive_scaling_forecast(
input: &crate::input::GetPredictiveScalingForecastInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetPredictiveScalingForecast", "2011-01-01");
#[allow(unused_mut)]
let mut scope_423 = writer.prefix("AutoScalingGroupName");
if let Some(var_424) = &input.auto_scaling_group_name {
scope_423.string(var_424);
}
#[allow(unused_mut)]
let mut scope_425 = writer.prefix("PolicyName");
if let Some(var_426) = &input.policy_name {
scope_425.string(var_426);
}
#[allow(unused_mut)]
let mut scope_427 = writer.prefix("StartTime");
if let Some(var_428) = &input.start_time {
scope_427.date_time(var_428, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_429 = writer.prefix("EndTime");
if let Some(var_430) = &input.end_time {
scope_429.date_time(var_430, aws_smithy_types::date_time::Format::DateTime)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_lifecycle_hook(
input: &crate::input::PutLifecycleHookInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutLifecycleHook", "2011-01-01");
#[allow(unused_mut)]
let mut scope_431 = writer.prefix("LifecycleHookName");
if let Some(var_432) = &input.lifecycle_hook_name {
scope_431.string(var_432);
}
#[allow(unused_mut)]
let mut scope_433 = writer.prefix("AutoScalingGroupName");
if let Some(var_434) = &input.auto_scaling_group_name {
scope_433.string(var_434);
}
#[allow(unused_mut)]
let mut scope_435 = writer.prefix("LifecycleTransition");
if let Some(var_436) = &input.lifecycle_transition {
scope_435.string(var_436);
}
#[allow(unused_mut)]
let mut scope_437 = writer.prefix("RoleARN");
if let Some(var_438) = &input.role_arn {
scope_437.string(var_438);
}
#[allow(unused_mut)]
let mut scope_439 = writer.prefix("NotificationTargetARN");
if let Some(var_440) = &input.notification_target_arn {
scope_439.string(var_440);
}
#[allow(unused_mut)]
let mut scope_441 = writer.prefix("NotificationMetadata");
if let Some(var_442) = &input.notification_metadata {
scope_441.string(var_442);
}
#[allow(unused_mut)]
let mut scope_443 = writer.prefix("HeartbeatTimeout");
if let Some(var_444) = &input.heartbeat_timeout {
scope_443.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_444).into()),
);
}
#[allow(unused_mut)]
let mut scope_445 = writer.prefix("DefaultResult");
if let Some(var_446) = &input.default_result {
scope_445.string(var_446);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_notification_configuration(
input: &crate::input::PutNotificationConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PutNotificationConfiguration", "2011-01-01");
#[allow(unused_mut)]
let mut scope_447 = writer.prefix("AutoScalingGroupName");
if let Some(var_448) = &input.auto_scaling_group_name {
scope_447.string(var_448);
}
#[allow(unused_mut)]
let mut scope_449 = writer.prefix("TopicARN");
if let Some(var_450) = &input.topic_arn {
scope_449.string(var_450);
}
#[allow(unused_mut)]
let mut scope_451 = writer.prefix("NotificationTypes");
if let Some(var_452) = &input.notification_types {
let mut list_454 = scope_451.start_list(false, None);
for item_453 in var_452 {
#[allow(unused_mut)]
let mut entry_455 = list_454.entry();
entry_455.string(item_453);
}
list_454.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_scaling_policy(
input: &crate::input::PutScalingPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutScalingPolicy", "2011-01-01");
#[allow(unused_mut)]
let mut scope_456 = writer.prefix("AutoScalingGroupName");
if let Some(var_457) = &input.auto_scaling_group_name {
scope_456.string(var_457);
}
#[allow(unused_mut)]
let mut scope_458 = writer.prefix("PolicyName");
if let Some(var_459) = &input.policy_name {
scope_458.string(var_459);
}
#[allow(unused_mut)]
let mut scope_460 = writer.prefix("PolicyType");
if let Some(var_461) = &input.policy_type {
scope_460.string(var_461);
}
#[allow(unused_mut)]
let mut scope_462 = writer.prefix("AdjustmentType");
if let Some(var_463) = &input.adjustment_type {
scope_462.string(var_463);
}
#[allow(unused_mut)]
let mut scope_464 = writer.prefix("MinAdjustmentStep");
if let Some(var_465) = &input.min_adjustment_step {
scope_464.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_465).into()),
);
}
#[allow(unused_mut)]
let mut scope_466 = writer.prefix("MinAdjustmentMagnitude");
if let Some(var_467) = &input.min_adjustment_magnitude {
scope_466.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_467).into()),
);
}
#[allow(unused_mut)]
let mut scope_468 = writer.prefix("ScalingAdjustment");
if let Some(var_469) = &input.scaling_adjustment {
scope_468.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_469).into()),
);
}
#[allow(unused_mut)]
let mut scope_470 = writer.prefix("Cooldown");
if let Some(var_471) = &input.cooldown {
scope_470.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_471).into()),
);
}
#[allow(unused_mut)]
let mut scope_472 = writer.prefix("MetricAggregationType");
if let Some(var_473) = &input.metric_aggregation_type {
scope_472.string(var_473);
}
#[allow(unused_mut)]
let mut scope_474 = writer.prefix("StepAdjustments");
if let Some(var_475) = &input.step_adjustments {
let mut list_477 = scope_474.start_list(false, None);
for item_476 in var_475 {
#[allow(unused_mut)]
let mut entry_478 = list_477.entry();
crate::query_ser::serialize_structure_crate_model_step_adjustment(entry_478, item_476)?;
}
list_477.finish();
}
#[allow(unused_mut)]
let mut scope_479 = writer.prefix("EstimatedInstanceWarmup");
if let Some(var_480) = &input.estimated_instance_warmup {
scope_479.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_480).into()),
);
}
#[allow(unused_mut)]
let mut scope_481 = writer.prefix("TargetTrackingConfiguration");
if let Some(var_482) = &input.target_tracking_configuration {
crate::query_ser::serialize_structure_crate_model_target_tracking_configuration(
scope_481, var_482,
)?;
}
#[allow(unused_mut)]
let mut scope_483 = writer.prefix("Enabled");
if let Some(var_484) = &input.enabled {
scope_483.boolean(*var_484);
}
#[allow(unused_mut)]
let mut scope_485 = writer.prefix("PredictiveScalingConfiguration");
if let Some(var_486) = &input.predictive_scaling_configuration {
crate::query_ser::serialize_structure_crate_model_predictive_scaling_configuration(
scope_485, var_486,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_scheduled_update_group_action(
input: &crate::input::PutScheduledUpdateGroupActionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PutScheduledUpdateGroupAction", "2011-01-01");
#[allow(unused_mut)]
let mut scope_487 = writer.prefix("AutoScalingGroupName");
if let Some(var_488) = &input.auto_scaling_group_name {
scope_487.string(var_488);
}
#[allow(unused_mut)]
let mut scope_489 = writer.prefix("ScheduledActionName");
if let Some(var_490) = &input.scheduled_action_name {
scope_489.string(var_490);
}
#[allow(unused_mut)]
let mut scope_491 = writer.prefix("Time");
if let Some(var_492) = &input.time {
scope_491.date_time(var_492, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_493 = writer.prefix("StartTime");
if let Some(var_494) = &input.start_time {
scope_493.date_time(var_494, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_495 = writer.prefix("EndTime");
if let Some(var_496) = &input.end_time {
scope_495.date_time(var_496, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_497 = writer.prefix("Recurrence");
if let Some(var_498) = &input.recurrence {
scope_497.string(var_498);
}
#[allow(unused_mut)]
let mut scope_499 = writer.prefix("MinSize");
if let Some(var_500) = &input.min_size {
scope_499.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_500).into()),
);
}
#[allow(unused_mut)]
let mut scope_501 = writer.prefix("MaxSize");
if let Some(var_502) = &input.max_size {
scope_501.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_502).into()),
);
}
#[allow(unused_mut)]
let mut scope_503 = writer.prefix("DesiredCapacity");
if let Some(var_504) = &input.desired_capacity {
scope_503.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_504).into()),
);
}
#[allow(unused_mut)]
let mut scope_505 = writer.prefix("TimeZone");
if let Some(var_506) = &input.time_zone {
scope_505.string(var_506);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_warm_pool(
input: &crate::input::PutWarmPoolInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutWarmPool", "2011-01-01");
#[allow(unused_mut)]
let mut scope_507 = writer.prefix("AutoScalingGroupName");
if let Some(var_508) = &input.auto_scaling_group_name {
scope_507.string(var_508);
}
#[allow(unused_mut)]
let mut scope_509 = writer.prefix("MaxGroupPreparedCapacity");
if let Some(var_510) = &input.max_group_prepared_capacity {
scope_509.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_510).into()),
);
}
#[allow(unused_mut)]
let mut scope_511 = writer.prefix("MinSize");
if let Some(var_512) = &input.min_size {
scope_511.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_512).into()),
);
}
#[allow(unused_mut)]
let mut scope_513 = writer.prefix("PoolState");
if let Some(var_514) = &input.pool_state {
scope_513.string(var_514.as_str());
}
#[allow(unused_mut)]
let mut scope_515 = writer.prefix("InstanceReusePolicy");
if let Some(var_516) = &input.instance_reuse_policy {
crate::query_ser::serialize_structure_crate_model_instance_reuse_policy(
scope_515, var_516,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_record_lifecycle_action_heartbeat(
input: &crate::input::RecordLifecycleActionHeartbeatInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RecordLifecycleActionHeartbeat",
"2011-01-01",
);
#[allow(unused_mut)]
let mut scope_517 = writer.prefix("LifecycleHookName");
if let Some(var_518) = &input.lifecycle_hook_name {
scope_517.string(var_518);
}
#[allow(unused_mut)]
let mut scope_519 = writer.prefix("AutoScalingGroupName");
if let Some(var_520) = &input.auto_scaling_group_name {
scope_519.string(var_520);
}
#[allow(unused_mut)]
let mut scope_521 = writer.prefix("LifecycleActionToken");
if let Some(var_522) = &input.lifecycle_action_token {
scope_521.string(var_522);
}
#[allow(unused_mut)]
let mut scope_523 = writer.prefix("InstanceId");
if let Some(var_524) = &input.instance_id {
scope_523.string(var_524);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_resume_processes(
input: &crate::input::ResumeProcessesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ResumeProcesses", "2011-01-01");
#[allow(unused_mut)]
let mut scope_525 = writer.prefix("AutoScalingGroupName");
if let Some(var_526) = &input.auto_scaling_group_name {
scope_525.string(var_526);
}
#[allow(unused_mut)]
let mut scope_527 = writer.prefix("ScalingProcesses");
if let Some(var_528) = &input.scaling_processes {
let mut list_530 = scope_527.start_list(false, None);
for item_529 in var_528 {
#[allow(unused_mut)]
let mut entry_531 = list_530.entry();
entry_531.string(item_529);
}
list_530.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_desired_capacity(
input: &crate::input::SetDesiredCapacityInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetDesiredCapacity", "2011-01-01");
#[allow(unused_mut)]
let mut scope_532 = writer.prefix("AutoScalingGroupName");
if let Some(var_533) = &input.auto_scaling_group_name {
scope_532.string(var_533);
}
#[allow(unused_mut)]
let mut scope_534 = writer.prefix("DesiredCapacity");
if let Some(var_535) = &input.desired_capacity {
scope_534.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_535).into()),
);
}
#[allow(unused_mut)]
let mut scope_536 = writer.prefix("HonorCooldown");
if let Some(var_537) = &input.honor_cooldown {
scope_536.boolean(*var_537);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_instance_health(
input: &crate::input::SetInstanceHealthInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetInstanceHealth", "2011-01-01");
#[allow(unused_mut)]
let mut scope_538 = writer.prefix("InstanceId");
if let Some(var_539) = &input.instance_id {
scope_538.string(var_539);
}
#[allow(unused_mut)]
let mut scope_540 = writer.prefix("HealthStatus");
if let Some(var_541) = &input.health_status {
scope_540.string(var_541);
}
#[allow(unused_mut)]
let mut scope_542 = writer.prefix("ShouldRespectGracePeriod");
if let Some(var_543) = &input.should_respect_grace_period {
scope_542.boolean(*var_543);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_instance_protection(
input: &crate::input::SetInstanceProtectionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetInstanceProtection", "2011-01-01");
#[allow(unused_mut)]
let mut scope_544 = writer.prefix("InstanceIds");
if let Some(var_545) = &input.instance_ids {
let mut list_547 = scope_544.start_list(false, None);
for item_546 in var_545 {
#[allow(unused_mut)]
let mut entry_548 = list_547.entry();
entry_548.string(item_546);
}
list_547.finish();
}
#[allow(unused_mut)]
let mut scope_549 = writer.prefix("AutoScalingGroupName");
if let Some(var_550) = &input.auto_scaling_group_name {
scope_549.string(var_550);
}
#[allow(unused_mut)]
let mut scope_551 = writer.prefix("ProtectedFromScaleIn");
if let Some(var_552) = &input.protected_from_scale_in {
scope_551.boolean(*var_552);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_instance_refresh(
input: &crate::input::StartInstanceRefreshInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "StartInstanceRefresh", "2011-01-01");
#[allow(unused_mut)]
let mut scope_553 = writer.prefix("AutoScalingGroupName");
if let Some(var_554) = &input.auto_scaling_group_name {
scope_553.string(var_554);
}
#[allow(unused_mut)]
let mut scope_555 = writer.prefix("Strategy");
if let Some(var_556) = &input.strategy {
scope_555.string(var_556.as_str());
}
#[allow(unused_mut)]
let mut scope_557 = writer.prefix("DesiredConfiguration");
if let Some(var_558) = &input.desired_configuration {
crate::query_ser::serialize_structure_crate_model_desired_configuration(
scope_557, var_558,
)?;
}
#[allow(unused_mut)]
let mut scope_559 = writer.prefix("Preferences");
if let Some(var_560) = &input.preferences {
crate::query_ser::serialize_structure_crate_model_refresh_preferences(scope_559, var_560)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_suspend_processes(
input: &crate::input::SuspendProcessesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "SuspendProcesses", "2011-01-01");
#[allow(unused_mut)]
let mut scope_561 = writer.prefix("AutoScalingGroupName");
if let Some(var_562) = &input.auto_scaling_group_name {
scope_561.string(var_562);
}
#[allow(unused_mut)]
let mut scope_563 = writer.prefix("ScalingProcesses");
if let Some(var_564) = &input.scaling_processes {
let mut list_566 = scope_563.start_list(false, None);
for item_565 in var_564 {
#[allow(unused_mut)]
let mut entry_567 = list_566.entry();
entry_567.string(item_565);
}
list_566.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_terminate_instance_in_auto_scaling_group(
input: &crate::input::TerminateInstanceInAutoScalingGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"TerminateInstanceInAutoScalingGroup",
"2011-01-01",
);
#[allow(unused_mut)]
let mut scope_568 = writer.prefix("InstanceId");
if let Some(var_569) = &input.instance_id {
scope_568.string(var_569);
}
#[allow(unused_mut)]
let mut scope_570 = writer.prefix("ShouldDecrementDesiredCapacity");
if let Some(var_571) = &input.should_decrement_desired_capacity {
scope_570.boolean(*var_571);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_auto_scaling_group(
input: &crate::input::UpdateAutoScalingGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateAutoScalingGroup", "2011-01-01");
#[allow(unused_mut)]
let mut scope_572 = writer.prefix("AutoScalingGroupName");
if let Some(var_573) = &input.auto_scaling_group_name {
scope_572.string(var_573);
}
#[allow(unused_mut)]
let mut scope_574 = writer.prefix("LaunchConfigurationName");
if let Some(var_575) = &input.launch_configuration_name {
scope_574.string(var_575);
}
#[allow(unused_mut)]
let mut scope_576 = writer.prefix("LaunchTemplate");
if let Some(var_577) = &input.launch_template {
crate::query_ser::serialize_structure_crate_model_launch_template_specification(
scope_576, var_577,
)?;
}
#[allow(unused_mut)]
let mut scope_578 = writer.prefix("MixedInstancesPolicy");
if let Some(var_579) = &input.mixed_instances_policy {
crate::query_ser::serialize_structure_crate_model_mixed_instances_policy(
scope_578, var_579,
)?;
}
#[allow(unused_mut)]
let mut scope_580 = writer.prefix("MinSize");
if let Some(var_581) = &input.min_size {
scope_580.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_581).into()),
);
}
#[allow(unused_mut)]
let mut scope_582 = writer.prefix("MaxSize");
if let Some(var_583) = &input.max_size {
scope_582.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_583).into()),
);
}
#[allow(unused_mut)]
let mut scope_584 = writer.prefix("DesiredCapacity");
if let Some(var_585) = &input.desired_capacity {
scope_584.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_585).into()),
);
}
#[allow(unused_mut)]
let mut scope_586 = writer.prefix("DefaultCooldown");
if let Some(var_587) = &input.default_cooldown {
scope_586.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_587).into()),
);
}
#[allow(unused_mut)]
let mut scope_588 = writer.prefix("AvailabilityZones");
if let Some(var_589) = &input.availability_zones {
let mut list_591 = scope_588.start_list(false, None);
for item_590 in var_589 {
#[allow(unused_mut)]
let mut entry_592 = list_591.entry();
entry_592.string(item_590);
}
list_591.finish();
}
#[allow(unused_mut)]
let mut scope_593 = writer.prefix("HealthCheckType");
if let Some(var_594) = &input.health_check_type {
scope_593.string(var_594);
}
#[allow(unused_mut)]
let mut scope_595 = writer.prefix("HealthCheckGracePeriod");
if let Some(var_596) = &input.health_check_grace_period {
scope_595.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_596).into()),
);
}
#[allow(unused_mut)]
let mut scope_597 = writer.prefix("PlacementGroup");
if let Some(var_598) = &input.placement_group {
scope_597.string(var_598);
}
#[allow(unused_mut)]
let mut scope_599 = writer.prefix("VPCZoneIdentifier");
if let Some(var_600) = &input.vpc_zone_identifier {
scope_599.string(var_600);
}
#[allow(unused_mut)]
let mut scope_601 = writer.prefix("TerminationPolicies");
if let Some(var_602) = &input.termination_policies {
let mut list_604 = scope_601.start_list(false, None);
for item_603 in var_602 {
#[allow(unused_mut)]
let mut entry_605 = list_604.entry();
entry_605.string(item_603);
}
list_604.finish();
}
#[allow(unused_mut)]
let mut scope_606 = writer.prefix("NewInstancesProtectedFromScaleIn");
if let Some(var_607) = &input.new_instances_protected_from_scale_in {
scope_606.boolean(*var_607);
}
#[allow(unused_mut)]
let mut scope_608 = writer.prefix("ServiceLinkedRoleARN");
if let Some(var_609) = &input.service_linked_role_arn {
scope_608.string(var_609);
}
#[allow(unused_mut)]
let mut scope_610 = writer.prefix("MaxInstanceLifetime");
if let Some(var_611) = &input.max_instance_lifetime {
scope_610.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_611).into()),
);
}
#[allow(unused_mut)]
let mut scope_612 = writer.prefix("CapacityRebalance");
if let Some(var_613) = &input.capacity_rebalance {
scope_612.boolean(*var_613);
}
#[allow(unused_mut)]
let mut scope_614 = writer.prefix("Context");
if let Some(var_615) = &input.context {
scope_614.string(var_615);
}
#[allow(unused_mut)]
let mut scope_616 = writer.prefix("DesiredCapacityType");
if let Some(var_617) = &input.desired_capacity_type {
scope_616.string(var_617);
}
#[allow(unused_mut)]
let mut scope_618 = writer.prefix("DefaultInstanceWarmup");
if let Some(var_619) = &input.default_instance_warmup {
scope_618.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_619).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}