aws-sdk-cloudwatch 0.0.26-alpha

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[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::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::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::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::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::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::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::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::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_metric_datum(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::MetricDatum,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_52 = writer.prefix("MetricName");
    if let Some(var_53) = &input.metric_name {
        scope_52.string(var_53);
    }
    #[allow(unused_mut)]
    let mut scope_54 = writer.prefix("Dimensions");
    if let Some(var_55) = &input.dimensions {
        let mut list_57 = scope_54.start_list(false, None);
        for item_56 in var_55 {
            #[allow(unused_mut)]
            let mut entry_58 = list_57.entry();
            crate::query_ser::serialize_structure_crate_model_dimension(entry_58, item_56)?;
        }
        list_57.finish();
    }
    #[allow(unused_mut)]
    let mut scope_59 = writer.prefix("Timestamp");
    if let Some(var_60) = &input.timestamp {
        scope_59.date_time(var_60, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_61 = writer.prefix("Value");
    if let Some(var_62) = &input.value {
        scope_61.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_62).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_63 = writer.prefix("StatisticValues");
    if let Some(var_64) = &input.statistic_values {
        crate::query_ser::serialize_structure_crate_model_statistic_set(scope_63, var_64)?;
    }
    #[allow(unused_mut)]
    let mut scope_65 = writer.prefix("Values");
    if let Some(var_66) = &input.values {
        let mut list_68 = scope_65.start_list(false, None);
        for item_67 in var_66 {
            #[allow(unused_mut)]
            let mut entry_69 = list_68.entry();
            entry_69.number(
                #[allow(clippy::useless_conversion)]
                aws_smithy_types::Number::Float((*item_67).into()),
            );
        }
        list_68.finish();
    }
    #[allow(unused_mut)]
    let mut scope_70 = writer.prefix("Counts");
    if let Some(var_71) = &input.counts {
        let mut list_73 = scope_70.start_list(false, None);
        for item_72 in var_71 {
            #[allow(unused_mut)]
            let mut entry_74 = list_73.entry();
            entry_74.number(
                #[allow(clippy::useless_conversion)]
                aws_smithy_types::Number::Float((*item_72).into()),
            );
        }
        list_73.finish();
    }
    #[allow(unused_mut)]
    let mut scope_75 = writer.prefix("Unit");
    if let Some(var_76) = &input.unit {
        scope_75.string(var_76.as_str());
    }
    #[allow(unused_mut)]
    let mut scope_77 = writer.prefix("StorageResolution");
    if let Some(var_78) = &input.storage_resolution {
        scope_77.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_78).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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_79 = writer.prefix("Namespace");
    if let Some(var_80) = &input.namespace {
        scope_79.string(var_80);
    }
    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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_81 = writer.prefix("Metric");
    if let Some(var_82) = &input.metric {
        crate::query_ser::serialize_structure_crate_model_metric(scope_81, var_82)?;
    }
    #[allow(unused_mut)]
    let mut scope_83 = writer.prefix("Period");
    if let Some(var_84) = &input.period {
        scope_83.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_84).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_85 = writer.prefix("Stat");
    if let Some(var_86) = &input.stat {
        scope_85.string(var_86);
    }
    #[allow(unused_mut)]
    let mut scope_87 = writer.prefix("Unit");
    if let Some(var_88) = &input.unit {
        scope_87.string(var_88.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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_89 = writer.prefix("StartTime");
    if let Some(var_90) = &input.start_time {
        scope_89.date_time(var_90, aws_smithy_types::date_time::Format::DateTime)?;
    }
    #[allow(unused_mut)]
    let mut scope_91 = writer.prefix("EndTime");
    if let Some(var_92) = &input.end_time {
        scope_91.date_time(var_92, 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::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_93 = writer.prefix("SampleCount");
    if let Some(var_94) = &input.sample_count {
        scope_93.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_94).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_95 = writer.prefix("Sum");
    if let Some(var_96) = &input.sum {
        scope_95.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_96).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_97 = writer.prefix("Minimum");
    if let Some(var_98) = &input.minimum {
        scope_97.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_98).into()),
        );
    }
    #[allow(unused_mut)]
    let mut scope_99 = writer.prefix("Maximum");
    if let Some(var_100) = &input.maximum {
        scope_99.number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_100).into()),
        );
    }
    Ok(())
}

#[allow(unused_mut)]
pub fn serialize_structure_crate_model_metric(
    mut writer: aws_smithy_query::QueryValueWriter,
    input: &crate::model::Metric,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    #[allow(unused_mut)]
    let mut scope_101 = writer.prefix("Namespace");
    if let Some(var_102) = &input.namespace {
        scope_101.string(var_102);
    }
    #[allow(unused_mut)]
    let mut scope_103 = writer.prefix("MetricName");
    if let Some(var_104) = &input.metric_name {
        scope_103.string(var_104);
    }
    #[allow(unused_mut)]
    let mut scope_105 = writer.prefix("Dimensions");
    if let Some(var_106) = &input.dimensions {
        let mut list_108 = scope_105.start_list(false, None);
        for item_107 in var_106 {
            #[allow(unused_mut)]
            let mut entry_109 = list_108.entry();
            crate::query_ser::serialize_structure_crate_model_dimension(entry_109, item_107)?;
        }
        list_108.finish();
    }
    Ok(())
}