{-# 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.CloudWatchEvents.StartReplay
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Starts the specified replay. Events are not necessarily replayed in the
-- exact same order that they were added to the archive. A replay processes
-- events to replay based on the time in the event, and replays them using
-- 1 minute intervals. If you specify an @EventStartTime@ and an
-- @EventEndTime@ that covers a 20 minute time range, the events are
-- replayed from the first minute of that 20 minute range first. Then the
-- events from the second minute are replayed. You can use @DescribeReplay@
-- to determine the progress of a replay. The value returned for
-- @EventLastReplayedTime@ indicates the time within the specified time
-- range associated with the last event replayed.
module Amazonka.CloudWatchEvents.StartReplay
  ( -- * Creating a Request
    StartReplay (..),
    newStartReplay,

    -- * Request Lenses
    startReplay_description,
    startReplay_replayName,
    startReplay_eventSourceArn,
    startReplay_eventStartTime,
    startReplay_eventEndTime,
    startReplay_destination,

    -- * Destructuring the Response
    StartReplayResponse (..),
    newStartReplayResponse,

    -- * Response Lenses
    startReplayResponse_replayArn,
    startReplayResponse_replayStartTime,
    startReplayResponse_state,
    startReplayResponse_stateReason,
    startReplayResponse_httpStatus,
  )
where

import Amazonka.CloudWatchEvents.Types
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
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newStartReplay' smart constructor.
data StartReplay = StartReplay'
  { -- | A description for the replay to start.
    StartReplay -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The name of the replay to start.
    StartReplay -> Text
replayName :: Prelude.Text,
    -- | The ARN of the archive to replay events from.
    StartReplay -> Text
eventSourceArn :: Prelude.Text,
    -- | A time stamp for the time to start replaying events. Only events that
    -- occurred between the @EventStartTime@ and @EventEndTime@ are replayed.
    StartReplay -> POSIX
eventStartTime :: Data.POSIX,
    -- | A time stamp for the time to stop replaying events. Only events that
    -- occurred between the @EventStartTime@ and @EventEndTime@ are replayed.
    StartReplay -> POSIX
eventEndTime :: Data.POSIX,
    -- | A @ReplayDestination@ object that includes details about the destination
    -- for the replay.
    StartReplay -> ReplayDestination
destination :: ReplayDestination
  }
  deriving (StartReplay -> StartReplay -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartReplay -> StartReplay -> Bool
$c/= :: StartReplay -> StartReplay -> Bool
== :: StartReplay -> StartReplay -> Bool
$c== :: StartReplay -> StartReplay -> Bool
Prelude.Eq, ReadPrec [StartReplay]
ReadPrec StartReplay
Int -> ReadS StartReplay
ReadS [StartReplay]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartReplay]
$creadListPrec :: ReadPrec [StartReplay]
readPrec :: ReadPrec StartReplay
$creadPrec :: ReadPrec StartReplay
readList :: ReadS [StartReplay]
$creadList :: ReadS [StartReplay]
readsPrec :: Int -> ReadS StartReplay
$creadsPrec :: Int -> ReadS StartReplay
Prelude.Read, Int -> StartReplay -> ShowS
[StartReplay] -> ShowS
StartReplay -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartReplay] -> ShowS
$cshowList :: [StartReplay] -> ShowS
show :: StartReplay -> String
$cshow :: StartReplay -> String
showsPrec :: Int -> StartReplay -> ShowS
$cshowsPrec :: Int -> StartReplay -> ShowS
Prelude.Show, forall x. Rep StartReplay x -> StartReplay
forall x. StartReplay -> Rep StartReplay x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartReplay x -> StartReplay
$cfrom :: forall x. StartReplay -> Rep StartReplay x
Prelude.Generic)

