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

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

-- |
-- Module      : Amazonka.LookoutMetrics.CreateAlert
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates an alert for an anomaly detector.
module Amazonka.LookoutMetrics.CreateAlert
  ( -- * Creating a Request
    CreateAlert (..),
    newCreateAlert,

    -- * Request Lenses
    createAlert_alertDescription,
    createAlert_alertFilters,
    createAlert_alertSensitivityThreshold,
    createAlert_tags,
    createAlert_alertName,
    createAlert_anomalyDetectorArn,
    createAlert_action,

    -- * Destructuring the Response
    CreateAlertResponse (..),
    newCreateAlertResponse,

    -- * Response Lenses
    createAlertResponse_alertArn,
    createAlertResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.LookoutMetrics.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateAlert' smart constructor.
data CreateAlert = CreateAlert'
  { -- | A description of the alert.
    CreateAlert -> Maybe Text
alertDescription :: Prelude.Maybe Prelude.Text,
    -- | The configuration of the alert filters, containing MetricList and
    -- DimensionFilterList.
    CreateAlert -> Maybe AlertFilters
alertFilters :: Prelude.Maybe AlertFilters,
    -- | An integer from 0 to 100 specifying the alert sensitivity threshold.
    CreateAlert -> Maybe Natural
alertSensitivityThreshold :: Prelude.Maybe Prelude.Natural,
    -- | A list of
    -- <https://docs.aws.amazon.com/lookoutmetrics/latest/dev/detectors-tags.html tags>
    -- to apply to the alert.
    CreateAlert -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The name of the alert.
    CreateAlert -> Text
alertName :: Prelude.Text,
    -- | The ARN of the detector to which the alert is attached.
    CreateAlert -> Text
anomalyDetectorArn :: Prelude.Text,
    -- | Action that will be triggered when there is an alert.
    CreateAlert -> Action
action :: Action
  }
  deriving (CreateAlert -> CreateAlert -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateAlert -> CreateAlert -> Bool
$c/= :: CreateAlert -> CreateAlert -> Bool
== :: CreateAlert -> CreateAlert -> Bool
$c== :: CreateAlert -> CreateAlert -> Bool
Prelude.Eq, ReadPrec [CreateAlert]
ReadPrec CreateAlert
Int -> ReadS CreateAlert
ReadS [CreateAlert]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateAlert]
$creadListPrec :: ReadPrec [CreateAlert]
readPrec :: ReadPrec CreateAlert
$creadPrec :: ReadPrec CreateAlert
readList :: ReadS [CreateAlert]
$creadList :: ReadS [CreateAlert]
readsPrec :: Int -> ReadS CreateAlert
$creadsPrec :: Int -> ReadS CreateAlert
Prelude.Read, Int -> CreateAlert -> ShowS
[CreateAlert] -> ShowS
CreateAlert -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateAlert] -> ShowS
$cshowList :: [CreateAlert] -> ShowS
show :: CreateAlert -> String
$cshow :: CreateAlert -> String
showsPrec :: Int -> CreateAlert -> ShowS
$cshowsPrec :: Int -> CreateAlert -> ShowS
Prelude.Show, forall x. Rep CreateAlert x -> CreateAlert
forall x. CreateAlert -> Rep CreateAlert x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateAlert x -> CreateAlert
$cfrom :: forall x. CreateAlert -> Rep CreateAlert x
Prelude.Generic)

-- |
-- Create a value of 'CreateAlert' 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:
--
-- 'alertDescription', 'createAlert_alertDescription' - A description of the alert.
--
-- 'alertFilters', 'createAlert_alertFilters' - The configuration of the alert filters, containing MetricList and
-- DimensionFilterList.
--
-- 'alertSensitivityThreshold', 'createAlert_alertSensitivityThreshold' - An integer from 0 to 100 specifying the alert sensitivity threshold.
--
-- 'tags', 'createAlert_tags' - A list of
-- <https://docs.aws.amazon.com/lookoutmetrics/latest/dev/detectors-tags.html tags>
-- to apply to the alert.
--
-- 'alertName', 'createAlert_alertName' - The name of the alert.
--
-- 'anomalyDetectorArn', 'createAlert_anomalyDetectorArn' - The ARN of the detector to which the alert is attached.
--
-- 'action', 'createAlert_action' - Action that will be triggered when there is an alert.
newCreateAlert ::
  -- | 'alertName'
  Prelude.Text ->
  -- | 'anomalyDetectorArn'
  Prelude.Text ->
  -- | 'action'
  Action ->
  CreateAlert
newCreateAlert :: Text -> Text -> Action -> CreateAlert
newCreateAlert
  Text
pAlertName_
  Text
pAnomalyDetectorArn_
  Action
