pub fn serialize_structure_crate_input_create_scaling_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateScalingPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.scaling_plan_name {
object.key("ScalingPlanName").string(var_1.as_str());
}
if let Some(var_2) = &input.application_source {
#[allow(unused_mut)]
let mut object_3 = object.key("ApplicationSource").start_object();
crate::json_ser::serialize_structure_crate_model_application_source(&mut object_3, var_2)?;
object_3.finish();
}
if let Some(var_4) = &input.scaling_instructions {
let mut array_5 = object.key("ScalingInstructions").start_array();
for item_6 in var_4 {
{
#[allow(unused_mut)]
let mut object_7 = array_5.value().start_object();
crate::json_ser::serialize_structure_crate_model_scaling_instruction(
&mut object_7,
item_6,
)?;
object_7.finish();
}
}
array_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_scaling_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteScalingPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.scaling_plan_name {
object.key("ScalingPlanName").string(var_8.as_str());
}
if let Some(var_9) = &input.scaling_plan_version {
object.key("ScalingPlanVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_9).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_scaling_plan_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeScalingPlanResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.scaling_plan_name {
object.key("ScalingPlanName").string(var_10.as_str());
}
if let Some(var_11) = &input.scaling_plan_version {
object.key("ScalingPlanVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_11).into()),
);
}
if let Some(var_12) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_12).into()),
);
}
if let Some(var_13) = &input.next_token {
object.key("NextToken").string(var_13.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_scaling_plans_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeScalingPlansInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.scaling_plan_names {
let mut array_15 = object.key("ScalingPlanNames").start_array();
for item_16 in var_14 {
{
array_15.value().string(item_16.as_str());
}
}
array_15.finish();
}
if let Some(var_17) = &input.scaling_plan_version {
object.key("ScalingPlanVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_17).into()),
);
}
if let Some(var_18) = &input.application_sources {
let mut array_19 = object.key("ApplicationSources").start_array();
for item_20 in var_18 {
{
#[allow(unused_mut)]
let mut object_21 = array_19.value().start_object();
crate::json_ser::serialize_structure_crate_model_application_source(
&mut object_21,
item_20,
)?;
object_21.finish();
}
}
array_19.finish();
}
if let Some(var_22) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_22).into()),
);
}
if let Some(var_23) = &input.next_token {
object.key("NextToken").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_scaling_plan_resource_forecast_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetScalingPlanResourceForecastDataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.scaling_plan_name {
object.key("ScalingPlanName").string(var_24.as_str());
}
if let Some(var_25) = &input.scaling_plan_version {
object.key("ScalingPlanVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_25).into()),
);
}
if let Some(var_26) = &input.service_namespace {
object.key("ServiceNamespace").string(var_26.as_str());
}
if let Some(var_27) = &input.resource_id {
object.key("ResourceId").string(var_27.as_str());
}
if let Some(var_28) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_28.as_str());
}
if let Some(var_29) = &input.forecast_data_type {
object.key("ForecastDataType").string(var_29.as_str());
}
if let Some(var_30) = &input.start_time {
object
.key("StartTime")
.date_time(var_30, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_31) = &input.end_time {
object
.key("EndTime")
.date_time(var_31, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_update_scaling_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateScalingPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.scaling_plan_name {
object.key("ScalingPlanName").string(var_32.as_str());
}
if let Some(var_33) = &input.scaling_plan_version {
object.key("ScalingPlanVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_33).into()),
);
}
if let Some(var_34) = &input.application_source {
#[allow(unused_mut)]
let mut object_35 = object.key("ApplicationSource").start_object();
crate::json_ser::serialize_structure_crate_model_application_source(
&mut object_35,
var_34,
)?;
object_35.finish();
}
if let Some(var_36) = &input.scaling_instructions {
let mut array_37 = object.key("ScalingInstructions").start_array();
for item_38 in var_36 {
{
#[allow(unused_mut)]
let mut object_39 = array_37.value().start_object();
crate::json_ser::serialize_structure_crate_model_scaling_instruction(
&mut object_39,
item_38,
)?;
object_39.finish();
}
}
array_37.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_application_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApplicationSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.cloud_formation_stack_arn {
object.key("CloudFormationStackARN").string(var_40.as_str());
}
if let Some(var_41) = &input.tag_filters {
let mut array_42 = object.key("TagFilters").start_array();
for item_43 in var_41 {
{
#[allow(unused_mut)]
let mut object_44 = array_42.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(
&mut object_44,
item_43,
)?;
object_44.finish();
}
}
array_42.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scaling_instruction(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScalingInstruction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.service_namespace {
object.key("ServiceNamespace").string(var_45.as_str());
}
if let Some(var_46) = &input.resource_id {
object.key("ResourceId").string(var_46.as_str());
}
if let Some(var_47) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_47.as_str());
}
if let Some(var_48) = &input.min_capacity {
object.key("MinCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_48).into()),
);
}
if let Some(var_49) = &input.max_capacity {
object.key("MaxCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_49).into()),
);
}
if let Some(var_50) = &input.target_tracking_configurations {
let mut array_51 = object.key("TargetTrackingConfigurations").start_array();
for item_52 in var_50 {
{
#[allow(unused_mut)]
let mut object_53 = array_51.value().start_object();
crate::json_ser::serialize_structure_crate_model_target_tracking_configuration(
&mut object_53,
item_52,
)?;
object_53.finish();
}
}
array_51.finish();
}
if let Some(var_54) = &input.predefined_load_metric_specification {
#[allow(unused_mut)]
let mut object_55 = object
.key("PredefinedLoadMetricSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_predefined_load_metric_specification(
&mut object_55,
var_54,
)?;
object_55.finish();
}
if let Some(var_56) = &input.customized_load_metric_specification {
#[allow(unused_mut)]
let mut object_57 = object
.key("CustomizedLoadMetricSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_customized_load_metric_specification(
&mut object_57,
var_56,
)?;
object_57.finish();
}
if let Some(var_58) = &input.scheduled_action_buffer_time {
object.key("ScheduledActionBufferTime").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_58).into()),
);
}
if let Some(var_59) = &input.predictive_scaling_max_capacity_behavior {
object
.key("PredictiveScalingMaxCapacityBehavior")
.string(var_59.as_str());
}
if let Some(var_60) = &input.predictive_scaling_max_capacity_buffer {
object.key("PredictiveScalingMaxCapacityBuffer").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_60).into()),
);
}
if let Some(var_61) = &input.predictive_scaling_mode {
object.key("PredictiveScalingMode").string(var_61.as_str());
}
if let Some(var_62) = &input.scaling_policy_update_behavior {
object
.key("ScalingPolicyUpdateBehavior")
.string(var_62.as_str());
}
if let Some(var_63) = &input.disable_dynamic_scaling {
object.key("DisableDynamicScaling").boolean(*var_63);
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.key {
object.key("Key").string(var_64.as_str());
}
if let Some(var_65) = &input.values {
let mut array_66 = object.key("Values").start_array();
for item_67 in var_65 {
{
array_66.value().string(item_67.as_str());
}
}
array_66.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_target_tracking_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetTrackingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.predefined_scaling_metric_specification {
#[allow(unused_mut)]
let mut object_69 = object
.key("PredefinedScalingMetricSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_predefined_scaling_metric_specification(
&mut object_69,
var_68,
)?;
object_69.finish();
}
if let Some(var_70) = &input.customized_scaling_metric_specification {
#[allow(unused_mut)]
let mut object_71 = object
.key("CustomizedScalingMetricSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_customized_scaling_metric_specification(
&mut object_71,
var_70,
)?;
object_71.finish();
}
if let Some(var_72) = &input.target_value {
object.key("TargetValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_72).into()),
);
}
if let Some(var_73) = &input.disable_scale_in {
object.key("DisableScaleIn").boolean(*var_73);
}
if let Some(var_74) = &input.scale_out_cooldown {
object.key("ScaleOutCooldown").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_74).into()),
);
}
if let Some(var_75) = &input.scale_in_cooldown {
object.key("ScaleInCooldown").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_75).into()),
);
}
if let Some(var_76) = &input.estimated_instance_warmup {
object.key("EstimatedInstanceWarmup").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_76).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_predefined_load_metric_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PredefinedLoadMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.predefined_load_metric_type {
object
.key("PredefinedLoadMetricType")
.string(var_77.as_str());
}
if let Some(var_78) = &input.resource_label {
object.key("ResourceLabel").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_customized_load_metric_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomizedLoadMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.metric_name {
object.key("MetricName").string(var_79.as_str());
}
if let Some(var_80) = &input.namespace {
object.key("Namespace").string(var_80.as_str());
}
if let Some(var_81) = &input.dimensions {
let mut array_82 = object.key("Dimensions").start_array();
for item_83 in var_81 {
{
#[allow(unused_mut)]
let mut object_84 = array_82.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_dimension(
&mut object_84,
item_83,
)?;
object_84.finish();
}
}
array_82.finish();
}
if let Some(var_85) = &input.statistic {
object.key("Statistic").string(var_85.as_str());
}
if let Some(var_86) = &input.unit {
object.key("Unit").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_predefined_scaling_metric_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PredefinedScalingMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.predefined_scaling_metric_type {
object
.key("PredefinedScalingMetricType")
.string(var_87.as_str());
}
if let Some(var_88) = &input.resource_label {
object.key("ResourceLabel").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_customized_scaling_metric_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomizedScalingMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.metric_name {
object.key("MetricName").string(var_89.as_str());
}
if let Some(var_90) = &input.namespace {
object.key("Namespace").string(var_90.as_str());
}
if let Some(var_91) = &input.dimensions {
let mut array_92 = object.key("Dimensions").start_array();
for item_93 in var_91 {
{
#[allow(unused_mut)]
let mut object_94 = array_92.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_dimension(
&mut object_94,
item_93,
)?;
object_94.finish();
}
}
array_92.finish();
}
if let Some(var_95) = &input.statistic {
object.key("Statistic").string(var_95.as_str());
}
if let Some(var_96) = &input.unit {
object.key("Unit").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.name {
object.key("Name").string(var_97.as_str());
}
if let Some(var_98) = &input.value {
object.key("Value").string(var_98.as_str());
}
Ok(())
}