# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'ScalingPlanApplicationSourceArgs',
    'ScalingPlanCustomizedLoadMetricSpecificationArgs',
    'ScalingPlanCustomizedScalingMetricSpecificationArgs',
    'ScalingPlanMetricDimensionArgs',
    'ScalingPlanPredefinedLoadMetricSpecificationArgs',
    'ScalingPlanPredefinedScalingMetricSpecificationArgs',
    'ScalingPlanScalingInstructionArgs',
    'ScalingPlanTagFilterArgs',
    'ScalingPlanTargetTrackingConfigurationArgs',
]

@pulumi.input_type
class ScalingPlanApplicationSourceArgs:
    def __init__(__self__, *,
                 cloud_formation_stack_arn: Optional[pulumi.Input[str]] = None,
                 tag_filters: Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPlanTagFilterArgs']]]] = None):
        if cloud_formation_stack_arn is not None:
            pulumi.set(__self__, "cloud_formation_stack_arn", cloud_formation_stack_arn)
        if tag_filters is not None:
            pulumi.set(__self__, "tag_filters", tag_filters)

    @property
    @pulumi.getter(name="cloudFormationStackARN")
    def cloud_formation_stack_arn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cloud_formation_stack_arn")

    @cloud_formation_stack_arn.setter
    def cloud_formation_stack_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud_formation_stack_arn", value)

    @property
    @pulumi.getter(name="tagFilters")
    def tag_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPlanTagFilterArgs']]]]:
        return pulumi.get(self, "tag_filters")

    @tag_filters.setter
    def tag_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPlanTagFilterArgs']]]]):
        pulumi.set(self, "tag_filters", value)


@pulumi.input_type
class ScalingPlanCustomizedLoadMetricSpecificationArgs:
    def __init__(__self__, *,
                 metric_name: pulumi.Input[str],
                 namespace: pulumi.Input[str],
                 statistic: pulumi.Input[str],
                 dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPlanMetricDimensionArgs']]]] = None,
                 unit: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "statistic", statistic)
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "metric_name")

    @metric_name.setter
    def metric_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "metric_name", value)

    @property
    @pulumi.getter
    def namespace(self) -> pulumi.Input[str]:
        return pulumi.get(self, "namespace")

    @namespace.setter
    def namespace(self, value: pulumi.Input[str]):
        pulumi.set(self, "namespace", value)

    @property
    @pulumi.getter
    def statistic(self) -> pulumi.Input[str]:
        return pulumi.get(self, "statistic")

    @statistic.setter
    def statistic(self, value: pulumi.Input[str]):
        pulumi.set(self, "statistic", value)

    @property
    @pulumi.getter
    def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPlanMetricDimensionArgs']]]]:
        return pulumi.get(self, "dimensions")

    @dimensions.setter
    def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPlanMetricDimensionArgs']]]]):
        pulumi.set(self, "dimensions", value)

    @property
    @pulumi.getter
    def unit(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "unit")

    @unit.setter
    def unit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "unit", value)


@pulumi.input_type
class ScalingPlanCustomizedScalingMetricSpecificationArgs:
    def __init__(__self__, *,
                 metric_name: pulumi.Input[str],
                 namespace: pulumi.Input[str],
                 statistic: pulumi.Input[str],
                 dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPlanMetricDimensionArgs']]]] = None,
                 unit: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "statistic", statistic)
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "metric_name")

    @metric_name.setter
    def metric_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "metric_name", value)

    @property
    @pulumi.getter
    def namespace(self) -> pulumi.Input[str]:
        return pulumi.get(self, "namespace")

    @namespace.setter
    def namespace(self, value: pulumi.Input[str]):
        pulumi.set(self, "namespace", value)

    @property
    @pulumi.getter
    def statistic(self) -> pulumi.Input[str]:
        return pulumi.get(self, "statistic")

    @statistic.setter
    def statistic(self, value: pulumi.Input[str]):
        pulumi.set(self, "statistic", value)

    @property
    @pulumi.getter
    def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPlanMetricDimensionArgs']]]]:
        return pulumi.get(self, "dimensions")

    @dimensions.setter
    def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPlanMetricDimensionArgs']]]]):
        pulumi.set(self, "dimensions", value)

    @property
    @pulumi.getter
    def unit(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "unit")

    @unit.setter
    def unit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "unit", value)