-- |
-- Create a value of 'StartReplay' 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:
--
-- 'description', 'startReplay_description' - A description for the replay to start.
--
-- 'replayName', 'startReplay_replayName' - The name of the replay to start.
--
-- 'eventSourceArn', 'startReplay_eventSourceArn' - The ARN of the archive to replay events from.
--
-- 'eventStartTime', 'startReplay_eventStartTime' - A time stamp for the time to start replaying events. Only events that
-- occurred between the @EventStartTime@ and @EventEndTime@ are replayed.
--
-- 'eventEndTime', 'startReplay_eventEndTime' - A time stamp for the time to stop replaying events. Only events that
-- occurred between the @EventStartTime@ and @EventEndTime@ are replayed.
--
-- 'destination', 'startReplay_destination' - A @ReplayDestination@ object that includes details about the destination
-- for the replay.
newStartReplay ::
  -- | 'replayName'
  Prelude.Text ->
  -- | 'eventSourceArn'
  Prelude.Text ->
  -- | 'eventStartTime'
  Prelude.UTCTime ->
  -- | 'eventEndTime'
  Prelude.UTCTime ->
  -- | 'destination'
  ReplayDestination ->
  StartReplay
newStartReplay :: Text
-> Text -> UTCTime -> UTCTime -> ReplayDestination -> StartReplay
newStartReplay
  Text
pReplayName_
  Text
pEventSourceArn_
  UTCTime
pEventStartTime_
  UTCTime
pEventEndTime_
  ReplayDestination
pDestination_ =
    StartReplay'
      { $sel:description:StartReplay' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
        $sel:replayName:StartReplay' :: Text
replayName = Text
pReplayName_,
        $sel:eventSourceArn:StartReplay' :: Text
eventSourceArn = Text
pEventSourceArn_,
        $sel:eventStartTime:StartReplay' :: POSIX
eventStartTime = forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pEventStartTime_,
        $sel:eventEndTime:StartReplay' :: POSIX
eventEndTime = forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pEventEndTime_,
        $sel:destination:StartReplay' :: ReplayDestination
destination = ReplayDestination
pDestination_
      }

-- | A description for the replay to start.
startReplay_description :: Lens.Lens' StartReplay (Prelude.Maybe Prelude.Text)
startReplay_description :: Lens' StartReplay (Maybe Text)
startReplay_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartReplay' {Maybe Text
description :: Maybe Text
$sel:description:StartReplay' :: StartReplay -> Maybe Text
description} -> Maybe Text
description) (\s :: StartReplay
s@StartReplay' {} Maybe Text
a -> StartReplay
s {$sel:description:StartReplay' :: Maybe Text
description = Maybe Text
a} :: StartReplay)

-- | The name of the replay to start.
startReplay_replayName :: Lens.Lens' StartReplay Prelude.Text
startReplay_replayName :: Lens' StartReplay Text
startReplay_replayName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartReplay' {Text
replayName :: Text
$sel:replayName:StartReplay' :: StartReplay -> Text
replayName} -> Text
replayName) (\s :: StartReplay
s@StartReplay' {} Text
a -> StartReplay
s {$sel:replayName:StartReplay' :: Text
replayName = Text
a} :: StartReplay)

-- | The ARN of the archive to replay events from.
startReplay_eventSourceArn :: Lens.Lens' StartReplay Prelude.Text
startReplay_eventSourceArn :: Lens' StartReplay Text
startReplay_eventSourceArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartReplay' {Text
eventSourceArn :: Text
$sel:eventSourceArn:StartReplay' :: StartReplay -> Text
eventSourceArn} -> Text
eventSourceArn) (\s :: StartReplay
s@StartReplay' {} Text
a -> StartReplay
s {$sel:eventSourceArn:StartReplay' :: Text
eventSourceArn = Text
a} :: StartReplay)

