{-# 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.CloudWatchEvents.Types.Replay
-- 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.CloudWatchEvents.Types.Replay where

import Amazonka.CloudWatchEvents.Types.ReplayState
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

-- | A @Replay@ object that contains details about a replay.
--
-- /See:/ 'newReplay' smart constructor.
data Replay = Replay'
  { -- | A time stamp for the time to start replaying events. Any event with a
    -- creation time prior to the @EventEndTime@ specified is replayed.
    Replay -> Maybe POSIX
eventEndTime :: Prelude.Maybe Data.POSIX,
    -- | A time stamp for the time that the last event was replayed.
    Replay -> Maybe POSIX
eventLastReplayedTime :: Prelude.Maybe Data.POSIX,
    -- | The ARN of the archive to replay event from.
    Replay -> Maybe Text
eventSourceArn :: Prelude.Maybe Prelude.Text,
    -- | A time stamp for the time to start replaying events. This is determined
    -- by the time in the event as described in
    -- <https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html#eventbridge-Type-PutEventsRequestEntry-Time Time>.
    Replay -> Maybe POSIX
eventStartTime :: Prelude.Maybe Data.POSIX,
    -- | A time stamp for the time that the replay completed.
    Replay -> Maybe POSIX
replayEndTime :: Prelude.Maybe Data.POSIX,
    -- | The name of the replay.
    Replay -> Maybe Text
replayName :: Prelude.Maybe Prelude.Text,
    -- | A time stamp for the time that the replay started.
    Replay -> Maybe POSIX
replayStartTime :: Prelude.Maybe Data.POSIX,
    -- | The current state of the replay.
    Replay -> Maybe ReplayState
state :: Prelude.Maybe ReplayState,
    -- | A description of why the replay is in the current state.
    Replay -> Maybe Text
stateReason :: Prelude.Maybe Prelude.Text
  }
  deriving (Replay -> Replay -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Replay -> Replay -> Bool
$c/= :: Replay -> Replay -> Bool
== :: Replay -> Replay -> Bool
$c== :: Replay -> Replay -> Bool
Prelude.Eq, ReadPrec [Replay]
ReadPrec Replay
Int -> ReadS Replay
ReadS [Replay]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Replay]
$creadListPrec :: ReadPrec [Replay]
readPrec :: ReadPrec Replay
$creadPrec :: ReadPrec Replay
readList :: ReadS [Replay]
$creadList :: ReadS [Replay]
readsPrec :: Int -> ReadS Replay
$creadsPrec :: Int -> ReadS Replay
Prelude.Read, Int -> Replay -> ShowS
[Replay] -> ShowS
Replay -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Replay] -> ShowS
$cshowList :: [Replay] -> ShowS
show :: Replay -> String
$cshow :: Replay -> String
showsPrec :: Int -> Replay -> ShowS
$cshowsPrec :: Int -> Replay -> ShowS
Prelude.Show, forall x. Rep Replay x -> Replay
forall x. Replay -> Rep Replay x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Replay x -> Replay
$cfrom :: forall x. Replay -> Rep Replay x
Prelude.Generic)

-- |
-- Create a value of 'Replay' 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:
--
-- 'eventEndTime', 'replay_eventEndTime' - A time stamp for the time to start replaying events. Any event with a
-- creation time prior to the @EventEndTime@ specified is replayed.
--
-- 'eventLastReplayedTime', 'replay_eventLastReplayedTime' - A time stamp for the time that the last event was replayed.
--
-- 'eventSourceArn', 'replay_eventSourceArn' - The ARN of the archive to replay event from.
--
-- 'eventStartTime', 'replay_eventStartTime' - A time stamp for the time to start replaying events. This is determined
-- by the time in the event as described in
-- <https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html#eventbridge-Type-PutEventsRequestEntry-Time Time>.
--
-- 'replayEndTime', 'replay_replayEndTime' - A time stamp for the time that the replay completed.
--
-- 'replayName', 'replay_replayName' - The name of the replay.
--
-- 'replayStartTime', 'replay_replayStartTime' - A time stamp for the time that the replay started.
--
-- 'state', 'replay_state' - The current state of the replay.
--
-- 'stateReason', 'replay_stateReason' - A description of why the replay is in the current state.
newReplay ::
  Replay
newReplay :: Replay
newReplay =
  Replay'
    { $sel:eventEndTime:Replay' :: Maybe POSIX
eventEndTime = forall a. Maybe a
Prelude.Nothing,
      $sel:eventLastReplayedTime:Replay' :: Maybe POSIX
eventLastReplayedTime = forall a. Maybe a
Prelude.Nothing,
      $sel:eventSourceArn:Replay' :: Maybe Text
eventSourceArn = forall a. Maybe a
Prelude.Nothing,
      $sel:eventStartTime:Replay' :: Maybe POSIX
eventStartTime = forall a. Maybe a
Prelude.Nothing,
      $sel:replayEndTime:Replay' :: Maybe POSIX
replayEndTime = forall a. Maybe a
Prelude.Nothing,
      $sel:replayName:Replay' :: Maybe Text
replayName = forall a. Maybe a
Prelude.Nothing,
      $sel:replayStartTime:Replay' :: Maybe POSIX
replayStartTime = forall a. Maybe a
Prelude.Nothing,
      $sel:state:Replay' :: Maybe ReplayState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:stateReason:Replay' :: Maybe Text
stateReason = forall a. Maybe a
Prelude.Nothing
    }

