{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.CloudWatch.Types.MetricAlarm
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.CloudWatch.Types.MetricAlarm where

import Amazonka.CloudWatch.Types.ComparisonOperator
import Amazonka.CloudWatch.Types.Dimension
import Amazonka.CloudWatch.Types.EvaluationState
import Amazonka.CloudWatch.Types.MetricDataQuery
import Amazonka.CloudWatch.Types.StandardUnit
import Amazonka.CloudWatch.Types.StateValue
import Amazonka.CloudWatch.Types.Statistic
import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude

-- | The details about a metric alarm.
--
-- /See:/ 'newMetricAlarm' smart constructor.
data MetricAlarm = MetricAlarm'
  { -- | Indicates whether actions should be executed during any changes to the
    -- alarm state.
    MetricAlarm -> Maybe Bool
actionsEnabled :: Prelude.Maybe Prelude.Bool,
    -- | The actions to execute when this alarm transitions to the @ALARM@ state
    -- from any other state. Each action is specified as an Amazon Resource
    -- Name (ARN).
    MetricAlarm -> Maybe [Text]
alarmActions :: Prelude.Maybe [Prelude.Text],
    -- | The Amazon Resource Name (ARN) of the alarm.
    MetricAlarm -> Maybe Text
alarmArn :: Prelude.Maybe Prelude.Text,
    -- | The time stamp of the last update to the alarm configuration.
    MetricAlarm -> Maybe ISO8601
alarmConfigurationUpdatedTimestamp :: Prelude.Maybe Data.ISO8601,
    -- | The description of the alarm.
    MetricAlarm -> Maybe Text
alarmDescription :: Prelude.Maybe Prelude.Text,
    -- | The name of the alarm.
    MetricAlarm -> Maybe Text
alarmName :: Prelude.Maybe Prelude.Text,
    -- | The arithmetic operation to use when comparing the specified statistic
    -- and threshold. The specified statistic value is used as the first
    -- operand.
    MetricAlarm -> Maybe ComparisonOperator
comparisonOperator :: Prelude.Maybe ComparisonOperator,
    -- | The number of data points that must be breaching to trigger the alarm.
    MetricAlarm -> Maybe Natural
datapointsToAlarm :: Prelude.Maybe Prelude.Natural,
    -- | The dimensions for the metric associated with the alarm.
    MetricAlarm -> Maybe [Dimension]
dimensions :: Prelude.Maybe [Dimension],
    -- | Used only for alarms based on percentiles. If @ignore@, the alarm state
    -- does not change during periods with too few data points to be
    -- statistically significant. If @evaluate@ or this parameter is not used,
    -- the alarm is always evaluated and possibly changes state no matter how
    -- many data points are available.
    MetricAlarm -> Maybe Text
evaluateLowSampleCountPercentile :: Prelude.Maybe Prelude.Text,
    -- | The number of periods over which data is compared to the specified
    -- threshold.
    MetricAlarm -> Maybe Natural
evaluationPeriods :: Prelude.Maybe Prelude.Natural,
    -- | If the value of this field is @PARTIAL_DATA@, the alarm is being
    -- evaluated based on only partial data. This happens if the query used for
    -- the alarm returns more than 10,000 metrics. For more information, see
    -- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Create_Metrics_Insights_Alarm.html Create alarms on Metrics Insights queries>.
    MetricAlarm -> Maybe EvaluationState
evaluationState :: Prelude.Maybe EvaluationState,
    -- | The percentile statistic for the metric associated with the alarm.
    -- Specify a value between p0.0 and p100.
    MetricAlarm -> Maybe Text
extendedStatistic :: Prelude.Maybe Prelude.Text,
    -- | The actions to execute when this alarm transitions to the
    -- @INSUFFICIENT_DATA@ state from any other state. Each action is specified
    -- as an Amazon Resource Name (ARN).
    MetricAlarm -> Maybe [Text]
insufficientDataActions :: Prelude.Maybe [Prelude.Text],
    -- | The name of the metric associated with the alarm, if this is an alarm
    -- based on a single metric.
    MetricAlarm -> Maybe Text
metricName :: Prelude.Maybe Prelude.Text,
    -- | An array of MetricDataQuery structures, used in an alarm based on a
    -- metric math expression. Each structure either retrieves a metric or
    -- performs a math expression. One item in the Metrics array is the math
    -- expression that the alarm watches. This expression by designated by
    -- having @ReturnData@ set to true.
    MetricAlarm -> Maybe [MetricDataQuery]
metrics :: Prelude.Maybe [MetricDataQuery],
    -- | The namespace of the metric associated with the alarm.
    MetricAlarm -> Maybe Text
namespace :: Prelude.Maybe Prelude.Text,
    -- | The actions to execute when this alarm transitions to the @OK@ state
    -- from any other state. Each action is specified as an Amazon Resource
    -- Name (ARN).
    MetricAlarm -> Maybe [Text]
oKActions :: Prelude.Maybe [Prelude.Text],
    -- | The period, in seconds, over which the statistic is applied.
    MetricAlarm -> Maybe Natural
period :: Prelude.Maybe Prelude.Natural,
    -- | An explanation for the alarm state, in text format.
    MetricAlarm -> Maybe Text
stateReason :: Prelude.Maybe Prelude.Text,
    -- | An explanation for the alarm state, in JSON format.
    MetricAlarm -> Maybe Text
stateReasonData :: Prelude.Maybe Prelude.Text,
    -- | The date and time that the alarm\'s @StateValue@ most recently changed.
    MetricAlarm -> Maybe ISO8601
stateTransitionedTimestamp :: Prelude.Maybe Data.ISO8601,
    -- | The time stamp of the last update to the value of either the
    -- @StateValue@ or @EvaluationState@ parameters.
    MetricAlarm -> Maybe ISO8601
stateUpdatedTimestamp :: Prelude.Maybe Data.ISO8601,
    -- | The state value for the alarm.
    MetricAlarm -> Maybe StateValue
stateValue :: Prelude.Maybe StateValue,
    -- | The statistic for the metric associated with the alarm, other than
    -- percentile. For percentile statistics, use @ExtendedStatistic@.
    MetricAlarm -> Maybe Statistic
statistic :: Prelude.Maybe Statistic,
    -- | The value to compare with the specified statistic.
    MetricAlarm -> Maybe Double
threshold :: Prelude.Maybe Prelude.Double,
    -- | In an alarm based on an anomaly detection model, this is the ID of the
    -- @ANOMALY_DETECTION_BAND@ function used as the threshold for the alarm.
    MetricAlarm -> Maybe Text
thresholdMetricId :: Prelude.Maybe Prelude.Text,
    -- | Sets how this alarm is to handle missing data points. The valid values
    -- are @breaching@, @notBreaching@, @ignore@, and @missing@. For more
    -- information, see
    -- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarms-and-missing-data Configuring how CloudWatch alarms treat missing data>.
    --
    -- If this parameter is omitted, the default behavior of @missing@ is used.
    MetricAlarm -> Maybe Text
treatMissingData :: Prelude.Maybe Prelude.Text,
    -- | The unit of the metric associated with the alarm.
    MetricAlarm -> Maybe StandardUnit
unit :: Prelude.Maybe StandardUnit
  }
  deriving (MetricAlarm -> MetricAlarm -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MetricAlarm -> MetricAlarm -> Bool
$c/= :: MetricAlarm -> MetricAlarm -> Bool
== :: MetricAlarm -> MetricAlarm -> Bool
$c== :: MetricAlarm -> MetricAlarm -> Bool
Prelude.Eq, ReadPrec [MetricAlarm]
ReadPrec MetricAlarm
Int -> ReadS MetricAlarm
ReadS [MetricAlarm]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MetricAlarm]
$creadListPrec :: ReadPrec [MetricAlarm]
readPrec :: ReadPrec MetricAlarm
$creadPrec :: ReadPrec MetricAlarm
readList :: ReadS [MetricAlarm]
$creadList :: ReadS [MetricAlarm]
readsPrec :: Int -> ReadS MetricAlarm
$creadsPrec :: Int -> ReadS MetricAlarm
Prelude.Read, Int -> MetricAlarm -> ShowS
[MetricAlarm] -> ShowS
MetricAlarm -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MetricAlarm] -> ShowS
$cshowList :: [MetricAlarm] -> ShowS
show :: MetricAlarm -> String
$cshow :: MetricAlarm -> String
showsPrec :: Int -> MetricAlarm -> ShowS
$cshowsPrec :: Int -> MetricAlarm -> ShowS
Prelude.Show, forall x. Rep MetricAlarm x -> MetricAlarm
forall x. MetricAlarm -> Rep MetricAlarm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MetricAlarm x -> MetricAlarm
$cfrom :: forall x. MetricAlarm -> Rep MetricAlarm x
Prelude.Generic)