-- | A time stamp for the time to start replaying events. Only events that
-- occurred between the @EventStartTime@ and @EventEndTime@ are replayed.
startReplay_eventStartTime :: Lens.Lens' StartReplay Prelude.UTCTime
startReplay_eventStartTime :: Lens' StartReplay UTCTime
startReplay_eventStartTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartReplay' {POSIX
eventStartTime :: POSIX
$sel:eventStartTime:StartReplay' :: StartReplay -> POSIX
eventStartTime} -> POSIX
eventStartTime) (\s :: StartReplay
s@StartReplay' {} POSIX
a -> StartReplay
s {$sel:eventStartTime:StartReplay' :: POSIX
eventStartTime = POSIX
a} :: StartReplay) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | A time stamp for the time to stop replaying events. Only events that
-- occurred between the @EventStartTime@ and @EventEndTime@ are replayed.
startReplay_eventEndTime :: Lens.Lens' StartReplay Prelude.UTCTime
startReplay_eventEndTime :: Lens' StartReplay UTCTime
startReplay_eventEndTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartReplay' {POSIX
eventEndTime :: POSIX
$sel:eventEndTime:StartReplay' :: StartReplay -> POSIX
eventEndTime} -> POSIX
eventEndTime) (\s :: StartReplay
s@StartReplay' {} POSIX
a -> StartReplay
s {$sel:eventEndTime:StartReplay' :: POSIX
eventEndTime = POSIX
a} :: StartReplay) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | A @ReplayDestination@ object that includes details about the destination
-- for the replay.
startReplay_destination :: Lens.Lens' StartReplay ReplayDestination
startReplay_destination :: Lens' StartReplay ReplayDestination
startReplay_destination = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartReplay' {ReplayDestination
destination :: ReplayDestination
$sel:destination:StartReplay' :: StartReplay -> ReplayDestination
destination} -> ReplayDestination
destination) (\s :: StartReplay
s@StartReplay' {} ReplayDestination
a -> StartReplay
s {$sel:destination:StartReplay' :: ReplayDestination
destination = ReplayDestination
a} :: StartReplay)

instance Core.AWSRequest StartReplay where
  type AWSResponse StartReplay = StartReplayResponse
  request :: (Service -> Service) -> StartReplay -> Request StartReplay
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 StartReplay
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse StartReplay)))
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
-> Maybe POSIX
-> Maybe ReplayState
-> Maybe Text
-> Int
-> StartReplayResponse
StartReplayResponse'
            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
"ReplayArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"ReplayStartTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"State")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"StateReason")
            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 StartReplay where
  hashWithSalt :: Int -> StartReplay -> Int
hashWithSalt Int
_salt StartReplay' {Maybe Text
Text
POSIX
ReplayDestination
destination :: ReplayDestination
eventEndTime :: POSIX
eventStartTime :: POSIX
eventSourceArn :: Text
replayName :: Text
description :: Maybe Text
$sel:destination:StartReplay' :: StartReplay -> ReplayDestination
$sel:eventEndTime:StartReplay' :: StartReplay -> POSIX
$sel:eventStartTime:StartReplay' :: StartReplay -> POSIX
$sel:eventSourceArn:StartReplay' :: StartReplay -> Text
$sel:replayName:StartReplay' :: StartReplay -> Text
$sel:description:StartReplay' :: StartReplay -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
replayName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
eventSourceArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` POSIX
eventStartTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` POSIX
eventEndTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ReplayDestination
destination

instance Prelude.NFData StartReplay where
  rnf :: StartReplay -> ()
rnf StartReplay' {Maybe Text
Text
POSIX
ReplayDestination
destination :: ReplayDestination
eventEndTime :: POSIX
eventStartTime :: POSIX
eventSourceArn :: Text
replayName :: Text
description :: Maybe Text
$sel:destination:StartReplay' :: StartReplay -> ReplayDestination
$sel:eventEndTime:StartReplay' :: StartReplay -> POSIX
$sel:eventStartTime:StartReplay' :: StartReplay -> POSIX
$sel:eventSourceArn:StartReplay' :: StartReplay -> Text
$sel:replayName:StartReplay' :: StartReplay -> Text
$sel:description:StartReplay' :: StartReplay -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
replayName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
eventSourceArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf POSIX
eventStartTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf POSIX
eventEndTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ReplayDestination
destination

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

instance Data.ToJSON StartReplay where
  toJSON :: StartReplay -> Value
toJSON StartReplay' {Maybe Text
Text
POSIX
ReplayDestination
destination :: ReplayDestination
eventEndTime :: POSIX
eventStartTime :: POSIX
eventSourceArn :: Text
replayName :: Text
description :: Maybe Text
$sel:destination:StartReplay' :: StartReplay -> ReplayDestination
$sel:eventEndTime:StartReplay' :: StartReplay -> POSIX
$sel:eventStartTime:StartReplay' :: StartReplay -> POSIX
$sel:eventSourceArn:StartReplay' :: StartReplay -> Text
$sel:replayName:StartReplay' :: StartReplay -> Text
$sel:description:StartReplay' :: StartReplay -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Description" 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
description,
            forall a. a -> Maybe a