pAction_ =
    CreateAlert'
      { $sel:alertDescription:CreateAlert' :: Maybe Text
alertDescription = forall a. Maybe a
Prelude.Nothing,
        $sel:alertFilters:CreateAlert' :: Maybe AlertFilters
alertFilters = forall a. Maybe a
Prelude.Nothing,
        $sel:alertSensitivityThreshold:CreateAlert' :: Maybe Natural
alertSensitivityThreshold = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateAlert' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:alertName:CreateAlert' :: Text
alertName = Text
pAlertName_,
        $sel:anomalyDetectorArn:CreateAlert' :: Text
anomalyDetectorArn = Text
pAnomalyDetectorArn_,
        $sel:action:CreateAlert' :: Action
action = Action
pAction_
      }

-- | A description of the alert.
createAlert_alertDescription :: Lens.Lens' CreateAlert (Prelude.Maybe Prelude.Text)
createAlert_alertDescription :: Lens' CreateAlert (Maybe Text)
createAlert_alertDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAlert' {Maybe Text
alertDescription :: Maybe Text
$sel:alertDescription:CreateAlert' :: CreateAlert -> Maybe Text
alertDescription} -> Maybe Text
alertDescription) (\s :: CreateAlert
s@CreateAlert' {} Maybe Text
a -> CreateAlert
s {$sel:alertDescription:CreateAlert' :: Maybe Text
alertDescription = Maybe Text
a} :: CreateAlert)

-- | The configuration of the alert filters, containing MetricList and
-- DimensionFilterList.
createAlert_alertFilters :: Lens.Lens' CreateAlert (Prelude.Maybe AlertFilters)
createAlert_alertFilters :: Lens' CreateAlert (Maybe AlertFilters)
createAlert_alertFilters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAlert' {Maybe AlertFilters
alertFilters :: Maybe AlertFilters
$sel:alertFilters:CreateAlert' :: CreateAlert -> Maybe AlertFilters
alertFilters} -> Maybe AlertFilters
alertFilters) (\s :: CreateAlert
s@CreateAlert' {} Maybe AlertFilters
a -> CreateAlert
s {$sel:alertFilters:CreateAlert' :: Maybe AlertFilters
alertFilters = Maybe AlertFilters
a} :: CreateAlert)

-- | An integer from 0 to 100 specifying the alert sensitivity threshold.
createAlert_alertSensitivityThreshold :: Lens.Lens' CreateAlert (Prelude.Maybe Prelude.Natural)
createAlert_alertSensitivityThreshold :: Lens' CreateAlert (Maybe Natural)
createAlert_alertSensitivityThreshold = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAlert' {Maybe Natural
alertSensitivityThreshold :: Maybe Natural
$sel:alertSensitivityThreshold:CreateAlert' :: CreateAlert -> Maybe Natural
alertSensitivityThreshold} -> Maybe Natural
alertSensitivityThreshold) (\s :: CreateAlert
s@CreateAlert' {} Maybe Natural
a -> CreateAlert
s {$sel:alertSensitivityThreshold:CreateAlert' :: Maybe Natural
alertSensitivityThreshold = Maybe Natural
a} :: CreateAlert)

-- | A list of
-- <https://docs.aws.amazon.com/lookoutmetrics/latest/dev/detectors-tags.html tags>
-- to apply to the alert.
createAlert_tags :: Lens.Lens' CreateAlert (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createAlert_tags :: Lens' CreateAlert (Maybe (HashMap Text Text))
createAlert_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAlert' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateAlert' :: CreateAlert -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateAlert
s@CreateAlert' {} Maybe (HashMap Text Text)
a -> CreateAlert
s {$sel:tags:CreateAlert' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateAlert) 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 alert.
createAlert_alertName :: Lens.Lens' CreateAlert Prelude.Text
createAlert_alertName :: Lens' CreateAlert Text
createAlert_alertName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAlert' {Text
alertName :: Text
$sel:alertName:CreateAlert' :: CreateAlert -> Text
alertName} -> Text
alertName) (\s :: CreateAlert
s@CreateAlert' {} Text
a -> CreateAlert
s {$sel:alertName:CreateAlert' :: Text
alertName = Text
a} :: CreateAlert)

-- | The ARN of the detector to which the alert is attached.
createAlert_anomalyDetectorArn :: Lens.Lens' CreateAlert Prelude.Text
createAlert_anomalyDetectorArn :: Lens' CreateAlert Text
createAlert_anomalyDetectorArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAlert' {Text
anomalyDetectorArn :: Text
$sel:anomalyDetectorArn:CreateAlert' :: CreateAlert -> Text
anomalyDetectorArn} -> Text
anomalyDetectorArn) (\s :: CreateAlert
s@CreateAlert' {} Text
a -> CreateAlert
s {$sel:anomalyDetectorArn:CreateAlert' :: Text
anomalyDetectorArn = Text
a} :: CreateAlert)