-- |
-- Create a value of 'MetricAlarm' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'actionsEnabled', 'metricAlarm_actionsEnabled' - Indicates whether actions should be executed during any changes to the
-- alarm state.
--
-- 'alarmActions', 'metricAlarm_alarmActions' - The actions to execute when this alarm transitions to the @ALARM@ state
-- from any other state. Each action is specified as an Amazon Resource
-- Name (ARN).
--
-- 'alarmArn', 'metricAlarm_alarmArn' - The Amazon Resource Name (ARN) of the alarm.
--
-- 'alarmConfigurationUpdatedTimestamp', 'metricAlarm_alarmConfigurationUpdatedTimestamp' - The time stamp of the last update to the alarm configuration.
--
-- 'alarmDescription', 'metricAlarm_alarmDescription' - The description of the alarm.
--
-- 'alarmName', 'metricAlarm_alarmName' - The name of the alarm.
--
-- 'comparisonOperator', 'metricAlarm_comparisonOperator' - The arithmetic operation to use when comparing the specified statistic
-- and threshold. The specified statistic value is used as the first
-- operand.
--
-- 'datapointsToAlarm', 'metricAlarm_datapointsToAlarm' - The number of data points that must be breaching to trigger the alarm.
--
-- 'dimensions', 'metricAlarm_dimensions' - The dimensions for the metric associated with the alarm.
--
-- 'evaluateLowSampleCountPercentile', 'metricAlarm_evaluateLowSampleCountPercentile' - Used only for alarms based on percentiles. If @ignore@, the alarm state
-- does not change during periods with too few data points to be
-- statistically significant. If @evaluate@ or this parameter is not used,
-- the alarm is always evaluated and possibly changes state no matter how
-- many data points are available.
--
-- 'evaluationPeriods', 'metricAlarm_evaluationPeriods' - The number of periods over which data is compared to the specified
-- threshold.
--
-- 'evaluationState', 'metricAlarm_evaluationState' - If the value of this field is @PARTIAL_DATA@, the alarm is being
-- evaluated based on only partial data. This happens if the query used for
-- the alarm returns more than 10,000 metrics. For more information, see
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Create_Metrics_Insights_Alarm.html Create alarms on Metrics Insights queries>.
--
-- 'extendedStatistic', 'metricAlarm_extendedStatistic' - The percentile statistic for the metric associated with the alarm.
-- Specify a value between p0.0 and p100.
--
-- 'insufficientDataActions', 'metricAlarm_insufficientDataActions' - The actions to execute when this alarm transitions to the
-- @INSUFFICIENT_DATA@ state from any other state. Each action is specified
-- as an Amazon Resource Name (ARN).
--
-- 'metricName', 'metricAlarm_metricName' - The name of the metric associated with the alarm, if this is an alarm
-- based on a single metric.
--
-- 'metrics', 'metricAlarm_metrics' - An array of MetricDataQuery structures, used in an alarm based on a
-- metric math expression. Each structure either retrieves a metric or
-- performs a math expression. One item in the Metrics array is the math
-- expression that the alarm watches. This expression by designated by
-- having @ReturnData@ set to true.
--
-- 'namespace', 'metricAlarm_namespace' - The namespace of the metric associated with the alarm.
--
-- 'oKActions', 'metricAlarm_oKActions' - The actions to execute when this alarm transitions to the @OK@ state
-- from any other state. Each action is specified as an Amazon Resource
-- Name (ARN).
--
-- 'period', 'metricAlarm_period' - The period, in seconds, over which the statistic is applied.
--
-- 'stateReason', 'metricAlarm_stateReason' - An explanation for the alarm state, in text format.
--
-- 'stateReasonData', 'metricAlarm_stateReasonData' - An explanation for the alarm state, in JSON format.
--
-- 'stateTransitionedTimestamp', 'metricAlarm_stateTransitionedTimestamp' - The date and time that the alarm\'s @StateValue@ most recently changed.
--
-- 'stateUpdatedTimestamp', 'metricAlarm_stateUpdatedTimestamp' - The time stamp of the last update to the value of either the
-- @StateValue@ or @EvaluationState@ parameters.
--
-- 'stateValue', 'metricAlarm_stateValue' - The state value for the alarm.
--
-- 'statistic', 'metricAlarm_statistic' - The statistic for the metric associated with the alarm, other than
-- percentile. For percentile statistics, use @ExtendedStatistic@.
--
-- 'threshold', 'metricAlarm_threshold' - The value to compare with the specified statistic.
--
-- 'thresholdMetricId', 'metricAlarm_thresholdMetricId' - In an alarm based on an anomaly detection model, this is the ID of the
-- @ANOMALY_DETECTION_BAND@ function used as the threshold for the alarm.
--
-- 'treatMissingData', 'metricAlarm_treatMissingData' - Sets how this alarm is to handle missing data points. The valid values
-- are @breaching@, @notBreaching@, @ignore@, and @missing@. For more
-- information, see
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarms-and-missing-data Configuring how CloudWatch alarms treat missing data>.
--
-- If this parameter is omitted, the default behavior of @missing@ is used.
--
-- 'unit', 'metricAlarm_unit' - The unit of the metric associated with the alarm.
newMetricAlarm ::
  MetricAlarm
