// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// <p>Deletes the specified scaling policy for an Application Auto Scaling scalable target.</p>
/// <p>Deleting a step scaling policy deletes the underlying alarm action, but does not delete
/// the CloudWatch alarm associated with the scaling policy, even if it no longer has an associated
/// action.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html#delete-step-scaling-policy">Delete a step scaling policy</a> and <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html#delete-target-tracking-policy">Delete a target tracking scaling policy</a> in the
/// <i>Application Auto Scaling User Guide</i>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteScalingPolicy {
    _private: (),
}
impl DeleteScalingPolicy {
    /// Creates a new builder-style object to manufacture [`DeleteScalingPolicyInput`](crate::input::DeleteScalingPolicyInput)
    pub fn builder() -> crate::input::delete_scaling_policy_input::Builder {
        crate::input::delete_scaling_policy_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteScalingPolicy {
    type Output = std::result::Result<
        crate::output::DeleteScalingPolicyOutput,
        crate::error::DeleteScalingPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_scaling_policy_error(response)
        } else {
            crate::operation_deser::parse_delete_scaling_policy_response(response)
        }
    }
}

/// <p>Deletes the specified scheduled action for an Application Auto Scaling scalable target.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/scheduled-scaling-additional-cli-commands.html#delete-scheduled-action">Delete a scheduled action</a> in the <i>Application Auto Scaling User Guide</i>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteScheduledAction {
    _private: (),
}
impl DeleteScheduledAction {
    /// Creates a new builder-style object to manufacture [`DeleteScheduledActionInput`](crate::input::DeleteScheduledActionInput)
    pub fn builder() -> crate::input::delete_scheduled_action_input::Builder {
        crate::input::delete_scheduled_action_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteScheduledAction {
    type Output = std::result::Result<
        crate::output::DeleteScheduledActionOutput,
        crate::error::DeleteScheduledActionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_scheduled_action_error(response)
        } else {
            crate::operation_deser::parse_delete_scheduled_action_response(response)
        }
    }
}

/// <p>Deregisters an Application Auto Scaling scalable target when you have finished using it. To see which
/// resources have been registered, use <a href="https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DescribeScalableTargets.html">DescribeScalableTargets</a>. </p>
/// <note>
/// <p>Deregistering a scalable target deletes the scaling policies and the scheduled
/// actions that are associated with it.</p>
/// </note>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeregisterScalableTarget {
    _private: (),
}
impl DeregisterScalableTarget {
    /// Creates a new builder-style object to manufacture [`DeregisterScalableTargetInput`](crate::input::DeregisterScalableTargetInput)
    pub fn builder() -> crate::input::deregister_scalable_target_input::Builder {
        crate::input::deregister_scalable_target_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeregisterScalableTarget {
    type Output = std::result::Result<
        crate::output::DeregisterScalableTargetOutput,
        crate::error::DeregisterScalableTargetError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_deregister_scalable_target_error(response)
        } else {
            crate::operation_deser::parse_deregister_scalable_target_response(response)
        }
    }
}

/// <p>Gets information about the scalable targets in the specified namespace.</p>
/// <p>You can filter the results using <code>ResourceIds</code> and
/// <code>ScalableDimension</code>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DescribeScalableTargets {
    _private: (),
}
impl DescribeScalableTargets {
    /// Creates a new builder-style object to manufacture [`DescribeScalableTargetsInput`](crate::input::DescribeScalableTargetsInput)
    pub fn builder() -> crate::input::describe_scalable_targets_input::Builder {
        crate::input::describe_scalable_targets_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DescribeScalableTargets {
    type Output = std::result::Result<
        crate::output::DescribeScalableTargetsOutput,
        crate::error::DescribeScalableTargetsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_describe_scalable_targets_error(response)
        } else {
            crate::operation_deser::parse_describe_scalable_targets_response(response)
        }
    }
}

/// <p>Provides descriptive information about the scaling activities in the specified namespace
/// from the previous six weeks.</p>
/// <p>You can filter the results using <code>ResourceId</code> and
/// <code>ScalableDimension</code>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DescribeScalingActivities {
    _private: (),
}
impl DescribeScalingActivities {
    /// Creates a new builder-style object to manufacture [`DescribeScalingActivitiesInput`](crate::input::DescribeScalingActivitiesInput)
    pub fn builder() -> crate::input::describe_scaling_activities_input::Builder {
        crate::input::describe_scaling_activities_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DescribeScalingActivities {
    type Output = std::result::Result<
        crate::output::DescribeScalingActivitiesOutput,
        crate::error::DescribeScalingActivitiesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_describe_scaling_activities_error(response)
        } else {
            crate::operation_deser::parse_describe_scaling_activities_response(response)
        }
    }
}

/// <p>Describes the Application Auto Scaling scaling policies for the specified service namespace.</p>
/// <p>You can filter the results using <code>ResourceId</code>,
/// <code>ScalableDimension</code>, and <code>PolicyNames</code>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html">Target tracking scaling policies</a> and <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html">Step scaling policies</a> in the <i>Application Auto Scaling User Guide</i>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DescribeScalingPolicies {
    _private: (),
}
impl DescribeScalingPolicies {
    /// Creates a new builder-style object to manufacture [`DescribeScalingPoliciesInput`](crate::input::DescribeScalingPoliciesInput)
    pub fn builder() -> crate::input::describe_scaling_policies_input::Builder {
        crate::input::describe_scaling_policies_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DescribeScalingPolicies {
    type Output = std::result::Result<
        crate::output::DescribeScalingPoliciesOutput,
        crate::error::DescribeScalingPoliciesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_describe_scaling_policies_error(response)
        } else {
            crate::operation_deser::parse_describe_scaling_policies_response(response)
        }
    }
}

/// <p>Describes the Application Auto Scaling scheduled actions for the specified service namespace.</p>
/// <p>You can filter the results using the <code>ResourceId</code>,
/// <code>ScalableDimension</code>, and <code>ScheduledActionNames</code> parameters.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scheduled-scaling.html">Scheduled scaling</a> and <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/scheduled-scaling-additional-cli-commands.html">Managing scheduled scaling</a> in the
/// <i>Application Auto Scaling User Guide</i>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DescribeScheduledActions {
    _private: (),
}
impl DescribeScheduledActions {
    /// Creates a new builder-style object to manufacture [`DescribeScheduledActionsInput`](crate::input::DescribeScheduledActionsInput)
    pub fn builder() -> crate::input::describe_scheduled_actions_input::Builder {
        crate::input::describe_scheduled_actions_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DescribeScheduledActions {
    type Output = std::result::Result<
        crate::output::DescribeScheduledActionsOutput,
        crate::error::DescribeScheduledActionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_describe_scheduled_actions_error(response)
        } else {
            crate::operation_deser::parse_describe_scheduled_actions_response(response)
        }
    }
}

/// <p>Creates or updates a scaling policy for an Application Auto Scaling scalable target.</p>
/// <p>Each scalable target is identified by a service namespace, resource ID, and scalable
/// dimension. A scaling policy applies to the scalable target identified by those three
/// attributes. You cannot create a scaling policy until you have registered the resource as a
/// scalable target.</p>
/// <p>Multiple scaling policies can be in force at the same time for the same scalable target.
/// You can have one or more target tracking scaling policies, one or more step scaling
/// policies, or both. However, there is a chance that multiple policies could conflict,
/// instructing the scalable target to scale out or in at the same time. Application Auto Scaling gives
/// precedence to the policy that provides the largest capacity for both scale out and scale
/// in. For example, if one policy increases capacity by 3, another policy increases capacity
/// by 200 percent, and the current capacity is 10, Application Auto Scaling uses the policy with the highest
/// calculated capacity (200% of 10 = 20) and scales out to 30. </p>
/// <p>We recommend caution, however, when using target tracking scaling policies with step
/// scaling policies because conflicts between these policies can cause undesirable behavior.
/// For example, if the step scaling policy initiates a scale-in activity before the target
/// tracking policy is ready to scale in, the scale-in activity will not be blocked. After the
/// scale-in activity completes, the target tracking policy could instruct the scalable target
/// to scale out again. </p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html">Target tracking scaling policies</a> and <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html">Step scaling policies</a> in the <i>Application Auto Scaling User Guide</i>.</p>
/// <note>
/// <p>If a scalable target is deregistered, the scalable target is no longer available to
/// execute scaling policies. Any scaling policies that were specified for the scalable
/// target are deleted.</p>
/// </note>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct PutScalingPolicy {
    _private: (),
}
impl PutScalingPolicy {
    /// Creates a new builder-style object to manufacture [`PutScalingPolicyInput`](crate::input::PutScalingPolicyInput)
    pub fn builder() -> crate::input::put_scaling_policy_input::Builder {
        crate::input::put_scaling_policy_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for PutScalingPolicy {
    type Output = std::result::Result<
        crate::output::PutScalingPolicyOutput,
        crate::error::PutScalingPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_put_scaling_policy_error(response)
        } else {
            crate::operation_deser::parse_put_scaling_policy_response(response)
        }
    }
}

/// <p>Creates or updates a scheduled action for an Application Auto Scaling scalable target. </p>
/// <p>Each scalable target is identified by a service namespace, resource ID, and scalable
/// dimension. A scheduled action applies to the scalable target identified by those three
/// attributes. You cannot create a scheduled action until you have registered the resource as
/// a scalable target.</p>
/// <p>When start and end times are specified with a recurring schedule using a cron expression
/// or rates, they form the boundaries for when the recurring action starts and stops.</p>
/// <p>To update a scheduled action, specify the parameters that you want to change. If you
/// don't specify start and end times, the old values are deleted.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scheduled-scaling.html">Scheduled scaling</a> in the <i>Application Auto Scaling User Guide</i>.</p>
/// <note>
/// <p>If a scalable target is deregistered, the scalable target is no longer available to
/// run scheduled actions. Any scheduled actions that were specified for the scalable target
/// are deleted.</p>
/// </note>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct PutScheduledAction {
    _private: (),
}
impl PutScheduledAction {
    /// Creates a new builder-style object to manufacture [`PutScheduledActionInput`](crate::input::PutScheduledActionInput)
    pub fn builder() -> crate::input::put_scheduled_action_input::Builder {
        crate::input::put_scheduled_action_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for PutScheduledAction {
    type Output = std::result::Result<
        crate::output::PutScheduledActionOutput,
        crate::error::PutScheduledActionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_put_scheduled_action_error(response)
        } else {
            crate::operation_deser::parse_put_scheduled_action_response(response)
        }
    }
}

/// <p>Registers or updates a scalable target. </p>
/// <p>A scalable target is a resource that Application Auto Scaling can scale out and scale in. Scalable
/// targets are uniquely identified by the combination of resource ID, scalable dimension, and
/// namespace. </p>
/// <p>When you register a new scalable target, you must specify values for minimum and maximum
/// capacity. Current capacity will be adjusted within the specified range when scaling starts.
/// Application Auto Scaling scaling policies will not scale capacity to values that are outside of this
/// range.</p>
/// <p>After you register a scalable target, you do not need to register it again to use other
/// Application Auto Scaling operations. To see which resources have been registered, use <a href="https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DescribeScalableTargets.html">DescribeScalableTargets</a>. You can also view the scaling policies for a service
/// namespace by using <a href="https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DescribeScalableTargets.html">DescribeScalableTargets</a>. If you no longer need a scalable target, you can
/// deregister it by using <a href="https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html">DeregisterScalableTarget</a>.</p>
/// <p>To update a scalable target, specify the parameters that you want to change. Include the
/// parameters that identify the scalable target: resource ID, scalable dimension, and
/// namespace. Any parameters that you don't specify are not changed by this update request. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct RegisterScalableTarget {
    _private: (),
}
impl RegisterScalableTarget {
    /// Creates a new builder-style object to manufacture [`RegisterScalableTargetInput`](crate::input::RegisterScalableTargetInput)
    pub fn builder() -> crate::input::register_scalable_target_input::Builder {
        crate::input::register_scalable_target_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for RegisterScalableTarget {
    type Output = std::result::Result<
        crate::output::RegisterScalableTargetOutput,
        crate::error::RegisterScalableTargetError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_register_scalable_target_error(response)
        } else {
            crate::operation_deser::parse_register_scalable_target_response(response)
        }
    }
}