-- | A time stamp for the time to start replaying events. Any event with a
-- creation time prior to the @EventEndTime@ specified is replayed.
replay_eventEndTime :: Lens.Lens' Replay (Prelude.Maybe Prelude.UTCTime)
replay_eventEndTime :: Lens' Replay (Maybe UTCTime)
replay_eventEndTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Replay' {Maybe POSIX
eventEndTime :: Maybe POSIX
$sel:eventEndTime:Replay' :: Replay -> Maybe POSIX
eventEndTime} -> Maybe POSIX
eventEndTime) (\s :: Replay
s@Replay' {} Maybe POSIX
a -> Replay
s {$sel:eventEndTime:Replay' :: Maybe POSIX
eventEndTime = Maybe POSIX
a} :: Replay) 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

-- | A time stamp for the time that the last event was replayed.
replay_eventLastReplayedTime :: Lens.Lens' Replay (Prelude.Maybe Prelude.UTCTime)
replay_eventLastReplayedTime :: Lens' Replay (Maybe UTCTime)
replay_eventLastReplayedTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Replay' {Maybe POSIX
eventLastReplayedTime :: Maybe POSIX
$sel:eventLastReplayedTime:Replay' :: Replay -> Maybe POSIX
eventLastReplayedTime} -> Maybe POSIX
eventLastReplayedTime) (\s :: Replay
s@Replay' {} Maybe POSIX
a -> Replay
s {$sel:eventLastReplayedTime:Replay' :: Maybe POSIX
eventLastReplayedTime = Maybe POSIX
a} :: Replay) 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 ARN of the archive to replay event from.
replay_eventSourceArn :: Lens.Lens' Replay (Prelude.Maybe Prelude.Text)
replay_eventSourceArn :: Lens' Replay (Maybe Text)
replay_eventSourceArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Replay' {Maybe Text
eventSourceArn :: Maybe Text
$sel:eventSourceArn:Replay' :: Replay -> Maybe Text
eventSourceArn} -> Maybe Text
eventSourceArn) (\s :: Replay
s@Replay' {} Maybe Text
a -> Replay
s {$sel:eventSourceArn:Replay' :: Maybe Text
eventSourceArn = Maybe Text
a} :: Replay)

-- | A time stamp for the time to start replaying events. This is determined
-- by the time in the event as described in
-- <https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html#eventbridge-Type-PutEventsRequestEntry-Time Time>.
replay_eventStartTime :: Lens.Lens' Replay (Prelude.Maybe Prelude.UTCTime)
replay_eventStartTime :: Lens' Replay (Maybe UTCTime)
replay_eventStartTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Replay' {Maybe POSIX
eventStartTime :: Maybe POSIX
$sel:eventStartTime:Replay' :: Replay -> Maybe POSIX
eventStartTime} -> Maybe POSIX
eventStartTime) (\s :: Replay
s@Replay' {} Maybe POSIX
a -> Replay
s {$sel:eventStartTime:Replay' :: Maybe POSIX
eventStartTime = Maybe POSIX
a} :: Replay) 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

-- | A time stamp for the time that the replay completed.
replay_replayEndTime :: Lens.Lens' Replay (Prelude.Maybe Prelude.UTCTime)
replay_replayEndTime :: Lens' Replay (Maybe UTCTime)
replay_replayEndTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Replay' {Maybe POSIX
replayEndTime :: Maybe POSIX
$sel:replayEndTime:Replay' :: Replay -> Maybe POSIX
replayEndTime} -> Maybe POSIX
replayEndTime) (\s :: Replay
s@Replay' {} Maybe POSIX
a -> Replay
s {$sel:replayEndTime:Replay' :: Maybe POSIX
replayEndTime = Maybe POSIX
a} :: Replay) 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 name of the replay.
replay_replayName :: Lens.Lens' Replay (Prelude.Maybe Prelude.Text)
replay_replayName :: Lens' Replay (Maybe Text)
replay_replayName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Replay' {Maybe Text
replayName :: Maybe Text
$sel:replayName:Replay' :: Replay -> Maybe Text
replayName} -> Maybe Text
replayName) (\s :: Replay
s@Replay' {} Maybe Text
a -> Replay
s {$sel:replayName:Replay' :: Maybe Text
replayName = Maybe Text
a} :: Replay)