newMetricAlarm :: MetricAlarm
newMetricAlarm =
  MetricAlarm'
    { $sel:actionsEnabled:MetricAlarm' :: Maybe Bool
actionsEnabled = forall a. Maybe a
Prelude.Nothing,
      $sel:alarmActions:MetricAlarm' :: Maybe [Text]
alarmActions = forall a. Maybe a
Prelude.Nothing,
      $sel:alarmArn:MetricAlarm' :: Maybe Text
alarmArn = forall a. Maybe a
Prelude.Nothing,
      $sel:alarmConfigurationUpdatedTimestamp:MetricAlarm' :: Maybe ISO8601
alarmConfigurationUpdatedTimestamp = forall a. Maybe a
Prelude.Nothing,
      $sel:alarmDescription:MetricAlarm' :: Maybe Text
alarmDescription = forall a. Maybe a
Prelude.Nothing,
      $sel:alarmName:MetricAlarm' :: Maybe Text
alarmName = forall a. Maybe a
Prelude.Nothing,
      $sel:comparisonOperator:MetricAlarm' :: Maybe ComparisonOperator
comparisonOperator = forall a. Maybe a
Prelude.Nothing,
      $sel:datapointsToAlarm:MetricAlarm' :: Maybe Natural
datapointsToAlarm = forall a. Maybe a
Prelude.Nothing,
      $sel:dimensions:MetricAlarm' :: Maybe [Dimension]
dimensions = forall a. Maybe a
Prelude.Nothing,
      $sel:evaluateLowSampleCountPercentile:MetricAlarm' :: Maybe Text
evaluateLowSampleCountPercentile = forall a. Maybe a
Prelude.Nothing,
      $sel:evaluationPeriods:MetricAlarm' :: Maybe Natural
evaluationPeriods = forall a. Maybe a
Prelude.Nothing,
      $sel:evaluationState:MetricAlarm' :: Maybe EvaluationState
evaluationState = forall a. Maybe a
Prelude.Nothing,
      $sel:extendedStatistic:MetricAlarm' :: Maybe Text
extendedStatistic = forall a. Maybe a
Prelude.Nothing,
      $sel:insufficientDataActions:MetricAlarm' :: Maybe [Text]
insufficientDataActions = forall a. Maybe a
Prelude.Nothing,
      $sel:metricName:MetricAlarm' :: Maybe Text
metricName = forall a. Maybe a
Prelude.Nothing,
      $sel:metrics:MetricAlarm' :: Maybe [MetricDataQuery]
metrics = forall a. Maybe a
Prelude.Nothing,
      $sel:namespace:MetricAlarm' :: Maybe Text
namespace = forall a. Maybe a
Prelude.Nothing,
      $sel:oKActions:MetricAlarm' :: Maybe [Text]
oKActions = forall a. Maybe a
Prelude.Nothing,
      $sel:period:MetricAlarm' :: Maybe Natural
period = forall a. Maybe a
Prelude.Nothing,
      $sel:stateReason:MetricAlarm' :: Maybe Text
stateReason = forall a. Maybe a
Prelude.Nothing,
      $sel:stateReasonData:MetricAlarm' :: Maybe Text
stateReasonData = forall a. Maybe a
Prelude.Nothing,
      $sel:stateTransitionedTimestamp:MetricAlarm' :: Maybe ISO8601
stateTransitionedTimestamp = forall a. Maybe a
Prelude.Nothing,
      $sel:stateUpdatedTimestamp:MetricAlarm' :: Maybe ISO8601
stateUpdatedTimestamp = forall a. Maybe a
Prelude.Nothing,
      $sel:stateValue:MetricAlarm' :: Maybe StateValue
stateValue = forall a. Maybe a
Prelude.Nothing,
      $sel:statistic:MetricAlarm' :: Maybe Statistic
statistic = forall a. Maybe a
Prelude.Nothing,
      $sel:threshold:MetricAlarm' :: Maybe Double
threshold = forall a. Maybe a
Prelude.Nothing,
      $sel:thresholdMetricId:MetricAlarm' :: Maybe Text
thresholdMetricId = forall a. Maybe a
Prelude.Nothing,
      $sel:treatMissingData:MetricAlarm' :: Maybe Text
treatMissingData = forall a. Maybe a
Prelude.Nothing,
      $sel:unit:MetricAlarm' :: Maybe StandardUnit
unit = forall a. Maybe a
Prelude.Nothing
    }

