pub fn serialize_operation_crate_operation_delete_alarms(
input: &crate::input::DeleteAlarmsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
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, std::convert::Infallible> {
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);
}
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, std::convert::Infallible> {
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_17 = writer.prefix("DashboardNames");
if let Some(var_18) = &input.dashboard_names {
let mut list_20 = scope_17.start_list(false, None);
for item_19 in var_18 {
#[allow(unused_mut)]
let mut entry_21 = list_20.entry();
entry_21.string(item_19);
}
list_20.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_insight_rules(
input: &crate::input::DeleteInsightRulesInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
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_22 = writer.prefix("RuleNames");
if let Some(var_23) = &input.rule_names {
let mut list_25 = scope_22.start_list(false, None);
for item_24 in var_23 {
#[allow(unused_mut)]
let mut entry_26 = list_25.entry();
entry_26.string(item_24);
}
list_25.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, std::convert::Infallible> {
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_27 = writer.prefix("Name");
if let Some(var_28) = &input.name {
scope_27.string(var_28);
}
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, std::convert::Infallible> {
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_29 = writer.prefix("AlarmName");
if let Some(var_30) = &input.alarm_name {
scope_29.string(var_30);
}
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("AlarmTypes");
if let Some(var_32) = &input.alarm_types {
let mut list_34 = scope_31.start_list(false, None);
for item_33 in var_32 {
#[allow(unused_mut)]
let mut entry_35 = list_34.entry();
entry_35.string(item_33.as_str());
}
list_34.finish();
}
#[allow(unused_mut)]
let mut scope_36 = writer.prefix("HistoryItemType");
if let Some(var_37) = &input.history_item_type {
scope_36.string(var_37.as_str());
}
#[allow(unused_mut)]
let mut scope_38 = writer.prefix("StartDate");
if let Some(var_39) = &input.start_date {
scope_38.instant(var_39, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_40 = writer.prefix("EndDate");
if let Some(var_41) = &input.end_date {
scope_40.instant(var_41, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_42 = writer.prefix("MaxRecords");
if let Some(var_43) = &input.max_records {
scope_42.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_43).into()),
);
}
#[allow(unused_mut)]
let mut scope_44 = writer.prefix("NextToken");
if let Some(var_45) = &input.next_token {
scope_44.string(var_45);
}
#[allow(unused_mut)]
let mut scope_46 = writer.prefix("ScanBy");
if let Some(var_47) = &input.scan_by {
scope_46.string(var_47.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, std::convert::Infallible> {
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_48 = writer.prefix("AlarmNames");
if let Some(var_49) = &input.alarm_names {
let mut list_51 = scope_48.start_list(false, None);
for item_50 in var_49 {
#[allow(unused_mut)]
let mut entry_52 = list_51.entry();
entry_52.string(item_50);
}
list_51.finish();
}
#[allow(unused_mut)]
let mut scope_53 = writer.prefix("AlarmNamePrefix");
if let Some(var_54) = &input.alarm_name_prefix {
scope_53.string(var_54);
}
#[allow(unused_mut)]
let mut scope_55 = writer.prefix("AlarmTypes");
if let Some(var_56) = &input.alarm_types {
let mut list_58 = scope_55.start_list(false, None);
for item_57 in var_56 {
#[allow(unused_mut)]
let mut entry_59 = list_58.entry();
entry_59.string(item_57.as_str());
}
list_58.finish();
}
#[allow(unused_mut)]
let mut scope_60 = writer.prefix("ChildrenOfAlarmName");
if let Some(var_61) = &input.children_of_alarm_name {
scope_60.string(var_61);
}
#[allow(unused_mut)]
let mut scope_62 = writer.prefix("ParentsOfAlarmName");
if let Some(var_63) = &input.parents_of_alarm_name {
scope_62.string(var_63);
}
#[allow(unused_mut)]
let mut scope_64 = writer.prefix("StateValue");
if let Some(var_65) = &input.state_value {
scope_64.string(var_65.as_str());
}
#[allow(unused_mut)]
let mut scope_66 = writer.prefix("ActionPrefix");
if let Some(var_67) = &input.action_prefix {
scope_66.string(var_67);
}
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("MaxRecords");
if let Some(var_69) = &input.max_records {
scope_68.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_69).into()),
);
}
#[allow(unused_mut)]
let mut scope_70 = writer.prefix("NextToken");
if let Some(var_71) = &input.next_token {
scope_70.string(var_71);
}
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, std::convert::Infallible> {
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_72 = writer.prefix("MetricName");
if let Some(var_73) = &input.metric_name {
scope_72.string(var_73);
}
#[allow(unused_mut)]
let mut scope_74 = writer.prefix("Namespace");
if let Some(var_75) = &input.namespace {
scope_74.string(var_75);
}
#[allow(unused_mut)]
let mut scope_76 = writer.prefix("Statistic");
if let Some(var_77) = &input.statistic {
scope_76.string(var_77.as_str());
}
#[allow(unused_mut)]
let mut scope_78 = writer.prefix("ExtendedStatistic");
if let Some(var_79) = &input.extended_statistic {
scope_78.string(var_79);
}
#[allow(unused_mut)]
let mut scope_80 = writer.prefix("Dimensions");
if let Some(var_81) = &input.dimensions {
let mut list_83 = scope_80.start_list(false, None);
for item_82 in var_81 {
#[allow(unused_mut)]
let mut entry_84 = list_83.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_84, item_82);
}
list_83.finish();
}
#[allow(unused_mut)]
let mut scope_85 = writer.prefix("Period");
if let Some(var_86) = &input.period {
scope_85.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_86).into()),
);
}
#[allow(unused_mut)]
let mut scope_87 = writer.prefix("Unit");
if let Some(var_88) = &input.unit {
scope_87.string(var_88.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, std::convert::Infallible> {
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_89 = writer.prefix("NextToken");
if let Some(var_90) = &input.next_token {
scope_89.string(var_90);
}
#[allow(unused_mut)]
let mut scope_91 = writer.prefix("MaxResults");
if let Some(var_92) = &input.max_results {
scope_91.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_92).into()),
);
}
#[allow(unused_mut)]
let mut scope_93 = writer.prefix("Namespace");
if let Some(var_94) = &input.namespace {
scope_93.string(var_94);
}
#[allow(unused_mut)]
let mut scope_95 = writer.prefix("MetricName");
if let Some(var_96) = &input.metric_name {
scope_95.string(var_96);
}
#[allow(unused_mut)]
let mut scope_97 = writer.prefix("Dimensions");
if let Some(var_98) = &input.dimensions {
let mut list_100 = scope_97.start_list(false, None);
for item_99 in var_98 {
#[allow(unused_mut)]
let mut entry_101 = list_100.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_101, item_99);
}
list_100.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, std::convert::Infallible> {
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_102 = writer.prefix("NextToken");
if let Some(var_103) = &input.next_token {
scope_102.string(var_103);
}
#[allow(unused_mut)]
let mut scope_104 = writer.prefix("MaxResults");
if let Some(var_105) = &input.max_results {
scope_104.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_105).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, std::convert::Infallible> {
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_106 = writer.prefix("AlarmNames");
if let Some(var_107) = &input.alarm_names {
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);
}
list_109.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, std::convert::Infallible> {
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_111 = writer.prefix("RuleNames");
if let Some(var_112) = &input.rule_names {
let mut list_114 = scope_111.start_list(false, None);
for item_113 in var_112 {
#[allow(unused_mut)]
let mut entry_115 = list_114.entry();
entry_115.string(item_113);
}
list_114.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, std::convert::Infallible> {
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_116 = writer.prefix("AlarmNames");
if let Some(var_117) = &input.alarm_names {
let mut list_119 = scope_116.start_list(false, None);
for item_118 in var_117 {
#[allow(unused_mut)]
let mut entry_120 = list_119.entry();
entry_120.string(item_118);
}
list_119.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, std::convert::Infallible> {
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_121 = writer.prefix("RuleNames");
if let Some(var_122) = &input.rule_names {
let mut list_124 = scope_121.start_list(false, None);
for item_123 in var_122 {
#[allow(unused_mut)]
let mut entry_125 = list_124.entry();
entry_125.string(item_123);
}
list_124.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, std::convert::Infallible> {
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_126 = writer.prefix("DashboardName");
if let Some(var_127) = &input.dashboard_name {
scope_126.string(var_127);
}
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, std::convert::Infallible> {
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_128 = writer.prefix("RuleName");
if let Some(var_129) = &input.rule_name {
scope_128.string(var_129);
}
#[allow(unused_mut)]
let mut scope_130 = writer.prefix("StartTime");
if let Some(var_131) = &input.start_time {
scope_130.instant(var_131, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_132 = writer.prefix("EndTime");
if let Some(var_133) = &input.end_time {
scope_132.instant(var_133, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_134 = writer.prefix("Period");
if let Some(var_135) = &input.period {
scope_134.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_135).into()),
);
}
#[allow(unused_mut)]
let mut scope_136 = writer.prefix("MaxContributorCount");
if let Some(var_137) = &input.max_contributor_count {
scope_136.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_137).into()),
);
}
#[allow(unused_mut)]
let mut scope_138 = writer.prefix("Metrics");
if let Some(var_139) = &input.metrics {
let mut list_141 = scope_138.start_list(false, None);
for item_140 in var_139 {
#[allow(unused_mut)]
let mut entry_142 = list_141.entry();
entry_142.string(item_140);
}
list_141.finish();
}
#[allow(unused_mut)]
let mut scope_143 = writer.prefix("OrderBy");
if let Some(var_144) = &input.order_by {
scope_143.string(var_144);
}
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, std::convert::Infallible> {
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_145 = writer.prefix("MetricDataQueries");
if let Some(var_146) = &input.metric_data_queries {
let mut list_148 = scope_145.start_list(false, None);
for item_147 in var_146 {
#[allow(unused_mut)]
let mut entry_149 = list_148.entry();
crate::query_ser::serialize_structure_crate_model_metric_data_query(
entry_149, item_147,
);
}
list_148.finish();
}
#[allow(unused_mut)]
let mut scope_150 = writer.prefix("StartTime");
if let Some(var_151) = &input.start_time {
scope_150.instant(var_151, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_152 = writer.prefix("EndTime");
if let Some(var_153) = &input.end_time {
scope_152.instant(var_153, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_154 = writer.prefix("NextToken");
if let Some(var_155) = &input.next_token {
scope_154.string(var_155);
}
#[allow(unused_mut)]
let mut scope_156 = writer.prefix("ScanBy");
if let Some(var_157) = &input.scan_by {
scope_156.string(var_157.as_str());
}
#[allow(unused_mut)]
let mut scope_158 = writer.prefix("MaxDatapoints");
if let Some(var_159) = &input.max_datapoints {
scope_158.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_159).into()),
);
}
#[allow(unused_mut)]
let mut scope_160 = writer.prefix("LabelOptions");
if let Some(var_161) = &input.label_options {
crate::query_ser::serialize_structure_crate_model_label_options(scope_160, var_161);
}
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, std::convert::Infallible> {
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_162 = writer.prefix("Namespace");
if let Some(var_163) = &input.namespace {
scope_162.string(var_163);
}
#[allow(unused_mut)]
let mut scope_164 = writer.prefix("MetricName");
if let Some(var_165) = &input.metric_name {
scope_164.string(var_165);
}
#[allow(unused_mut)]
let mut scope_166 = writer.prefix("Dimensions");
if let Some(var_167) = &input.dimensions {
let mut list_169 = scope_166.start_list(false, None);
for item_168 in var_167 {
#[allow(unused_mut)]
let mut entry_170 = list_169.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_170, item_168);
}
list_169.finish();
}
#[allow(unused_mut)]
let mut scope_171 = writer.prefix("StartTime");
if let Some(var_172) = &input.start_time {
scope_171.instant(var_172, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_173 = writer.prefix("EndTime");
if let Some(var_174) = &input.end_time {
scope_173.instant(var_174, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_175 = writer.prefix("Period");
if let Some(var_176) = &input.period {
scope_175.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_176).into()),
);
}
#[allow(unused_mut)]
let mut scope_177 = writer.prefix("Statistics");
if let Some(var_178) = &input.statistics {
let mut list_180 = scope_177.start_list(false, None);
for item_179 in var_178 {
#[allow(unused_mut)]
let mut entry_181 = list_180.entry();
entry_181.string(item_179.as_str());
}
list_180.finish();
}
#[allow(unused_mut)]
let mut scope_182 = writer.prefix("ExtendedStatistics");
if let Some(var_183) = &input.extended_statistics {
let mut list_185 = scope_182.start_list(false, None);
for item_184 in var_183 {
#[allow(unused_mut)]
let mut entry_186 = list_185.entry();
entry_186.string(item_184);
}
list_185.finish();
}
#[allow(unused_mut)]
let mut scope_187 = writer.prefix("Unit");
if let Some(var_188) = &input.unit {
scope_187.string(var_188.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, std::convert::Infallible> {
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_189 = writer.prefix("Name");
if let Some(var_190) = &input.name {
scope_189.string(var_190);
}
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, std::convert::Infallible> {
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_191 = writer.prefix("MetricWidget");
if let Some(var_192) = &input.metric_widget {
scope_191.string(var_192);
}
#[allow(unused_mut)]
let mut scope_193 = writer.prefix("OutputFormat");
if let Some(var_194) = &input.output_format {
scope_193.string(var_194);
}
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, std::convert::Infallible> {
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_195 = writer.prefix("DashboardNamePrefix");
if let Some(var_196) = &input.dashboard_name_prefix {
scope_195.string(var_196);
}
#[allow(unused_mut)]
let mut scope_197 = writer.prefix("NextToken");
if let Some(var_198) = &input.next_token {
scope_197.string(var_198);
}
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, std::convert::Infallible> {
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_199 = writer.prefix("Namespace");
if let Some(var_200) = &input.namespace {
scope_199.string(var_200);
}
#[allow(unused_mut)]
let mut scope_201 = writer.prefix("MetricName");
if let Some(var_202) = &input.metric_name {
scope_201.string(var_202);
}
#[allow(unused_mut)]
let mut scope_203 = writer.prefix("Dimensions");
if let Some(var_204) = &input.dimensions {
let mut list_206 = scope_203.start_list(false, None);
for item_205 in var_204 {
#[allow(unused_mut)]
let mut entry_207 = list_206.entry();
crate::query_ser::serialize_structure_crate_model_dimension_filter(entry_207, item_205);
}
list_206.finish();
}
#[allow(unused_mut)]
let mut scope_208 = writer.prefix("NextToken");
if let Some(var_209) = &input.next_token {
scope_208.string(var_209);
}
#[allow(unused_mut)]
let mut scope_210 = writer.prefix("RecentlyActive");
if let Some(var_211) = &input.recently_active {
scope_210.string(var_211.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, std::convert::Infallible> {
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_212 = writer.prefix("NextToken");
if let Some(var_213) = &input.next_token {
scope_212.string(var_213);
}
#[allow(unused_mut)]
let mut scope_214 = writer.prefix("MaxResults");
if let Some(var_215) = &input.max_results {
scope_214.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_215).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, std::convert::Infallible> {
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_216 = writer.prefix("ResourceARN");
if let Some(var_217) = &input.resource_arn {
scope_216.string(var_217);
}
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, std::convert::Infallible> {
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_218 = writer.prefix("Namespace");
if let Some(var_219) = &input.namespace {
scope_218.string(var_219);
}
#[allow(unused_mut)]
let mut scope_220 = writer.prefix("MetricName");
if let Some(var_221) = &input.metric_name {
scope_220.string(var_221);
}
#[allow(unused_mut)]
let mut scope_222 = writer.prefix("Dimensions");
if let Some(var_223) = &input.dimensions {
let mut list_225 = scope_222.start_list(false, None);
for item_224 in var_223 {
#[allow(unused_mut)]
let mut entry_226 = list_225.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_226, item_224);
}
list_225.finish();
}
#[allow(unused_mut)]
let mut scope_227 = writer.prefix("Stat");
if let Some(var_228) = &input.stat {
scope_227.string(var_228);
}
#[allow(unused_mut)]
let mut scope_229 = writer.prefix("Configuration");
if let Some(var_230) = &input.configuration {
crate::query_ser::serialize_structure_crate_model_anomaly_detector_configuration(
scope_229, var_230,
);
}
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, std::convert::Infallible> {
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_231 = writer.prefix("ActionsEnabled");
if let Some(var_232) = &input.actions_enabled {
scope_231.boolean(*var_232);
}
#[allow(unused_mut)]
let mut scope_233 = writer.prefix("AlarmActions");
if let Some(var_234) = &input.alarm_actions {
let mut list_236 = scope_233.start_list(false, None);
for item_235 in var_234 {
#[allow(unused_mut)]
let mut entry_237 = list_236.entry();
entry_237.string(item_235);
}
list_236.finish();
}
#[allow(unused_mut)]
let mut scope_238 = writer.prefix("AlarmDescription");
if let Some(var_239) = &input.alarm_description {
scope_238.string(var_239);
}
#[allow(unused_mut)]
let mut scope_240 = writer.prefix("AlarmName");
if let Some(var_241) = &input.alarm_name {
scope_240.string(var_241);
}
#[allow(unused_mut)]
let mut scope_242 = writer.prefix("AlarmRule");
if let Some(var_243) = &input.alarm_rule {
scope_242.string(var_243);
}
#[allow(unused_mut)]
let mut scope_244 = writer.prefix("InsufficientDataActions");
if let Some(var_245) = &input.insufficient_data_actions {
let mut list_247 = scope_244.start_list(false, None);
for item_246 in var_245 {
#[allow(unused_mut)]
let mut entry_248 = list_247.entry();
entry_248.string(item_246);
}
list_247.finish();
}
#[allow(unused_mut)]
let mut scope_249 = writer.prefix("OKActions");
if let Some(var_250) = &input.ok_actions {
let mut list_252 = scope_249.start_list(false, None);
for item_251 in var_250 {
#[allow(unused_mut)]
let mut entry_253 = list_252.entry();
entry_253.string(item_251);
}
list_252.finish();
}
#[allow(unused_mut)]
let mut scope_254 = writer.prefix("Tags");
if let Some(var_255) = &input.tags {
let mut list_257 = scope_254.start_list(false, None);
for item_256 in var_255 {
#[allow(unused_mut)]
let mut entry_258 = list_257.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_258, item_256);
}
list_257.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, std::convert::Infallible> {
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_259 = writer.prefix("DashboardName");
if let Some(var_260) = &input.dashboard_name {
scope_259.string(var_260);
}
#[allow(unused_mut)]
let mut scope_261 = writer.prefix("DashboardBody");
if let Some(var_262) = &input.dashboard_body {
scope_261.string(var_262);
}
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, std::convert::Infallible> {
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_263 = writer.prefix("RuleName");
if let Some(var_264) = &input.rule_name {
scope_263.string(var_264);
}
#[allow(unused_mut)]
let mut scope_265 = writer.prefix("RuleState");
if let Some(var_266) = &input.rule_state {
scope_265.string(var_266);
}
#[allow(unused_mut)]
let mut scope_267 = writer.prefix("RuleDefinition");
if let Some(var_268) = &input.rule_definition {
scope_267.string(var_268);
}
#[allow(unused_mut)]
let mut scope_269 = writer.prefix("Tags");
if let Some(var_270) = &input.tags {
let mut list_272 = scope_269.start_list(false, None);
for item_271 in var_270 {
#[allow(unused_mut)]
let mut entry_273 = list_272.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_273, item_271);
}
list_272.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, std::convert::Infallible> {
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_274 = writer.prefix("AlarmName");
if let Some(var_275) = &input.alarm_name {
scope_274.string(var_275);
}
#[allow(unused_mut)]
let mut scope_276 = writer.prefix("AlarmDescription");
if let Some(var_277) = &input.alarm_description {
scope_276.string(var_277);
}
#[allow(unused_mut)]
let mut scope_278 = writer.prefix("ActionsEnabled");
if let Some(var_279) = &input.actions_enabled {
scope_278.boolean(*var_279);
}
#[allow(unused_mut)]
let mut scope_280 = writer.prefix("OKActions");
if let Some(var_281) = &input.ok_actions {
let mut list_283 = scope_280.start_list(false, None);
for item_282 in var_281 {
#[allow(unused_mut)]
let mut entry_284 = list_283.entry();
entry_284.string(item_282);
}
list_283.finish();
}
#[allow(unused_mut)]
let mut scope_285 = writer.prefix("AlarmActions");
if let Some(var_286) = &input.alarm_actions {
let mut list_288 = scope_285.start_list(false, None);
for item_287 in var_286 {
#[allow(unused_mut)]
let mut entry_289 = list_288.entry();
entry_289.string(item_287);
}
list_288.finish();
}
#[allow(unused_mut)]
let mut scope_290 = writer.prefix("InsufficientDataActions");
if let Some(var_291) = &input.insufficient_data_actions {
let mut list_293 = scope_290.start_list(false, None);
for item_292 in var_291 {
#[allow(unused_mut)]
let mut entry_294 = list_293.entry();
entry_294.string(item_292);
}
list_293.finish();
}
#[allow(unused_mut)]
let mut scope_295 = writer.prefix("MetricName");
if let Some(var_296) = &input.metric_name {
scope_295.string(var_296);
}
#[allow(unused_mut)]
let mut scope_297 = writer.prefix("Namespace");
if let Some(var_298) = &input.namespace {
scope_297.string(var_298);
}
#[allow(unused_mut)]
let mut scope_299 = writer.prefix("Statistic");
if let Some(var_300) = &input.statistic {
scope_299.string(var_300.as_str());
}
#[allow(unused_mut)]
let mut scope_301 = writer.prefix("ExtendedStatistic");
if let Some(var_302) = &input.extended_statistic {
scope_301.string(var_302);
}
#[allow(unused_mut)]
let mut scope_303 = writer.prefix("Dimensions");
if let Some(var_304) = &input.dimensions {
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();
crate::query_ser::serialize_structure_crate_model_dimension(entry_307, item_305);
}
list_306.finish();
}
#[allow(unused_mut)]
let mut scope_308 = writer.prefix("Period");
if let Some(var_309) = &input.period {
scope_308.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_309).into()),
);
}
#[allow(unused_mut)]
let mut scope_310 = writer.prefix("Unit");
if let Some(var_311) = &input.unit {
scope_310.string(var_311.as_str());
}
#[allow(unused_mut)]
let mut scope_312 = writer.prefix("EvaluationPeriods");
if let Some(var_313) = &input.evaluation_periods {
scope_312.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_313).into()),
);
}
#[allow(unused_mut)]
let mut scope_314 = writer.prefix("DatapointsToAlarm");
if let Some(var_315) = &input.datapoints_to_alarm {
scope_314.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_315).into()),
);
}
#[allow(unused_mut)]
let mut scope_316 = writer.prefix("Threshold");
if let Some(var_317) = &input.threshold {
scope_316.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_317).into()),
);
}
#[allow(unused_mut)]
let mut scope_318 = writer.prefix("ComparisonOperator");
if let Some(var_319) = &input.comparison_operator {
scope_318.string(var_319.as_str());
}
#[allow(unused_mut)]
let mut scope_320 = writer.prefix("TreatMissingData");
if let Some(var_321) = &input.treat_missing_data {
scope_320.string(var_321);
}
#[allow(unused_mut)]
let mut scope_322 = writer.prefix("EvaluateLowSampleCountPercentile");
if let Some(var_323) = &input.evaluate_low_sample_count_percentile {
scope_322.string(var_323);
}
#[allow(unused_mut)]
let mut scope_324 = writer.prefix("Metrics");
if let Some(var_325) = &input.metrics {
let mut list_327 = scope_324.start_list(false, None);
for item_326 in var_325 {
#[allow(unused_mut)]
let mut entry_328 = list_327.entry();
crate::query_ser::serialize_structure_crate_model_metric_data_query(
entry_328, item_326,
);
}
list_327.finish();
}
#[allow(unused_mut)]
let mut scope_329 = writer.prefix("Tags");
if let Some(var_330) = &input.tags {
let mut list_332 = scope_329.start_list(false, None);
for item_331 in var_330 {
#[allow(unused_mut)]
let mut entry_333 = list_332.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_333, item_331);
}
list_332.finish();
}
#[allow(unused_mut)]
let mut scope_334 = writer.prefix("ThresholdMetricId");
if let Some(var_335) = &input.threshold_metric_id {
scope_334.string(var_335);
}
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, std::convert::Infallible> {
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_336 = writer.prefix("Namespace");
if let Some(var_337) = &input.namespace {
scope_336.string(var_337);
}
#[allow(unused_mut)]
let mut scope_338 = writer.prefix("MetricData");
if let Some(var_339) = &input.metric_data {
let mut list_341 = scope_338.start_list(false, None);
for item_340 in var_339 {
#[allow(unused_mut)]
let mut entry_342 = list_341.entry();
crate::query_ser::serialize_structure_crate_model_metric_datum(entry_342, item_340);
}
list_341.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, std::convert::Infallible> {
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_343 = writer.prefix("Name");
if let Some(var_344) = &input.name {
scope_343.string(var_344);
}
#[allow(unused_mut)]
let mut scope_345 = writer.prefix("IncludeFilters");
if let Some(var_346) = &input.include_filters {
let mut list_348 = scope_345.start_list(false, None);
for item_347 in var_346 {
#[allow(unused_mut)]
let mut entry_349 = list_348.entry();
crate::query_ser::serialize_structure_crate_model_metric_stream_filter(
entry_349, item_347,
);
}
list_348.finish();
}
#[allow(unused_mut)]
let mut scope_350 = writer.prefix("ExcludeFilters");
if let Some(var_351) = &input.exclude_filters {
let mut list_353 = scope_350.start_list(false, None);
for item_352 in var_351 {
#[allow(unused_mut)]
let mut entry_354 = list_353.entry();
crate::query_ser::serialize_structure_crate_model_metric_stream_filter(
entry_354, item_352,
);
}
list_353.finish();
}
#[allow(unused_mut)]
let mut scope_355 = writer.prefix("FirehoseArn");
if let Some(var_356) = &input.firehose_arn {
scope_355.string(var_356);
}
#[allow(unused_mut)]
let mut scope_357 = writer.prefix("RoleArn");
if let Some(var_358) = &input.role_arn {
scope_357.string(var_358);
}
#[allow(unused_mut)]
let mut scope_359 = writer.prefix("OutputFormat");
if let Some(var_360) = &input.output_format {
scope_359.string(var_360.as_str());
}
#[allow(unused_mut)]
let mut scope_361 = writer.prefix("Tags");
if let Some(var_362) = &input.tags {
let mut list_364 = scope_361.start_list(false, None);
for item_363 in var_362 {
#[allow(unused_mut)]
let mut entry_365 = list_364.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_365, item_363);
}
list_364.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, std::convert::Infallible> {
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_366 = writer.prefix("AlarmName");
if let Some(var_367) = &input.alarm_name {
scope_366.string(var_367);
}
#[allow(unused_mut)]
let mut scope_368 = writer.prefix("StateValue");
if let Some(var_369) = &input.state_value {
scope_368.string(var_369.as_str());
}
#[allow(unused_mut)]
let mut scope_370 = writer.prefix("StateReason");
if let Some(var_371) = &input.state_reason {
scope_370.string(var_371);
}
#[allow(unused_mut)]
let mut scope_372 = writer.prefix("StateReasonData");
if let Some(var_373) = &input.state_reason_data {
scope_372.string(var_373);
}
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, std::convert::Infallible> {
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_374 = writer.prefix("Names");
if let Some(var_375) = &input.names {
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();
entry_378.string(item_376);
}
list_377.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, std::convert::Infallible> {
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_379 = writer.prefix("Names");
if let Some(var_380) = &input.names {
let mut list_382 = scope_379.start_list(false, None);
for item_381 in var_380 {
#[allow(unused_mut)]
let mut entry_383 = list_382.entry();
entry_383.string(item_381);
}
list_382.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, std::convert::Infallible> {
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_384 = writer.prefix("ResourceARN");
if let Some(var_385) = &input.resource_arn {
scope_384.string(var_385);
}
#[allow(unused_mut)]
let mut scope_386 = writer.prefix("Tags");
if let Some(var_387) = &input.tags {
let mut list_389 = scope_386.start_list(false, None);
for item_388 in var_387 {
#[allow(unused_mut)]
let mut entry_390 = list_389.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_390, item_388);
}
list_389.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, std::convert::Infallible> {
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_391 = writer.prefix("ResourceARN");
if let Some(var_392) = &input.resource_arn {
scope_391.string(var_392);
}
#[allow(unused_mut)]
let mut scope_393 = writer.prefix("TagKeys");
if let Some(var_394) = &input.tag_keys {
let mut list_396 = scope_393.start_list(false, None);
for item_395 in var_394 {
#[allow(unused_mut)]
let mut entry_397 = list_396.entry();
entry_397.string(item_395);
}
list_396.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}