#[allow(unused_mut)]
pub fn serialize_structure_crate_model_traffic_source_identifier(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TrafficSourceIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("Identifier");
if let Some(var_2) = &input.identifier {
scope_1.string(var_2);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scheduled_update_group_action_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScheduledUpdateGroupActionRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("ScheduledActionName");
if let Some(var_4) = &input.scheduled_action_name {
scope_3.string(var_4);
}
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("StartTime");
if let Some(var_6) = &input.start_time {
scope_5.date_time(var_6, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("EndTime");
if let Some(var_8) = &input.end_time {
scope_7.date_time(var_8, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_9 = writer.prefix("Recurrence");
if let Some(var_10) = &input.recurrence {
scope_9.string(var_10);
}
#[allow(unused_mut)]
let mut scope_11 = writer.prefix("MinSize");
if let Some(var_12) = &input.min_size {
scope_11.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_12).into()),
);
}
#[allow(unused_mut)]
let mut scope_13 = writer.prefix("MaxSize");
if let Some(var_14) = &input.max_size {
scope_13.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_14).into()),
);
}
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("DesiredCapacity");
if let Some(var_16) = &input.desired_capacity {
scope_15.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_16).into()),
);
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("TimeZone");
if let Some(var_18) = &input.time_zone {
scope_17.string(var_18);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("LaunchTemplateId");
if let Some(var_20) = &input.launch_template_id {
scope_19.string(var_20);
}
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("LaunchTemplateName");
if let Some(var_22) = &input.launch_template_name {
scope_21.string(var_22);
}
#[allow(unused_mut)]
let mut scope_23 = writer.prefix("Version");
if let Some(var_24) = &input.version {
scope_23.string(var_24);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_mixed_instances_policy(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MixedInstancesPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_25 = writer.prefix("LaunchTemplate");
if let Some(var_26) = &input.launch_template {
crate::query_ser::serialize_structure_crate_model_launch_template(scope_25, var_26)?;
}
#[allow(unused_mut)]
let mut scope_27 = writer.prefix("InstancesDistribution");
if let Some(var_28) = &input.instances_distribution {
crate::query_ser::serialize_structure_crate_model_instances_distribution(scope_27, var_28)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_lifecycle_hook_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LifecycleHookSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_29 = writer.prefix("LifecycleHookName");
if let Some(var_30) = &input.lifecycle_hook_name {
scope_29.string(var_30);
}
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("LifecycleTransition");
if let Some(var_32) = &input.lifecycle_transition {
scope_31.string(var_32);
}
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("NotificationMetadata");
if let Some(var_34) = &input.notification_metadata {
scope_33.string(var_34);
}
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("HeartbeatTimeout");
if let Some(var_36) = &input.heartbeat_timeout {
scope_35.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_36).into()),
);
}
#[allow(unused_mut)]
let mut scope_37 = writer.prefix("DefaultResult");
if let Some(var_38) = &input.default_result {
scope_37.string(var_38);
}
#[allow(unused_mut)]
let mut scope_39 = writer.prefix("NotificationTargetARN");
if let Some(var_40) = &input.notification_target_arn {
scope_39.string(var_40);
}
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("RoleARN");
if let Some(var_42) = &input.role_arn {
scope_41.string(var_42);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_tag(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_43 = writer.prefix("ResourceId");
if let Some(var_44) = &input.resource_id {
scope_43.string(var_44);
}
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("ResourceType");
if let Some(var_46) = &input.resource_type {
scope_45.string(var_46);
}
#[allow(unused_mut)]
let mut scope_47 = writer.prefix("Key");
if let Some(var_48) = &input.key {
scope_47.string(var_48);
}
#[allow(unused_mut)]
let mut scope_49 = writer.prefix("Value");
if let Some(var_50) = &input.value {
scope_49.string(var_50);
}
#[allow(unused_mut)]
let mut scope_51 = writer.prefix("PropagateAtLaunch");
if let Some(var_52) = &input.propagate_at_launch {
scope_51.boolean(*var_52);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_block_device_mapping(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::BlockDeviceMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_53 = writer.prefix("VirtualName");
if let Some(var_54) = &input.virtual_name {
scope_53.string(var_54);
}
#[allow(unused_mut)]
let mut scope_55 = writer.prefix("DeviceName");
if let Some(var_56) = &input.device_name {
scope_55.string(var_56);
}
#[allow(unused_mut)]
let mut scope_57 = writer.prefix("Ebs");
if let Some(var_58) = &input.ebs {
crate::query_ser::serialize_structure_crate_model_ebs(scope_57, var_58)?;
}
#[allow(unused_mut)]
let mut scope_59 = writer.prefix("NoDevice");
if let Some(var_60) = &input.no_device {
scope_59.boolean(*var_60);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_monitoring(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceMonitoring,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_61 = writer.prefix("Enabled");
if let Some(var_62) = &input.enabled {
scope_61.boolean(*var_62);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_metadata_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceMetadataOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_63 = writer.prefix("HttpTokens");
if let Some(var_64) = &input.http_tokens {
scope_63.string(var_64.as_str());
}
#[allow(unused_mut)]
let mut scope_65 = writer.prefix("HttpPutResponseHopLimit");
if let Some(var_66) = &input.http_put_response_hop_limit {
scope_65.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_66).into()),
);
}
#[allow(unused_mut)]
let mut scope_67 = writer.prefix("HttpEndpoint");
if let Some(var_68) = &input.http_endpoint {
scope_67.string(var_68.as_str());
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_filter(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_69 = writer.prefix("Name");
if let Some(var_70) = &input.name {
scope_69.string(var_70);
}
#[allow(unused_mut)]
let mut scope_71 = writer.prefix("Values");
if let Some(var_72) = &input.values {
let mut list_74 = scope_71.start_list(false, None);
for item_73 in var_72 {
#[allow(unused_mut)]
let mut entry_75 = list_74.entry();
entry_75.string(item_73);
}
list_74.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_step_adjustment(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::StepAdjustment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_76 = writer.prefix("MetricIntervalLowerBound");
if let Some(var_77) = &input.metric_interval_lower_bound {
scope_76.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_77).into()),
);
}
#[allow(unused_mut)]
let mut scope_78 = writer.prefix("MetricIntervalUpperBound");
if let Some(var_79) = &input.metric_interval_upper_bound {
scope_78.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_79).into()),
);
}
#[allow(unused_mut)]
let mut scope_80 = writer.prefix("ScalingAdjustment");
if let Some(var_81) = &input.scaling_adjustment {
scope_80.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_81).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_tracking_configuration(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetTrackingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_82 = writer.prefix("PredefinedMetricSpecification");
if let Some(var_83) = &input.predefined_metric_specification {
crate::query_ser::serialize_structure_crate_model_predefined_metric_specification(
scope_82, var_83,
)?;
}
#[allow(unused_mut)]
let mut scope_84 = writer.prefix("CustomizedMetricSpecification");
if let Some(var_85) = &input.customized_metric_specification {
crate::query_ser::serialize_structure_crate_model_customized_metric_specification(
scope_84, var_85,
)?;
}
#[allow(unused_mut)]
let mut scope_86 = writer.prefix("TargetValue");
if let Some(var_87) = &input.target_value {
scope_86.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_87).into()),
);
}
#[allow(unused_mut)]
let mut scope_88 = writer.prefix("DisableScaleIn");
if let Some(var_89) = &input.disable_scale_in {
scope_88.boolean(*var_89);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_configuration(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PredictiveScalingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_90 = writer.prefix("MetricSpecifications");
if let Some(var_91) = &input.metric_specifications {
let mut list_93 = scope_90.start_list(false, None);
for item_92 in var_91 {
#[allow(unused_mut)]
let mut entry_94 = list_93.entry();
crate::query_ser::serialize_structure_crate_model_predictive_scaling_metric_specification(entry_94, item_92)?;
}
list_93.finish();
}
#[allow(unused_mut)]
let mut scope_95 = writer.prefix("Mode");
if let Some(var_96) = &input.mode {
scope_95.string(var_96.as_str());
}
#[allow(unused_mut)]
let mut scope_97 = writer.prefix("SchedulingBufferTime");
if let Some(var_98) = &input.scheduling_buffer_time {
scope_97.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_98).into()),
);
}
#[allow(unused_mut)]
let mut scope_99 = writer.prefix("MaxCapacityBreachBehavior");
if let Some(var_100) = &input.max_capacity_breach_behavior {
scope_99.string(var_100.as_str());
}
#[allow(unused_mut)]
let mut scope_101 = writer.prefix("MaxCapacityBuffer");
if let Some(var_102) = &input.max_capacity_buffer {
scope_101.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_102).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_reuse_policy(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceReusePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_103 = writer.prefix("ReuseOnScaleIn");
if let Some(var_104) = &input.reuse_on_scale_in {
scope_103.boolean(*var_104);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_desired_configuration(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DesiredConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_105 = writer.prefix("LaunchTemplate");
if let Some(var_106) = &input.launch_template {
crate::query_ser::serialize_structure_crate_model_launch_template_specification(
scope_105, var_106,
)?;
}
#[allow(unused_mut)]
let mut scope_107 = writer.prefix("MixedInstancesPolicy");
if let Some(var_108) = &input.mixed_instances_policy {
crate::query_ser::serialize_structure_crate_model_mixed_instances_policy(
scope_107, var_108,
)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_refresh_preferences(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RefreshPreferences,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_109 = writer.prefix("MinHealthyPercentage");
if let Some(var_110) = &input.min_healthy_percentage {
scope_109.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_110).into()),
);
}
#[allow(unused_mut)]
let mut scope_111 = writer.prefix("InstanceWarmup");
if let Some(var_112) = &input.instance_warmup {
scope_111.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_112).into()),
);
}
#[allow(unused_mut)]
let mut scope_113 = writer.prefix("CheckpointPercentages");
if let Some(var_114) = &input.checkpoint_percentages {
let mut list_116 = scope_113.start_list(false, None);
for item_115 in var_114 {
#[allow(unused_mut)]
let mut entry_117 = list_116.entry();
entry_117.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_115).into()),
);
}
list_116.finish();
}
#[allow(unused_mut)]
let mut scope_118 = writer.prefix("CheckpointDelay");
if let Some(var_119) = &input.checkpoint_delay {
scope_118.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_119).into()),
);
}
#[allow(unused_mut)]
let mut scope_120 = writer.prefix("SkipMatching");
if let Some(var_121) = &input.skip_matching {
scope_120.boolean(*var_121);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_122 = writer.prefix("LaunchTemplateSpecification");
if let Some(var_123) = &input.launch_template_specification {
crate::query_ser::serialize_structure_crate_model_launch_template_specification(
scope_122, var_123,
)?;
}
#[allow(unused_mut)]
let mut scope_124 = writer.prefix("Overrides");
if let Some(var_125) = &input.overrides {
let mut list_127 = scope_124.start_list(false, None);
for item_126 in var_125 {
#[allow(unused_mut)]
let mut entry_128 = list_127.entry();
crate::query_ser::serialize_structure_crate_model_launch_template_overrides(
entry_128, item_126,
)?;
}
list_127.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instances_distribution(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstancesDistribution,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_129 = writer.prefix("OnDemandAllocationStrategy");
if let Some(var_130) = &input.on_demand_allocation_strategy {
scope_129.string(var_130);
}
#[allow(unused_mut)]
let mut scope_131 = writer.prefix("OnDemandBaseCapacity");
if let Some(var_132) = &input.on_demand_base_capacity {
scope_131.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_132).into()),
);
}
#[allow(unused_mut)]
let mut scope_133 = writer.prefix("OnDemandPercentageAboveBaseCapacity");
if let Some(var_134) = &input.on_demand_percentage_above_base_capacity {
scope_133.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_134).into()),
);
}
#[allow(unused_mut)]
let mut scope_135 = writer.prefix("SpotAllocationStrategy");
if let Some(var_136) = &input.spot_allocation_strategy {
scope_135.string(var_136);
}
#[allow(unused_mut)]
let mut scope_137 = writer.prefix("SpotInstancePools");
if let Some(var_138) = &input.spot_instance_pools {
scope_137.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_138).into()),
);
}
#[allow(unused_mut)]
let mut scope_139 = writer.prefix("SpotMaxPrice");
if let Some(var_140) = &input.spot_max_price {
scope_139.string(var_140);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_ebs(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Ebs,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_141 = writer.prefix("SnapshotId");
if let Some(var_142) = &input.snapshot_id {
scope_141.string(var_142);
}
#[allow(unused_mut)]
let mut scope_143 = writer.prefix("VolumeSize");
if let Some(var_144) = &input.volume_size {
scope_143.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_144).into()),
);
}
#[allow(unused_mut)]
let mut scope_145 = writer.prefix("VolumeType");
if let Some(var_146) = &input.volume_type {
scope_145.string(var_146);
}
#[allow(unused_mut)]
let mut scope_147 = writer.prefix("DeleteOnTermination");
if let Some(var_148) = &input.delete_on_termination {
scope_147.boolean(*var_148);
}
#[allow(unused_mut)]
let mut scope_149 = writer.prefix("Iops");
if let Some(var_150) = &input.iops {
scope_149.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_150).into()),
);
}
#[allow(unused_mut)]
let mut scope_151 = writer.prefix("Encrypted");
if let Some(var_152) = &input.encrypted {
scope_151.boolean(*var_152);
}
#[allow(unused_mut)]
let mut scope_153 = writer.prefix("Throughput");
if let Some(var_154) = &input.throughput {
scope_153.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_154).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predefined_metric_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PredefinedMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_155 = writer.prefix("PredefinedMetricType");
if let Some(var_156) = &input.predefined_metric_type {
scope_155.string(var_156.as_str());
}
#[allow(unused_mut)]
let mut scope_157 = writer.prefix("ResourceLabel");
if let Some(var_158) = &input.resource_label {
scope_157.string(var_158);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_customized_metric_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CustomizedMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_159 = writer.prefix("MetricName");
if let Some(var_160) = &input.metric_name {
scope_159.string(var_160);
}
#[allow(unused_mut)]
let mut scope_161 = writer.prefix("Namespace");
if let Some(var_162) = &input.namespace {
scope_161.string(var_162);
}
#[allow(unused_mut)]
let mut scope_163 = writer.prefix("Dimensions");
if let Some(var_164) = &input.dimensions {
let mut list_166 = scope_163.start_list(false, None);
for item_165 in var_164 {
#[allow(unused_mut)]
let mut entry_167 = list_166.entry();
crate::query_ser::serialize_structure_crate_model_metric_dimension(
entry_167, item_165,
)?;
}
list_166.finish();
}
#[allow(unused_mut)]
let mut scope_168 = writer.prefix("Statistic");
if let Some(var_169) = &input.statistic {
scope_168.string(var_169.as_str());
}
#[allow(unused_mut)]
let mut scope_170 = writer.prefix("Unit");
if let Some(var_171) = &input.unit {
scope_170.string(var_171);
}
#[allow(unused_mut)]
let mut scope_172 = writer.prefix("Metrics");
if let Some(var_173) = &input.metrics {
let mut list_175 = scope_172.start_list(false, None);
for item_174 in var_173 {
#[allow(unused_mut)]
let mut entry_176 = list_175.entry();
crate::query_ser::serialize_structure_crate_model_target_tracking_metric_data_query(
entry_176, item_174,
)?;
}
list_175.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_metric_specification(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PredictiveScalingMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_177 = writer.prefix("TargetValue");
if let Some(var_178) = &input.target_value {
scope_177.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_178).into()),
);
}
#[allow(unused_mut)]
let mut scope_179 = writer.prefix("PredefinedMetricPairSpecification");
if let Some(var_180) = &input.predefined_metric_pair_specification {
crate::query_ser::serialize_structure_crate_model_predictive_scaling_predefined_metric_pair(scope_179, var_180)?;
}
#[allow(unused_mut)]
let mut scope_181 = writer.prefix("PredefinedScalingMetricSpecification");
if let Some(var_182) = &input.predefined_scaling_metric_specification {
crate::query_ser::serialize_structure_crate_model_predictive_scaling_predefined_scaling_metric(scope_181, var_182)?;
}
#[allow(unused_mut)]
let mut scope_183 = writer.prefix("PredefinedLoadMetricSpecification");
if let Some(var_184) = &input.predefined_load_metric_specification {
crate::query_ser::serialize_structure_crate_model_predictive_scaling_predefined_load_metric(scope_183, var_184)?;
}
#[allow(unused_mut)]
let mut scope_185 = writer.prefix("CustomizedScalingMetricSpecification");
if let Some(var_186) = &input.customized_scaling_metric_specification {
crate::query_ser::serialize_structure_crate_model_predictive_scaling_customized_scaling_metric(scope_185, var_186)?;
}
#[allow(unused_mut)]
let mut scope_187 = writer.prefix("CustomizedLoadMetricSpecification");
if let Some(var_188) = &input.customized_load_metric_specification {
crate::query_ser::serialize_structure_crate_model_predictive_scaling_customized_load_metric(scope_187, var_188)?;
}
#[allow(unused_mut)]
let mut scope_189 = writer.prefix("CustomizedCapacityMetricSpecification");
if let Some(var_190) = &input.customized_capacity_metric_specification {
crate::query_ser::serialize_structure_crate_model_predictive_scaling_customized_capacity_metric(scope_189, var_190)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_launch_template_overrides(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LaunchTemplateOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_191 = writer.prefix("InstanceType");
if let Some(var_192) = &input.instance_type {
scope_191.string(var_192);
}
#[allow(unused_mut)]
let mut scope_193 = writer.prefix("WeightedCapacity");
if let Some(var_194) = &input.weighted_capacity {
scope_193.string(var_194);
}
#[allow(unused_mut)]
let mut scope_195 = writer.prefix("LaunchTemplateSpecification");
if let Some(var_196) = &input.launch_template_specification {
crate::query_ser::serialize_structure_crate_model_launch_template_specification(
scope_195, var_196,
)?;
}
#[allow(unused_mut)]
let mut scope_197 = writer.prefix("InstanceRequirements");
if let Some(var_198) = &input.instance_requirements {
crate::query_ser::serialize_structure_crate_model_instance_requirements(
scope_197, var_198,
)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_dimension(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MetricDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_199 = writer.prefix("Name");
if let Some(var_200) = &input.name {
scope_199.string(var_200);
}
#[allow(unused_mut)]
let mut scope_201 = writer.prefix("Value");
if let Some(var_202) = &input.value {
scope_201.string(var_202);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_tracking_metric_data_query(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetTrackingMetricDataQuery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_203 = writer.prefix("Id");
if let Some(var_204) = &input.id {
scope_203.string(var_204);
}
#[allow(unused_mut)]
let mut scope_205 = writer.prefix("Expression");
if let Some(var_206) = &input.expression {
scope_205.string(var_206);
}
#[allow(unused_mut)]
let mut scope_207 = writer.prefix("MetricStat");
if let Some(var_208) = &input.metric_stat {
crate::query_ser::serialize_structure_crate_model_target_tracking_metric_stat(
scope_207, var_208,
)?;
}
#[allow(unused_mut)]
let mut scope_209 = writer.prefix("Label");
if let Some(var_210) = &input.label {
scope_209.string(var_210);
}
#[allow(unused_mut)]
let mut scope_211 = writer.prefix("ReturnData");
if let Some(var_212) = &input.return_data {
scope_211.boolean(*var_212);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_predefined_metric_pair(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PredictiveScalingPredefinedMetricPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_213 = writer.prefix("PredefinedMetricType");
if let Some(var_214) = &input.predefined_metric_type {
scope_213.string(var_214.as_str());
}
#[allow(unused_mut)]
let mut scope_215 = writer.prefix("ResourceLabel");
if let Some(var_216) = &input.resource_label {
scope_215.string(var_216);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_predefined_scaling_metric(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PredictiveScalingPredefinedScalingMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_217 = writer.prefix("PredefinedMetricType");
if let Some(var_218) = &input.predefined_metric_type {
scope_217.string(var_218.as_str());
}
#[allow(unused_mut)]
let mut scope_219 = writer.prefix("ResourceLabel");
if let Some(var_220) = &input.resource_label {
scope_219.string(var_220);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_predefined_load_metric(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PredictiveScalingPredefinedLoadMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_221 = writer.prefix("PredefinedMetricType");
if let Some(var_222) = &input.predefined_metric_type {
scope_221.string(var_222.as_str());
}
#[allow(unused_mut)]
let mut scope_223 = writer.prefix("ResourceLabel");
if let Some(var_224) = &input.resource_label {
scope_223.string(var_224);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_customized_scaling_metric(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PredictiveScalingCustomizedScalingMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_225 = writer.prefix("MetricDataQueries");
if let Some(var_226) = &input.metric_data_queries {
let mut list_228 = scope_225.start_list(false, None);
for item_227 in var_226 {
#[allow(unused_mut)]
let mut entry_229 = list_228.entry();
crate::query_ser::serialize_structure_crate_model_metric_data_query(
entry_229, item_227,
)?;
}
list_228.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_customized_load_metric(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PredictiveScalingCustomizedLoadMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_230 = writer.prefix("MetricDataQueries");
if let Some(var_231) = &input.metric_data_queries {
let mut list_233 = scope_230.start_list(false, None);
for item_232 in var_231 {
#[allow(unused_mut)]
let mut entry_234 = list_233.entry();
crate::query_ser::serialize_structure_crate_model_metric_data_query(
entry_234, item_232,
)?;
}
list_233.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_predictive_scaling_customized_capacity_metric(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PredictiveScalingCustomizedCapacityMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_235 = writer.prefix("MetricDataQueries");
if let Some(var_236) = &input.metric_data_queries {
let mut list_238 = scope_235.start_list(false, None);
for item_237 in var_236 {
#[allow(unused_mut)]
let mut entry_239 = list_238.entry();
crate::query_ser::serialize_structure_crate_model_metric_data_query(
entry_239, item_237,
)?;
}
list_238.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_instance_requirements(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::InstanceRequirements,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_240 = writer.prefix("VCpuCount");
if let Some(var_241) = &input.v_cpu_count {
crate::query_ser::serialize_structure_crate_model_v_cpu_count_request(scope_240, var_241)?;
}
#[allow(unused_mut)]
let mut scope_242 = writer.prefix("MemoryMiB");
if let Some(var_243) = &input.memory_mi_b {
crate::query_ser::serialize_structure_crate_model_memory_mi_b_request(scope_242, var_243)?;
}
#[allow(unused_mut)]
let mut scope_244 = writer.prefix("CpuManufacturers");
if let Some(var_245) = &input.cpu_manufacturers {
let mut list_247 = scope_244.start_list(false, None);
for item_246 in var_245 {
#[allow(unused_mut)]
let mut entry_248 = list_247.entry();
entry_248.string(item_246.as_str());
}
list_247.finish();
}
#[allow(unused_mut)]
let mut scope_249 = writer.prefix("MemoryGiBPerVCpu");
if let Some(var_250) = &input.memory_gi_b_per_v_cpu {
crate::query_ser::serialize_structure_crate_model_memory_gi_b_per_v_cpu_request(
scope_249, var_250,
)?;
}
#[allow(unused_mut)]
let mut scope_251 = writer.prefix("ExcludedInstanceTypes");
if let Some(var_252) = &input.excluded_instance_types {
let mut list_254 = scope_251.start_list(false, None);
for item_253 in var_252 {
#[allow(unused_mut)]
let mut entry_255 = list_254.entry();
entry_255.string(item_253);
}
list_254.finish();
}
#[allow(unused_mut)]
let mut scope_256 = writer.prefix("InstanceGenerations");
if let Some(var_257) = &input.instance_generations {
let mut list_259 = scope_256.start_list(false, None);
for item_258 in var_257 {
#[allow(unused_mut)]
let mut entry_260 = list_259.entry();
entry_260.string(item_258.as_str());
}
list_259.finish();
}
#[allow(unused_mut)]
let mut scope_261 = writer.prefix("SpotMaxPricePercentageOverLowestPrice");
if let Some(var_262) = &input.spot_max_price_percentage_over_lowest_price {
scope_261.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_262).into()),
);
}
#[allow(unused_mut)]
let mut scope_263 = writer.prefix("OnDemandMaxPricePercentageOverLowestPrice");
if let Some(var_264) = &input.on_demand_max_price_percentage_over_lowest_price {
scope_263.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_264).into()),
);
}
#[allow(unused_mut)]
let mut scope_265 = writer.prefix("BareMetal");
if let Some(var_266) = &input.bare_metal {
scope_265.string(var_266.as_str());
}
#[allow(unused_mut)]
let mut scope_267 = writer.prefix("BurstablePerformance");
if let Some(var_268) = &input.burstable_performance {
scope_267.string(var_268.as_str());
}
#[allow(unused_mut)]
let mut scope_269 = writer.prefix("RequireHibernateSupport");
if let Some(var_270) = &input.require_hibernate_support {
scope_269.boolean(*var_270);
}
#[allow(unused_mut)]
let mut scope_271 = writer.prefix("NetworkInterfaceCount");
if let Some(var_272) = &input.network_interface_count {
crate::query_ser::serialize_structure_crate_model_network_interface_count_request(
scope_271, var_272,
)?;
}
#[allow(unused_mut)]
let mut scope_273 = writer.prefix("LocalStorage");
if let Some(var_274) = &input.local_storage {
scope_273.string(var_274.as_str());
}
#[allow(unused_mut)]
let mut scope_275 = writer.prefix("LocalStorageTypes");
if let Some(var_276) = &input.local_storage_types {
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.as_str());
}
list_278.finish();
}
#[allow(unused_mut)]
let mut scope_280 = writer.prefix("TotalLocalStorageGB");
if let Some(var_281) = &input.total_local_storage_gb {
crate::query_ser::serialize_structure_crate_model_total_local_storage_gb_request(
scope_280, var_281,
)?;
}
#[allow(unused_mut)]
let mut scope_282 = writer.prefix("BaselineEbsBandwidthMbps");
if let Some(var_283) = &input.baseline_ebs_bandwidth_mbps {
crate::query_ser::serialize_structure_crate_model_baseline_ebs_bandwidth_mbps_request(
scope_282, var_283,
)?;
}
#[allow(unused_mut)]
let mut scope_284 = writer.prefix("AcceleratorTypes");
if let Some(var_285) = &input.accelerator_types {
let mut list_287 = scope_284.start_list(false, None);
for item_286 in var_285 {
#[allow(unused_mut)]
let mut entry_288 = list_287.entry();
entry_288.string(item_286.as_str());
}
list_287.finish();
}
#[allow(unused_mut)]
let mut scope_289 = writer.prefix("AcceleratorCount");
if let Some(var_290) = &input.accelerator_count {
crate::query_ser::serialize_structure_crate_model_accelerator_count_request(
scope_289, var_290,
)?;
}
#[allow(unused_mut)]
let mut scope_291 = writer.prefix("AcceleratorManufacturers");
if let Some(var_292) = &input.accelerator_manufacturers {
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.as_str());
}
list_294.finish();
}
#[allow(unused_mut)]
let mut scope_296 = writer.prefix("AcceleratorNames");
if let Some(var_297) = &input.accelerator_names {
let mut list_299 = scope_296.start_list(false, None);
for item_298 in var_297 {
#[allow(unused_mut)]
let mut entry_300 = list_299.entry();
entry_300.string(item_298.as_str());
}
list_299.finish();
}
#[allow(unused_mut)]
let mut scope_301 = writer.prefix("AcceleratorTotalMemoryMiB");
if let Some(var_302) = &input.accelerator_total_memory_mi_b {
crate::query_ser::serialize_structure_crate_model_accelerator_total_memory_mi_b_request(
scope_301, var_302,
)?;
}
#[allow(unused_mut)]
let mut scope_303 = writer.prefix("NetworkBandwidthGbps");
if let Some(var_304) = &input.network_bandwidth_gbps {
crate::query_ser::serialize_structure_crate_model_network_bandwidth_gbps_request(
scope_303, var_304,
)?;
}
#[allow(unused_mut)]
let mut scope_305 = writer.prefix("AllowedInstanceTypes");
if let Some(var_306) = &input.allowed_instance_types {
let mut list_308 = scope_305.start_list(false, None);
for item_307 in var_306 {
#[allow(unused_mut)]
let mut entry_309 = list_308.entry();
entry_309.string(item_307);
}
list_308.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_tracking_metric_stat(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetTrackingMetricStat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_310 = writer.prefix("Metric");
if let Some(var_311) = &input.metric {
crate::query_ser::serialize_structure_crate_model_metric(scope_310, var_311)?;
}
#[allow(unused_mut)]
let mut scope_312 = writer.prefix("Stat");
if let Some(var_313) = &input.stat {
scope_312.string(var_313);
}
#[allow(unused_mut)]
let mut scope_314 = writer.prefix("Unit");
if let Some(var_315) = &input.unit {
scope_314.string(var_315);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_data_query(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MetricDataQuery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_316 = writer.prefix("Id");
if let Some(var_317) = &input.id {
scope_316.string(var_317);
}
#[allow(unused_mut)]
let mut scope_318 = writer.prefix("Expression");
if let Some(var_319) = &input.expression {
scope_318.string(var_319);
}
#[allow(unused_mut)]
let mut scope_320 = writer.prefix("MetricStat");
if let Some(var_321) = &input.metric_stat {
crate::query_ser::serialize_structure_crate_model_metric_stat(scope_320, var_321)?;
}
#[allow(unused_mut)]
let mut scope_322 = writer.prefix("Label");
if let Some(var_323) = &input.label {
scope_322.string(var_323);
}
#[allow(unused_mut)]
let mut scope_324 = writer.prefix("ReturnData");
if let Some(var_325) = &input.return_data {
scope_324.boolean(*var_325);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_v_cpu_count_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::VCpuCountRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_326 = writer.prefix("Min");
if let Some(var_327) = &input.min {
scope_326.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_327).into()),
);
}
#[allow(unused_mut)]
let mut scope_328 = writer.prefix("Max");
if let Some(var_329) = &input.max {
scope_328.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_329).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_memory_mi_b_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MemoryMiBRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_330 = writer.prefix("Min");
if let Some(var_331) = &input.min {
scope_330.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_331).into()),
);
}
#[allow(unused_mut)]
let mut scope_332 = writer.prefix("Max");
if let Some(var_333) = &input.max {
scope_332.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_333).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_memory_gi_b_per_v_cpu_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MemoryGiBPerVCpuRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_334 = writer.prefix("Min");
if let Some(var_335) = &input.min {
scope_334.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_335).into()),
);
}
#[allow(unused_mut)]
let mut scope_336 = writer.prefix("Max");
if let Some(var_337) = &input.max {
scope_336.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_337).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_network_interface_count_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::NetworkInterfaceCountRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_338 = writer.prefix("Min");
if let Some(var_339) = &input.min {
scope_338.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_339).into()),
);
}
#[allow(unused_mut)]
let mut scope_340 = writer.prefix("Max");
if let Some(var_341) = &input.max {
scope_340.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_341).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_total_local_storage_gb_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TotalLocalStorageGbRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_342 = writer.prefix("Min");
if let Some(var_343) = &input.min {
scope_342.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_343).into()),
);
}
#[allow(unused_mut)]
let mut scope_344 = writer.prefix("Max");
if let Some(var_345) = &input.max {
scope_344.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_345).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_baseline_ebs_bandwidth_mbps_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::BaselineEbsBandwidthMbpsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_346 = writer.prefix("Min");
if let Some(var_347) = &input.min {
scope_346.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_347).into()),
);
}
#[allow(unused_mut)]
let mut scope_348 = writer.prefix("Max");
if let Some(var_349) = &input.max {
scope_348.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_349).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_accelerator_count_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AcceleratorCountRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_350 = writer.prefix("Min");
if let Some(var_351) = &input.min {
scope_350.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_351).into()),
);
}
#[allow(unused_mut)]
let mut scope_352 = writer.prefix("Max");
if let Some(var_353) = &input.max {
scope_352.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_353).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_accelerator_total_memory_mi_b_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AcceleratorTotalMemoryMiBRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_354 = writer.prefix("Min");
if let Some(var_355) = &input.min {
scope_354.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_355).into()),
);
}
#[allow(unused_mut)]
let mut scope_356 = writer.prefix("Max");
if let Some(var_357) = &input.max {
scope_356.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_357).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_network_bandwidth_gbps_request(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::NetworkBandwidthGbpsRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_358 = writer.prefix("Min");
if let Some(var_359) = &input.min {
scope_358.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_359).into()),
);
}
#[allow(unused_mut)]
let mut scope_360 = writer.prefix("Max");
if let Some(var_361) = &input.max {
scope_360.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_361).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Metric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_362 = writer.prefix("Namespace");
if let Some(var_363) = &input.namespace {
scope_362.string(var_363);
}
#[allow(unused_mut)]
let mut scope_364 = writer.prefix("MetricName");
if let Some(var_365) = &input.metric_name {
scope_364.string(var_365);
}
#[allow(unused_mut)]
let mut scope_366 = writer.prefix("Dimensions");
if let Some(var_367) = &input.dimensions {
let mut list_369 = scope_366.start_list(false, None);
for item_368 in var_367 {
#[allow(unused_mut)]
let mut entry_370 = list_369.entry();
crate::query_ser::serialize_structure_crate_model_metric_dimension(
entry_370, item_368,
)?;
}
list_369.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_stat(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MetricStat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_371 = writer.prefix("Metric");
if let Some(var_372) = &input.metric {
crate::query_ser::serialize_structure_crate_model_metric(scope_371, var_372)?;
}
#[allow(unused_mut)]
let mut scope_373 = writer.prefix("Stat");
if let Some(var_374) = &input.stat {
scope_373.string(var_374);
}
#[allow(unused_mut)]
let mut scope_375 = writer.prefix("Unit");
if let Some(var_376) = &input.unit {
scope_375.string(var_376);
}
Ok(())
}