-- | Indicates whether actions should be executed during any changes to the
-- alarm state.
metricAlarm_actionsEnabled :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Bool)
metricAlarm_actionsEnabled :: Lens' MetricAlarm (Maybe Bool)
metricAlarm_actionsEnabled = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Bool
actionsEnabled :: Maybe Bool
$sel:actionsEnabled:MetricAlarm' :: MetricAlarm -> Maybe Bool
actionsEnabled} -> Maybe Bool
actionsEnabled) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Bool
a -> MetricAlarm
s {$sel:actionsEnabled:MetricAlarm' :: Maybe Bool
actionsEnabled = Maybe Bool
a} :: MetricAlarm)

-- | The actions to execute when this alarm transitions to the @ALARM@ state
-- from any other state. Each action is specified as an Amazon Resource
-- Name (ARN).
metricAlarm_alarmActions :: Lens.Lens' MetricAlarm (Prelude.Maybe [Prelude.Text])
metricAlarm_alarmActions :: Lens' MetricAlarm (Maybe [Text])
metricAlarm_alarmActions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe [Text]
alarmActions :: Maybe [Text]
$sel:alarmActions:MetricAlarm' :: MetricAlarm -> Maybe [Text]
alarmActions} -> Maybe [Text]
alarmActions) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe [Text]
a -> MetricAlarm
s {$sel:alarmActions:MetricAlarm' :: Maybe [Text]
alarmActions = Maybe [Text]
a} :: MetricAlarm) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The Amazon Resource Name (ARN) of the alarm.
metricAlarm_alarmArn :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_alarmArn :: Lens' MetricAlarm (Maybe Text)
metricAlarm_alarmArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
alarmArn :: Maybe Text
$sel:alarmArn:MetricAlarm' :: MetricAlarm -> Maybe Text
alarmArn} -> Maybe Text
alarmArn) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:alarmArn:MetricAlarm' :: Maybe Text
alarmArn = Maybe Text
a} :: MetricAlarm)

-- | The time stamp of the last update to the alarm configuration.
metricAlarm_alarmConfigurationUpdatedTimestamp :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.UTCTime)
metricAlarm_alarmConfigurationUpdatedTimestamp :: Lens' MetricAlarm (Maybe UTCTime)
metricAlarm_alarmConfigurationUpdatedTimestamp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe ISO8601
alarmConfigurationUpdatedTimestamp :: Maybe ISO8601
$sel:alarmConfigurationUpdatedTimestamp:MetricAlarm' :: MetricAlarm -> Maybe ISO8601
alarmConfigurationUpdatedTimestamp} -> Maybe ISO8601
alarmConfigurationUpdatedTimestamp) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe ISO8601
a -> MetricAlarm
s {$sel:alarmConfigurationUpdatedTimestamp:MetricAlarm' :: Maybe ISO8601
alarmConfigurationUpdatedTimestamp = Maybe ISO8601
a} :: MetricAlarm) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The description of the alarm.
metricAlarm_alarmDescription :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_alarmDescription :: Lens' MetricAlarm (Maybe Text)
metricAlarm_alarmDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
alarmDescription :: Maybe Text
$sel:alarmDescription:MetricAlarm' :: MetricAlarm -> Maybe Text
alarmDescription} -> Maybe Text
alarmDescription) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:alarmDescription:MetricAlarm' :: Maybe Text
alarmDescription = Maybe Text
a} :: MetricAlarm)

-- | The name of the alarm.
metricAlarm_alarmName :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_alarmName :: Lens' MetricAlarm (Maybe Text)
metricAlarm_alarmName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
alarmName :: Maybe Text
$sel:alarmName:MetricAlarm' :: MetricAlarm -> Maybe Text
alarmName} -> Maybe Text
alarmName) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:alarmName:MetricAlarm' :: Maybe Text
alarmName = Maybe Text
a} :: MetricAlarm)

-- | The arithmetic operation to use when comparing the specified statistic
-- and threshold. The specified statistic value is used as the first
-- operand.
metricAlarm_comparisonOperator :: Lens.Lens' MetricAlarm (Prelude.Maybe ComparisonOperator)
metricAlarm_comparisonOperator :: Lens' MetricAlarm (Maybe ComparisonOperator)
metricAlarm_comparisonOperator = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe ComparisonOperator
comparisonOperator :: Maybe ComparisonOperator
$sel:comparisonOperator:MetricAlarm' :: MetricAlarm -> Maybe ComparisonOperator
comparisonOperator} -> Maybe ComparisonOperator
comparisonOperator) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe ComparisonOperator
a -> MetricAlarm
s {$sel:comparisonOperator:MetricAlarm' :: Maybe ComparisonOperator
comparisonOperator = Maybe ComparisonOperator
a} :: MetricAlarm)

-- | The number of data points that must be breaching to trigger the alarm.
metricAlarm_datapointsToAlarm :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Natural)
metricAlarm_datapointsToAlarm :: Lens' MetricAlarm (Maybe Natural)
metricAlarm_datapointsToAlarm = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Natural
datapointsToAlarm :: Maybe Natural
$sel:datapointsToAlarm:MetricAlarm' :: MetricAlarm -> Maybe Natural
datapointsToAlarm} -> Maybe Natural
datapointsToAlarm) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Natural
a -> MetricAlarm
s {$sel:datapointsToAlarm:MetricAlarm' :: Maybe Natural
datapointsToAlarm = Maybe Natural
a} :: MetricAlarm)

-- | The dimensions for the metric associated with the alarm.
metricAlarm_dimensions :: Lens.Lens' MetricAlarm (Prelude.Maybe [Dimension])
metricAlarm_dimensions :: Lens' MetricAlarm (Maybe [Dimension])
metricAlarm_dimensions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe [Dimension]
dimensions :: Maybe [Dimension]
$sel:dimensions:MetricAlarm' :: MetricAlarm -> Maybe [Dimension]
dimensions} -> Maybe [Dimension]
dimensions) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe [Dimension]
a -> MetricAlarm
s {$sel:dimensions:MetricAlarm' :: Maybe [Dimension]
dimensions = Maybe [Dimension]
a} :: MetricAlarm) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Used only for alarms based on percentiles. If @ignore@, the alarm state
-- does not change during periods with too few data points to be
-- statistically significant. If @evaluate@ or this parameter is not used,
-- the alarm is always evaluated and possibly changes state no matter how
-- many data points are available.
metricAlarm_evaluateLowSampleCountPercentile :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_evaluateLowSampleCountPercentile :: Lens' MetricAlarm (Maybe Text)
metricAlarm_evaluateLowSampleCountPercentile = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
evaluateLowSampleCountPercentile :: Maybe Text
$sel:evaluateLowSampleCountPercentile:MetricAlarm' :: MetricAlarm -> Maybe Text
evaluateLowSampleCountPercentile} -> Maybe Text
evaluateLowSampleCountPercentile) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:evaluateLowSampleCountPercentile:MetricAlarm' :: Maybe Text
evaluateLowSampleCountPercentile = Maybe Text
a} :: MetricAlarm)

-- | The number of periods over which data is compared to the specified
-- threshold.
metricAlarm_evaluationPeriods :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Natural)
metricAlarm_evaluationPeriods :: Lens' MetricAlarm (Maybe Natural)
metricAlarm_evaluationPeriods = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Natural
evaluationPeriods :: Maybe Natural
$sel:evaluationPeriods:MetricAlarm' :: MetricAlarm -> Maybe Natural
evaluationPeriods} -> Maybe Natural
evaluationPeriods) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Natural
a -> MetricAlarm
s {$sel:evaluationPeriods:MetricAlarm' :: Maybe Natural
evaluationPeriods = Maybe Natural
a} :: MetricAlarm)

-- | If the value of this field is @PARTIAL_DATA@, the alarm is being
-- evaluated based on only partial data. This happens if the query used for
-- the alarm returns more than 10,000 metrics. For more information, see
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Create_Metrics_Insights_Alarm.html Create alarms on Metrics Insights queries>.
metricAlarm_evaluationState :: Lens.Lens' MetricAlarm (Prelude.Maybe EvaluationState)
metricAlarm_evaluationState :: Lens' MetricAlarm (Maybe EvaluationState)
metricAlarm_evaluationState = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe EvaluationState
evaluationState :: Maybe EvaluationState
$sel:evaluationState:MetricAlarm' :: MetricAlarm -> Maybe EvaluationState
evaluationState} -> Maybe EvaluationState
evaluationState) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe EvaluationState
a -> MetricAlarm
s {$sel:evaluationState:MetricAlarm' :: Maybe EvaluationState
evaluationState = Maybe EvaluationState
a} :: MetricAlarm)

-- | The percentile statistic for the metric associated with the alarm.
-- Specify a value between p0.0 and p100.
metricAlarm_extendedStatistic :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_extendedStatistic :: Lens' MetricAlarm (Maybe Text)
metricAlarm_extendedStatistic = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
extendedStatistic :: Maybe Text
$sel:extendedStatistic:MetricAlarm' :: MetricAlarm -> Maybe Text
extendedStatistic} -> Maybe Text
extendedStatistic) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:extendedStatistic:MetricAlarm' :: Maybe Text
extendedStatistic = Maybe Text
a} :: MetricAlarm)

-- | The actions to execute when this alarm transitions to the
-- @INSUFFICIENT_DATA@ state from any other state. Each action is specified
-- as an Amazon Resource Name (ARN).
metricAlarm_insufficientDataActions :: Lens.Lens' MetricAlarm (Prelude.Maybe [Prelude.Text])
metricAlarm_insufficientDataActions :: Lens' MetricAlarm (Maybe [Text])
metricAlarm_insufficientDataActions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe [Text]
insufficientDataActions :: Maybe [Text]
$sel:insufficientDataActions:MetricAlarm' :: MetricAlarm -> Maybe [Text]
insufficientDataActions} -> Maybe [Text]
insufficientDataActions) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe [Text]
a -> MetricAlarm
s {$sel:insufficientDataActions:MetricAlarm' :: Maybe [Text]
insufficientDataActions = Maybe [Text]
a} :: MetricAlarm) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of the metric associated with the alarm, if this is an alarm
-- based on a single metric.
metricAlarm_metricName :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_metricName :: Lens' MetricAlarm (Maybe Text)
metricAlarm_metricName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
metricName :: Maybe Text
$sel:metricName:MetricAlarm' :: MetricAlarm -> Maybe Text
metricName} -> Maybe Text
metricName) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:metricName:MetricAlarm' :: Maybe Text
metricName = Maybe Text
a} :: MetricAlarm)

-- | An array of MetricDataQuery structures, used in an alarm based on a
-- metric math expression. Each structure either retrieves a metric or
-- performs a math expression. One item in the Metrics array is the math
-- expression that the alarm watches. This expression by designated by
-- having @ReturnData@ set to true.
metricAlarm_metrics :: Lens.Lens' MetricAlarm (Prelude.Maybe [MetricDataQuery])
metricAlarm_metrics :: Lens' MetricAlarm (Maybe [MetricDataQuery])
metricAlarm_metrics = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe [MetricDataQuery]
metrics :: Maybe [MetricDataQuery]
$sel:metrics:MetricAlarm' :: MetricAlarm -> Maybe [MetricDataQuery]
metrics} -> Maybe [MetricDataQuery]
metrics) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe [MetricDataQuery]
a -> MetricAlarm
s {$sel:metrics:MetricAlarm' :: Maybe [MetricDataQuery]
metrics = Maybe [MetricDataQuery]
a} :: MetricAlarm) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The namespace of the metric associated with the alarm.
metricAlarm_namespace :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_namespace :: Lens' MetricAlarm (Maybe Text)
metricAlarm_namespace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
namespace :: Maybe Text
$sel:namespace:MetricAlarm' :: MetricAlarm -> Maybe Text
namespace} -> Maybe Text
namespace) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:namespace:MetricAlarm' :: Maybe Text
namespace = Maybe Text
a} :: MetricAlarm)

-- | The actions to execute when this alarm transitions to the @OK@ state
-- from any other state. Each action is specified as an Amazon Resource
-- Name (ARN).
metricAlarm_oKActions :: Lens.Lens' MetricAlarm (Prelude.Maybe [Prelude.Text])
metricAlarm_oKActions :: Lens' MetricAlarm (Maybe [Text])
metricAlarm_oKActions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe [Text]
oKActions :: Maybe [Text]
$sel:oKActions:MetricAlarm' :: MetricAlarm -> Maybe [Text]
oKActions} -> Maybe [Text]
oKActions) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe [Text]
a -> MetricAlarm
s {$sel:oKActions:MetricAlarm' :: Maybe [Text]
oKActions = Maybe [Text]
a} :: MetricAlarm) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The period, in seconds, over which the statistic is applied.
metricAlarm_period :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Natural)
metricAlarm_period :: Lens' MetricAlarm (Maybe Natural)
metricAlarm_period = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Natural
period :: Maybe Natural
$sel:period:MetricAlarm' :: MetricAlarm -> Maybe Natural
period} -> Maybe Natural
period) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Natural
a -> MetricAlarm
s {$sel:period:MetricAlarm' :: Maybe Natural
period = Maybe Natural
a} :: MetricAlarm)

-- | An explanation for the alarm state, in text format.
metricAlarm_stateReason :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_stateReason :: Lens' MetricAlarm (Maybe Text)
metricAlarm_stateReason = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
stateReason :: Maybe Text
$sel:stateReason:MetricAlarm' :: MetricAlarm -> Maybe Text
stateReason} -> Maybe Text
stateReason) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:stateReason:MetricAlarm' :: Maybe Text
stateReason = Maybe Text
a} :: MetricAlarm)

-- | An explanation for the alarm state, in JSON format.
metricAlarm_stateReasonData :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_stateReasonData :: Lens' MetricAlarm (Maybe Text)
metricAlarm_stateReasonData = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
stateReasonData :: Maybe Text
$sel:stateReasonData:MetricAlarm' :: MetricAlarm -> Maybe Text
stateReasonData} -> Maybe Text
stateReasonData) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:stateReasonData:MetricAlarm' :: Maybe Text
stateReasonData = Maybe Text
a} :: MetricAlarm)

-- | The date and time that the alarm\'s @StateValue@ most recently changed.
metricAlarm_stateTransitionedTimestamp :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.UTCTime)
metricAlarm_stateTransitionedTimestamp :: Lens' MetricAlarm (Maybe UTCTime)
metricAlarm_stateTransitionedTimestamp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe ISO8601
stateTransitionedTimestamp :: Maybe ISO8601
$sel:stateTransitionedTimestamp:MetricAlarm' :: MetricAlarm -> Maybe ISO8601
stateTransitionedTimestamp} -> Maybe ISO8601
stateTransitionedTimestamp) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe ISO8601
a -> MetricAlarm
s {$sel:stateTransitionedTimestamp:MetricAlarm' :: Maybe ISO8601
stateTransitionedTimestamp = Maybe ISO8601
a} :: MetricAlarm) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The time stamp of the last update to the value of either the
-- @StateValue@ or @EvaluationState@ parameters.
metricAlarm_stateUpdatedTimestamp :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.UTCTime)
metricAlarm_stateUpdatedTimestamp :: Lens' MetricAlarm (Maybe UTCTime)
metricAlarm_stateUpdatedTimestamp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe ISO8601
stateUpdatedTimestamp :: Maybe ISO8601
$sel:stateUpdatedTimestamp:MetricAlarm' :: MetricAlarm -> Maybe ISO8601
stateUpdatedTimestamp} -> Maybe ISO8601
stateUpdatedTimestamp) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe ISO8601
a -> MetricAlarm
s {$sel:stateUpdatedTimestamp:MetricAlarm' :: Maybe ISO8601
stateUpdatedTimestamp = Maybe ISO8601
a} :: MetricAlarm) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The state value for the alarm.
metricAlarm_stateValue :: Lens.Lens' MetricAlarm (Prelude.Maybe StateValue)
metricAlarm_stateValue :: Lens' MetricAlarm (Maybe StateValue)
metricAlarm_stateValue = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe StateValue
stateValue :: Maybe StateValue
$sel:stateValue:MetricAlarm' :: MetricAlarm -> Maybe StateValue
stateValue} -> Maybe StateValue
stateValue) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe StateValue
a -> MetricAlarm
s {$sel:stateValue:MetricAlarm' :: Maybe StateValue
stateValue = Maybe StateValue
a} :: MetricAlarm)

-- | The statistic for the metric associated with the alarm, other than
-- percentile. For percentile statistics, use @ExtendedStatistic@.
metricAlarm_statistic :: Lens.Lens' MetricAlarm (Prelude.Maybe Statistic)
metricAlarm_statistic :: Lens' MetricAlarm (Maybe Statistic)
metricAlarm_statistic = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Statistic
statistic :: Maybe Statistic
$sel:statistic:MetricAlarm' :: MetricAlarm -> Maybe Statistic
statistic} -> Maybe Statistic
statistic) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Statistic
a -> MetricAlarm
s {$sel:statistic:MetricAlarm' :: Maybe Statistic
statistic = Maybe Statistic
a} :: MetricAlarm)

-- | The value to compare with the specified statistic.
metricAlarm_threshold :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Double)
metricAlarm_threshold :: Lens' MetricAlarm (Maybe Double)
metricAlarm_threshold = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Double
threshold :: Maybe Double
$sel:threshold:MetricAlarm' :: MetricAlarm -> Maybe Double
threshold} -> Maybe Double
threshold) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Double
a -> MetricAlarm
s {$sel:threshold:MetricAlarm' :: Maybe Double
threshold = Maybe Double
a} :: MetricAlarm)

-- | In an alarm based on an anomaly detection model, this is the ID of the
-- @ANOMALY_DETECTION_BAND@ function used as the threshold for the alarm.
metricAlarm_thresholdMetricId :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_thresholdMetricId :: Lens' MetricAlarm (Maybe Text)
metricAlarm_thresholdMetricId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
thresholdMetricId :: Maybe Text
$sel:thresholdMetricId:MetricAlarm' :: MetricAlarm -> Maybe Text
thresholdMetricId} -> Maybe Text
thresholdMetricId) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:thresholdMetricId:MetricAlarm' :: Maybe Text
thresholdMetricId = Maybe Text
a} :: MetricAlarm)