Prelude.Just (Key
"ReplayName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
replayName),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"EventSourceArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
eventSourceArn),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"EventStartTime" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= POSIX
eventStartTime),
            forall a. a -> Maybe a
Prelude.Just (Key
"EventEndTime" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= POSIX
eventEndTime),
            forall a. a -> Maybe a
Prelude.Just (Key
"Destination" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ReplayDestination
destination)
          ]
      )

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

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

-- | /See:/ 'newStartReplayResponse' smart constructor.
data StartReplayResponse = StartReplayResponse'
  { -- | The ARN of the replay.
    StartReplayResponse -> Maybe Text
replayArn :: Prelude.Maybe Prelude.Text,
    -- | The time at which the replay started.
    StartReplayResponse -> Maybe POSIX
replayStartTime :: Prelude.Maybe Data.POSIX,
    -- | The state of the replay.
    StartReplayResponse -> Maybe ReplayState
state :: Prelude.Maybe ReplayState,
    -- | The reason that the replay is in the state.
    StartReplayResponse -> Maybe Text
stateReason :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    StartReplayResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (StartReplayResponse -> StartReplayResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartReplayResponse -> StartReplayResponse -> Bool
$c/= :: StartReplayResponse -> StartReplayResponse -> Bool
== :: StartReplayResponse -> StartReplayResponse -> Bool
$c== :: StartReplayResponse -> StartReplayResponse -> Bool
Prelude.Eq, ReadPrec [StartReplayResponse]
ReadPrec StartReplayResponse
Int -> ReadS StartReplayResponse
ReadS [StartReplayResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartReplayResponse]
$creadListPrec :: ReadPrec [StartReplayResponse]
readPrec :: ReadPrec StartReplayResponse
$creadPrec :: ReadPrec StartReplayResponse
readList :: ReadS [StartReplayResponse]
$creadList :: ReadS [StartReplayResponse]
readsPrec :: Int -> ReadS StartReplayResponse
$creadsPrec :: Int -> ReadS StartReplayResponse
Prelude.Read, Int -> StartReplayResponse -> ShowS
[StartReplayResponse] -> ShowS
StartReplayResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartReplayResponse] -> ShowS
$cshowList :: [StartReplayResponse] -> ShowS
show :: StartReplayResponse -> String
$cshow :: StartReplayResponse -> String
showsPrec :: Int -> StartReplayResponse -> ShowS
$cshowsPrec :: Int -> StartReplayResponse -> ShowS
Prelude.Show, forall x. Rep StartReplayResponse x -> StartReplayResponse
forall x. StartReplayResponse -> Rep StartReplayResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartReplayResponse x -> StartReplayResponse
$cfrom :: forall x. StartReplayResponse -> Rep StartReplayResponse x
Prelude.Generic)

-- |
-- Create a value of 'StartReplayResponse' 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:
--
-- 'replayArn', 'startReplayResponse_replayArn' - The ARN of the replay.
--
-- 'replayStartTime', 'startReplayResponse_replayStartTime' - The time at which the replay started.
--
-- 'state', 'startReplayResponse_state' - The state of the replay.
--
-- 'stateReason', 'startReplayResponse_stateReason' - The reason that the replay is in the state.
--
-- 'httpStatus', 'startReplayResponse_httpStatus' - The response's http status code.
newStartReplayResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  StartReplayResponse
newStartReplayResponse :: Int -> StartReplayResponse
newStartReplayResponse Int
pHttpStatus_ =
  StartReplayResponse'
    { $sel:replayArn:StartReplayResponse' :: Maybe Text
replayArn = forall a. Maybe a
Prelude.Nothing,
      $sel:replayStartTime:StartReplayResponse' :: Maybe POSIX
replayStartTime = forall a. Maybe a
Prelude.Nothing,
      $sel:state:StartReplayResponse' :: Maybe ReplayState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:stateReason:StartReplayResponse' :: Maybe Text
stateReason = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:StartReplayResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the replay.
startReplayResponse_replayArn :: Lens.Lens' StartReplayResponse (Prelude.Maybe Prelude.Text)
startReplayResponse_replayArn :: Lens' StartReplayResponse (Maybe Text)
startReplayResponse_replayArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartReplayResponse' {Maybe Text
replayArn :: Maybe Text
$sel:replayArn:StartReplayResponse' :: StartReplayResponse -> Maybe Text
replayArn} -> Maybe Text
replayArn) (\s :: StartReplayResponse
s@StartReplayResponse' {} Maybe Text
a -> StartReplayResponse
s {$sel:replayArn:StartReplayResponse' :: Maybe Text
replayArn = Maybe Text
a} :: StartReplayResponse)