-- | A time stamp for the time that the replay started.
replay_replayStartTime :: Lens.Lens' Replay (Prelude.Maybe Prelude.UTCTime)
replay_replayStartTime :: Lens' Replay (Maybe UTCTime)
replay_replayStartTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Replay' {Maybe POSIX
replayStartTime :: Maybe POSIX
$sel:replayStartTime:Replay' :: Replay -> Maybe POSIX
replayStartTime} -> Maybe POSIX
replayStartTime) (\s :: Replay
s@Replay' {} Maybe POSIX
a -> Replay
s {$sel:replayStartTime:Replay' :: Maybe POSIX
replayStartTime = Maybe POSIX
a} :: Replay) 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 current state of the replay.
replay_state :: Lens.Lens' Replay (Prelude.Maybe ReplayState)
replay_state :: Lens' Replay (Maybe ReplayState)
replay_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Replay' {Maybe ReplayState
state :: Maybe ReplayState
$sel:state:Replay' :: Replay -> Maybe ReplayState
state} -> Maybe ReplayState
state) (\s :: Replay
s@Replay' {} Maybe ReplayState
a -> Replay
s {$sel:state:Replay' :: Maybe ReplayState
state = Maybe ReplayState
a} :: Replay)

-- | A description of why the replay is in the current state.
replay_stateReason :: Lens.Lens' Replay (Prelude.Maybe Prelude.Text)
replay_stateReason :: Lens' Replay (Maybe Text)
replay_stateReason = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Replay' {Maybe Text
stateReason :: Maybe Text
$sel:stateReason:Replay' :: Replay -> Maybe Text
stateReason} -> Maybe Text
stateReason) (\s :: Replay
s@Replay' {} Maybe Text
a -> Replay
s {$sel:stateReason:Replay' :: Maybe Text
stateReason = Maybe Text
a} :: Replay)

instance Data.FromJSON Replay where
  parseJSON :: Value -> Parser Replay
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Replay"
      ( \Object
x ->
          Maybe POSIX
-> Maybe POSIX
-> Maybe Text
-> Maybe POSIX
-> Maybe POSIX
-> Maybe Text
-> Maybe POSIX
-> Maybe ReplayState
-> Maybe Text
-> Replay
Replay'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"EventEndTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"EventLastReplayedTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"EventSourceArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"EventStartTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ReplayEndTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ReplayName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (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 -> Parser (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 -> Parser (Maybe a)
Data..:? Key
"StateReason")
      )

instance Prelude.Hashable Replay where
  hashWithSalt :: Int -> Replay -> Int
hashWithSalt Int
_salt Replay' {Maybe Text
Maybe POSIX
Maybe ReplayState
stateReason :: Maybe Text
state :: Maybe ReplayState
replayStartTime :: Maybe POSIX
replayName :: Maybe Text
replayEndTime :: Maybe POSIX
eventStartTime :: Maybe POSIX
eventSourceArn :: Maybe Text
eventLastReplayedTime :: Maybe POSIX
eventEndTime :: Maybe POSIX
$sel:stateReason:Replay' :: Replay -> Maybe Text
$sel:state:Replay' :: Replay -> Maybe ReplayState
$sel:replayStartTime:Replay' :: Replay -> Maybe POSIX
$sel:replayName:Replay' :: Replay -> Maybe Text
$sel:replayEndTime:Replay' :: Replay -> Maybe POSIX
$sel:eventStartTime:Replay' :: Replay -> Maybe POSIX
$sel:eventSourceArn:Replay' :: Replay -> Maybe Text
$sel:eventLastReplayedTime:Replay' :: Replay -> Maybe POSIX
$sel:eventEndTime:Replay' :: Replay -> Maybe POSIX
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
eventEndTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
eventLastReplayedTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
eventSourceArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
eventStartTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
replayEndTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
replayName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
replayStartTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ReplayState
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
stateReason

instance Prelude.NFData Replay where
  rnf :: Replay -> ()
rnf Replay' {Maybe Text
Maybe POSIX
Maybe ReplayState
stateReason :: Maybe Text
state :: Maybe ReplayState
replayStartTime :: Maybe POSIX
replayName :: Maybe Text
replayEndTime :: Maybe POSIX
eventStartTime :: Maybe POSIX
eventSourceArn :: Maybe Text
eventLastReplayedTime :: Maybe POSIX
eventEndTime :: Maybe POSIX
$sel:stateReason:Replay' :: Replay -> Maybe Text
$sel:state:Replay' :: Replay -> Maybe ReplayState
$sel:replayStartTime:Replay' :: Replay -> Maybe POSIX
$sel:replayName:Replay' :: Replay -> Maybe Text
$sel:replayEndTime:Replay' :: Replay -> Maybe POSIX
$sel:eventStartTime:Replay' :: Replay -> Maybe POSIX
$sel:eventSourceArn:Replay' :: Replay -> Maybe Text
$sel:eventLastReplayedTime:Replay' :: Replay -> Maybe POSIX
$sel:eventEndTime:Replay' :: Replay -> Maybe POSIX
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
eventEndTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
eventLastReplayedTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
eventSourceArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
eventStartTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
replayEndTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
replayName
      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