-- | Sets how this alarm is to handle missing data points. The valid values
-- are @breaching@, @notBreaching@, @ignore@, and @missing@. For more
-- information, see
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarms-and-missing-data Configuring how CloudWatch alarms treat missing data>.
--
-- If this parameter is omitted, the default behavior of @missing@ is used.
metricAlarm_treatMissingData :: Lens.Lens' MetricAlarm (Prelude.Maybe Prelude.Text)
metricAlarm_treatMissingData :: Lens' MetricAlarm (Maybe Text)
metricAlarm_treatMissingData = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe Text
treatMissingData :: Maybe Text
$sel:treatMissingData:MetricAlarm' :: MetricAlarm -> Maybe Text
treatMissingData} -> Maybe Text
treatMissingData) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe Text
a -> MetricAlarm
s {$sel:treatMissingData:MetricAlarm' :: Maybe Text
treatMissingData = Maybe Text
a} :: MetricAlarm)

-- | The unit of the metric associated with the alarm.
metricAlarm_unit :: Lens.Lens' MetricAlarm (Prelude.Maybe StandardUnit)
metricAlarm_unit :: Lens' MetricAlarm (Maybe StandardUnit)
metricAlarm_unit = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\MetricAlarm' {Maybe StandardUnit
unit :: Maybe StandardUnit
$sel:unit:MetricAlarm' :: MetricAlarm -> Maybe StandardUnit
unit} -> Maybe StandardUnit
unit) (\s :: MetricAlarm
s@MetricAlarm' {} Maybe StandardUnit
a -> MetricAlarm
s {$sel:unit:MetricAlarm' :: Maybe StandardUnit
unit = Maybe StandardUnit
a} :: MetricAlarm)

instance Data.FromXML MetricAlarm where
  parseXML :: [Node] -> Either String MetricAlarm
parseXML [Node]
x =
    Maybe Bool
-> Maybe [Text]
-> Maybe Text
-> Maybe ISO8601
-> Maybe Text
-> Maybe Text
-> Maybe ComparisonOperator
-> Maybe Natural
-> Maybe [Dimension]
-> Maybe Text
-> Maybe Natural
-> Maybe EvaluationState
-> Maybe Text
-> Maybe [Text]
-> Maybe Text
-> Maybe [MetricDataQuery]
-> Maybe Text
-> Maybe [Text]
-> Maybe Natural
-> Maybe Text
-> Maybe Text
-> Maybe ISO8601
-> Maybe ISO8601
-> Maybe StateValue
-> Maybe Statistic
-> Maybe Double
-> Maybe Text
-> Maybe Text
-> Maybe StandardUnit
-> MetricAlarm
MetricAlarm'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ActionsEnabled")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"AlarmActions"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"AlarmArn")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"AlarmConfigurationUpdatedTimestamp")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"AlarmDescription")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"AlarmName")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ComparisonOperator")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"DatapointsToAlarm")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Dimensions"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"EvaluateLowSampleCountPercentile")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"EvaluationPeriods")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"EvaluationState")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ExtendedStatistic")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"InsufficientDataActions"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"MetricName")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Metrics"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Namespace")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"OKActions"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Period")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"StateReason")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"StateReasonData")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"StateTransitionedTimestamp")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"StateUpdatedTimestamp")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"StateValue")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Statistic")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Threshold")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ThresholdMetricId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"TreatMissingData")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Unit")

instance Prelude.Hashable MetricAlarm where
  hashWithSalt :: Int -> MetricAlarm -> Int
hashWithSalt Int
_salt MetricAlarm' {Maybe Bool
Maybe Double
Maybe Natural
Maybe [Text]
Maybe [Dimension]
Maybe [MetricDataQuery]
Maybe Text
Maybe ISO8601
Maybe ComparisonOperator
Maybe EvaluationState
Maybe StandardUnit
Maybe StateValue
Maybe Statistic
unit :: Maybe StandardUnit
treatMissingData :: Maybe Text
thresholdMetricId :: Maybe Text
threshold :: Maybe Double
statistic :: Maybe Statistic
stateValue :: Maybe StateValue
stateUpdatedTimestamp :: Maybe ISO8601
stateTransitionedTimestamp :: Maybe ISO8601
stateReasonData :: Maybe Text
stateReason :: Maybe Text
period :: Maybe Natural
oKActions :: Maybe [Text]
namespace :: Maybe Text
metrics :: Maybe [MetricDataQuery]
metricName :: Maybe Text
insufficientDataActions :: Maybe [Text]
extendedStatistic :: Maybe Text
evaluationState :: Maybe EvaluationState
evaluationPeriods :: Maybe Natural
evaluateLowSampleCountPercentile :: Maybe Text
dimensions :: Maybe [Dimension]
datapointsToAlarm :: Maybe Natural
comparisonOperator :: Maybe ComparisonOperator
alarmName :: Maybe Text
alarmDescription :: Maybe Text
alarmConfigurationUpdatedTimestamp :: Maybe ISO8601
alarmArn :: Maybe Text
alarmActions :: Maybe [Text]
actionsEnabled :: Maybe Bool
$sel:unit:MetricAlarm' :: MetricAlarm -> Maybe StandardUnit
$sel:treatMissingData:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:thresholdMetricId:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:threshold:MetricAlarm' :: MetricAlarm -> Maybe Double
$sel:statistic:MetricAlarm' :: MetricAlarm -> Maybe Statistic
$sel:stateValue:MetricAlarm' :: MetricAlarm -> Maybe StateValue
$sel:stateUpdatedTimestamp:MetricAlarm' :: MetricAlarm -> Maybe ISO8601
$sel:stateTransitionedTimestamp:MetricAlarm' :: MetricAlarm -> Maybe ISO8601
$sel:stateReasonData:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:stateReason:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:period:MetricAlarm' :: MetricAlarm -> Maybe Natural
$sel:oKActions:MetricAlarm' :: MetricAlarm -> Maybe [Text]
$sel:namespace:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:metrics:MetricAlarm' :: MetricAlarm -> Maybe [MetricDataQuery]
$sel:metricName:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:insufficientDataActions:MetricAlarm' :: MetricAlarm -> Maybe [Text]
$sel:extendedStatistic:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:evaluationState:MetricAlarm' :: MetricAlarm -> Maybe EvaluationState
$sel:evaluationPeriods:MetricAlarm' :: MetricAlarm -> Maybe Natural
$sel:evaluateLowSampleCountPercentile:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:dimensions:MetricAlarm' :: MetricAlarm -> Maybe [Dimension]
$sel:datapointsToAlarm:MetricAlarm' :: MetricAlarm -> Maybe Natural
$sel:comparisonOperator:MetricAlarm' :: MetricAlarm -> Maybe ComparisonOperator
$sel:alarmName:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:alarmDescription:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:alarmConfigurationUpdatedTimestamp:MetricAlarm' :: MetricAlarm -> Maybe ISO8601
$sel:alarmArn:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:alarmActions:MetricAlarm' :: MetricAlarm -> Maybe [Text]
$sel:actionsEnabled:MetricAlarm' :: MetricAlarm -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
actionsEnabled
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
alarmActions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
alarmArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
alarmConfigurationUpdatedTimestamp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
alarmDescription
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
alarmName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ComparisonOperator
comparisonOperator
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
datapointsToAlarm
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Dimension]
dimensions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
evaluateLowSampleCountPercentile
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
evaluationPeriods
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EvaluationState
evaluationState
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
extendedStatistic
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
insufficientDataActions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
metricName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [MetricDataQuery]
metrics
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
namespace
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
oKActions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
period
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
stateReason
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
stateReasonData
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
stateTransitionedTimestamp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
stateUpdatedTimestamp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe StateValue
stateValue
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Statistic
statistic
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Double
threshold
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
thresholdMetricId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
treatMissingData
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe StandardUnit
unit

