pub fn serialize_operation_crate_operation_delete_alarms(
input: &crate::input::DeleteAlarmsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::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_managed_insight_rules(
input: &crate::input::ListManagedInsightRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListManagedInsightRules", "2010-08-01");
#[allow(unused_mut)]
let mut scope_208 = writer.prefix("ResourceARN");
if let Some(var_209) = &input.resource_arn {
scope_208.string(var_209);
}
#[allow(unused_mut)]
let mut scope_210 = writer.prefix("NextToken");
if let Some(var_211) = &input.next_token {
scope_210.string(var_211);
}
#[allow(unused_mut)]
let mut scope_212 = writer.prefix("MaxResults");
if let Some(var_213) = &input.max_results {
scope_212.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_213).into()),
);
}
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::error::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_214 = writer.prefix("Namespace");
if let Some(var_215) = &input.namespace {
scope_214.string(var_215);
}
#[allow(unused_mut)]
let mut scope_216 = writer.prefix("MetricName");
if let Some(var_217) = &input.metric_name {
scope_216.string(var_217);
}
#[allow(unused_mut)]
let mut scope_218 = writer.prefix("Dimensions");
if let Some(var_219) = &input.dimensions {
let mut list_221 = scope_218.start_list(false, None);
for item_220 in var_219 {
#[allow(unused_mut)]
let mut entry_222 = list_221.entry();
crate::query_ser::serialize_structure_crate_model_dimension_filter(
entry_222, item_220,
)?;
}
list_221.finish();
}
#[allow(unused_mut)]
let mut scope_223 = writer.prefix("NextToken");
if let Some(var_224) = &input.next_token {
scope_223.string(var_224);
}
#[allow(unused_mut)]
let mut scope_225 = writer.prefix("RecentlyActive");
if let Some(var_226) = &input.recently_active {
scope_225.string(var_226.as_str());
}
#[allow(unused_mut)]
let mut scope_227 = writer.prefix("IncludeLinkedAccounts");
if input.include_linked_accounts {
scope_227.boolean(input.include_linked_accounts);
}
#[allow(unused_mut)]
let mut scope_228 = writer.prefix("OwningAccount");
if let Some(var_229) = &input.owning_account {
scope_228.string(var_229);
}
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::error::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_230 = writer.prefix("NextToken");
if let Some(var_231) = &input.next_token {
scope_230.string(var_231);
}
#[allow(unused_mut)]
let mut scope_232 = writer.prefix("MaxResults");
if let Some(var_233) = &input.max_results {
scope_232.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_233).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::error::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_234 = writer.prefix("ResourceARN");
if let Some(var_235) = &input.resource_arn {
scope_234.string(var_235);
}
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::error::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_236 = writer.prefix("Namespace");
if let Some(var_237) = &input.namespace {
scope_236.string(var_237);
}
#[allow(unused_mut)]
let mut scope_238 = writer.prefix("MetricName");
if let Some(var_239) = &input.metric_name {
scope_238.string(var_239);
}
#[allow(unused_mut)]
let mut scope_240 = writer.prefix("Dimensions");
if let Some(var_241) = &input.dimensions {
let mut list_243 = scope_240.start_list(false, None);
for item_242 in var_241 {
#[allow(unused_mut)]
let mut entry_244 = list_243.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_244, item_242)?;
}
list_243.finish();
}
#[allow(unused_mut)]
let mut scope_245 = writer.prefix("Stat");
if let Some(var_246) = &input.stat {
scope_245.string(var_246);
}
#[allow(unused_mut)]
let mut scope_247 = writer.prefix("Configuration");
if let Some(var_248) = &input.configuration {
crate::query_ser::serialize_structure_crate_model_anomaly_detector_configuration(
scope_247, var_248,
)?;
}
#[allow(unused_mut)]
let mut scope_249 = writer.prefix("SingleMetricAnomalyDetector");
if let Some(var_250) = &input.single_metric_anomaly_detector {
crate::query_ser::serialize_structure_crate_model_single_metric_anomaly_detector(
scope_249, var_250,
)?;
}
#[allow(unused_mut)]
let mut scope_251 = writer.prefix("MetricMathAnomalyDetector");
if let Some(var_252) = &input.metric_math_anomaly_detector {
crate::query_ser::serialize_structure_crate_model_metric_math_anomaly_detector(
scope_251, var_252,
)?;
}
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::error::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_253 = writer.prefix("ActionsEnabled");
if let Some(var_254) = &input.actions_enabled {
scope_253.boolean(*var_254);
}
#[allow(unused_mut)]
let mut scope_255 = writer.prefix("AlarmActions");
if let Some(var_256) = &input.alarm_actions {
let mut list_258 = scope_255.start_list(false, None);
for item_257 in var_256 {
#[allow(unused_mut)]
let mut entry_259 = list_258.entry();
entry_259.string(item_257);
}
list_258.finish();
}
#[allow(unused_mut)]
let mut scope_260 = writer.prefix("AlarmDescription");
if let Some(var_261) = &input.alarm_description {
scope_260.string(var_261);
}
#[allow(unused_mut)]
let mut scope_262 = writer.prefix("AlarmName");
if let Some(var_263) = &input.alarm_name {
scope_262.string(var_263);
}
#[allow(unused_mut)]
let mut scope_264 = writer.prefix("AlarmRule");
if let Some(var_265) = &input.alarm_rule {
scope_264.string(var_265);
}
#[allow(unused_mut)]
let mut scope_266 = writer.prefix("InsufficientDataActions");
if let Some(var_267) = &input.insufficient_data_actions {
let mut list_269 = scope_266.start_list(false, None);
for item_268 in var_267 {
#[allow(unused_mut)]
let mut entry_270 = list_269.entry();
entry_270.string(item_268);
}
list_269.finish();
}
#[allow(unused_mut)]
let mut scope_271 = writer.prefix("OKActions");
if let Some(var_272) = &input.ok_actions {
let mut list_274 = scope_271.start_list(false, None);
for item_273 in var_272 {
#[allow(unused_mut)]
let mut entry_275 = list_274.entry();
entry_275.string(item_273);
}
list_274.finish();
}
#[allow(unused_mut)]
let mut scope_276 = writer.prefix("Tags");
if let Some(var_277) = &input.tags {
let mut list_279 = scope_276.start_list(false, None);
for item_278 in var_277 {
#[allow(unused_mut)]
let mut entry_280 = list_279.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_280, item_278)?;
}
list_279.finish();
}
#[allow(unused_mut)]
let mut scope_281 = writer.prefix("ActionsSuppressor");
if let Some(var_282) = &input.actions_suppressor {
scope_281.string(var_282);
}
#[allow(unused_mut)]
let mut scope_283 = writer.prefix("ActionsSuppressorWaitPeriod");
if let Some(var_284) = &input.actions_suppressor_wait_period {
scope_283.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_284).into()),
);
}
#[allow(unused_mut)]
let mut scope_285 = writer.prefix("ActionsSuppressorExtensionPeriod");
if let Some(var_286) = &input.actions_suppressor_extension_period {
scope_285.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_286).into()),
);
}
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::error::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_287 = writer.prefix("DashboardName");
if let Some(var_288) = &input.dashboard_name {
scope_287.string(var_288);
}
#[allow(unused_mut)]
let mut scope_289 = writer.prefix("DashboardBody");
if let Some(var_290) = &input.dashboard_body {
scope_289.string(var_290);
}
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::error::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_291 = writer.prefix("RuleName");
if let Some(var_292) = &input.rule_name {
scope_291.string(var_292);
}
#[allow(unused_mut)]
let mut scope_293 = writer.prefix("RuleState");
if let Some(var_294) = &input.rule_state {
scope_293.string(var_294);
}
#[allow(unused_mut)]
let mut scope_295 = writer.prefix("RuleDefinition");
if let Some(var_296) = &input.rule_definition {
scope_295.string(var_296);
}
#[allow(unused_mut)]
let mut scope_297 = writer.prefix("Tags");
if let Some(var_298) = &input.tags {
let mut list_300 = scope_297.start_list(false, None);
for item_299 in var_298 {
#[allow(unused_mut)]
let mut entry_301 = list_300.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_301, item_299)?;
}
list_300.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_managed_insight_rules(
input: &crate::input::PutManagedInsightRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PutManagedInsightRules", "2010-08-01");
#[allow(unused_mut)]
let mut scope_302 = writer.prefix("ManagedRules");
if let Some(var_303) = &input.managed_rules {
let mut list_305 = scope_302.start_list(false, None);
for item_304 in var_303 {
#[allow(unused_mut)]
let mut entry_306 = list_305.entry();
crate::query_ser::serialize_structure_crate_model_managed_rule(entry_306, item_304)?;
}
list_305.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::error::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_307 = writer.prefix("AlarmName");
if let Some(var_308) = &input.alarm_name {
scope_307.string(var_308);
}
#[allow(unused_mut)]
let mut scope_309 = writer.prefix("AlarmDescription");
if let Some(var_310) = &input.alarm_description {
scope_309.string(var_310);
}
#[allow(unused_mut)]
let mut scope_311 = writer.prefix("ActionsEnabled");
if let Some(var_312) = &input.actions_enabled {
scope_311.boolean(*var_312);
}
#[allow(unused_mut)]
let mut scope_313 = writer.prefix("OKActions");
if let Some(var_314) = &input.ok_actions {
let mut list_316 = scope_313.start_list(false, None);
for item_315 in var_314 {
#[allow(unused_mut)]
let mut entry_317 = list_316.entry();
entry_317.string(item_315);
}
list_316.finish();
}
#[allow(unused_mut)]
let mut scope_318 = writer.prefix("AlarmActions");
if let Some(var_319) = &input.alarm_actions {
let mut list_321 = scope_318.start_list(false, None);
for item_320 in var_319 {
#[allow(unused_mut)]
let mut entry_322 = list_321.entry();
entry_322.string(item_320);
}
list_321.finish();
}
#[allow(unused_mut)]
let mut scope_323 = writer.prefix("InsufficientDataActions");
if let Some(var_324) = &input.insufficient_data_actions {
let mut list_326 = scope_323.start_list(false, None);
for item_325 in var_324 {
#[allow(unused_mut)]
let mut entry_327 = list_326.entry();
entry_327.string(item_325);
}
list_326.finish();
}
#[allow(unused_mut)]
let mut scope_328 = writer.prefix("MetricName");
if let Some(var_329) = &input.metric_name {
scope_328.string(var_329);
}
#[allow(unused_mut)]
let mut scope_330 = writer.prefix("Namespace");
if let Some(var_331) = &input.namespace {
scope_330.string(var_331);
}
#[allow(unused_mut)]
let mut scope_332 = writer.prefix("Statistic");
if let Some(var_333) = &input.statistic {
scope_332.string(var_333.as_str());
}
#[allow(unused_mut)]
let mut scope_334 = writer.prefix("ExtendedStatistic");
if let Some(var_335) = &input.extended_statistic {
scope_334.string(var_335);
}
#[allow(unused_mut)]
let mut scope_336 = writer.prefix("Dimensions");
if let Some(var_337) = &input.dimensions {
let mut list_339 = scope_336.start_list(false, None);
for item_338 in var_337 {
#[allow(unused_mut)]
let mut entry_340 = list_339.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_340, item_338)?;
}
list_339.finish();
}
#[allow(unused_mut)]
let mut scope_341 = writer.prefix("Period");
if let Some(var_342) = &input.period {
scope_341.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_342).into()),
);
}
#[allow(unused_mut)]
let mut scope_343 = writer.prefix("Unit");
if let Some(var_344) = &input.unit {
scope_343.string(var_344.as_str());
}
#[allow(unused_mut)]
let mut scope_345 = writer.prefix("EvaluationPeriods");
if let Some(var_346) = &input.evaluation_periods {
scope_345.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_346).into()),
);
}
#[allow(unused_mut)]
let mut scope_347 = writer.prefix("DatapointsToAlarm");
if let Some(var_348) = &input.datapoints_to_alarm {
scope_347.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_348).into()),
);
}
#[allow(unused_mut)]
let mut scope_349 = writer.prefix("Threshold");
if let Some(var_350) = &input.threshold {
scope_349.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_350).into()),
);
}
#[allow(unused_mut)]
let mut scope_351 = writer.prefix("ComparisonOperator");
if let Some(var_352) = &input.comparison_operator {
scope_351.string(var_352.as_str());
}
#[allow(unused_mut)]
let mut scope_353 = writer.prefix("TreatMissingData");
if let Some(var_354) = &input.treat_missing_data {
scope_353.string(var_354);
}
#[allow(unused_mut)]
let mut scope_355 = writer.prefix("EvaluateLowSampleCountPercentile");
if let Some(var_356) = &input.evaluate_low_sample_count_percentile {
scope_355.string(var_356);
}
#[allow(unused_mut)]
let mut scope_357 = writer.prefix("Metrics");
if let Some(var_358) = &input.metrics {
let mut list_360 = scope_357.start_list(false, None);
for item_359 in var_358 {
#[allow(unused_mut)]
let mut entry_361 = list_360.entry();
crate::query_ser::serialize_structure_crate_model_metric_data_query(
entry_361, item_359,
)?;
}
list_360.finish();
}
#[allow(unused_mut)]
let mut scope_362 = writer.prefix("Tags");
if let Some(var_363) = &input.tags {
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();
crate::query_ser::serialize_structure_crate_model_tag(entry_366, item_364)?;
}
list_365.finish();
}
#[allow(unused_mut)]
let mut scope_367 = writer.prefix("ThresholdMetricId");
if let Some(var_368) = &input.threshold_metric_id {
scope_367.string(var_368);
}
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::error::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_369 = writer.prefix("Namespace");
if let Some(var_370) = &input.namespace {
scope_369.string(var_370);
}
#[allow(unused_mut)]
let mut scope_371 = writer.prefix("MetricData");
if let Some(var_372) = &input.metric_data {
let mut list_374 = scope_371.start_list(false, None);
for item_373 in var_372 {
#[allow(unused_mut)]
let mut entry_375 = list_374.entry();
crate::query_ser::serialize_structure_crate_model_metric_datum(entry_375, item_373)?;
}
list_374.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::error::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_376 = writer.prefix("Name");
if let Some(var_377) = &input.name {
scope_376.string(var_377);
}
#[allow(unused_mut)]
let mut scope_378 = writer.prefix("IncludeFilters");
if let Some(var_379) = &input.include_filters {
let mut list_381 = scope_378.start_list(false, None);
for item_380 in var_379 {
#[allow(unused_mut)]
let mut entry_382 = list_381.entry();
crate::query_ser::serialize_structure_crate_model_metric_stream_filter(
entry_382, item_380,
)?;
}
list_381.finish();
}
#[allow(unused_mut)]
let mut scope_383 = writer.prefix("ExcludeFilters");
if let Some(var_384) = &input.exclude_filters {
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();
crate::query_ser::serialize_structure_crate_model_metric_stream_filter(
entry_387, item_385,
)?;
}
list_386.finish();
}
#[allow(unused_mut)]
let mut scope_388 = writer.prefix("FirehoseArn");
if let Some(var_389) = &input.firehose_arn {
scope_388.string(var_389);
}
#[allow(unused_mut)]
let mut scope_390 = writer.prefix("RoleArn");
if let Some(var_391) = &input.role_arn {
scope_390.string(var_391);
}
#[allow(unused_mut)]
let mut scope_392 = writer.prefix("OutputFormat");
if let Some(var_393) = &input.output_format {
scope_392.string(var_393.as_str());
}
#[allow(unused_mut)]
let mut scope_394 = writer.prefix("Tags");
if let Some(var_395) = &input.tags {
let mut list_397 = scope_394.start_list(false, None);
for item_396 in var_395 {
#[allow(unused_mut)]
let mut entry_398 = list_397.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_398, item_396)?;
}
list_397.finish();
}
#[allow(unused_mut)]
let mut scope_399 = writer.prefix("StatisticsConfigurations");
if let Some(var_400) = &input.statistics_configurations {
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_metric_stream_statistics_configuration(entry_403, item_401)?;
}
list_402.finish();
}
#[allow(unused_mut)]
let mut scope_404 = writer.prefix("IncludeLinkedAccountsMetrics");
if let Some(var_405) = &input.include_linked_accounts_metrics {
scope_404.boolean(*var_405);
}
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::error::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_406 = writer.prefix("AlarmName");
if let Some(var_407) = &input.alarm_name {
scope_406.string(var_407);
}
#[allow(unused_mut)]
let mut scope_408 = writer.prefix("StateValue");
if let Some(var_409) = &input.state_value {
scope_408.string(var_409.as_str());
}
#[allow(unused_mut)]
let mut scope_410 = writer.prefix("StateReason");
if let Some(var_411) = &input.state_reason {
scope_410.string(var_411);
}
#[allow(unused_mut)]
let mut scope_412 = writer.prefix("StateReasonData");
if let Some(var_413) = &input.state_reason_data {
scope_412.string(var_413);
}
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::error::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_414 = writer.prefix("Names");
if let Some(var_415) = &input.names {
let mut list_417 = scope_414.start_list(false, None);
for item_416 in var_415 {
#[allow(unused_mut)]
let mut entry_418 = list_417.entry();
entry_418.string(item_416);
}
list_417.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::error::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_419 = writer.prefix("Names");
if let Some(var_420) = &input.names {
let mut list_422 = scope_419.start_list(false, None);
for item_421 in var_420 {
#[allow(unused_mut)]
let mut entry_423 = list_422.entry();
entry_423.string(item_421);
}
list_422.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::error::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_424 = writer.prefix("ResourceARN");
if let Some(var_425) = &input.resource_arn {
scope_424.string(var_425);
}
#[allow(unused_mut)]
let mut scope_426 = writer.prefix("Tags");
if let Some(var_427) = &input.tags {
let mut list_429 = scope_426.start_list(false, None);
for item_428 in var_427 {
#[allow(unused_mut)]
let mut entry_430 = list_429.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_430, item_428)?;
}
list_429.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::error::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_431 = writer.prefix("ResourceARN");
if let Some(var_432) = &input.resource_arn {
scope_431.string(var_432);
}
#[allow(unused_mut)]
let mut scope_433 = writer.prefix("TagKeys");
if let Some(var_434) = &input.tag_keys {
let mut list_436 = scope_433.start_list(false, None);
for item_435 in var_434 {
#[allow(unused_mut)]
let mut entry_437 = list_436.entry();
entry_437.string(item_435);
}
list_436.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}