-- | Action that will be triggered when there is an alert.
createAlert_action :: Lens.Lens' CreateAlert Action
createAlert_action :: Lens' CreateAlert Action
createAlert_action = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAlert' {Action
action :: Action
$sel:action:CreateAlert' :: CreateAlert -> Action
action} -> Action
action) (\s :: CreateAlert
s@CreateAlert' {} Action
a -> CreateAlert
s {$sel:action:CreateAlert' :: Action
action = Action
a} :: CreateAlert)

instance Core.AWSRequest CreateAlert where
  type AWSResponse CreateAlert = CreateAlertResponse
  request :: (Service -> Service) -> CreateAlert -> Request CreateAlert
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateAlert
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateAlert)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text -> Int -> CreateAlertResponse
CreateAlertResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"AlertArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreateAlert where
  hashWithSalt :: Int -> CreateAlert -> Int
hashWithSalt Int
_salt CreateAlert' {Maybe Natural
Maybe Text
Maybe (HashMap Text Text)
Maybe AlertFilters
Text
Action
action :: Action
anomalyDetectorArn :: Text
alertName :: Text
tags :: Maybe (HashMap Text Text)
alertSensitivityThreshold :: Maybe Natural
alertFilters :: Maybe AlertFilters
alertDescription :: Maybe Text
$sel:action:CreateAlert' :: CreateAlert -> Action
$sel:anomalyDetectorArn:CreateAlert' :: CreateAlert -> Text
$sel:alertName:CreateAlert' :: CreateAlert -> Text
$sel:tags:CreateAlert' :: CreateAlert -> Maybe (HashMap Text Text)
$sel:alertSensitivityThreshold:CreateAlert' :: CreateAlert -> Maybe Natural
$sel:alertFilters:CreateAlert' :: CreateAlert -> Maybe AlertFilters
$sel:alertDescription:CreateAlert' :: CreateAlert -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
alertDescription
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AlertFilters
alertFilters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
alertSensitivityThreshold
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
alertName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
anomalyDetectorArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Action
action

instance Prelude.NFData CreateAlert where
  rnf :: CreateAlert -> ()
rnf CreateAlert' {Maybe Natural
Maybe Text
Maybe (HashMap Text Text)
Maybe AlertFilters
Text
Action
action :: Action
anomalyDetectorArn :: Text
alertName :: Text
tags :: Maybe (HashMap Text Text)
alertSensitivityThreshold :: Maybe Natural
alertFilters :: Maybe AlertFilters
alertDescription :: Maybe Text
$sel:action:CreateAlert' :: CreateAlert -> Action
$sel:anomalyDetectorArn:CreateAlert' :: CreateAlert -> Text
$sel:alertName:CreateAlert' :: CreateAlert -> Text
$sel:tags:CreateAlert' :: CreateAlert -> Maybe (HashMap Text Text)
$sel:alertSensitivityThreshold:CreateAlert' :: CreateAlert -> Maybe Natural
$sel:alertFilters:CreateAlert' :: CreateAlert -> Maybe AlertFilters
$sel:alertDescription:CreateAlert' :: CreateAlert -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
alertDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AlertFilters
alertFilters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
alertSensitivityThreshold
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
alertName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
anomalyDetectorArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Action
action

instance Data.ToHeaders CreateAlert where
  toHeaders :: CreateAlert -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateAlert where
  toJSON :: CreateAlert -> Value
toJSON CreateAlert' {Maybe Natural
Maybe Text
Maybe (HashMap Text Text)
Maybe AlertFilters
Text
Action
action :: Action
anomalyDetectorArn :: Text
alertName :: Text
tags :: Maybe (HashMap Text Text)
alertSensitivityThreshold :: Maybe Natural
alertFilters :: Maybe AlertFilters
alertDescription :: Maybe Text
$sel:action:CreateAlert' :: CreateAlert -> Action
$sel:anomalyDetectorArn:CreateAlert' :: CreateAlert -> Text
$sel:alertName:CreateAlert' :: CreateAlert -> Text
$sel:tags:CreateAlert' :: CreateAlert -> Maybe (HashMap Text Text)
$sel:alertSensitivityThreshold:CreateAlert' :: CreateAlert -> Maybe Natural
$sel:alertFilters:CreateAlert' :: CreateAlert -> Maybe AlertFilters
$sel:alertDescription:CreateAlert' :: CreateAlert -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"AlertDescription" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
alertDescription,
            (Key
"AlertFilters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe AlertFilters
alertFilters,
            (Key
"AlertSensitivityThreshold" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
alertSensitivityThreshold,
            (Key
"Tags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text Text)
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"AlertName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
alertName),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"AnomalyDetectorArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
anomalyDetectorArn),
            forall a. a -> Maybe a
Prelude.Just (Key
"Action" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Action
action)
          ]
      )