instance Prelude.NFData MetricAlarm where
  rnf :: MetricAlarm -> ()
rnf MetricAlarm' {Maybe Bool
Maybe Double
Maybe Natural
Maybe [Text]
Maybe [Dimension]
Maybe [MetricDataQuery]
Maybe Text
Maybe ISO8601
Maybe ComparisonOperator
Maybe EvaluationState
Maybe StandardUnit
Maybe StateValue
Maybe Statistic
unit :: Maybe StandardUnit
treatMissingData :: Maybe Text
thresholdMetricId :: Maybe Text
threshold :: Maybe Double
statistic :: Maybe Statistic
stateValue :: Maybe StateValue
stateUpdatedTimestamp :: Maybe ISO8601
stateTransitionedTimestamp :: Maybe ISO8601
stateReasonData :: Maybe Text
stateReason :: Maybe Text
period :: Maybe Natural
oKActions :: Maybe [Text]
namespace :: Maybe Text
metrics :: Maybe [MetricDataQuery]
metricName :: Maybe Text
insufficientDataActions :: Maybe [Text]
extendedStatistic :: Maybe Text
evaluationState :: Maybe EvaluationState
evaluationPeriods :: Maybe Natural
evaluateLowSampleCountPercentile :: Maybe Text
dimensions :: Maybe [Dimension]
datapointsToAlarm :: Maybe Natural
comparisonOperator :: Maybe ComparisonOperator
alarmName :: Maybe Text
alarmDescription :: Maybe Text
alarmConfigurationUpdatedTimestamp :: Maybe ISO8601
alarmArn :: Maybe Text
alarmActions :: Maybe [Text]
actionsEnabled :: Maybe Bool
$sel:unit:MetricAlarm' :: MetricAlarm -> Maybe StandardUnit
$sel:treatMissingData:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:thresholdMetricId:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:threshold:MetricAlarm' :: MetricAlarm -> Maybe Double
$sel:statistic:MetricAlarm' :: MetricAlarm -> Maybe Statistic
$sel:stateValue:MetricAlarm' :: MetricAlarm -> Maybe StateValue
$sel:stateUpdatedTimestamp:MetricAlarm' :: MetricAlarm -> Maybe ISO8601
$sel:stateTransitionedTimestamp:MetricAlarm' :: MetricAlarm -> Maybe ISO8601
$sel:stateReasonData:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:stateReason:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:period:MetricAlarm' :: MetricAlarm -> Maybe Natural
$sel:oKActions:MetricAlarm' :: MetricAlarm -> Maybe [Text]
$sel:namespace:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:metrics:MetricAlarm' :: MetricAlarm -> Maybe [MetricDataQuery]
$sel:metricName:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:insufficientDataActions:MetricAlarm' :: MetricAlarm -> Maybe [Text]
$sel:extendedStatistic:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:evaluationState:MetricAlarm' :: MetricAlarm -> Maybe EvaluationState
$sel:evaluationPeriods:MetricAlarm' :: MetricAlarm -> Maybe Natural
$sel:evaluateLowSampleCountPercentile:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:dimensions:MetricAlarm' :: MetricAlarm -> Maybe [Dimension]
$sel:datapointsToAlarm:MetricAlarm' :: MetricAlarm -> Maybe Natural
$sel:comparisonOperator:MetricAlarm' :: MetricAlarm -> Maybe ComparisonOperator
$sel:alarmName:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:alarmDescription:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:alarmConfigurationUpdatedTimestamp:MetricAlarm' :: MetricAlarm -> Maybe ISO8601
$sel:alarmArn:MetricAlarm' :: MetricAlarm -> Maybe Text
$sel:alarmActions:MetricAlarm' :: MetricAlarm -> Maybe [Text]
$sel:actionsEnabled:MetricAlarm' :: MetricAlarm -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
actionsEnabled
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
alarmActions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
alarmArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
alarmConfigurationUpdatedTimestamp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
alarmDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
alarmName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ComparisonOperator
comparisonOperator
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
datapointsToAlarm
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Dimension]
dimensions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
evaluateLowSampleCountPercentile
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
evaluationPeriods
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EvaluationState
evaluationState
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
extendedStatistic
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
insufficientDataActions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
metricName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [MetricDataQuery]
metrics
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
namespace
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
oKActions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
period
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
stateReason
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
stateReasonData
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe ISO8601
stateTransitionedTimestamp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe ISO8601
stateUpdatedTimestamp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StateValue
stateValue
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Statistic
statistic
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Double
threshold
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Text
thresholdMetricId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Text
treatMissingData
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe StandardUnit
unit