pub fn serialize_operation_crate_operation_delete_alarms(
input: &crate::input::DeleteAlarmsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteAlarms", "2010-08-01");
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("AlarmNames");
if let Some(var_2) = &input.alarm_names {
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();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_anomaly_detector(
input: &crate::input::DeleteAnomalyDetectorInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteAnomalyDetector", "2010-08-01");
#[allow(unused_mut)]
let mut scope_6 = writer.prefix("Namespace");
if let Some(var_7) = &input.namespace {
scope_6.string(var_7);
}
#[allow(unused_mut)]
let mut scope_8 = writer.prefix("MetricName");
if let Some(var_9) = &input.metric_name {
scope_8.string(var_9);
}
#[allow(unused_mut)]
let mut scope_10 = writer.prefix("Dimensions");
if let Some(var_11) = &input.dimensions {
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();
crate::query_ser::serialize_structure_crate_model_dimension(entry_14, item_12)?;
}
list_13.finish();
}
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("Stat");
if let Some(var_16) = &input.stat {
scope_15.string(var_16);
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("SingleMetricAnomalyDetector");
if let Some(var_18) = &input.single_metric_anomaly_detector {
crate::query_ser::serialize_structure_crate_model_single_metric_anomaly_detector(
scope_17, var_18,
)?;
}
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("MetricMathAnomalyDetector");
if let Some(var_20) = &input.metric_math_anomaly_detector {
crate::query_ser::serialize_structure_crate_model_metric_math_anomaly_detector(
scope_19, var_20,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_dashboards(
input: &crate::input::DeleteDashboardsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteDashboards", "2010-08-01");
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("DashboardNames");
if let Some(var_22) = &input.dashboard_names {
let mut list_24 = scope_21.start_list(false, None);
for item_23 in var_22 {
#[allow(unused_mut)]
let mut entry_25 = list_24.entry();
entry_25.string(item_23);
}
list_24.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_insight_rules(
input: &crate::input::DeleteInsightRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteInsightRules", "2010-08-01");
#[allow(unused_mut)]
let mut scope_26 = writer.prefix("RuleNames");
if let Some(var_27) = &input.rule_names {
let mut list_29 = scope_26.start_list(false, None);
for item_28 in var_27 {
#[allow(unused_mut)]
let mut entry_30 = list_29.entry();
entry_30.string(item_28);
}
list_29.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_metric_stream(
input: &crate::input::DeleteMetricStreamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteMetricStream", "2010-08-01");
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("Name");
if let Some(var_32) = &input.name {
scope_31.string(var_32);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_alarm_history(
input: &crate::input::DescribeAlarmHistoryInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAlarmHistory", "2010-08-01");
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("AlarmName");
if let Some(var_34) = &input.alarm_name {
scope_33.string(var_34);
}
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("AlarmTypes");
if let Some(var_36) = &input.alarm_types {
let mut list_38 = scope_35.start_list(false, None);
for item_37 in var_36 {
#[allow(unused_mut)]
let mut entry_39 = list_38.entry();
entry_39.string(item_37.as_str());
}
list_38.finish();
}
#[allow(unused_mut)]
let mut scope_40 = writer.prefix("HistoryItemType");
if let Some(var_41) = &input.history_item_type {
scope_40.string(var_41.as_str());
}
#[allow(unused_mut)]
let mut scope_42 = writer.prefix("StartDate");
if let Some(var_43) = &input.start_date {
scope_42.date_time(var_43, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_44 = writer.prefix("EndDate");
if let Some(var_45) = &input.end_date {
scope_44.date_time(var_45, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_46 = writer.prefix("MaxRecords");
if let Some(var_47) = &input.max_records {
scope_46.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_47).into()),
);
}
#[allow(unused_mut)]
let mut scope_48 = writer.prefix("NextToken");
if let Some(var_49) = &input.next_token {
scope_48.string(var_49);
}
#[allow(unused_mut)]
let mut scope_50 = writer.prefix("ScanBy");
if let Some(var_51) = &input.scan_by {
scope_50.string(var_51.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_alarms(
input: &crate::input::DescribeAlarmsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeAlarms", "2010-08-01");
#[allow(unused_mut)]
let mut scope_52 = writer.prefix("AlarmNames");
if let Some(var_53) = &input.alarm_names {
let mut list_55 = scope_52.start_list(false, None);
for item_54 in var_53 {
#[allow(unused_mut)]
let mut entry_56 = list_55.entry();
entry_56.string(item_54);
}
list_55.finish();
}
#[allow(unused_mut)]
let mut scope_57 = writer.prefix("AlarmNamePrefix");
if let Some(var_58) = &input.alarm_name_prefix {
scope_57.string(var_58);
}
#[allow(unused_mut)]
let mut scope_59 = writer.prefix("AlarmTypes");
if let Some(var_60) = &input.alarm_types {
let mut list_62 = scope_59.start_list(false, None);
for item_61 in var_60 {
#[allow(unused_mut)]
let mut entry_63 = list_62.entry();
entry_63.string(item_61.as_str());
}
list_62.finish();
}
#[allow(unused_mut)]
let mut scope_64 = writer.prefix("ChildrenOfAlarmName");
if let Some(var_65) = &input.children_of_alarm_name {
scope_64.string(var_65);
}
#[allow(unused_mut)]
let mut scope_66 = writer.prefix("ParentsOfAlarmName");
if let Some(var_67) = &input.parents_of_alarm_name {
scope_66.string(var_67);
}
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("StateValue");
if let Some(var_69) = &input.state_value {
scope_68.string(var_69.as_str());
}
#[allow(unused_mut)]
let mut scope_70 = writer.prefix("ActionPrefix");
if let Some(var_71) = &input.action_prefix {
scope_70.string(var_71);
}
#[allow(unused_mut)]
let mut scope_72 = writer.prefix("MaxRecords");
if let Some(var_73) = &input.max_records {
scope_72.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_73).into()),
);
}
#[allow(unused_mut)]
let mut scope_74 = writer.prefix("NextToken");
if let Some(var_75) = &input.next_token {
scope_74.string(var_75);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_alarms_for_metric(
input: &crate::input::DescribeAlarmsForMetricInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAlarmsForMetric", "2010-08-01");
#[allow(unused_mut)]
let mut scope_76 = writer.prefix("MetricName");
if let Some(var_77) = &input.metric_name {
scope_76.string(var_77);
}
#[allow(unused_mut)]
let mut scope_78 = writer.prefix("Namespace");
if let Some(var_79) = &input.namespace {
scope_78.string(var_79);
}
#[allow(unused_mut)]
let mut scope_80 = writer.prefix("Statistic");
if let Some(var_81) = &input.statistic {
scope_80.string(var_81.as_str());
}
#[allow(unused_mut)]
let mut scope_82 = writer.prefix("ExtendedStatistic");
if let Some(var_83) = &input.extended_statistic {
scope_82.string(var_83);
}
#[allow(unused_mut)]
let mut scope_84 = writer.prefix("Dimensions");
if let Some(var_85) = &input.dimensions {
let mut list_87 = scope_84.start_list(false, None);
for item_86 in var_85 {
#[allow(unused_mut)]
let mut entry_88 = list_87.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_88, item_86)?;
}
list_87.finish();
}
#[allow(unused_mut)]
let mut scope_89 = writer.prefix("Period");
if let Some(var_90) = &input.period {
scope_89.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_90).into()),
);
}
#[allow(unused_mut)]
let mut scope_91 = writer.prefix("Unit");
if let Some(var_92) = &input.unit {
scope_91.string(var_92.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_anomaly_detectors(
input: &crate::input::DescribeAnomalyDetectorsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAnomalyDetectors", "2010-08-01");
#[allow(unused_mut)]
let mut scope_93 = writer.prefix("NextToken");
if let Some(var_94) = &input.next_token {
scope_93.string(var_94);
}
#[allow(unused_mut)]
let mut scope_95 = writer.prefix("MaxResults");
if let Some(var_96) = &input.max_results {
scope_95.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_96).into()),
);
}
#[allow(unused_mut)]
let mut scope_97 = writer.prefix("Namespace");
if let Some(var_98) = &input.namespace {
scope_97.string(var_98);
}
#[allow(unused_mut)]
let mut scope_99 = writer.prefix("MetricName");
if let Some(var_100) = &input.metric_name {
scope_99.string(var_100);
}
#[allow(unused_mut)]
let mut scope_101 = writer.prefix("Dimensions");
if let Some(var_102) = &input.dimensions {
let mut list_104 = scope_101.start_list(false, None);
for item_103 in var_102 {
#[allow(unused_mut)]
let mut entry_105 = list_104.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_105, item_103)?;
}
list_104.finish();
}
#[allow(unused_mut)]
let mut scope_106 = writer.prefix("AnomalyDetectorTypes");
if let Some(var_107) = &input.anomaly_detector_types {
let mut list_109 = scope_106.start_list(false, None);
for item_108 in var_107 {
#[allow(unused_mut)]
let mut entry_110 = list_109.entry();
entry_110.string(item_108.as_str());
}
list_109.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_insight_rules(
input: &crate::input::DescribeInsightRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeInsightRules", "2010-08-01");
#[allow(unused_mut)]
let mut scope_111 = writer.prefix("NextToken");
if let Some(var_112) = &input.next_token {
scope_111.string(var_112);
}
#[allow(unused_mut)]
let mut scope_113 = writer.prefix("MaxResults");
if let Some(var_114) = &input.max_results {
scope_113.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_114).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_alarm_actions(
input: &crate::input::DisableAlarmActionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableAlarmActions", "2010-08-01");
#[allow(unused_mut)]
let mut scope_115 = writer.prefix("AlarmNames");
if let Some(var_116) = &input.alarm_names {
let mut list_118 = scope_115.start_list(false, None);
for item_117 in var_116 {
#[allow(unused_mut)]
let mut entry_119 = list_118.entry();
entry_119.string(item_117);
}
list_118.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_insight_rules(
input: &crate::input::DisableInsightRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableInsightRules", "2010-08-01");
#[allow(unused_mut)]
let mut scope_120 = writer.prefix("RuleNames");
if let Some(var_121) = &input.rule_names {
let mut list_123 = scope_120.start_list(false, None);
for item_122 in var_121 {
#[allow(unused_mut)]
let mut entry_124 = list_123.entry();
entry_124.string(item_122);
}
list_123.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_alarm_actions(
input: &crate::input::EnableAlarmActionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableAlarmActions", "2010-08-01");
#[allow(unused_mut)]
let mut scope_125 = writer.prefix("AlarmNames");
if let Some(var_126) = &input.alarm_names {
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();
entry_129.string(item_127);
}
list_128.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_insight_rules(
input: &crate::input::EnableInsightRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableInsightRules", "2010-08-01");
#[allow(unused_mut)]
let mut scope_130 = writer.prefix("RuleNames");
if let Some(var_131) = &input.rule_names {
let mut list_133 = scope_130.start_list(false, None);
for item_132 in var_131 {
#[allow(unused_mut)]
let mut entry_134 = list_133.entry();
entry_134.string(item_132);
}
list_133.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_dashboard(
input: &crate::input::GetDashboardInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetDashboard", "2010-08-01");
#[allow(unused_mut)]
let mut scope_135 = writer.prefix("DashboardName");
if let Some(var_136) = &input.dashboard_name {
scope_135.string(var_136);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_insight_rule_report(
input: &crate::input::GetInsightRuleReportInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetInsightRuleReport", "2010-08-01");
#[allow(unused_mut)]
let mut scope_137 = writer.prefix("RuleName");
if let Some(var_138) = &input.rule_name {
scope_137.string(var_138);
}
#[allow(unused_mut)]
let mut scope_139 = writer.prefix("StartTime");
if let Some(var_140) = &input.start_time {
scope_139.date_time(var_140, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_141 = writer.prefix("EndTime");
if let Some(var_142) = &input.end_time {
scope_141.date_time(var_142, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_143 = writer.prefix("Period");
if let Some(var_144) = &input.period {
scope_143.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_144).into()),
);
}
#[allow(unused_mut)]
let mut scope_145 = writer.prefix("MaxContributorCount");
if let Some(var_146) = &input.max_contributor_count {
scope_145.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_146).into()),
);
}
#[allow(unused_mut)]
let mut scope_147 = writer.prefix("Metrics");
if let Some(var_148) = &input.metrics {
let mut list_150 = scope_147.start_list(false, None);
for item_149 in var_148 {
#[allow(unused_mut)]
let mut entry_151 = list_150.entry();
entry_151.string(item_149);
}
list_150.finish();
}
#[allow(unused_mut)]
let mut scope_152 = writer.prefix("OrderBy");
if let Some(var_153) = &input.order_by {
scope_152.string(var_153);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_metric_data(
input: &crate::input::GetMetricDataInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetMetricData", "2010-08-01");
#[allow(unused_mut)]
let mut scope_154 = writer.prefix("MetricDataQueries");
if let Some(var_155) = &input.metric_data_queries {
let mut list_157 = scope_154.start_list(false, None);
for item_156 in var_155 {
#[allow(unused_mut)]
let mut entry_158 = list_157.entry();
crate::query_ser::serialize_structure_crate_model_metric_data_query(
entry_158, item_156,
)?;
}
list_157.finish();
}
#[allow(unused_mut)]
let mut scope_159 = writer.prefix("StartTime");
if let Some(var_160) = &input.start_time {
scope_159.date_time(var_160, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_161 = writer.prefix("EndTime");
if let Some(var_162) = &input.end_time {
scope_161.date_time(var_162, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_163 = writer.prefix("NextToken");
if let Some(var_164) = &input.next_token {
scope_163.string(var_164);
}
#[allow(unused_mut)]
let mut scope_165 = writer.prefix("ScanBy");
if let Some(var_166) = &input.scan_by {
scope_165.string(var_166.as_str());
}
#[allow(unused_mut)]
let mut scope_167 = writer.prefix("MaxDatapoints");
if let Some(var_168) = &input.max_datapoints {
scope_167.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_168).into()),
);
}
#[allow(unused_mut)]
let mut scope_169 = writer.prefix("LabelOptions");
if let Some(var_170) = &input.label_options {
crate::query_ser::serialize_structure_crate_model_label_options(scope_169, var_170)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_metric_statistics(
input: &crate::input::GetMetricStatisticsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetMetricStatistics", "2010-08-01");
#[allow(unused_mut)]
let mut scope_171 = writer.prefix("Namespace");
if let Some(var_172) = &input.namespace {
scope_171.string(var_172);
}
#[allow(unused_mut)]
let mut scope_173 = writer.prefix("MetricName");
if let Some(var_174) = &input.metric_name {
scope_173.string(var_174);
}
#[allow(unused_mut)]
let mut scope_175 = writer.prefix("Dimensions");
if let Some(var_176) = &input.dimensions {
let mut list_178 = scope_175.start_list(false, None);
for item_177 in var_176 {
#[allow(unused_mut)]
let mut entry_179 = list_178.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_179, item_177)?;
}
list_178.finish();
}
#[allow(unused_mut)]
let mut scope_180 = writer.prefix("StartTime");
if let Some(var_181) = &input.start_time {
scope_180.date_time(var_181, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_182 = writer.prefix("EndTime");
if let Some(var_183) = &input.end_time {
scope_182.date_time(var_183, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_184 = writer.prefix("Period");
if let Some(var_185) = &input.period {
scope_184.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_185).into()),
);
}
#[allow(unused_mut)]
let mut scope_186 = writer.prefix("Statistics");
if let Some(var_187) = &input.statistics {
let mut list_189 = scope_186.start_list(false, None);
for item_188 in var_187 {
#[allow(unused_mut)]
let mut entry_190 = list_189.entry();
entry_190.string(item_188.as_str());
}
list_189.finish();
}
#[allow(unused_mut)]
let mut scope_191 = writer.prefix("ExtendedStatistics");
if let Some(var_192) = &input.extended_statistics {
let mut list_194 = scope_191.start_list(false, None);
for item_193 in var_192 {
#[allow(unused_mut)]
let mut entry_195 = list_194.entry();
entry_195.string(item_193);
}
list_194.finish();
}
#[allow(unused_mut)]
let mut scope_196 = writer.prefix("Unit");
if let Some(var_197) = &input.unit {
scope_196.string(var_197.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_metric_stream(
input: &crate::input::GetMetricStreamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetMetricStream", "2010-08-01");
#[allow(unused_mut)]
let mut scope_198 = writer.prefix("Name");
if let Some(var_199) = &input.name {
scope_198.string(var_199);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_metric_widget_image(
input: &crate::input::GetMetricWidgetImageInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetMetricWidgetImage", "2010-08-01");
#[allow(unused_mut)]
let mut scope_200 = writer.prefix("MetricWidget");
if let Some(var_201) = &input.metric_widget {
scope_200.string(var_201);
}
#[allow(unused_mut)]
let mut scope_202 = writer.prefix("OutputFormat");
if let Some(var_203) = &input.output_format {
scope_202.string(var_203);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_dashboards(
input: &crate::input::ListDashboardsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListDashboards", "2010-08-01");
#[allow(unused_mut)]
let mut scope_204 = writer.prefix("DashboardNamePrefix");
if let Some(var_205) = &input.dashboard_name_prefix {
scope_204.string(var_205);
}
#[allow(unused_mut)]
let mut scope_206 = writer.prefix("NextToken");
if let Some(var_207) = &input.next_token {
scope_206.string(var_207);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_metrics(
input: &crate::input::ListMetricsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListMetrics", "2010-08-01");
#[allow(unused_mut)]
let mut scope_208 = writer.prefix("Namespace");
if let Some(var_209) = &input.namespace {
scope_208.string(var_209);
}
#[allow(unused_mut)]
let mut scope_210 = writer.prefix("MetricName");
if let Some(var_211) = &input.metric_name {
scope_210.string(var_211);
}
#[allow(unused_mut)]
let mut scope_212 = writer.prefix("Dimensions");
if let Some(var_213) = &input.dimensions {
let mut list_215 = scope_212.start_list(false, None);
for item_214 in var_213 {
#[allow(unused_mut)]
let mut entry_216 = list_215.entry();
crate::query_ser::serialize_structure_crate_model_dimension_filter(
entry_216, item_214,
)?;
}
list_215.finish();
}
#[allow(unused_mut)]
let mut scope_217 = writer.prefix("NextToken");
if let Some(var_218) = &input.next_token {
scope_217.string(var_218);
}
#[allow(unused_mut)]
let mut scope_219 = writer.prefix("RecentlyActive");
if let Some(var_220) = &input.recently_active {
scope_219.string(var_220.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_metric_streams(
input: &crate::input::ListMetricStreamsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListMetricStreams", "2010-08-01");
#[allow(unused_mut)]
let mut scope_221 = writer.prefix("NextToken");
if let Some(var_222) = &input.next_token {
scope_221.string(var_222);
}
#[allow(unused_mut)]
let mut scope_223 = writer.prefix("MaxResults");
if let Some(var_224) = &input.max_results {
scope_223.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_224).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_tags_for_resource(
input: &crate::input::ListTagsForResourceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListTagsForResource", "2010-08-01");
#[allow(unused_mut)]
let mut scope_225 = writer.prefix("ResourceARN");
if let Some(var_226) = &input.resource_arn {
scope_225.string(var_226);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_anomaly_detector(
input: &crate::input::PutAnomalyDetectorInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PutAnomalyDetector", "2010-08-01");
#[allow(unused_mut)]
let mut scope_227 = writer.prefix("Namespace");
if let Some(var_228) = &input.namespace {
scope_227.string(var_228);
}
#[allow(unused_mut)]
let mut scope_229 = writer.prefix("MetricName");
if let Some(var_230) = &input.metric_name {
scope_229.string(var_230);
}
#[allow(unused_mut)]
let mut scope_231 = writer.prefix("Dimensions");
if let Some(var_232) = &input.dimensions {
let mut list_234 = scope_231.start_list(false, None);
for item_233 in var_232 {
#[allow(unused_mut)]
let mut entry_235 = list_234.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_235, item_233)?;
}
list_234.finish();
}
#[allow(unused_mut)]
let mut scope_236 = writer.prefix("Stat");
if let Some(var_237) = &input.stat {
scope_236.string(var_237);
}
#[allow(unused_mut)]
let mut scope_238 = writer.prefix("Configuration");
if let Some(var_239) = &input.configuration {
crate::query_ser::serialize_structure_crate_model_anomaly_detector_configuration(
scope_238, var_239,
)?;
}
#[allow(unused_mut)]
let mut scope_240 = writer.prefix("SingleMetricAnomalyDetector");
if let Some(var_241) = &input.single_metric_anomaly_detector {
crate::query_ser::serialize_structure_crate_model_single_metric_anomaly_detector(
scope_240, var_241,
)?;
}
#[allow(unused_mut)]
let mut scope_242 = writer.prefix("MetricMathAnomalyDetector");
if let Some(var_243) = &input.metric_math_anomaly_detector {
crate::query_ser::serialize_structure_crate_model_metric_math_anomaly_detector(
scope_242, var_243,
)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_composite_alarm(
input: &crate::input::PutCompositeAlarmInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PutCompositeAlarm", "2010-08-01");
#[allow(unused_mut)]
let mut scope_244 = writer.prefix("ActionsEnabled");
if let Some(var_245) = &input.actions_enabled {
scope_244.boolean(*var_245);
}
#[allow(unused_mut)]
let mut scope_246 = writer.prefix("AlarmActions");
if let Some(var_247) = &input.alarm_actions {
let mut list_249 = scope_246.start_list(false, None);
for item_248 in var_247 {
#[allow(unused_mut)]
let mut entry_250 = list_249.entry();
entry_250.string(item_248);
}
list_249.finish();
}
#[allow(unused_mut)]
let mut scope_251 = writer.prefix("AlarmDescription");
if let Some(var_252) = &input.alarm_description {
scope_251.string(var_252);
}
#[allow(unused_mut)]
let mut scope_253 = writer.prefix("AlarmName");
if let Some(var_254) = &input.alarm_name {
scope_253.string(var_254);
}
#[allow(unused_mut)]
let mut scope_255 = writer.prefix("AlarmRule");
if let Some(var_256) = &input.alarm_rule {
scope_255.string(var_256);
}
#[allow(unused_mut)]
let mut scope_257 = writer.prefix("InsufficientDataActions");
if let Some(var_258) = &input.insufficient_data_actions {
let mut list_260 = scope_257.start_list(false, None);
for item_259 in var_258 {
#[allow(unused_mut)]
let mut entry_261 = list_260.entry();
entry_261.string(item_259);
}
list_260.finish();
}
#[allow(unused_mut)]
let mut scope_262 = writer.prefix("OKActions");
if let Some(var_263) = &input.ok_actions {
let mut list_265 = scope_262.start_list(false, None);
for item_264 in var_263 {
#[allow(unused_mut)]
let mut entry_266 = list_265.entry();
entry_266.string(item_264);
}
list_265.finish();
}
#[allow(unused_mut)]
let mut scope_267 = writer.prefix("Tags");
if let Some(var_268) = &input.tags {
let mut list_270 = scope_267.start_list(false, None);
for item_269 in var_268 {
#[allow(unused_mut)]
let mut entry_271 = list_270.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_271, item_269)?;
}
list_270.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_dashboard(
input: &crate::input::PutDashboardInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutDashboard", "2010-08-01");
#[allow(unused_mut)]
let mut scope_272 = writer.prefix("DashboardName");
if let Some(var_273) = &input.dashboard_name {
scope_272.string(var_273);
}
#[allow(unused_mut)]
let mut scope_274 = writer.prefix("DashboardBody");
if let Some(var_275) = &input.dashboard_body {
scope_274.string(var_275);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_insight_rule(
input: &crate::input::PutInsightRuleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutInsightRule", "2010-08-01");
#[allow(unused_mut)]
let mut scope_276 = writer.prefix("RuleName");
if let Some(var_277) = &input.rule_name {
scope_276.string(var_277);
}
#[allow(unused_mut)]
let mut scope_278 = writer.prefix("RuleState");
if let Some(var_279) = &input.rule_state {
scope_278.string(var_279);
}
#[allow(unused_mut)]
let mut scope_280 = writer.prefix("RuleDefinition");
if let Some(var_281) = &input.rule_definition {
scope_280.string(var_281);
}
#[allow(unused_mut)]
let mut scope_282 = writer.prefix("Tags");
if let Some(var_283) = &input.tags {
let mut list_285 = scope_282.start_list(false, None);
for item_284 in var_283 {
#[allow(unused_mut)]
let mut entry_286 = list_285.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_286, item_284)?;
}
list_285.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_metric_alarm(
input: &crate::input::PutMetricAlarmInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutMetricAlarm", "2010-08-01");
#[allow(unused_mut)]
let mut scope_287 = writer.prefix("AlarmName");
if let Some(var_288) = &input.alarm_name {
scope_287.string(var_288);
}
#[allow(unused_mut)]
let mut scope_289 = writer.prefix("AlarmDescription");
if let Some(var_290) = &input.alarm_description {
scope_289.string(var_290);
}
#[allow(unused_mut)]
let mut scope_291 = writer.prefix("ActionsEnabled");
if let Some(var_292) = &input.actions_enabled {
scope_291.boolean(*var_292);
}
#[allow(unused_mut)]
let mut scope_293 = writer.prefix("OKActions");
if let Some(var_294) = &input.ok_actions {
let mut list_296 = scope_293.start_list(false, None);
for item_295 in var_294 {
#[allow(unused_mut)]
let mut entry_297 = list_296.entry();
entry_297.string(item_295);
}
list_296.finish();
}
#[allow(unused_mut)]
let mut scope_298 = writer.prefix("AlarmActions");
if let Some(var_299) = &input.alarm_actions {
let mut list_301 = scope_298.start_list(false, None);
for item_300 in var_299 {
#[allow(unused_mut)]
let mut entry_302 = list_301.entry();
entry_302.string(item_300);
}
list_301.finish();
}
#[allow(unused_mut)]
let mut scope_303 = writer.prefix("InsufficientDataActions");
if let Some(var_304) = &input.insufficient_data_actions {
let mut list_306 = scope_303.start_list(false, None);
for item_305 in var_304 {
#[allow(unused_mut)]
let mut entry_307 = list_306.entry();
entry_307.string(item_305);
}
list_306.finish();
}
#[allow(unused_mut)]
let mut scope_308 = writer.prefix("MetricName");
if let Some(var_309) = &input.metric_name {
scope_308.string(var_309);
}
#[allow(unused_mut)]
let mut scope_310 = writer.prefix("Namespace");
if let Some(var_311) = &input.namespace {
scope_310.string(var_311);
}
#[allow(unused_mut)]
let mut scope_312 = writer.prefix("Statistic");
if let Some(var_313) = &input.statistic {
scope_312.string(var_313.as_str());
}
#[allow(unused_mut)]
let mut scope_314 = writer.prefix("ExtendedStatistic");
if let Some(var_315) = &input.extended_statistic {
scope_314.string(var_315);
}
#[allow(unused_mut)]
let mut scope_316 = writer.prefix("Dimensions");
if let Some(var_317) = &input.dimensions {
let mut list_319 = scope_316.start_list(false, None);
for item_318 in var_317 {
#[allow(unused_mut)]
let mut entry_320 = list_319.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_320, item_318)?;
}
list_319.finish();
}
#[allow(unused_mut)]
let mut scope_321 = writer.prefix("Period");
if let Some(var_322) = &input.period {
scope_321.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_322).into()),
);
}
#[allow(unused_mut)]
let mut scope_323 = writer.prefix("Unit");
if let Some(var_324) = &input.unit {
scope_323.string(var_324.as_str());
}
#[allow(unused_mut)]
let mut scope_325 = writer.prefix("EvaluationPeriods");
if let Some(var_326) = &input.evaluation_periods {
scope_325.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_326).into()),
);
}
#[allow(unused_mut)]
let mut scope_327 = writer.prefix("DatapointsToAlarm");
if let Some(var_328) = &input.datapoints_to_alarm {
scope_327.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_328).into()),
);
}
#[allow(unused_mut)]
let mut scope_329 = writer.prefix("Threshold");
if let Some(var_330) = &input.threshold {
scope_329.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_330).into()),
);
}
#[allow(unused_mut)]
let mut scope_331 = writer.prefix("ComparisonOperator");
if let Some(var_332) = &input.comparison_operator {
scope_331.string(var_332.as_str());
}
#[allow(unused_mut)]
let mut scope_333 = writer.prefix("TreatMissingData");
if let Some(var_334) = &input.treat_missing_data {
scope_333.string(var_334);
}
#[allow(unused_mut)]
let mut scope_335 = writer.prefix("EvaluateLowSampleCountPercentile");
if let Some(var_336) = &input.evaluate_low_sample_count_percentile {
scope_335.string(var_336);
}
#[allow(unused_mut)]
let mut scope_337 = writer.prefix("Metrics");
if let Some(var_338) = &input.metrics {
let mut list_340 = scope_337.start_list(false, None);
for item_339 in var_338 {
#[allow(unused_mut)]
let mut entry_341 = list_340.entry();
crate::query_ser::serialize_structure_crate_model_metric_data_query(
entry_341, item_339,
)?;
}
list_340.finish();
}
#[allow(unused_mut)]
let mut scope_342 = writer.prefix("Tags");
if let Some(var_343) = &input.tags {
let mut list_345 = scope_342.start_list(false, None);
for item_344 in var_343 {
#[allow(unused_mut)]
let mut entry_346 = list_345.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_346, item_344)?;
}
list_345.finish();
}
#[allow(unused_mut)]
let mut scope_347 = writer.prefix("ThresholdMetricId");
if let Some(var_348) = &input.threshold_metric_id {
scope_347.string(var_348);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_metric_data(
input: &crate::input::PutMetricDataInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutMetricData", "2010-08-01");
#[allow(unused_mut)]
let mut scope_349 = writer.prefix("Namespace");
if let Some(var_350) = &input.namespace {
scope_349.string(var_350);
}
#[allow(unused_mut)]
let mut scope_351 = writer.prefix("MetricData");
if let Some(var_352) = &input.metric_data {
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();
crate::query_ser::serialize_structure_crate_model_metric_datum(entry_355, item_353)?;
}
list_354.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_metric_stream(
input: &crate::input::PutMetricStreamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PutMetricStream", "2010-08-01");
#[allow(unused_mut)]
let mut scope_356 = writer.prefix("Name");
if let Some(var_357) = &input.name {
scope_356.string(var_357);
}
#[allow(unused_mut)]
let mut scope_358 = writer.prefix("IncludeFilters");
if let Some(var_359) = &input.include_filters {
let mut list_361 = scope_358.start_list(false, None);
for item_360 in var_359 {
#[allow(unused_mut)]
let mut entry_362 = list_361.entry();
crate::query_ser::serialize_structure_crate_model_metric_stream_filter(
entry_362, item_360,
)?;
}
list_361.finish();
}
#[allow(unused_mut)]
let mut scope_363 = writer.prefix("ExcludeFilters");
if let Some(var_364) = &input.exclude_filters {
let mut list_366 = scope_363.start_list(false, None);
for item_365 in var_364 {
#[allow(unused_mut)]
let mut entry_367 = list_366.entry();
crate::query_ser::serialize_structure_crate_model_metric_stream_filter(
entry_367, item_365,
)?;
}
list_366.finish();
}
#[allow(unused_mut)]
let mut scope_368 = writer.prefix("FirehoseArn");
if let Some(var_369) = &input.firehose_arn {
scope_368.string(var_369);
}
#[allow(unused_mut)]
let mut scope_370 = writer.prefix("RoleArn");
if let Some(var_371) = &input.role_arn {
scope_370.string(var_371);
}
#[allow(unused_mut)]
let mut scope_372 = writer.prefix("OutputFormat");
if let Some(var_373) = &input.output_format {
scope_372.string(var_373.as_str());
}
#[allow(unused_mut)]
let mut scope_374 = writer.prefix("Tags");
if let Some(var_375) = &input.tags {
let mut list_377 = scope_374.start_list(false, None);
for item_376 in var_375 {
#[allow(unused_mut)]
let mut entry_378 = list_377.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_378, item_376)?;
}
list_377.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_alarm_state(
input: &crate::input::SetAlarmStateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "SetAlarmState", "2010-08-01");
#[allow(unused_mut)]
let mut scope_379 = writer.prefix("AlarmName");
if let Some(var_380) = &input.alarm_name {
scope_379.string(var_380);
}
#[allow(unused_mut)]
let mut scope_381 = writer.prefix("StateValue");
if let Some(var_382) = &input.state_value {
scope_381.string(var_382.as_str());
}
#[allow(unused_mut)]
let mut scope_383 = writer.prefix("StateReason");
if let Some(var_384) = &input.state_reason {
scope_383.string(var_384);
}
#[allow(unused_mut)]
let mut scope_385 = writer.prefix("StateReasonData");
if let Some(var_386) = &input.state_reason_data {
scope_385.string(var_386);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_metric_streams(
input: &crate::input::StartMetricStreamsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "StartMetricStreams", "2010-08-01");
#[allow(unused_mut)]
let mut scope_387 = writer.prefix("Names");
if let Some(var_388) = &input.names {
let mut list_390 = scope_387.start_list(false, None);
for item_389 in var_388 {
#[allow(unused_mut)]
let mut entry_391 = list_390.entry();
entry_391.string(item_389);
}
list_390.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_stop_metric_streams(
input: &crate::input::StopMetricStreamsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "StopMetricStreams", "2010-08-01");
#[allow(unused_mut)]
let mut scope_392 = writer.prefix("Names");
if let Some(var_393) = &input.names {
let mut list_395 = scope_392.start_list(false, None);
for item_394 in var_393 {
#[allow(unused_mut)]
let mut entry_396 = list_395.entry();
entry_396.string(item_394);
}
list_395.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_tag_resource(
input: &crate::input::TagResourceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "TagResource", "2010-08-01");
#[allow(unused_mut)]
let mut scope_397 = writer.prefix("ResourceARN");
if let Some(var_398) = &input.resource_arn {
scope_397.string(var_398);
}
#[allow(unused_mut)]
let mut scope_399 = writer.prefix("Tags");
if let Some(var_400) = &input.tags {
let mut list_402 = scope_399.start_list(false, None);
for item_401 in var_400 {
#[allow(unused_mut)]
let mut entry_403 = list_402.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_403, item_401)?;
}
list_402.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_untag_resource(
input: &crate::input::UntagResourceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UntagResource", "2010-08-01");
#[allow(unused_mut)]
let mut scope_404 = writer.prefix("ResourceARN");
if let Some(var_405) = &input.resource_arn {
scope_404.string(var_405);
}
#[allow(unused_mut)]
let mut scope_406 = writer.prefix("TagKeys");
if let Some(var_407) = &input.tag_keys {
let mut list_409 = scope_406.start_list(false, None);
for item_408 in var_407 {
#[allow(unused_mut)]
let mut entry_410 = list_409.entry();
entry_410.string(item_408);
}
list_409.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}