pub fn serialize_structure_crate_input_create_auto_predictor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAutoPredictorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.predictor_name {
object.key("PredictorName").string(var_1.as_str());
}
if let Some(var_2) = &input.forecast_horizon {
object.key("ForecastHorizon").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2).into()),
);
}
if let Some(var_3) = &input.forecast_types {
let mut array_4 = object.key("ForecastTypes").start_array();
for item_5 in var_3 {
{
array_4.value().string(item_5.as_str());
}
}
array_4.finish();
}
if let Some(var_6) = &input.forecast_dimensions {
let mut array_7 = object.key("ForecastDimensions").start_array();
for item_8 in var_6 {
{
array_7.value().string(item_8.as_str());
}
}
array_7.finish();
}
if let Some(var_9) = &input.forecast_frequency {
object.key("ForecastFrequency").string(var_9.as_str());
}
if let Some(var_10) = &input.data_config {
#[allow(unused_mut)]
let mut object_11 = object.key("DataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_data_config(&mut object_11, var_10)?;
object_11.finish();
}
if let Some(var_12) = &input.encryption_config {
#[allow(unused_mut)]
let mut object_13 = object.key("EncryptionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_config(&mut object_13, var_12)?;
object_13.finish();
}
if let Some(var_14) = &input.reference_predictor_arn {
object.key("ReferencePredictorArn").string(var_14.as_str());
}
if let Some(var_15) = &input.optimization_metric {
object.key("OptimizationMetric").string(var_15.as_str());
}
if let Some(var_16) = &input.explain_predictor {
object.key("ExplainPredictor").boolean(*var_16);
}
if let Some(var_17) = &input.tags {
let mut array_18 = object.key("Tags").start_array();
for item_19 in var_17 {
{
#[allow(unused_mut)]
let mut object_20 = array_18.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_20, item_19)?;
object_20.finish();
}
}
array_18.finish();
}
if let Some(var_21) = &input.monitor_config {
#[allow(unused_mut)]
let mut object_22 = object.key("MonitorConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitor_config(&mut object_22, var_21)?;
object_22.finish();
}
if let Some(var_23) = &input.time_alignment_boundary {
#[allow(unused_mut)]
let mut object_24 = object.key("TimeAlignmentBoundary").start_object();
crate::json_ser::serialize_structure_crate_model_time_alignment_boundary(
&mut object_24,
var_23,
)?;
object_24.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dataset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatasetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.dataset_name {
object.key("DatasetName").string(var_25.as_str());
}
if let Some(var_26) = &input.domain {
object.key("Domain").string(var_26.as_str());
}
if let Some(var_27) = &input.dataset_type {
object.key("DatasetType").string(var_27.as_str());
}
if let Some(var_28) = &input.data_frequency {
object.key("DataFrequency").string(var_28.as_str());
}
if let Some(var_29) = &input.schema {
#[allow(unused_mut)]
let mut object_30 = object.key("Schema").start_object();
crate::json_ser::serialize_structure_crate_model_schema(&mut object_30, var_29)?;
object_30.finish();
}
if let Some(var_31) = &input.encryption_config {
#[allow(unused_mut)]
let mut object_32 = object.key("EncryptionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_config(&mut object_32, var_31)?;
object_32.finish();
}
if let Some(var_33) = &input.tags {
let mut array_34 = object.key("Tags").start_array();
for item_35 in var_33 {
{
#[allow(unused_mut)]
let mut object_36 = array_34.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_36, item_35)?;
object_36.finish();
}
}
array_34.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dataset_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatasetGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.dataset_group_name {
object.key("DatasetGroupName").string(var_37.as_str());
}
if let Some(var_38) = &input.domain {
object.key("Domain").string(var_38.as_str());
}
if let Some(var_39) = &input.dataset_arns {
let mut array_40 = object.key("DatasetArns").start_array();
for item_41 in var_39 {
{
array_40.value().string(item_41.as_str());
}
}
array_40.finish();
}
if let Some(var_42) = &input.tags {
let mut array_43 = object.key("Tags").start_array();
for item_44 in var_42 {
{
#[allow(unused_mut)]
let mut object_45 = array_43.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_45, item_44)?;
object_45.finish();
}
}
array_43.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dataset_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatasetImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.dataset_import_job_name {
object.key("DatasetImportJobName").string(var_46.as_str());
}
if let Some(var_47) = &input.dataset_arn {
object.key("DatasetArn").string(var_47.as_str());
}
if let Some(var_48) = &input.data_source {
#[allow(unused_mut)]
let mut object_49 = object.key("DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_data_source(&mut object_49, var_48)?;
object_49.finish();
}
if let Some(var_50) = &input.timestamp_format {
object.key("TimestampFormat").string(var_50.as_str());
}
if let Some(var_51) = &input.time_zone {
object.key("TimeZone").string(var_51.as_str());
}
if input.use_geolocation_for_time_zone {
object
.key("UseGeolocationForTimeZone")
.boolean(input.use_geolocation_for_time_zone);
}
if let Some(var_52) = &input.geolocation_format {
object.key("GeolocationFormat").string(var_52.as_str());
}
if let Some(var_53) = &input.tags {
let mut array_54 = object.key("Tags").start_array();
for item_55 in var_53 {
{
#[allow(unused_mut)]
let mut object_56 = array_54.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_56, item_55)?;
object_56.finish();
}
}
array_54.finish();
}
if let Some(var_57) = &input.format {
object.key("Format").string(var_57.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_explainability_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateExplainabilityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.explainability_name {
object.key("ExplainabilityName").string(var_58.as_str());
}
if let Some(var_59) = &input.resource_arn {
object.key("ResourceArn").string(var_59.as_str());
}
if let Some(var_60) = &input.explainability_config {
#[allow(unused_mut)]
let mut object_61 = object.key("ExplainabilityConfig").start_object();
crate::json_ser::serialize_structure_crate_model_explainability_config(
&mut object_61,
var_60,
)?;
object_61.finish();
}
if let Some(var_62) = &input.data_source {
#[allow(unused_mut)]
let mut object_63 = object.key("DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_data_source(&mut object_63, var_62)?;
object_63.finish();
}
if let Some(var_64) = &input.schema {
#[allow(unused_mut)]
let mut object_65 = object.key("Schema").start_object();
crate::json_ser::serialize_structure_crate_model_schema(&mut object_65, var_64)?;
object_65.finish();
}
if let Some(var_66) = &input.enable_visualization {
object.key("EnableVisualization").boolean(*var_66);
}
if let Some(var_67) = &input.start_date_time {
object.key("StartDateTime").string(var_67.as_str());
}
if let Some(var_68) = &input.end_date_time {
object.key("EndDateTime").string(var_68.as_str());
}
if let Some(var_69) = &input.tags {
let mut array_70 = object.key("Tags").start_array();
for item_71 in var_69 {
{
#[allow(unused_mut)]
let mut object_72 = array_70.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_72, item_71)?;
object_72.finish();
}
}
array_70.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_explainability_export_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateExplainabilityExportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.explainability_export_name {
object
.key("ExplainabilityExportName")
.string(var_73.as_str());
}
if let Some(var_74) = &input.explainability_arn {
object.key("ExplainabilityArn").string(var_74.as_str());
}
if let Some(var_75) = &input.destination {
#[allow(unused_mut)]
let mut object_76 = object.key("Destination").start_object();
crate::json_ser::serialize_structure_crate_model_data_destination(&mut object_76, var_75)?;
object_76.finish();
}
if let Some(var_77) = &input.tags {
let mut array_78 = object.key("Tags").start_array();
for item_79 in var_77 {
{
#[allow(unused_mut)]
let mut object_80 = array_78.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_80, item_79)?;
object_80.finish();
}
}
array_78.finish();
}
if let Some(var_81) = &input.format {
object.key("Format").string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_forecast_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateForecastInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.forecast_name {
object.key("ForecastName").string(var_82.as_str());
}
if let Some(var_83) = &input.predictor_arn {
object.key("PredictorArn").string(var_83.as_str());
}
if let Some(var_84) = &input.forecast_types {
let mut array_85 = object.key("ForecastTypes").start_array();
for item_86 in var_84 {
{
array_85.value().string(item_86.as_str());
}
}
array_85.finish();
}
if let Some(var_87) = &input.tags {
let mut array_88 = object.key("Tags").start_array();
for item_89 in var_87 {
{
#[allow(unused_mut)]
let mut object_90 = array_88.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_90, item_89)?;
object_90.finish();
}
}
array_88.finish();
}
if let Some(var_91) = &input.time_series_selector {
#[allow(unused_mut)]
let mut object_92 = object.key("TimeSeriesSelector").start_object();
crate::json_ser::serialize_structure_crate_model_time_series_selector(
&mut object_92,
var_91,
)?;
object_92.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_forecast_export_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateForecastExportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.forecast_export_job_name {
object.key("ForecastExportJobName").string(var_93.as_str());
}
if let Some(var_94) = &input.forecast_arn {
object.key("ForecastArn").string(var_94.as_str());
}
if let Some(var_95) = &input.destination {
#[allow(unused_mut)]
let mut object_96 = object.key("Destination").start_object();
crate::json_ser::serialize_structure_crate_model_data_destination(&mut object_96, var_95)?;
object_96.finish();
}
if let Some(var_97) = &input.tags {
let mut array_98 = object.key("Tags").start_array();
for item_99 in var_97 {
{
#[allow(unused_mut)]
let mut object_100 = array_98.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_100, item_99)?;
object_100.finish();
}
}
array_98.finish();
}
if let Some(var_101) = &input.format {
object.key("Format").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_monitor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMonitorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.monitor_name {
object.key("MonitorName").string(var_102.as_str());
}
if let Some(var_103) = &input.resource_arn {
object.key("ResourceArn").string(var_103.as_str());
}
if let Some(var_104) = &input.tags {
let mut array_105 = object.key("Tags").start_array();
for item_106 in var_104 {
{
#[allow(unused_mut)]
let mut object_107 = array_105.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_107, item_106)?;
object_107.finish();
}
}
array_105.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_predictor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePredictorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.predictor_name {
object.key("PredictorName").string(var_108.as_str());
}
if let Some(var_109) = &input.algorithm_arn {
object.key("AlgorithmArn").string(var_109.as_str());
}
if let Some(var_110) = &input.forecast_horizon {
object.key("ForecastHorizon").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_110).into()),
);
}
if let Some(var_111) = &input.forecast_types {
let mut array_112 = object.key("ForecastTypes").start_array();
for item_113 in var_111 {
{
array_112.value().string(item_113.as_str());
}
}
array_112.finish();
}
if let Some(var_114) = &input.perform_auto_ml {
object.key("PerformAutoML").boolean(*var_114);
}
if let Some(var_115) = &input.auto_ml_override_strategy {
object
.key("AutoMLOverrideStrategy")
.string(var_115.as_str());
}
if let Some(var_116) = &input.perform_hpo {
object.key("PerformHPO").boolean(*var_116);
}
if let Some(var_117) = &input.training_parameters {
#[allow(unused_mut)]
let mut object_118 = object.key("TrainingParameters").start_object();
for (key_119, value_120) in var_117 {
{
object_118.key(key_119.as_str()).string(value_120.as_str());
}
}
object_118.finish();
}
if let Some(var_121) = &input.evaluation_parameters {
#[allow(unused_mut)]
let mut object_122 = object.key("EvaluationParameters").start_object();
crate::json_ser::serialize_structure_crate_model_evaluation_parameters(
&mut object_122,
var_121,
)?;
object_122.finish();
}
if let Some(var_123) = &input.hpo_config {
#[allow(unused_mut)]
let mut object_124 = object.key("HPOConfig").start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_tuning_job_config(
&mut object_124,
var_123,
)?;
object_124.finish();
}
if let Some(var_125) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_126 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_data_config(
&mut object_126,
var_125,
)?;
object_126.finish();
}
if let Some(var_127) = &input.featurization_config {
#[allow(unused_mut)]
let mut object_128 = object.key("FeaturizationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_featurization_config(
&mut object_128,
var_127,
)?;
object_128.finish();
}
if let Some(var_129) = &input.encryption_config {
#[allow(unused_mut)]
let mut object_130 = object.key("EncryptionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_config(
&mut object_130,
var_129,
)?;
object_130.finish();
}
if let Some(var_131) = &input.tags {
let mut array_132 = object.key("Tags").start_array();
for item_133 in var_131 {
{
#[allow(unused_mut)]
let mut object_134 = array_132.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_134, item_133)?;
object_134.finish();
}
}
array_132.finish();
}
if let Some(var_135) = &input.optimization_metric {
object.key("OptimizationMetric").string(var_135.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_predictor_backtest_export_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePredictorBacktestExportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.predictor_backtest_export_job_name {
object
.key("PredictorBacktestExportJobName")
.string(var_136.as_str());
}
if let Some(var_137) = &input.predictor_arn {
object.key("PredictorArn").string(var_137.as_str());
}
if let Some(var_138) = &input.destination {
#[allow(unused_mut)]
let mut object_139 = object.key("Destination").start_object();
crate::json_ser::serialize_structure_crate_model_data_destination(
&mut object_139,
var_138,
)?;
object_139.finish();
}
if let Some(var_140) = &input.tags {
let mut array_141 = object.key("Tags").start_array();
for item_142 in var_140 {
{
#[allow(unused_mut)]
let mut object_143 = array_141.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_143, item_142)?;
object_143.finish();
}
}
array_141.finish();
}
if let Some(var_144) = &input.format {
object.key("Format").string(var_144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_what_if_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWhatIfAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.what_if_analysis_name {
object.key("WhatIfAnalysisName").string(var_145.as_str());
}
if let Some(var_146) = &input.forecast_arn {
object.key("ForecastArn").string(var_146.as_str());
}
if let Some(var_147) = &input.time_series_selector {
#[allow(unused_mut)]
let mut object_148 = object.key("TimeSeriesSelector").start_object();
crate::json_ser::serialize_structure_crate_model_time_series_selector(
&mut object_148,
var_147,
)?;
object_148.finish();
}
if let Some(var_149) = &input.tags {
let mut array_150 = object.key("Tags").start_array();
for item_151 in var_149 {
{
#[allow(unused_mut)]
let mut object_152 = array_150.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_152, item_151)?;
object_152.finish();
}
}
array_150.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_what_if_forecast_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWhatIfForecastInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_153) = &input.what_if_forecast_name {
object.key("WhatIfForecastName").string(var_153.as_str());
}
if let Some(var_154) = &input.what_if_analysis_arn {
object.key("WhatIfAnalysisArn").string(var_154.as_str());
}
if let Some(var_155) = &input.time_series_transformations {
let mut array_156 = object.key("TimeSeriesTransformations").start_array();
for item_157 in var_155 {
{
#[allow(unused_mut)]
let mut object_158 = array_156.value().start_object();
crate::json_ser::serialize_structure_crate_model_time_series_transformation(
&mut object_158,
item_157,
)?;
object_158.finish();
}
}
array_156.finish();
}
if let Some(var_159) = &input.time_series_replacements_data_source {
#[allow(unused_mut)]
let mut object_160 = object
.key("TimeSeriesReplacementsDataSource")
.start_object();
crate::json_ser::serialize_structure_crate_model_time_series_replacements_data_source(
&mut object_160,
var_159,
)?;
object_160.finish();
}
if let Some(var_161) = &input.tags {
let mut array_162 = object.key("Tags").start_array();
for item_163 in var_161 {
{
#[allow(unused_mut)]
let mut object_164 = array_162.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_164, item_163)?;
object_164.finish();
}
}
array_162.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_what_if_forecast_export_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWhatIfForecastExportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.what_if_forecast_export_name {
object
.key("WhatIfForecastExportName")
.string(var_165.as_str());
}
if let Some(var_166) = &input.what_if_forecast_arns {
let mut array_167 = object.key("WhatIfForecastArns").start_array();
for item_168 in var_166 {
{
array_167.value().string(item_168.as_str());
}
}
array_167.finish();
}
if let Some(var_169) = &input.destination {
#[allow(unused_mut)]
let mut object_170 = object.key("Destination").start_object();
crate::json_ser::serialize_structure_crate_model_data_destination(
&mut object_170,
var_169,
)?;
object_170.finish();
}
if let Some(var_171) = &input.tags {
let mut array_172 = object.key("Tags").start_array();
for item_173 in var_171 {
{
#[allow(unused_mut)]
let mut object_174 = array_172.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_174, item_173)?;
object_174.finish();
}
}
array_172.finish();
}
if let Some(var_175) = &input.format {
object.key("Format").string(var_175.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_dataset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDatasetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.dataset_arn {
object.key("DatasetArn").string(var_176.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_dataset_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDatasetGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_177) = &input.dataset_group_arn {
object.key("DatasetGroupArn").string(var_177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_dataset_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDatasetImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.dataset_import_job_arn {
object.key("DatasetImportJobArn").string(var_178.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_explainability_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteExplainabilityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.explainability_arn {
object.key("ExplainabilityArn").string(var_179.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_explainability_export_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteExplainabilityExportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.explainability_export_arn {
object
.key("ExplainabilityExportArn")
.string(var_180.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_forecast_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteForecastInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_181) = &input.forecast_arn {
object.key("ForecastArn").string(var_181.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_forecast_export_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteForecastExportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.forecast_export_job_arn {
object.key("ForecastExportJobArn").string(var_182.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_monitor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteMonitorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.monitor_arn {
object.key("MonitorArn").string(var_183.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_predictor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePredictorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.predictor_arn {
object.key("PredictorArn").string(var_184.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_predictor_backtest_export_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePredictorBacktestExportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_185) = &input.predictor_backtest_export_job_arn {
object
.key("PredictorBacktestExportJobArn")
.string(var_185.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resource_tree_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResourceTreeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.resource_arn {
object.key("ResourceArn").string(var_186.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_what_if_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteWhatIfAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.what_if_analysis_arn {
object.key("WhatIfAnalysisArn").string(var_187.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_what_if_forecast_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteWhatIfForecastInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_188) = &input.what_if_forecast_arn {
object.key("WhatIfForecastArn").string(var_188.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_what_if_forecast_export_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteWhatIfForecastExportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.what_if_forecast_export_arn {
object
.key("WhatIfForecastExportArn")
.string(var_189.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_auto_predictor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAutoPredictorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.predictor_arn {
object.key("PredictorArn").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_dataset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDatasetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.dataset_arn {
object.key("DatasetArn").string(var_191.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_dataset_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDatasetGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_192) = &input.dataset_group_arn {
object.key("DatasetGroupArn").string(var_192.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_dataset_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDatasetImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.dataset_import_job_arn {
object.key("DatasetImportJobArn").string(var_193.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_explainability_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeExplainabilityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_194) = &input.explainability_arn {
object.key("ExplainabilityArn").string(var_194.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_explainability_export_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeExplainabilityExportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.explainability_export_arn {
object
.key("ExplainabilityExportArn")
.string(var_195.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_forecast_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeForecastInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.forecast_arn {
object.key("ForecastArn").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_forecast_export_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeForecastExportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.forecast_export_job_arn {
object.key("ForecastExportJobArn").string(var_197.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_monitor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeMonitorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_198) = &input.monitor_arn {
object.key("MonitorArn").string(var_198.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_predictor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePredictorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.predictor_arn {
object.key("PredictorArn").string(var_199.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_predictor_backtest_export_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePredictorBacktestExportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.predictor_backtest_export_job_arn {
object
.key("PredictorBacktestExportJobArn")
.string(var_200.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_what_if_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWhatIfAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.what_if_analysis_arn {
object.key("WhatIfAnalysisArn").string(var_201.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_what_if_forecast_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWhatIfForecastInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.what_if_forecast_arn {
object.key("WhatIfForecastArn").string(var_202.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_what_if_forecast_export_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWhatIfForecastExportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.what_if_forecast_export_arn {
object
.key("WhatIfForecastExportArn")
.string(var_203.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_accuracy_metrics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAccuracyMetricsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.predictor_arn {
object.key("PredictorArn").string(var_204.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_dataset_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDatasetGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_205) = &input.next_token {
object.key("NextToken").string(var_205.as_str());
}
if let Some(var_206) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_206).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_dataset_import_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDatasetImportJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.next_token {
object.key("NextToken").string(var_207.as_str());
}
if let Some(var_208) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_208).into()),
);
}
if let Some(var_209) = &input.filters {
let mut array_210 = object.key("Filters").start_array();
for item_211 in var_209 {
{
#[allow(unused_mut)]
let mut object_212 = array_210.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_212, item_211)?;
object_212.finish();
}
}
array_210.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_datasets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDatasetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_213) = &input.next_token {
object.key("NextToken").string(var_213.as_str());
}
if let Some(var_214) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_214).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_explainabilities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListExplainabilitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.next_token {
object.key("NextToken").string(var_215.as_str());
}
if let Some(var_216) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_216).into()),
);
}
if let Some(var_217) = &input.filters {
let mut array_218 = object.key("Filters").start_array();
for item_219 in var_217 {
{
#[allow(unused_mut)]
let mut object_220 = array_218.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_220, item_219)?;
object_220.finish();
}
}
array_218.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_explainability_exports_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListExplainabilityExportsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_221) = &input.next_token {
object.key("NextToken").string(var_221.as_str());
}
if let Some(var_222) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_222).into()),
);
}
if let Some(var_223) = &input.filters {
let mut array_224 = object.key("Filters").start_array();
for item_225 in var_223 {
{
#[allow(unused_mut)]
let mut object_226 = array_224.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_226, item_225)?;
object_226.finish();
}
}
array_224.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_forecast_export_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListForecastExportJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_227) = &input.next_token {
object.key("NextToken").string(var_227.as_str());
}
if let Some(var_228) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_228).into()),
);
}
if let Some(var_229) = &input.filters {
let mut array_230 = object.key("Filters").start_array();
for item_231 in var_229 {
{
#[allow(unused_mut)]
let mut object_232 = array_230.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_232, item_231)?;
object_232.finish();
}
}
array_230.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_forecasts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListForecastsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_233) = &input.next_token {
object.key("NextToken").string(var_233.as_str());
}
if let Some(var_234) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_234).into()),
);
}
if let Some(var_235) = &input.filters {
let mut array_236 = object.key("Filters").start_array();
for item_237 in var_235 {
{
#[allow(unused_mut)]
let mut object_238 = array_236.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_238, item_237)?;
object_238.finish();
}
}
array_236.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_monitor_evaluations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMonitorEvaluationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.next_token {
object.key("NextToken").string(var_239.as_str());
}
if let Some(var_240) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_240).into()),
);
}
if let Some(var_241) = &input.monitor_arn {
object.key("MonitorArn").string(var_241.as_str());
}
if let Some(var_242) = &input.filters {
let mut array_243 = object.key("Filters").start_array();
for item_244 in var_242 {
{
#[allow(unused_mut)]
let mut object_245 = array_243.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_245, item_244)?;
object_245.finish();
}
}
array_243.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_monitors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMonitorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_246) = &input.next_token {
object.key("NextToken").string(var_246.as_str());
}
if let Some(var_247) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_247).into()),
);
}
if let Some(var_248) = &input.filters {
let mut array_249 = object.key("Filters").start_array();
for item_250 in var_248 {
{
#[allow(unused_mut)]
let mut object_251 = array_249.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_251, item_250)?;
object_251.finish();
}
}
array_249.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_predictor_backtest_export_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPredictorBacktestExportJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.next_token {
object.key("NextToken").string(var_252.as_str());
}
if let Some(var_253) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_253).into()),
);
}
if let Some(var_254) = &input.filters {
let mut array_255 = object.key("Filters").start_array();
for item_256 in var_254 {
{
#[allow(unused_mut)]
let mut object_257 = array_255.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_257, item_256)?;
object_257.finish();
}
}
array_255.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_predictors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPredictorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_258) = &input.next_token {
object.key("NextToken").string(var_258.as_str());
}
if let Some(var_259) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_259).into()),
);
}
if let Some(var_260) = &input.filters {
let mut array_261 = object.key("Filters").start_array();
for item_262 in var_260 {
{
#[allow(unused_mut)]
let mut object_263 = array_261.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_263, item_262)?;
object_263.finish();
}
}
array_261.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_264) = &input.resource_arn {
object.key("ResourceArn").string(var_264.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_what_if_analyses_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListWhatIfAnalysesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_265) = &input.next_token {
object.key("NextToken").string(var_265.as_str());
}
if let Some(var_266) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_266).into()),
);
}
if let Some(var_267) = &input.filters {
let mut array_268 = object.key("Filters").start_array();
for item_269 in var_267 {
{
#[allow(unused_mut)]
let mut object_270 = array_268.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_270, item_269)?;
object_270.finish();
}
}
array_268.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_what_if_forecast_exports_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListWhatIfForecastExportsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_271) = &input.next_token {
object.key("NextToken").string(var_271.as_str());
}
if let Some(var_272) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_272).into()),
);
}
if let Some(var_273) = &input.filters {
let mut array_274 = object.key("Filters").start_array();
for item_275 in var_273 {
{
#[allow(unused_mut)]
let mut object_276 = array_274.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_276, item_275)?;
object_276.finish();
}
}
array_274.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_what_if_forecasts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListWhatIfForecastsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_277) = &input.next_token {
object.key("NextToken").string(var_277.as_str());
}
if let Some(var_278) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_278).into()),
);
}
if let Some(var_279) = &input.filters {
let mut array_280 = object.key("Filters").start_array();
for item_281 in var_279 {
{
#[allow(unused_mut)]
let mut object_282 = array_280.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_282, item_281)?;
object_282.finish();
}
}
array_280.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_resume_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResumeResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.resource_arn {
object.key("ResourceArn").string(var_283.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_284) = &input.resource_arn {
object.key("ResourceArn").string(var_284.as_str());
}
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_285) = &input.resource_arn {
object.key("ResourceArn").string(var_285.as_str());
}
if let Some(var_286) = &input.tags {
let mut array_287 = object.key("Tags").start_array();
for item_288 in var_286 {
{
#[allow(unused_mut)]
let mut object_289 = array_287.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_289, item_288)?;
object_289.finish();
}
}
array_287.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_290) = &input.resource_arn {
object.key("ResourceArn").string(var_290.as_str());
}
if let Some(var_291) = &input.tag_keys {
let mut array_292 = object.key("TagKeys").start_array();
for item_293 in var_291 {
{
array_292.value().string(item_293.as_str());
}
}
array_292.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_dataset_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDatasetGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_294) = &input.dataset_group_arn {
object.key("DatasetGroupArn").string(var_294.as_str());
}
if let Some(var_295) = &input.dataset_arns {
let mut array_296 = object.key("DatasetArns").start_array();
for item_297 in var_295 {
{
array_296.value().string(item_297.as_str());
}
}
array_296.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_298) = &input.dataset_group_arn {
object.key("DatasetGroupArn").string(var_298.as_str());
}
if let Some(var_299) = &input.attribute_configs {
let mut array_300 = object.key("AttributeConfigs").start_array();
for item_301 in var_299 {
{
#[allow(unused_mut)]
let mut object_302 = array_300.value().start_object();
crate::json_ser::serialize_structure_crate_model_attribute_config(
&mut object_302,
item_301,
)?;
object_302.finish();
}
}
array_300.finish();
}
if let Some(var_303) = &input.additional_datasets {
let mut array_304 = object.key("AdditionalDatasets").start_array();
for item_305 in var_303 {
{
#[allow(unused_mut)]
let mut object_306 = array_304.value().start_object();
crate::json_ser::serialize_structure_crate_model_additional_dataset(
&mut object_306,
item_305,
)?;
object_306.finish();
}
}
array_304.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncryptionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_307) = &input.role_arn {
object.key("RoleArn").string(var_307.as_str());
}
if let Some(var_308) = &input.kms_key_arn {
object.key("KMSKeyArn").string(var_308.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_309) = &input.key {
object.key("Key").string(var_309.as_str());
}
if let Some(var_310) = &input.value {
object.key("Value").string(var_310.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_monitor_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitorConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_311) = &input.monitor_name {
object.key("MonitorName").string(var_311.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_time_alignment_boundary(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeAlignmentBoundary,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_312) = &input.month {
object.key("Month").string(var_312.as_str());
}
if let Some(var_313) = &input.day_of_month {
object.key("DayOfMonth").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_313).into()),
);
}
if let Some(var_314) = &input.day_of_week {
object.key("DayOfWeek").string(var_314.as_str());
}
if let Some(var_315) = &input.hour {
object.key("Hour").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_315).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_schema(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Schema,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_316) = &input.attributes {
let mut array_317 = object.key("Attributes").start_array();
for item_318 in var_316 {
{
#[allow(unused_mut)]
let mut object_319 = array_317.value().start_object();
crate::json_ser::serialize_structure_crate_model_schema_attribute(
&mut object_319,
item_318,
)?;
object_319.finish();
}
}
array_317.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_320) = &input.s3_config {
#[allow(unused_mut)]
let mut object_321 = object.key("S3Config").start_object();
crate::json_ser::serialize_structure_crate_model_s3_config(&mut object_321, var_320)?;
object_321.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_explainability_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExplainabilityConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_322) = &input.time_series_granularity {
object.key("TimeSeriesGranularity").string(var_322.as_str());
}
if let Some(var_323) = &input.time_point_granularity {
object.key("TimePointGranularity").string(var_323.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_324) = &input.s3_config {
#[allow(unused_mut)]
let mut object_325 = object.key("S3Config").start_object();
crate::json_ser::serialize_structure_crate_model_s3_config(&mut object_325, var_324)?;
object_325.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_time_series_selector(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeSeriesSelector,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_326) = &input.time_series_identifiers {
#[allow(unused_mut)]
let mut object_327 = object.key("TimeSeriesIdentifiers").start_object();
crate::json_ser::serialize_structure_crate_model_time_series_identifiers(
&mut object_327,
var_326,
)?;
object_327.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_evaluation_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EvaluationParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_328) = &input.number_of_backtest_windows {
object.key("NumberOfBacktestWindows").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_328).into()),
);
}
if let Some(var_329) = &input.back_test_window_offset {
object.key("BackTestWindowOffset").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_329).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_hyper_parameter_tuning_job_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperParameterTuningJobConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_330) = &input.parameter_ranges {
#[allow(unused_mut)]
let mut object_331 = object.key("ParameterRanges").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_ranges(
&mut object_331,
var_330,
)?;
object_331.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_input_data_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputDataConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_332) = &input.dataset_group_arn {
object.key("DatasetGroupArn").string(var_332.as_str());
}
if let Some(var_333) = &input.supplementary_features {
let mut array_334 = object.key("SupplementaryFeatures").start_array();
for item_335 in var_333 {
{
#[allow(unused_mut)]
let mut object_336 = array_334.value().start_object();
crate::json_ser::serialize_structure_crate_model_supplementary_feature(
&mut object_336,
item_335,
)?;
object_336.finish();
}
}
array_334.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_featurization_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FeaturizationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_337) = &input.forecast_frequency {
object.key("ForecastFrequency").string(var_337.as_str());
}
if let Some(var_338) = &input.forecast_dimensions {
let mut array_339 = object.key("ForecastDimensions").start_array();
for item_340 in var_338 {
{
array_339.value().string(item_340.as_str());
}
}
array_339.finish();
}
if let Some(var_341) = &input.featurizations {
let mut array_342 = object.key("Featurizations").start_array();
for item_343 in var_341 {
{
#[allow(unused_mut)]
let mut object_344 = array_342.value().start_object();
crate::json_ser::serialize_structure_crate_model_featurization(
&mut object_344,
item_343,
)?;
object_344.finish();
}
}
array_342.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_time_series_transformation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeSeriesTransformation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_345) = &input.action {
#[allow(unused_mut)]
let mut object_346 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_action(&mut object_346, var_345)?;
object_346.finish();
}
if let Some(var_347) = &input.time_series_conditions {
let mut array_348 = object.key("TimeSeriesConditions").start_array();
for item_349 in var_347 {
{
#[allow(unused_mut)]
let mut object_350 = array_348.value().start_object();
crate::json_ser::serialize_structure_crate_model_time_series_condition(
&mut object_350,
item_349,
)?;
object_350.finish();
}
}
array_348.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_time_series_replacements_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeSeriesReplacementsDataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_351) = &input.s3_config {
#[allow(unused_mut)]
let mut object_352 = object.key("S3Config").start_object();
crate::json_ser::serialize_structure_crate_model_s3_config(&mut object_352, var_351)?;
object_352.finish();
}
if let Some(var_353) = &input.schema {
#[allow(unused_mut)]
let mut object_354 = object.key("Schema").start_object();
crate::json_ser::serialize_structure_crate_model_schema(&mut object_354, var_353)?;
object_354.finish();
}
if let Some(var_355) = &input.format {
object.key("Format").string(var_355.as_str());
}
if let Some(var_356) = &input.timestamp_format {
object.key("TimestampFormat").string(var_356.as_str());
}
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_357) = &input.key {
object.key("Key").string(var_357.as_str());
}
if let Some(var_358) = &input.value {
object.key("Value").string(var_358.as_str());
}
if let Some(var_359) = &input.condition {
object.key("Condition").string(var_359.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_attribute_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AttributeConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_360) = &input.attribute_name {
object.key("AttributeName").string(var_360.as_str());
}
if let Some(var_361) = &input.transformations {
#[allow(unused_mut)]
let mut object_362 = object.key("Transformations").start_object();
for (key_363, value_364) in var_361 {
{
object_362.key(key_363.as_str()).string(value_364.as_str());
}
}
object_362.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_additional_dataset(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdditionalDataset,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_365) = &input.name {
object.key("Name").string(var_365.as_str());
}
if let Some(var_366) = &input.configuration {
#[allow(unused_mut)]
let mut object_367 = object.key("Configuration").start_object();
for (key_368, value_369) in var_366 {
{
let mut array_370 = object_367.key(key_368.as_str()).start_array();
for item_371 in value_369 {
{
array_370.value().string(item_371.as_str());
}
}
array_370.finish();
}
}
object_367.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_schema_attribute(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SchemaAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_372) = &input.attribute_name {
object.key("AttributeName").string(var_372.as_str());
}
if let Some(var_373) = &input.attribute_type {
object.key("AttributeType").string(var_373.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Config,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_374) = &input.path {
object.key("Path").string(var_374.as_str());
}
if let Some(var_375) = &input.role_arn {
object.key("RoleArn").string(var_375.as_str());
}
if let Some(var_376) = &input.kms_key_arn {
object.key("KMSKeyArn").string(var_376.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_time_series_identifiers(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeSeriesIdentifiers,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_377) = &input.data_source {
#[allow(unused_mut)]
let mut object_378 = object.key("DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_data_source(&mut object_378, var_377)?;
object_378.finish();
}
if let Some(var_379) = &input.schema {
#[allow(unused_mut)]
let mut object_380 = object.key("Schema").start_object();
crate::json_ser::serialize_structure_crate_model_schema(&mut object_380, var_379)?;
object_380.finish();
}
if let Some(var_381) = &input.format {
object.key("Format").string(var_381.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_ranges(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterRanges,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_382) = &input.categorical_parameter_ranges {
let mut array_383 = object.key("CategoricalParameterRanges").start_array();
for item_384 in var_382 {
{
#[allow(unused_mut)]
let mut object_385 = array_383.value().start_object();
crate::json_ser::serialize_structure_crate_model_categorical_parameter_range(
&mut object_385,
item_384,
)?;
object_385.finish();
}
}
array_383.finish();
}
if let Some(var_386) = &input.continuous_parameter_ranges {
let mut array_387 = object.key("ContinuousParameterRanges").start_array();
for item_388 in var_386 {
{
#[allow(unused_mut)]
let mut object_389 = array_387.value().start_object();
crate::json_ser::serialize_structure_crate_model_continuous_parameter_range(
&mut object_389,
item_388,
)?;
object_389.finish();
}
}
array_387.finish();
}
if let Some(var_390) = &input.integer_parameter_ranges {
let mut array_391 = object.key("IntegerParameterRanges").start_array();
for item_392 in var_390 {
{
#[allow(unused_mut)]
let mut object_393 = array_391.value().start_object();
crate::json_ser::serialize_structure_crate_model_integer_parameter_range(
&mut object_393,
item_392,
)?;
object_393.finish();
}
}
array_391.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_supplementary_feature(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SupplementaryFeature,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_394) = &input.name {
object.key("Name").string(var_394.as_str());
}
if let Some(var_395) = &input.value {
object.key("Value").string(var_395.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_featurization(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Featurization,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_396) = &input.attribute_name {
object.key("AttributeName").string(var_396.as_str());
}
if let Some(var_397) = &input.featurization_pipeline {
let mut array_398 = object.key("FeaturizationPipeline").start_array();
for item_399 in var_397 {
{
#[allow(unused_mut)]
let mut object_400 = array_398.value().start_object();
crate::json_ser::serialize_structure_crate_model_featurization_method(
&mut object_400,
item_399,
)?;
object_400.finish();
}
}
array_398.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_401) = &input.attribute_name {
object.key("AttributeName").string(var_401.as_str());
}
if let Some(var_402) = &input.operation {
object.key("Operation").string(var_402.as_str());
}
if let Some(var_403) = &input.value {
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_403).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_time_series_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeSeriesCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_404) = &input.attribute_name {
object.key("AttributeName").string(var_404.as_str());
}
if let Some(var_405) = &input.attribute_value {
object.key("AttributeValue").string(var_405.as_str());
}
if let Some(var_406) = &input.condition {
object.key("Condition").string(var_406.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_categorical_parameter_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CategoricalParameterRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_407) = &input.name {
object.key("Name").string(var_407.as_str());
}
if let Some(var_408) = &input.values {
let mut array_409 = object.key("Values").start_array();
for item_410 in var_408 {
{
array_409.value().string(item_410.as_str());
}
}
array_409.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_continuous_parameter_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContinuousParameterRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_411) = &input.name {
object.key("Name").string(var_411.as_str());
}
if let Some(var_412) = &input.max_value {
object.key("MaxValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_412).into()),
);
}
if let Some(var_413) = &input.min_value {
object.key("MinValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_413).into()),
);
}
if let Some(var_414) = &input.scaling_type {
object.key("ScalingType").string(var_414.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_integer_parameter_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntegerParameterRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_415) = &input.name {
object.key("Name").string(var_415.as_str());
}
if let Some(var_416) = &input.max_value {
object.key("MaxValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_416).into()),
);
}
if let Some(var_417) = &input.min_value {
object.key("MinValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_417).into()),
);
}
if let Some(var_418) = &input.scaling_type {
object.key("ScalingType").string(var_418.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_featurization_method(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FeaturizationMethod,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_419) = &input.featurization_method_name {
object
.key("FeaturizationMethodName")
.string(var_419.as_str());
}
if let Some(var_420) = &input.featurization_method_parameters {
#[allow(unused_mut)]
let mut object_421 = object.key("FeaturizationMethodParameters").start_object();
for (key_422, value_423) in var_420 {
{
object_421.key(key_422.as_str()).string(value_423.as_str());
}
}
object_421.finish();
}
Ok(())
}