instance Data.ToPath CreateAlert where
  toPath :: CreateAlert -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/CreateAlert"

instance Data.ToQuery CreateAlert where
  toQuery :: CreateAlert -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newCreateAlertResponse' smart constructor.
data CreateAlertResponse = CreateAlertResponse'
  { -- | The ARN of the alert.
    CreateAlertResponse -> Maybe Text
alertArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CreateAlertResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateAlertResponse -> CreateAlertResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateAlertResponse -> CreateAlertResponse -> Bool
$c/= :: CreateAlertResponse -> CreateAlertResponse -> Bool
== :: CreateAlertResponse -> CreateAlertResponse -> Bool
$c== :: CreateAlertResponse -> CreateAlertResponse -> Bool
Prelude.Eq, ReadPrec [CreateAlertResponse]
ReadPrec CreateAlertResponse
Int -> ReadS CreateAlertResponse
ReadS [CreateAlertResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateAlertResponse]
$creadListPrec :: ReadPrec [CreateAlertResponse]
readPrec :: ReadPrec CreateAlertResponse
$creadPrec :: ReadPrec CreateAlertResponse
readList :: ReadS [CreateAlertResponse]
$creadList :: ReadS [CreateAlertResponse]
readsPrec :: Int -> ReadS CreateAlertResponse
$creadsPrec :: Int -> ReadS CreateAlertResponse
Prelude.Read, Int -> CreateAlertResponse -> ShowS
[CreateAlertResponse] -> ShowS
CreateAlertResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateAlertResponse] -> ShowS
$cshowList :: [CreateAlertResponse] -> ShowS
show :: CreateAlertResponse -> String
$cshow :: CreateAlertResponse -> String
showsPrec :: Int -> CreateAlertResponse -> ShowS
$cshowsPrec :: Int -> CreateAlertResponse -> ShowS
Prelude.Show, forall x. Rep CreateAlertResponse x -> CreateAlertResponse
forall x. CreateAlertResponse -> Rep CreateAlertResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateAlertResponse x -> CreateAlertResponse
$cfrom :: forall x. CreateAlertResponse -> Rep CreateAlertResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateAlertResponse' 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:
--
-- 'alertArn', 'createAlertResponse_alertArn' - The ARN of the alert.
--
-- 'httpStatus', 'createAlertResponse_httpStatus' - The response's http status code.
newCreateAlertResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateAlertResponse
newCreateAlertResponse :: Int -> CreateAlertResponse
newCreateAlertResponse Int
pHttpStatus_ =
  CreateAlertResponse'
    { $sel:alertArn:CreateAlertResponse' :: Maybe Text
alertArn = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateAlertResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the alert.
createAlertResponse_alertArn :: Lens.Lens' CreateAlertResponse (Prelude.Maybe Prelude.Text)
createAlertResponse_alertArn :: Lens' CreateAlertResponse (Maybe Text)
createAlertResponse_alertArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAlertResponse' {Maybe Text
alertArn :: Maybe Text
$sel:alertArn:CreateAlertResponse' :: CreateAlertResponse -> Maybe Text
alertArn} -> Maybe Text
alertArn) (\s :: CreateAlertResponse
s@CreateAlertResponse' {} Maybe Text
a -> CreateAlertResponse
s {$sel:alertArn:CreateAlertResponse' :: Maybe Text
alertArn = Maybe Text
a} :: CreateAlertResponse)

-- | The response's http status code.
createAlertResponse_httpStatus :: Lens.Lens' CreateAlertResponse Prelude.Int
createAlertResponse_httpStatus :: Lens' CreateAlertResponse Int
createAlertResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAlertResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateAlertResponse' :: CreateAlertResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateAlertResponse
s@CreateAlertResponse' {} Int
a -> CreateAlertResponse
s {$sel:httpStatus:CreateAlertResponse' :: Int
httpStatus = Int
a} :: CreateAlertResponse)

instance Prelude.NFData CreateAlertResponse where
  rnf :: CreateAlertResponse -> ()
rnf CreateAlertResponse' {Int
Maybe Text
httpStatus :: Int
alertArn :: Maybe Text
$sel:httpStatus:CreateAlertResponse' :: CreateAlertResponse -> Int
$sel:alertArn:CreateAlertResponse' :: CreateAlertResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
alertArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus