pub fn serialize_structure_crate_input_delete_scaling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteScalingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.policy_name {
object.key("PolicyName").string(var_1.as_str());
}
if let Some(var_2) = &input.service_namespace {
object.key("ServiceNamespace").string(var_2.as_str());
}
if let Some(var_3) = &input.resource_id {
object.key("ResourceId").string(var_3.as_str());
}
if let Some(var_4) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_4.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_scheduled_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteScheduledActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.service_namespace {
object.key("ServiceNamespace").string(var_5.as_str());
}
if let Some(var_6) = &input.scheduled_action_name {
object.key("ScheduledActionName").string(var_6.as_str());
}
if let Some(var_7) = &input.resource_id {
object.key("ResourceId").string(var_7.as_str());
}
if let Some(var_8) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_8.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_scalable_target_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterScalableTargetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.service_namespace {
object.key("ServiceNamespace").string(var_9.as_str());
}
if let Some(var_10) = &input.resource_id {
object.key("ResourceId").string(var_10.as_str());
}
if let Some(var_11) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_scalable_targets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeScalableTargetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.service_namespace {
object.key("ServiceNamespace").string(var_12.as_str());
}
if let Some(var_13) = &input.resource_ids {
let mut array_14 = object.key("ResourceIds").start_array();
for item_15 in var_13 {
{
array_14.value().string(item_15.as_str());
}
}
array_14.finish();
}
if let Some(var_16) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_16.as_str());
}
if let Some(var_17) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_17).into()),
);
}
if let Some(var_18) = &input.next_token {
object.key("NextToken").string(var_18.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_scaling_activities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeScalingActivitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_19) = &input.service_namespace {
object.key("ServiceNamespace").string(var_19.as_str());
}
if let Some(var_20) = &input.resource_id {
object.key("ResourceId").string(var_20.as_str());
}
if let Some(var_21) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_21.as_str());
}
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());
}
if let Some(var_24) = &input.include_not_scaled_activities {
object.key("IncludeNotScaledActivities").boolean(*var_24);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_scaling_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeScalingPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.policy_names {
let mut array_26 = object.key("PolicyNames").start_array();
for item_27 in var_25 {
{
array_26.value().string(item_27.as_str());
}
}
array_26.finish();
}
if let Some(var_28) = &input.service_namespace {
object.key("ServiceNamespace").string(var_28.as_str());
}
if let Some(var_29) = &input.resource_id {
object.key("ResourceId").string(var_29.as_str());
}
if let Some(var_30) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_30.as_str());
}
if let Some(var_31) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_31).into()),
);
}
if let Some(var_32) = &input.next_token {
object.key("NextToken").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_scheduled_actions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeScheduledActionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.scheduled_action_names {
let mut array_34 = object.key("ScheduledActionNames").start_array();
for item_35 in var_33 {
{
array_34.value().string(item_35.as_str());
}
}
array_34.finish();
}
if let Some(var_36) = &input.service_namespace {
object.key("ServiceNamespace").string(var_36.as_str());
}
if let Some(var_37) = &input.resource_id {
object.key("ResourceId").string(var_37.as_str());
}
if let Some(var_38) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_38.as_str());
}
if let Some(var_39) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_39).into()),
);
}
if let Some(var_40) = &input.next_token {
object.key("NextToken").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_scaling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutScalingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.policy_name {
object.key("PolicyName").string(var_41.as_str());
}
if let Some(var_42) = &input.service_namespace {
object.key("ServiceNamespace").string(var_42.as_str());
}
if let Some(var_43) = &input.resource_id {
object.key("ResourceId").string(var_43.as_str());
}
if let Some(var_44) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_44.as_str());
}
if let Some(var_45) = &input.policy_type {
object.key("PolicyType").string(var_45.as_str());
}
if let Some(var_46) = &input.step_scaling_policy_configuration {
#[allow(unused_mut)]
let mut object_47 = object.key("StepScalingPolicyConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_step_scaling_policy_configuration(
&mut object_47,
var_46,
)?;
object_47.finish();
}
if let Some(var_48) = &input.target_tracking_scaling_policy_configuration {
#[allow(unused_mut)]
let mut object_49 = object
.key("TargetTrackingScalingPolicyConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_target_tracking_scaling_policy_configuration(&mut object_49, var_48)?;
object_49.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_scheduled_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutScheduledActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.service_namespace {
object.key("ServiceNamespace").string(var_50.as_str());
}
if let Some(var_51) = &input.schedule {
object.key("Schedule").string(var_51.as_str());
}
if let Some(var_52) = &input.timezone {
object.key("Timezone").string(var_52.as_str());
}
if let Some(var_53) = &input.scheduled_action_name {
object.key("ScheduledActionName").string(var_53.as_str());
}
if let Some(var_54) = &input.resource_id {
object.key("ResourceId").string(var_54.as_str());
}
if let Some(var_55) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_55.as_str());
}
if let Some(var_56) = &input.start_time {
object
.key("StartTime")
.date_time(var_56, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_57) = &input.end_time {
object
.key("EndTime")
.date_time(var_57, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_58) = &input.scalable_target_action {
#[allow(unused_mut)]
let mut object_59 = object.key("ScalableTargetAction").start_object();
crate::json_ser::serialize_structure_crate_model_scalable_target_action(
&mut object_59,
var_58,
)?;
object_59.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_scalable_target_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterScalableTargetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.service_namespace {
object.key("ServiceNamespace").string(var_60.as_str());
}
if let Some(var_61) = &input.resource_id {
object.key("ResourceId").string(var_61.as_str());
}
if let Some(var_62) = &input.scalable_dimension {
object.key("ScalableDimension").string(var_62.as_str());
}
if let Some(var_63) = &input.min_capacity {
object.key("MinCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_63).into()),
);
}
if let Some(var_64) = &input.max_capacity {
object.key("MaxCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_64).into()),
);
}
if let Some(var_65) = &input.role_arn {
object.key("RoleARN").string(var_65.as_str());
}
if let Some(var_66) = &input.suspended_state {
#[allow(unused_mut)]
let mut object_67 = object.key("SuspendedState").start_object();
crate::json_ser::serialize_structure_crate_model_suspended_state(&mut object_67, var_66)?;
object_67.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_step_scaling_policy_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StepScalingPolicyConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.adjustment_type {
object.key("AdjustmentType").string(var_68.as_str());
}
if let Some(var_69) = &input.step_adjustments {
let mut array_70 = object.key("StepAdjustments").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_step_adjustment(
&mut object_72,
item_71,
)?;
object_72.finish();
}
}
array_70.finish();
}
if let Some(var_73) = &input.min_adjustment_magnitude {
object.key("MinAdjustmentMagnitude").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_73).into()),
);
}
if let Some(var_74) = &input.cooldown {
object.key("Cooldown").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_74).into()),
);
}
if let Some(var_75) = &input.metric_aggregation_type {
object.key("MetricAggregationType").string(var_75.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_target_tracking_scaling_policy_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetTrackingScalingPolicyConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.target_value {
object.key("TargetValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_76).into()),
);
}
if let Some(var_77) = &input.predefined_metric_specification {
#[allow(unused_mut)]
let mut object_78 = object.key("PredefinedMetricSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_predefined_metric_specification(
&mut object_78,
var_77,
)?;
object_78.finish();
}
if let Some(var_79) = &input.customized_metric_specification {
#[allow(unused_mut)]
let mut object_80 = object.key("CustomizedMetricSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_customized_metric_specification(
&mut object_80,
var_79,
)?;
object_80.finish();
}
if let Some(var_81) = &input.scale_out_cooldown {
object.key("ScaleOutCooldown").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_81).into()),
);
}
if let Some(var_82) = &input.scale_in_cooldown {
object.key("ScaleInCooldown").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_82).into()),
);
}
if let Some(var_83) = &input.disable_scale_in {
object.key("DisableScaleIn").boolean(*var_83);
}
Ok(())
}
pub fn serialize_structure_crate_model_scalable_target_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScalableTargetAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.min_capacity {
object.key("MinCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_84).into()),
);
}
if let Some(var_85) = &input.max_capacity {
object.key("MaxCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_85).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_suspended_state(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SuspendedState,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.dynamic_scaling_in_suspended {
object.key("DynamicScalingInSuspended").boolean(*var_86);
}
if let Some(var_87) = &input.dynamic_scaling_out_suspended {
object.key("DynamicScalingOutSuspended").boolean(*var_87);
}
if let Some(var_88) = &input.scheduled_scaling_suspended {
object.key("ScheduledScalingSuspended").boolean(*var_88);
}
Ok(())
}
pub fn serialize_structure_crate_model_step_adjustment(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StepAdjustment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.metric_interval_lower_bound {
object.key("MetricIntervalLowerBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_89).into()),
);
}
if let Some(var_90) = &input.metric_interval_upper_bound {
object.key("MetricIntervalUpperBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_90).into()),
);
}
if let Some(var_91) = &input.scaling_adjustment {
object.key("ScalingAdjustment").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_91).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_predefined_metric_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PredefinedMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.predefined_metric_type {
object.key("PredefinedMetricType").string(var_92.as_str());
}
if let Some(var_93) = &input.resource_label {
object.key("ResourceLabel").string(var_93.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_customized_metric_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomizedMetricSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.metric_name {
object.key("MetricName").string(var_94.as_str());
}
if let Some(var_95) = &input.namespace {
object.key("Namespace").string(var_95.as_str());
}
if let Some(var_96) = &input.dimensions {
let mut array_97 = object.key("Dimensions").start_array();
for item_98 in var_96 {
{
#[allow(unused_mut)]
let mut object_99 = array_97.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_dimension(
&mut object_99,
item_98,
)?;
object_99.finish();
}
}
array_97.finish();
}
if let Some(var_100) = &input.statistic {
object.key("Statistic").string(var_100.as_str());
}
if let Some(var_101) = &input.unit {
object.key("Unit").string(var_101.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_102) = &input.name {
object.key("Name").string(var_102.as_str());
}
if let Some(var_103) = &input.value {
object.key("Value").string(var_103.as_str());
}
Ok(())
}