pub fn serialize_structure_crate_input_activate_anomaly_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ActivateAnomalyDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_back_test_anomaly_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BackTestAnomalyDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_alert_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAlertInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.action {
#[allow(unused_mut)]
let mut object_4 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_action(&mut object_4, var_3)?;
object_4.finish();
}
if let Some(var_5) = &input.alert_description {
object.key("AlertDescription").string(var_5.as_str());
}
if let Some(var_6) = &input.alert_filters {
#[allow(unused_mut)]
let mut object_7 = object.key("AlertFilters").start_object();
crate::json_ser::serialize_structure_crate_model_alert_filters(&mut object_7, var_6)?;
object_7.finish();
}
if let Some(var_8) = &input.alert_name {
object.key("AlertName").string(var_8.as_str());
}
if input.alert_sensitivity_threshold != 0 {
object.key("AlertSensitivityThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.alert_sensitivity_threshold).into()),
);
}
if let Some(var_9) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_9.as_str());
}
if let Some(var_10) = &input.tags {
#[allow(unused_mut)]
let mut object_11 = object.key("Tags").start_object();
for (key_12, value_13) in var_10 {
{
object_11.key(key_12.as_str()).string(value_13.as_str());
}
}
object_11.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_anomaly_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAnomalyDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.anomaly_detector_config {
#[allow(unused_mut)]
let mut object_15 = object.key("AnomalyDetectorConfig").start_object();
crate::json_ser::serialize_structure_crate_model_anomaly_detector_config(
&mut object_15,
var_14,
)?;
object_15.finish();
}
if let Some(var_16) = &input.anomaly_detector_description {
object
.key("AnomalyDetectorDescription")
.string(var_16.as_str());
}
if let Some(var_17) = &input.anomaly_detector_name {
object.key("AnomalyDetectorName").string(var_17.as_str());
}
if let Some(var_18) = &input.kms_key_arn {
object.key("KmsKeyArn").string(var_18.as_str());
}
if let Some(var_19) = &input.tags {
#[allow(unused_mut)]
let mut object_20 = object.key("Tags").start_object();
for (key_21, value_22) in var_19 {
{
object_20.key(key_21.as_str()).string(value_22.as_str());
}
}
object_20.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_metric_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMetricSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_23.as_str());
}
if let Some(var_24) = &input.dimension_filter_list {
let mut array_25 = object.key("DimensionFilterList").start_array();
for item_26 in var_24 {
{
#[allow(unused_mut)]
let mut object_27 = array_25.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_set_dimension_filter(
&mut object_27,
item_26,
)?;
object_27.finish();
}
}
array_25.finish();
}
if let Some(var_28) = &input.dimension_list {
let mut array_29 = object.key("DimensionList").start_array();
for item_30 in var_28 {
{
array_29.value().string(item_30.as_str());
}
}
array_29.finish();
}
if let Some(var_31) = &input.metric_list {
let mut array_32 = object.key("MetricList").start_array();
for item_33 in var_31 {
{
#[allow(unused_mut)]
let mut object_34 = array_32.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric(&mut object_34, item_33)?;
object_34.finish();
}
}
array_32.finish();
}
if let Some(var_35) = &input.metric_set_description {
object.key("MetricSetDescription").string(var_35.as_str());
}
if let Some(var_36) = &input.metric_set_frequency {
object.key("MetricSetFrequency").string(var_36.as_str());
}
if let Some(var_37) = &input.metric_set_name {
object.key("MetricSetName").string(var_37.as_str());
}
if let Some(var_38) = &input.metric_source {
#[allow(unused_mut)]
let mut object_39 = object.key("MetricSource").start_object();
crate::json_ser::serialize_structure_crate_model_metric_source(&mut object_39, var_38)?;
object_39.finish();
}
if let Some(var_40) = &input.offset {
object.key("Offset").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_40).into()),
);
}
if let Some(var_41) = &input.tags {
#[allow(unused_mut)]
let mut object_42 = object.key("Tags").start_object();
for (key_43, value_44) in var_41 {
{
object_42.key(key_43.as_str()).string(value_44.as_str());
}
}
object_42.finish();
}
if let Some(var_45) = &input.timestamp_column {
#[allow(unused_mut)]
let mut object_46 = object.key("TimestampColumn").start_object();
crate::json_ser::serialize_structure_crate_model_timestamp_column(&mut object_46, var_45)?;
object_46.finish();
}
if let Some(var_47) = &input.timezone {
object.key("Timezone").string(var_47.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deactivate_anomaly_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeactivateAnomalyDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_48.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_alert_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAlertInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.alert_arn {
object.key("AlertArn").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_anomaly_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAnomalyDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_50.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_alert_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAlertInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.alert_arn {
object.key("AlertArn").string(var_51.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_anomaly_detection_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAnomalyDetectionExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_52.as_str());
}
if let Some(var_53) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_53).into()),
);
}
if let Some(var_54) = &input.next_token {
object.key("NextToken").string(var_54.as_str());
}
if let Some(var_55) = &input.timestamp {
object.key("Timestamp").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_anomaly_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAnomalyDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_metric_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeMetricSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.metric_set_arn {
object.key("MetricSetArn").string(var_57.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_metric_set_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectMetricSetConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_58.as_str());
}
if let Some(var_59) = &input.auto_detection_metric_source {
#[allow(unused_mut)]
let mut object_60 = object.key("AutoDetectionMetricSource").start_object();
crate::json_ser::serialize_structure_crate_model_auto_detection_metric_source(
&mut object_60,
var_59,
)?;
object_60.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_anomaly_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAnomalyGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_61.as_str());
}
if let Some(var_62) = &input.anomaly_group_id {
object.key("AnomalyGroupId").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_data_quality_metrics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDataQualityMetricsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_63.as_str());
}
if let Some(var_64) = &input.metric_set_arn {
object.key("MetricSetArn").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_feedback_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFeedbackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_65.as_str());
}
if let Some(var_66) = &input.anomaly_group_time_series_feedback {
#[allow(unused_mut)]
let mut object_67 = object.key("AnomalyGroupTimeSeriesFeedback").start_object();
crate::json_ser::serialize_structure_crate_model_anomaly_group_time_series(
&mut object_67,
var_66,
)?;
object_67.finish();
}
if let Some(var_68) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
if let Some(var_69) = &input.next_token {
object.key("NextToken").string(var_69.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_sample_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSampleDataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.s3_source_config {
#[allow(unused_mut)]
let mut object_71 = object.key("S3SourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_sample_data_s3_source_config(
&mut object_71,
var_70,
)?;
object_71.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_alerts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAlertsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_72.as_str());
}
if let Some(var_73) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_73).into()),
);
}
if let Some(var_74) = &input.next_token {
object.key("NextToken").string(var_74.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_anomaly_detectors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAnomalyDetectorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_75).into()),
);
}
if let Some(var_76) = &input.next_token {
object.key("NextToken").string(var_76.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_anomaly_group_related_metrics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAnomalyGroupRelatedMetricsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_77.as_str());
}
if let Some(var_78) = &input.anomaly_group_id {
object.key("AnomalyGroupId").string(var_78.as_str());
}
if let Some(var_79) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_79).into()),
);
}
if let Some(var_80) = &input.next_token {
object.key("NextToken").string(var_80.as_str());
}
if let Some(var_81) = &input.relationship_type_filter {
object.key("RelationshipTypeFilter").string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_anomaly_group_summaries_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAnomalyGroupSummariesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_82.as_str());
}
if let Some(var_83) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_83).into()),
);
}
if let Some(var_84) = &input.next_token {
object.key("NextToken").string(var_84.as_str());
}
{
object.key("SensitivityThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.sensitivity_threshold).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_anomaly_group_time_series_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAnomalyGroupTimeSeriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_85.as_str());
}
if let Some(var_86) = &input.anomaly_group_id {
object.key("AnomalyGroupId").string(var_86.as_str());
}
if let Some(var_87) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_87).into()),
);
}
if let Some(var_88) = &input.metric_name {
object.key("MetricName").string(var_88.as_str());
}
if let Some(var_89) = &input.next_token {
object.key("NextToken").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_metric_sets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMetricSetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_90.as_str());
}
if let Some(var_91) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_91).into()),
);
}
if let Some(var_92) = &input.next_token {
object.key("NextToken").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_feedback_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutFeedbackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_93.as_str());
}
if let Some(var_94) = &input.anomaly_group_time_series_feedback {
#[allow(unused_mut)]
let mut object_95 = object.key("AnomalyGroupTimeSeriesFeedback").start_object();
crate::json_ser::serialize_structure_crate_model_anomaly_group_time_series_feedback(
&mut object_95,
var_94,
)?;
object_95.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.tags {
#[allow(unused_mut)]
let mut object_97 = object.key("tags").start_object();
for (key_98, value_99) in var_96 {
{
object_97.key(key_98.as_str()).string(value_99.as_str());
}
}
object_97.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_alert_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAlertInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.action {
#[allow(unused_mut)]
let mut object_101 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_action(&mut object_101, var_100)?;
object_101.finish();
}
if let Some(var_102) = &input.alert_arn {
object.key("AlertArn").string(var_102.as_str());
}
if let Some(var_103) = &input.alert_description {
object.key("AlertDescription").string(var_103.as_str());
}
if let Some(var_104) = &input.alert_filters {
#[allow(unused_mut)]
let mut object_105 = object.key("AlertFilters").start_object();
crate::json_ser::serialize_structure_crate_model_alert_filters(&mut object_105, var_104)?;
object_105.finish();
}
if input.alert_sensitivity_threshold != 0 {
object.key("AlertSensitivityThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.alert_sensitivity_threshold).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_anomaly_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAnomalyDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.anomaly_detector_arn {
object.key("AnomalyDetectorArn").string(var_106.as_str());
}
if let Some(var_107) = &input.anomaly_detector_config {
#[allow(unused_mut)]
let mut object_108 = object.key("AnomalyDetectorConfig").start_object();
crate::json_ser::serialize_structure_crate_model_anomaly_detector_config(
&mut object_108,
var_107,
)?;
object_108.finish();
}
if let Some(var_109) = &input.anomaly_detector_description {
object
.key("AnomalyDetectorDescription")
.string(var_109.as_str());
}
if let Some(var_110) = &input.kms_key_arn {
object.key("KmsKeyArn").string(var_110.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_metric_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMetricSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.dimension_filter_list {
let mut array_112 = object.key("DimensionFilterList").start_array();
for item_113 in var_111 {
{
#[allow(unused_mut)]
let mut object_114 = array_112.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_set_dimension_filter(
&mut object_114,
item_113,
)?;
object_114.finish();
}
}
array_112.finish();
}
if let Some(var_115) = &input.dimension_list {
let mut array_116 = object.key("DimensionList").start_array();
for item_117 in var_115 {
{
array_116.value().string(item_117.as_str());
}
}
array_116.finish();
}
if let Some(var_118) = &input.metric_list {
let mut array_119 = object.key("MetricList").start_array();
for item_120 in var_118 {
{
#[allow(unused_mut)]
let mut object_121 = array_119.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric(&mut object_121, item_120)?;
object_121.finish();
}
}
array_119.finish();
}
if let Some(var_122) = &input.metric_set_arn {
object.key("MetricSetArn").string(var_122.as_str());
}
if let Some(var_123) = &input.metric_set_description {
object.key("MetricSetDescription").string(var_123.as_str());
}
if let Some(var_124) = &input.metric_set_frequency {
object.key("MetricSetFrequency").string(var_124.as_str());
}
if let Some(var_125) = &input.metric_source {
#[allow(unused_mut)]
let mut object_126 = object.key("MetricSource").start_object();
crate::json_ser::serialize_structure_crate_model_metric_source(&mut object_126, var_125)?;
object_126.finish();
}
if let Some(var_127) = &input.offset {
object.key("Offset").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_127).into()),
);
}
if let Some(var_128) = &input.timestamp_column {
#[allow(unused_mut)]
let mut object_129 = object.key("TimestampColumn").start_object();
crate::json_ser::serialize_structure_crate_model_timestamp_column(
&mut object_129,
var_128,
)?;
object_129.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Action,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.sns_configuration {
#[allow(unused_mut)]
let mut object_131 = object.key("SNSConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_sns_configuration(
&mut object_131,
var_130,
)?;
object_131.finish();
}
if let Some(var_132) = &input.lambda_configuration {
#[allow(unused_mut)]
let mut object_133 = object.key("LambdaConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_configuration(
&mut object_133,
var_132,
)?;
object_133.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_alert_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AlertFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.metric_list {
let mut array_135 = object.key("MetricList").start_array();
for item_136 in var_134 {
{
array_135.value().string(item_136.as_str());
}
}
array_135.finish();
}
if let Some(var_137) = &input.dimension_filter_list {
let mut array_138 = object.key("DimensionFilterList").start_array();
for item_139 in var_137 {
{
#[allow(unused_mut)]
let mut object_140 = array_138.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension_filter(
&mut object_140,
item_139,
)?;
object_140.finish();
}
}
array_138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_anomaly_detector_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnomalyDetectorConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.anomaly_detector_frequency {
object
.key("AnomalyDetectorFrequency")
.string(var_141.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_set_dimension_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricSetDimensionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.name {
object.key("Name").string(var_142.as_str());
}
if let Some(var_143) = &input.filter_list {
let mut array_144 = object.key("FilterList").start_array();
for item_145 in var_143 {
{
#[allow(unused_mut)]
let mut object_146 = array_144.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_146, item_145)?;
object_146.finish();
}
}
array_144.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_metric(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Metric,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.metric_name {
object.key("MetricName").string(var_147.as_str());
}
if let Some(var_148) = &input.aggregation_function {
object.key("AggregationFunction").string(var_148.as_str());
}
if let Some(var_149) = &input.namespace {
object.key("Namespace").string(var_149.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.s3_source_config {
#[allow(unused_mut)]
let mut object_151 = object.key("S3SourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_s3_source_config(
&mut object_151,
var_150,
)?;
object_151.finish();
}
if let Some(var_152) = &input.app_flow_config {
#[allow(unused_mut)]
let mut object_153 = object.key("AppFlowConfig").start_object();
crate::json_ser::serialize_structure_crate_model_app_flow_config(&mut object_153, var_152)?;
object_153.finish();
}
if let Some(var_154) = &input.cloud_watch_config {
#[allow(unused_mut)]
let mut object_155 = object.key("CloudWatchConfig").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_config(
&mut object_155,
var_154,
)?;
object_155.finish();
}
if let Some(var_156) = &input.rds_source_config {
#[allow(unused_mut)]
let mut object_157 = object.key("RDSSourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_rds_source_config(
&mut object_157,
var_156,
)?;
object_157.finish();
}
if let Some(var_158) = &input.redshift_source_config {
#[allow(unused_mut)]
let mut object_159 = object.key("RedshiftSourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_redshift_source_config(
&mut object_159,
var_158,
)?;
object_159.finish();
}
if let Some(var_160) = &input.athena_source_config {
#[allow(unused_mut)]
let mut object_161 = object.key("AthenaSourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_athena_source_config(
&mut object_161,
var_160,
)?;
object_161.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_timestamp_column(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimestampColumn,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.column_name {
object.key("ColumnName").string(var_162.as_str());
}
if let Some(var_163) = &input.column_format {
object.key("ColumnFormat").string(var_163.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_detection_metric_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoDetectionMetricSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.s3_source_config {
#[allow(unused_mut)]
let mut object_165 = object.key("S3SourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_auto_detection_s3_source_config(
&mut object_165,
var_164,
)?;
object_165.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_anomaly_group_time_series(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnomalyGroupTimeSeries,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.anomaly_group_id {
object.key("AnomalyGroupId").string(var_166.as_str());
}
if let Some(var_167) = &input.time_series_id {
object.key("TimeSeriesId").string(var_167.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sample_data_s3_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SampleDataS3SourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.role_arn {
object.key("RoleArn").string(var_168.as_str());
}
if let Some(var_169) = &input.templated_path_list {
let mut array_170 = object.key("TemplatedPathList").start_array();
for item_171 in var_169 {
{
array_170.value().string(item_171.as_str());
}
}
array_170.finish();
}
if let Some(var_172) = &input.historical_data_path_list {
let mut array_173 = object.key("HistoricalDataPathList").start_array();
for item_174 in var_172 {
{
array_173.value().string(item_174.as_str());
}
}
array_173.finish();
}
if let Some(var_175) = &input.file_format_descriptor {
#[allow(unused_mut)]
let mut object_176 = object.key("FileFormatDescriptor").start_object();
crate::json_ser::serialize_structure_crate_model_file_format_descriptor(
&mut object_176,
var_175,
)?;
object_176.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_anomaly_group_time_series_feedback(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnomalyGroupTimeSeriesFeedback,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_177) = &input.anomaly_group_id {
object.key("AnomalyGroupId").string(var_177.as_str());
}
if let Some(var_178) = &input.time_series_id {
object.key("TimeSeriesId").string(var_178.as_str());
}
if let Some(var_179) = &input.is_anomaly {
object.key("IsAnomaly").boolean(*var_179);
}
Ok(())
}
pub fn serialize_structure_crate_model_sns_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.role_arn {
object.key("RoleArn").string(var_180.as_str());
}
if let Some(var_181) = &input.sns_topic_arn {
object.key("SnsTopicArn").string(var_181.as_str());
}
if let Some(var_182) = &input.sns_format {
object.key("SnsFormat").string(var_182.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.role_arn {
object.key("RoleArn").string(var_183.as_str());
}
if let Some(var_184) = &input.lambda_arn {
object.key("LambdaArn").string(var_184.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dimension_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DimensionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_185) = &input.dimension_name {
object.key("DimensionName").string(var_185.as_str());
}
if let Some(var_186) = &input.dimension_value_list {
let mut array_187 = object.key("DimensionValueList").start_array();
for item_188 in var_186 {
{
array_187.value().string(item_188.as_str());
}
}
array_187.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.dimension_value {
object.key("DimensionValue").string(var_189.as_str());
}
if let Some(var_190) = &input.filter_operation {
object.key("FilterOperation").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3SourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.role_arn {
object.key("RoleArn").string(var_191.as_str());
}
if let Some(var_192) = &input.templated_path_list {
let mut array_193 = object.key("TemplatedPathList").start_array();
for item_194 in var_192 {
{
array_193.value().string(item_194.as_str());
}
}
array_193.finish();
}
if let Some(var_195) = &input.historical_data_path_list {
let mut array_196 = object.key("HistoricalDataPathList").start_array();
for item_197 in var_195 {
{
array_196.value().string(item_197.as_str());
}
}
array_196.finish();
}
if let Some(var_198) = &input.file_format_descriptor {
#[allow(unused_mut)]
let mut object_199 = object.key("FileFormatDescriptor").start_object();
crate::json_ser::serialize_structure_crate_model_file_format_descriptor(
&mut object_199,
var_198,
)?;
object_199.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_app_flow_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AppFlowConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.role_arn {
object.key("RoleArn").string(var_200.as_str());
}
if let Some(var_201) = &input.flow_name {
object.key("FlowName").string(var_201.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.role_arn {
object.key("RoleArn").string(var_202.as_str());
}
if let Some(var_203) = &input.back_test_configuration {
#[allow(unused_mut)]
let mut object_204 = object.key("BackTestConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_back_test_configuration(
&mut object_204,
var_203,
)?;
object_204.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rds_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RdsSourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_205) = &input.db_instance_identifier {
object.key("DBInstanceIdentifier").string(var_205.as_str());
}
if let Some(var_206) = &input.database_host {
object.key("DatabaseHost").string(var_206.as_str());
}
if let Some(var_207) = &input.database_port {
object.key("DatabasePort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_207).into()),
);
}
if let Some(var_208) = &input.secret_manager_arn {
object.key("SecretManagerArn").string(var_208.as_str());
}
if let Some(var_209) = &input.database_name {
object.key("DatabaseName").string(var_209.as_str());
}
if let Some(var_210) = &input.table_name {
object.key("TableName").string(var_210.as_str());
}
if let Some(var_211) = &input.role_arn {
object.key("RoleArn").string(var_211.as_str());
}
if let Some(var_212) = &input.vpc_configuration {
#[allow(unused_mut)]
let mut object_213 = object.key("VpcConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_configuration(
&mut object_213,
var_212,
)?;
object_213.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftSourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.cluster_identifier {
object.key("ClusterIdentifier").string(var_214.as_str());
}
if let Some(var_215) = &input.database_host {
object.key("DatabaseHost").string(var_215.as_str());
}
if let Some(var_216) = &input.database_port {
object.key("DatabasePort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_216).into()),
);
}
if let Some(var_217) = &input.secret_manager_arn {
object.key("SecretManagerArn").string(var_217.as_str());
}
if let Some(var_218) = &input.database_name {
object.key("DatabaseName").string(var_218.as_str());
}
if let Some(var_219) = &input.table_name {
object.key("TableName").string(var_219.as_str());
}
if let Some(var_220) = &input.role_arn {
object.key("RoleArn").string(var_220.as_str());
}
if let Some(var_221) = &input.vpc_configuration {
#[allow(unused_mut)]
let mut object_222 = object.key("VpcConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_configuration(
&mut object_222,
var_221,
)?;
object_222.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_athena_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AthenaSourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.role_arn {
object.key("RoleArn").string(var_223.as_str());
}
if let Some(var_224) = &input.database_name {
object.key("DatabaseName").string(var_224.as_str());
}
if let Some(var_225) = &input.data_catalog {
object.key("DataCatalog").string(var_225.as_str());
}
if let Some(var_226) = &input.table_name {
object.key("TableName").string(var_226.as_str());
}
if let Some(var_227) = &input.work_group_name {
object.key("WorkGroupName").string(var_227.as_str());
}
if let Some(var_228) = &input.s3_results_path {
object.key("S3ResultsPath").string(var_228.as_str());
}
if let Some(var_229) = &input.back_test_configuration {
#[allow(unused_mut)]
let mut object_230 = object.key("BackTestConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_back_test_configuration(
&mut object_230,
var_229,
)?;
object_230.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_detection_s3_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoDetectionS3SourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.templated_path_list {
let mut array_232 = object.key("TemplatedPathList").start_array();
for item_233 in var_231 {
{
array_232.value().string(item_233.as_str());
}
}
array_232.finish();
}
if let Some(var_234) = &input.historical_data_path_list {
let mut array_235 = object.key("HistoricalDataPathList").start_array();
for item_236 in var_234 {
{
array_235.value().string(item_236.as_str());
}
}
array_235.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_file_format_descriptor(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FileFormatDescriptor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_237) = &input.csv_format_descriptor {
#[allow(unused_mut)]
let mut object_238 = object.key("CsvFormatDescriptor").start_object();
crate::json_ser::serialize_structure_crate_model_csv_format_descriptor(
&mut object_238,
var_237,
)?;
object_238.finish();
}
if let Some(var_239) = &input.json_format_descriptor {
#[allow(unused_mut)]
let mut object_240 = object.key("JsonFormatDescriptor").start_object();
crate::json_ser::serialize_structure_crate_model_json_format_descriptor(
&mut object_240,
var_239,
)?;
object_240.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_back_test_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackTestConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_241) = &input.run_back_test_mode {
object.key("RunBackTestMode").boolean(*var_241);
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.subnet_id_list {
let mut array_243 = object.key("SubnetIdList").start_array();
for item_244 in var_242 {
{
array_243.value().string(item_244.as_str());
}
}
array_243.finish();
}
if let Some(var_245) = &input.security_group_id_list {
let mut array_246 = object.key("SecurityGroupIdList").start_array();
for item_247 in var_245 {
{
array_246.value().string(item_247.as_str());
}
}
array_246.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_csv_format_descriptor(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CsvFormatDescriptor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_248) = &input.file_compression {
object.key("FileCompression").string(var_248.as_str());
}
if let Some(var_249) = &input.charset {
object.key("Charset").string(var_249.as_str());
}
if let Some(var_250) = &input.contains_header {
object.key("ContainsHeader").boolean(*var_250);
}
if let Some(var_251) = &input.delimiter {
object.key("Delimiter").string(var_251.as_str());
}
if let Some(var_252) = &input.header_list {
let mut array_253 = object.key("HeaderList").start_array();
for item_254 in var_252 {
{
array_253.value().string(item_254.as_str());
}
}
array_253.finish();
}
if let Some(var_255) = &input.quote_symbol {
object.key("QuoteSymbol").string(var_255.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_json_format_descriptor(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JsonFormatDescriptor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_256) = &input.file_compression {
object.key("FileCompression").string(var_256.as_str());
}
if let Some(var_257) = &input.charset {
object.key("Charset").string(var_257.as_str());
}
Ok(())
}