-- | The time at which the replay started.
startReplayResponse_replayStartTime :: Lens.Lens' StartReplayResponse (Prelude.Maybe Prelude.UTCTime)
startReplayResponse_replayStartTime :: Lens' StartReplayResponse (Maybe UTCTime)
startReplayResponse_replayStartTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartReplayResponse' {Maybe POSIX
replayStartTime :: Maybe POSIX
$sel:replayStartTime:StartReplayResponse' :: StartReplayResponse -> Maybe POSIX
replayStartTime} -> Maybe POSIX
replayStartTime) (\s :: StartReplayResponse
s@StartReplayResponse' {} Maybe POSIX
a -> StartReplayResponse
s {$sel:replayStartTime:StartReplayResponse' :: Maybe POSIX
replayStartTime = Maybe POSIX
a} :: StartReplayResponse) 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 of the replay.
startReplayResponse_state :: Lens.Lens' StartReplayResponse (Prelude.Maybe ReplayState)
startReplayResponse_state :: Lens' StartReplayResponse (Maybe ReplayState)
startReplayResponse_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartReplayResponse' {Maybe ReplayState
state :: Maybe ReplayState
$sel:state:StartReplayResponse' :: StartReplayResponse -> Maybe ReplayState
state} -> Maybe ReplayState
state) (\s :: StartReplayResponse
s@StartReplayResponse' {} Maybe ReplayState
a -> StartReplayResponse
s {$sel:state:StartReplayResponse' :: Maybe ReplayState
state = Maybe ReplayState
a} :: StartReplayResponse)

-- | The reason that the replay is in the state.
startReplayResponse_stateReason :: Lens.Lens' StartReplayResponse (Prelude.Maybe Prelude.Text)
startReplayResponse_stateReason :: Lens' StartReplayResponse (Maybe Text)
startReplayResponse_stateReason = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartReplayResponse' {Maybe Text
stateReason :: Maybe Text
$sel:stateReason:StartReplayResponse' :: StartReplayResponse -> Maybe Text
stateReason} -> Maybe Text
stateReason) (\s :: StartReplayResponse
s@StartReplayResponse' {} Maybe Text
a -> StartReplayResponse
s {$sel:stateReason:StartReplayResponse' :: Maybe Text
stateReason = Maybe Text
a} :: StartReplayResponse)

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

instance Prelude.NFData StartReplayResponse where
  rnf :: StartReplayResponse -> ()
rnf StartReplayResponse' {Int
Maybe Text
Maybe POSIX
Maybe ReplayState
httpStatus :: Int
stateReason :: Maybe Text
state :: Maybe ReplayState
replayStartTime :: Maybe POSIX
replayArn :: Maybe Text
$sel:httpStatus:StartReplayResponse' :: StartReplayResponse -> Int
$sel:stateReason:StartReplayResponse' :: StartReplayResponse -> Maybe Text
$sel:state:StartReplayResponse' :: StartReplayResponse -> Maybe ReplayState
$sel:replayStartTime:StartReplayResponse' :: StartReplayResponse -> Maybe POSIX
$sel:replayArn:StartReplayResponse' :: StartReplayResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
replayArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
replayStartTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ReplayState
state
      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 Int
httpStatus