#[allow(unused_mut)]
pub fn serialize_structure_crate_model_dimension(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Dimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("Name");
if let Some(var_2) = &input.name {
scope_1.string(var_2);
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("Value");
if let Some(var_4) = &input.value {
scope_3.string(var_4);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_single_metric_anomaly_detector(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SingleMetricAnomalyDetector,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("Namespace");
if let Some(var_6) = &input.namespace {
scope_5.string(var_6);
}
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("MetricName");
if let Some(var_8) = &input.metric_name {
scope_7.string(var_8);
}
#[allow(unused_mut)]
let mut scope_9 = writer.prefix("Dimensions");
if let Some(var_10) = &input.dimensions {
let mut list_12 = scope_9.start_list(false, None);
for item_11 in var_10 {
#[allow(unused_mut)]
let mut entry_13 = list_12.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_13, item_11)?;
}
list_12.finish();
}
#[allow(unused_mut)]
let mut scope_14 = writer.prefix("Stat");
if let Some(var_15) = &input.stat {
scope_14.string(var_15);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_math_anomaly_detector(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MetricMathAnomalyDetector,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_16 = writer.prefix("MetricDataQueries");
if let Some(var_17) = &input.metric_data_queries {
let mut list_19 = scope_16.start_list(false, None);
for item_18 in var_17 {
#[allow(unused_mut)]
let mut entry_20 = list_19.entry();
crate::query_ser::serialize_structure_crate_model_metric_data_query(entry_20, item_18)?;
}
list_19.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_data_query(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MetricDataQuery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("Id");
if let Some(var_22) = &input.id {
scope_21.string(var_22);
}
#[allow(unused_mut)]
let mut scope_23 = writer.prefix("MetricStat");
if let Some(var_24) = &input.metric_stat {
crate::query_ser::serialize_structure_crate_model_metric_stat(scope_23, var_24)?;
}
#[allow(unused_mut)]
let mut scope_25 = writer.prefix("Expression");
if let Some(var_26) = &input.expression {
scope_25.string(var_26);
}
#[allow(unused_mut)]
let mut scope_27 = writer.prefix("Label");
if let Some(var_28) = &input.label {
scope_27.string(var_28);
}
#[allow(unused_mut)]
let mut scope_29 = writer.prefix("ReturnData");
if let Some(var_30) = &input.return_data {
scope_29.boolean(*var_30);
}
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("Period");
if let Some(var_32) = &input.period {
scope_31.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_32).into()),
);
}
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("AccountId");
if let Some(var_34) = &input.account_id {
scope_33.string(var_34);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_label_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LabelOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("Timezone");
if let Some(var_36) = &input.timezone {
scope_35.string(var_36);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_dimension_filter(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DimensionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_37 = writer.prefix("Name");
if let Some(var_38) = &input.name {
scope_37.string(var_38);
}
#[allow(unused_mut)]
let mut scope_39 = writer.prefix("Value");
if let Some(var_40) = &input.value {
scope_39.string(var_40);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_anomaly_detector_configuration(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AnomalyDetectorConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("ExcludedTimeRanges");
if let Some(var_42) = &input.excluded_time_ranges {
let mut list_44 = scope_41.start_list(false, None);
for item_43 in var_42 {
#[allow(unused_mut)]
let mut entry_45 = list_44.entry();
crate::query_ser::serialize_structure_crate_model_range(entry_45, item_43)?;
}
list_44.finish();
}
#[allow(unused_mut)]
let mut scope_46 = writer.prefix("MetricTimezone");
if let Some(var_47) = &input.metric_timezone {
scope_46.string(var_47);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_tag(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_48 = writer.prefix("Key");
if let Some(var_49) = &input.key {
scope_48.string(var_49);
}
#[allow(unused_mut)]
let mut scope_50 = writer.prefix("Value");
if let Some(var_51) = &input.value {
scope_50.string(var_51);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_managed_rule(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ManagedRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_52 = writer.prefix("TemplateName");
if let Some(var_53) = &input.template_name {
scope_52.string(var_53);
}
#[allow(unused_mut)]
let mut scope_54 = writer.prefix("ResourceARN");
if let Some(var_55) = &input.resource_arn {
scope_54.string(var_55);
}
#[allow(unused_mut)]
let mut scope_56 = writer.prefix("Tags");
if let Some(var_57) = &input.tags {
let mut list_59 = scope_56.start_list(false, None);
for item_58 in var_57 {
#[allow(unused_mut)]
let mut entry_60 = list_59.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_60, item_58)?;
}
list_59.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_datum(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MetricDatum,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_61 = writer.prefix("MetricName");
if let Some(var_62) = &input.metric_name {
scope_61.string(var_62);
}
#[allow(unused_mut)]
let mut scope_63 = writer.prefix("Dimensions");
if let Some(var_64) = &input.dimensions {
let mut list_66 = scope_63.start_list(false, None);
for item_65 in var_64 {
#[allow(unused_mut)]
let mut entry_67 = list_66.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_67, item_65)?;
}
list_66.finish();
}
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("Timestamp");
if let Some(var_69) = &input.timestamp {
scope_68.date_time(var_69, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_70 = writer.prefix("Value");
if let Some(var_71) = &input.value {
scope_70.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_71).into()),
);
}
#[allow(unused_mut)]
let mut scope_72 = writer.prefix("StatisticValues");
if let Some(var_73) = &input.statistic_values {
crate::query_ser::serialize_structure_crate_model_statistic_set(scope_72, var_73)?;
}
#[allow(unused_mut)]
let mut scope_74 = writer.prefix("Values");
if let Some(var_75) = &input.values {
let mut list_77 = scope_74.start_list(false, None);
for item_76 in var_75 {
#[allow(unused_mut)]
let mut entry_78 = list_77.entry();
entry_78.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_76).into()),
);
}
list_77.finish();
}
#[allow(unused_mut)]
let mut scope_79 = writer.prefix("Counts");
if let Some(var_80) = &input.counts {
let mut list_82 = scope_79.start_list(false, None);
for item_81 in var_80 {
#[allow(unused_mut)]
let mut entry_83 = list_82.entry();
entry_83.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_81).into()),
);
}
list_82.finish();
}
#[allow(unused_mut)]
let mut scope_84 = writer.prefix("Unit");
if let Some(var_85) = &input.unit {
scope_84.string(var_85.as_str());
}
#[allow(unused_mut)]
let mut scope_86 = writer.prefix("StorageResolution");
if let Some(var_87) = &input.storage_resolution {
scope_86.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_87).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_stream_filter(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MetricStreamFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_88 = writer.prefix("Namespace");
if let Some(var_89) = &input.namespace {
scope_88.string(var_89);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_stream_statistics_configuration(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MetricStreamStatisticsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_90 = writer.prefix("IncludeMetrics");
if let Some(var_91) = &input.include_metrics {
let mut list_93 = scope_90.start_list(false, None);
for item_92 in var_91 {
#[allow(unused_mut)]
let mut entry_94 = list_93.entry();
crate::query_ser::serialize_structure_crate_model_metric_stream_statistics_metric(
entry_94, item_92,
)?;
}
list_93.finish();
}
#[allow(unused_mut)]
let mut scope_95 = writer.prefix("AdditionalStatistics");
if let Some(var_96) = &input.additional_statistics {
let mut list_98 = scope_95.start_list(false, None);
for item_97 in var_96 {
#[allow(unused_mut)]
let mut entry_99 = list_98.entry();
entry_99.string(item_97);
}
list_98.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_stat(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MetricStat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_100 = writer.prefix("Metric");
if let Some(var_101) = &input.metric {
crate::query_ser::serialize_structure_crate_model_metric(scope_100, var_101)?;
}
#[allow(unused_mut)]
let mut scope_102 = writer.prefix("Period");
if let Some(var_103) = &input.period {
scope_102.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_103).into()),
);
}
#[allow(unused_mut)]
let mut scope_104 = writer.prefix("Stat");
if let Some(var_105) = &input.stat {
scope_104.string(var_105);
}
#[allow(unused_mut)]
let mut scope_106 = writer.prefix("Unit");
if let Some(var_107) = &input.unit {
scope_106.string(var_107.as_str());
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_range(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Range,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_108 = writer.prefix("StartTime");
if let Some(var_109) = &input.start_time {
scope_108.date_time(var_109, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_110 = writer.prefix("EndTime");
if let Some(var_111) = &input.end_time {
scope_110.date_time(var_111, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_statistic_set(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::StatisticSet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_112 = writer.prefix("SampleCount");
if let Some(var_113) = &input.sample_count {
scope_112.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_113).into()),
);
}
#[allow(unused_mut)]
let mut scope_114 = writer.prefix("Sum");
if let Some(var_115) = &input.sum {
scope_114.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_115).into()),
);
}
#[allow(unused_mut)]
let mut scope_116 = writer.prefix("Minimum");
if let Some(var_117) = &input.minimum {
scope_116.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_117).into()),
);
}
#[allow(unused_mut)]
let mut scope_118 = writer.prefix("Maximum");
if let Some(var_119) = &input.maximum {
scope_118.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_119).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric_stream_statistics_metric(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MetricStreamStatisticsMetric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_120 = writer.prefix("Namespace");
if let Some(var_121) = &input.namespace {
scope_120.string(var_121);
}
#[allow(unused_mut)]
let mut scope_122 = writer.prefix("MetricName");
if let Some(var_123) = &input.metric_name {
scope_122.string(var_123);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Metric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_124 = writer.prefix("Namespace");
if let Some(var_125) = &input.namespace {
scope_124.string(var_125);
}
#[allow(unused_mut)]
let mut scope_126 = writer.prefix("MetricName");
if let Some(var_127) = &input.metric_name {
scope_126.string(var_127);
}
#[allow(unused_mut)]
let mut scope_128 = writer.prefix("Dimensions");
if let Some(var_129) = &input.dimensions {
let mut list_131 = scope_128.start_list(false, None);
for item_130 in var_129 {
#[allow(unused_mut)]
let mut entry_132 = list_131.entry();
crate::query_ser::serialize_structure_crate_model_dimension(entry_132, item_130)?;
}
list_131.finish();
}
Ok(())
}