{-# 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 #-}
module Amazonka.CloudWatchEvents.StartReplay
(
StartReplay (..),
newStartReplay,
startReplay_description,
startReplay_replayName,
startReplay_eventSourceArn,
startReplay_eventStartTime,
startReplay_eventEndTime,
startReplay_destination,
StartReplayResponse (..),
newStartReplayResponse,
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
data StartReplay = StartReplay'
{
StartReplay -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
StartReplay -> Text
replayName :: Prelude.Text,
StartReplay -> Text
eventSourceArn :: Prelude.Text,
StartReplay -> POSIX
eventStartTime :: Data.POSIX,
StartReplay -> POSIX
eventEndTime :: Data.POSIX,
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)
newStartReplay ::
Prelude.Text ->
Prelude.Text ->
Prelude.UTCTime ->
Prelude.UTCTime ->
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_
}
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)
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)
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)
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
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
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
data StartReplayResponse = StartReplayResponse'
{
StartReplayResponse -> Maybe Text
replayArn :: Prelude.Maybe Prelude.Text,
StartReplayResponse -> Maybe POSIX
replayStartTime :: Prelude.Maybe Data.POSIX,
StartReplayResponse -> Maybe ReplayState
state :: Prelude.Maybe ReplayState,
StartReplayResponse -> Maybe Text
stateReason :: Prelude.Maybe Prelude.Text,
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)
newStartReplayResponse ::
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_
}
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)
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
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)
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)
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