@pulumi.input_type
class ScalingPlanMetricDimensionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class ScalingPlanPredefinedLoadMetricSpecificationArgs:
    def __init__(__self__, *,
                 predefined_load_metric_type: pulumi.Input[str],
                 resource_label: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "predefined_load_metric_type", predefined_load_metric_type)
        if resource_label is not None:
            pulumi.set(__self__, "resource_label", resource_label)

    @property
    @pulumi.getter(name="predefinedLoadMetricType")
    def predefined_load_metric_type(self) -> pulumi.Input[str]:
        return pulumi.get(self, "predefined_load_metric_type")

    @predefined_load_metric_type.setter
    def predefined_load_metric_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "predefined_load_metric_type", value)

    @property
    @pulumi.getter(name="resourceLabel")
    def resource_label(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource_label")

    @resource_label.setter
    def resource_label(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_label", value)


@pulumi.input_type
class ScalingPlanPredefinedScalingMetricSpecificationArgs:
    def __init__(__self__, *,
                 predefined_scaling_metric_type: pulumi.Input[str],
                 resource_label: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "predefined_scaling_metric_type", predefined_scaling_metric_type)
        if resource_label is not None:
            pulumi.set(__self__, "resource_label", resource_label)

    @property
    @pulumi.getter(name="predefinedScalingMetricType")
    def predefined_scaling_metric_type(self) -> pulumi.Input[str]:
        return pulumi.get(self, "predefined_scaling_metric_type")

    @predefined_scaling_metric_type.setter
    def predefined_scaling_metric_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "predefined_scaling_metric_type", value)

    @property
    @pulumi.getter(name="resourceLabel")
    def resource_label(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource_label")

    @resource_label.setter
    def resource_label(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_label", value)


@pulumi.input_type
class ScalingPlanScalingInstructionArgs:
    def __init__(__self__, *,
                 max_capacity: pulumi.Input[int],
                 min_capacity: pulumi.Input[int],
                 resource_id: pulumi.Input[str],
                 scalable_dimension: pulumi.Input[str],
                 service_namespace: pulumi.Input[str],
                 target_tracking_configurations: pulumi.Input[Sequence[pulumi.Input['ScalingPlanTargetTrackingConfigurationArgs']]],
                 customized_load_metric_specification: Optional[pulumi.Input['ScalingPlanCustomizedLoadMetricSpecificationArgs']] = None,
                 disable_dynamic_scaling: Optional[pulumi.Input[bool]] = None,
                 predefined_load_metric_specification: Optional[pulumi.Input['ScalingPlanPredefinedLoadMetricSpecificationArgs']] = None,
                 predictive_scaling_max_capacity_behavior: Optional[pulumi.Input[str]] = None,
                 predictive_scaling_max_capacity_buffer: Optional[pulumi.Input[int]] = None,
                 predictive_scaling_mode: Optional[pulumi.Input[str]] = None,
                 scaling_policy_update_behavior: Optional[pulumi.Input[str]] = None,
                 scheduled_action_buffer_time: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "max_capacity", max_capacity)
        pulumi.set(__self__, "min_capacity", min_capacity)
        pulumi.set(__self__, "resource_id", resource_id)
        pulumi.set(__self__, "scalable_dimension", scalable_dimension)
        pulumi.set(__self__, "service_namespace", service_namespace)
        pulumi.set(__self__, "target_tracking_configurations", target_tracking_configurations)
        if customized_load_metric_specification is not None:
            pulumi.set(__self__, "customized_load_metric_specification", customized_load_metric_specification)
        if disable_dynamic_scaling is not None:
            pulumi.set(__self__, "disable_dynamic_scaling", disable_dynamic_scaling)
        if predefined_load_metric_specification is not None:
            pulumi.set(__self__, "predefined_load_metric_specification", predefined_load_metric_specification)
        if predictive_scaling_max_capacity_behavior is not None:
            pulumi.set(__self__, "predictive_scaling_max_capacity_behavior", predictive_scaling_max_capacity_behavior)
        if predictive_scaling_max_capacity_buffer is not None:
            pulumi.set(__self__, "predictive_scaling_max_capacity_buffer", predictive_scaling_max_capacity_buffer)
        if predictive_scaling_mode is not None:
            pulumi.set(__self__, "predictive_scaling_mode", predictive_scaling_mode)
        if scaling_policy_update_behavior is not None:
            pulumi.set(__self__, "scaling_policy_update_behavior", scaling_policy_update_behavior)
        if scheduled_action_buffer_time is not None:
            pulumi.set(__self__, "scheduled_action_buffer_time", scheduled_action_buffer_time)

    @property
    @pulumi.getter(name="maxCapacity")
    def max_capacity(self) -> pulumi.Input[int]:
        return pulumi.get(self, "max_capacity")

    @max_capacity.setter
    def max_capacity(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_capacity", value)

    @property
    @pulumi.getter(name="minCapacity")
    def min_capacity(self) -> pulumi.Input[int]:
        return pulumi.get(self, "min_capacity")

    @min_capacity.setter
    def min_capacity(self, value: pulumi.Input[int]):
        pulumi.set(self, "min_capacity", value)

    @property
    @pulumi.getter(name="resourceId")
    def resource_id(self) -> pulumi.Input[str]:
        return pulumi.get(self, "resource_id")

    @resource_id.setter
    def resource_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "resource_id", value)

    @property
    @pulumi.getter(name="scalableDimension")
    def scalable_dimension(self) -> pulumi.Input[str]:
        return pulumi.get(self, "scalable_dimension")

    @scalable_dimension.setter
    def scalable_dimension(self, value: pulumi.Input[str]):
        pulumi.set(self, "scalable_dimension", value)

    @property
    @pulumi.getter(name="serviceNamespace")
    def service_namespace(self) -> pulumi.Input[str]:
        return pulumi.get(self, "service_namespace")

    @service_namespace.setter
    def service_namespace(self, value: pulumi.Input[str]):
        pulumi.set(self, "service_namespace", value)

    @property
    @pulumi.getter(name="targetTrackingConfigurations")
    def target_tracking_configurations(self) -> pulumi.Input[Sequence[pulumi.Input['ScalingPlanTargetTrackingConfigurationArgs']]]:
        return pulumi.get(self, "target_tracking_configurations")

    @target_tracking_configurations.setter
    def target_tracking_configurations(self, value: pulumi.Input[Sequence[pulumi.Input['ScalingPlanTargetTrackingConfigurationArgs']]]):
        pulumi.set(self, "target_tracking_configurations", value)

    @property
    @pulumi.getter(name="customizedLoadMetricSpecification")
    def customized_load_metric_specification(self) -> Optional[pulumi.Input['ScalingPlanCustomizedLoadMetricSpecificationArgs']]:
        return pulumi.get(self, "customized_load_metric_specification")

    @customized_load_metric_specification.setter
    def customized_load_metric_specification(self, value: Optional[pulumi.Input['ScalingPlanCustomizedLoadMetricSpecificationArgs']]):
        pulumi.set(self, "customized_load_metric_specification", value)

    @property
    @pulumi.getter(name="disableDynamicScaling")
    def disable_dynamic_scaling(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "disable_dynamic_scaling")

    @disable_dynamic_scaling.setter
    def disable_dynamic_scaling(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_dynamic_scaling", value)

    @property
    @pulumi.getter(name="predefinedLoadMetricSpecification")
    def predefined_load_metric_specification(self) -> Optional[pulumi.Input['ScalingPlanPredefinedLoadMetricSpecificationArgs']]:
        return pulumi.get(self, "predefined_load_metric_specification")

    @predefined_load_metric_specification.setter
    def predefined_load_metric_specification(self, value: Optional[pulumi.Input['ScalingPlanPredefinedLoadMetricSpecificationArgs']]):
        pulumi.set(self, "predefined_load_metric_specification", value)

    @property
    @pulumi.getter(name="predictiveScalingMaxCapacityBehavior")
    def predictive_scaling_max_capacity_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "predictive_scaling_max_capacity_behavior")

    @predictive_scaling_max_capacity_behavior.setter
    def predictive_scaling_max_capacity_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "predictive_scaling_max_capacity_behavior", value)

    @property
    @pulumi.getter(name="predictiveScalingMaxCapacityBuffer")
    def predictive_scaling_max_capacity_buffer(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "predictive_scaling_max_capacity_buffer")

    @predictive_scaling_max_capacity_buffer.setter
    def predictive_scaling_max_capacity_buffer(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "predictive_scaling_max_capacity_buffer", value)

    @property
    @pulumi.getter(name="predictiveScalingMode")
    def predictive_scaling_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "predictive_scaling_mode")

    @predictive_scaling_mode.setter
    def predictive_scaling_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "predictive_scaling_mode", value)

    @property
    @pulumi.getter(name="scalingPolicyUpdateBehavior")
    def scaling_policy_update_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scaling_policy_update_behavior")

    @scaling_policy_update_behavior.setter
    def scaling_policy_update_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scaling_policy_update_behavior", value)

    @property
    @pulumi.getter(name="scheduledActionBufferTime")
    def scheduled_action_buffer_time(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "scheduled_action_buffer_time")

    @scheduled_action_buffer_time.setter
    def scheduled_action_buffer_time(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "scheduled_action_buffer_time", value)


@pulumi.input_type
class ScalingPlanTagFilterArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "key", key)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class ScalingPlanTargetTrackingConfigurationArgs:
    def __init__(__self__, *,
                 target_value: pulumi.Input[float],
                 customized_scaling_metric_specification: Optional[pulumi.Input['ScalingPlanCustomizedScalingMetricSpecificationArgs']] = None,
                 disable_scale_in: Optional[pulumi.Input[bool]] = None,
                 estimated_instance_warmup: Optional[pulumi.Input[int]] = None,
                 predefined_scaling_metric_specification: Optional[pulumi.Input['ScalingPlanPredefinedScalingMetricSpecificationArgs']] = None,
                 scale_in_cooldown: Optional[pulumi.Input[int]] = None,
                 scale_out_cooldown: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "target_value", target_value)
        if customized_scaling_metric_specification is not None:
            pulumi.set(__self__, "customized_scaling_metric_specification", customized_scaling_metric_specification)
        if disable_scale_in is not None:
            pulumi.set(__self__, "disable_scale_in", disable_scale_in)
        if estimated_instance_warmup is not None:
            pulumi.set(__self__, "estimated_instance_warmup", estimated_instance_warmup)
        if predefined_scaling_metric_specification is not None:
            pulumi.set(__self__, "predefined_scaling_metric_specification", predefined_scaling_metric_specification)
        if scale_in_cooldown is not None:
            pulumi.set(__self__, "scale_in_cooldown", scale_in_cooldown)
        if scale_out_cooldown is not None:
            pulumi.set(__self__, "scale_out_cooldown", scale_out_cooldown)

    @property
    @pulumi.getter(name="targetValue")
    def target_value(self) -> pulumi.Input[float]:
        return pulumi.get(self, "target_value")

    @target_value.setter
    def target_value(self, value: pulumi.Input[float]):
        pulumi.set(self, "target_value", value)

    @property
    @pulumi.getter(name="customizedScalingMetricSpecification")
    def customized_scaling_metric_specification(self) -> Optional[pulumi.Input['ScalingPlanCustomizedScalingMetricSpecificationArgs']]:
        return pulumi.get(self, "customized_scaling_metric_specification")

    @customized_scaling_metric_specification.setter
    def customized_scaling_metric_specification(self, value: Optional[pulumi.Input['ScalingPlanCustomizedScalingMetricSpecificationArgs']]):
        pulumi.set(self, "customized_scaling_metric_specification", value)

    @property
    @pulumi.getter(name="disableScaleIn")
    def disable_scale_in(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "disable_scale_in")

    @disable_scale_in.setter
    def disable_scale_in(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_scale_in", value)

    @property
    @pulumi.getter(name="estimatedInstanceWarmup")
    def estimated_instance_warmup(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "estimated_instance_warmup")

    @estimated_instance_warmup.setter
    def estimated_instance_warmup(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "estimated_instance_warmup", value)

    @property
    @pulumi.getter(name="predefinedScalingMetricSpecification")
    def predefined_scaling_metric_specification(self) -> Optional[pulumi.Input['ScalingPlanPredefinedScalingMetricSpecificationArgs']]:
        return pulumi.get(self, "predefined_scaling_metric_specification")

    @predefined_scaling_metric_specification.setter
    def predefined_scaling_metric_specification(self, value: Optional[pulumi.Input['ScalingPlanPredefinedScalingMetricSpecificationArgs']]):
        pulumi.set(self, "predefined_scaling_metric_specification", value)

    @property
    @pulumi.getter(name="scaleInCooldown")
    def scale_in_cooldown(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "scale_in_cooldown")

    @scale_in_cooldown.setter
    def scale_in_cooldown(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "scale_in_cooldown", value)

    @property
    @pulumi.getter(name="scaleOutCooldown")
    def scale_out_cooldown(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "scale_out_cooldown")

    @scale_out_cooldown.setter
    def scale_out_cooldown(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "scale_out_cooldown", value)


