{-# 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.SSMIncidents.UpdateTimelineEvent
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Updates a timeline event. You can update events of type @Custom Event@.
module Amazonka.SSMIncidents.UpdateTimelineEvent
  ( -- * Creating a Request
    UpdateTimelineEvent (..),
    newUpdateTimelineEvent,

    -- * Request Lenses
    updateTimelineEvent_clientToken,
    updateTimelineEvent_eventData,
    updateTimelineEvent_eventReferences,
    updateTimelineEvent_eventTime,
    updateTimelineEvent_eventType,
    updateTimelineEvent_eventId,
    updateTimelineEvent_incidentRecordArn,

    -- * Destructuring the Response
    UpdateTimelineEventResponse (..),
    newUpdateTimelineEventResponse,

    -- * Response Lenses
    updateTimelineEventResponse_httpStatus,
  )
where

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

-- | /See:/ 'newUpdateTimelineEvent' smart constructor.
data UpdateTimelineEvent = UpdateTimelineEvent'
  { -- | A token ensuring that the operation is called only once with the
    -- specified details.
    UpdateTimelineEvent -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | A short description of the event.
    UpdateTimelineEvent -> Maybe Text
eventData :: Prelude.Maybe Prelude.Text,
    -- | Updates all existing references in a @TimelineEvent@. A reference can be
    -- an Amazon Web Services resource involved in the incident or in some way
    -- associated with it. When you specify a reference, you enter the Amazon
    -- Resource Name (ARN) of the resource. You can also specify a related
    -- item. As an example, you could specify the ARN of an Amazon DynamoDB
    -- (DynamoDB) table. The table for this example is the resource. You could
    -- also specify a Amazon CloudWatch metric for that table. The metric is
    -- the related item.
    --
    -- This update action overrides all existing references. If you want to
    -- keep existing references, you must specify them in the call. If you
    -- don\'t, this action removes them and enters only new references.
    UpdateTimelineEvent -> Maybe [EventReference]
eventReferences :: Prelude.Maybe [EventReference],
    -- | The time that the event occurred.
    UpdateTimelineEvent -> Maybe POSIX
eventTime :: Prelude.Maybe Data.POSIX,
    -- | The type of the event. You can update events of type @Custom Event@.
    UpdateTimelineEvent -> Maybe Text
eventType :: Prelude.Maybe Prelude.Text,
    -- | The ID of the event you are updating. You can find this by using
    -- @ListTimelineEvents@.
    UpdateTimelineEvent -> Text
eventId :: Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the incident that includes the
    -- timeline event.
    UpdateTimelineEvent -> Text
incidentRecordArn :: Prelude.Text
  }
  deriving (UpdateTimelineEvent -> UpdateTimelineEvent -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateTimelineEvent -> UpdateTimelineEvent -> Bool
$c/= :: UpdateTimelineEvent -> UpdateTimelineEvent -> Bool
== :: UpdateTimelineEvent -> UpdateTimelineEvent -> Bool
$c== :: UpdateTimelineEvent -> UpdateTimelineEvent -> Bool
Prelude.Eq, ReadPrec [UpdateTimelineEvent]
ReadPrec UpdateTimelineEvent
Int -> ReadS UpdateTimelineEvent
ReadS [UpdateTimelineEvent]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateTimelineEvent]
$creadListPrec :: ReadPrec [UpdateTimelineEvent]
readPrec :: ReadPrec UpdateTimelineEvent
$creadPrec :: ReadPrec UpdateTimelineEvent
readList :: ReadS [UpdateTimelineEvent]
$creadList :: ReadS [UpdateTimelineEvent]
readsPrec :: Int -> ReadS UpdateTimelineEvent
$creadsPrec :: Int -> ReadS UpdateTimelineEvent
Prelude.Read, Int -> UpdateTimelineEvent -> ShowS
[UpdateTimelineEvent] -> ShowS
UpdateTimelineEvent -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateTimelineEvent] -> ShowS
$cshowList :: [UpdateTimelineEvent] -> ShowS
show :: UpdateTimelineEvent -> String
$cshow :: UpdateTimelineEvent -> String
showsPrec :: Int -> UpdateTimelineEvent -> ShowS
$cshowsPrec :: Int -> UpdateTimelineEvent -> ShowS
Prelude.Show, forall x. Rep UpdateTimelineEvent x -> UpdateTimelineEvent
forall x. UpdateTimelineEvent -> Rep UpdateTimelineEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateTimelineEvent x -> UpdateTimelineEvent
$cfrom :: forall x. UpdateTimelineEvent -> Rep UpdateTimelineEvent x
Prelude.Generic)

-- |
-- Create a value of 'UpdateTimelineEvent' 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:
--
-- 'clientToken', 'updateTimelineEvent_clientToken' - A token ensuring that the operation is called only once with the
-- specified details.
--
-- 'eventData', 'updateTimelineEvent_eventData' - A short description of the event.
--
-- 'eventReferences', 'updateTimelineEvent_eventReferences' - Updates all existing references in a @TimelineEvent@. A reference can be
-- an Amazon Web Services resource involved in the incident or in some way
-- associated with it. When you specify a reference, you enter the Amazon
-- Resource Name (ARN) of the resource. You can also specify a related
-- item. As an example, you could specify the ARN of an Amazon DynamoDB
-- (DynamoDB) table. The table for this example is the resource. You could
-- also specify a Amazon CloudWatch metric for that table. The metric is
-- the related item.
--
-- This update action overrides all existing references. If you want to
-- keep existing references, you must specify them in the call. If you
-- don\'t, this action removes them and enters only new references.
--
-- 'eventTime', 'updateTimelineEvent_eventTime' - The time that the event occurred.
--
-- 'eventType', 'updateTimelineEvent_eventType' - The type of the event. You can update events of type @Custom Event@.
--
-- 'eventId', 'updateTimelineEvent_eventId' - The ID of the event you are updating. You can find this by using
-- @ListTimelineEvents@.
--
-- 'incidentRecordArn', 'updateTimelineEvent_incidentRecordArn' - The Amazon Resource Name (ARN) of the incident that includes the
-- timeline event.
newUpdateTimelineEvent ::
  -- | 'eventId'
  Prelude.Text ->
  -- | 'incidentRecordArn'
  Prelude.Text ->
  UpdateTimelineEvent
newUpdateTimelineEvent :: Text -> Text -> UpdateTimelineEvent
newUpdateTimelineEvent Text
pEventId_ Text
pIncidentRecordArn_ =
  UpdateTimelineEvent'
    { $sel:clientToken:UpdateTimelineEvent' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
      $sel:eventData:UpdateTimelineEvent' :: Maybe Text
eventData = forall a. Maybe a
Prelude.Nothing,
      $sel:eventReferences:UpdateTimelineEvent' :: Maybe [EventReference]
eventReferences = forall a. Maybe a
Prelude.Nothing,
      $sel:eventTime:UpdateTimelineEvent' :: Maybe POSIX
eventTime = forall a. Maybe a
Prelude.Nothing,
      $sel:eventType:UpdateTimelineEvent' :: Maybe Text
eventType = forall a. Maybe a
Prelude.Nothing,
      $sel:eventId:UpdateTimelineEvent' :: Text
eventId = Text
pEventId_,
      $sel:incidentRecordArn:UpdateTimelineEvent' :: Text
incidentRecordArn = Text
pIncidentRecordArn_
    }

-- | A token ensuring that the operation is called only once with the
-- specified details.
updateTimelineEvent_clientToken :: Lens.Lens' UpdateTimelineEvent (Prelude.Maybe Prelude.Text)
updateTimelineEvent_clientToken :: Lens' UpdateTimelineEvent (Maybe Text)
updateTimelineEvent_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateTimelineEvent' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: UpdateTimelineEvent
s@UpdateTimelineEvent' {} Maybe Text
a -> UpdateTimelineEvent
s {$sel:clientToken:UpdateTimelineEvent' :: Maybe Text
clientToken = Maybe Text
a} :: UpdateTimelineEvent)

-- | A short description of the event.
updateTimelineEvent_eventData :: Lens.Lens' UpdateTimelineEvent (Prelude.Maybe Prelude.Text)
updateTimelineEvent_eventData :: Lens' UpdateTimelineEvent (Maybe Text)
updateTimelineEvent_eventData = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateTimelineEvent' {Maybe Text
eventData :: Maybe Text
$sel:eventData:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
eventData} -> Maybe Text
eventData) (\s :: UpdateTimelineEvent
s@UpdateTimelineEvent' {} Maybe Text
a -> UpdateTimelineEvent
s {$sel:eventData:UpdateTimelineEvent' :: Maybe Text
eventData = Maybe Text
a} :: UpdateTimelineEvent)

-- | Updates all existing references in a @TimelineEvent@. A reference can be
-- an Amazon Web Services resource involved in the incident or in some way
-- associated with it. When you specify a reference, you enter the Amazon
-- Resource Name (ARN) of the resource. You can also specify a related
-- item. As an example, you could specify the ARN of an Amazon DynamoDB
-- (DynamoDB) table. The table for this example is the resource. You could
-- also specify a Amazon CloudWatch metric for that table. The metric is
-- the related item.
--
-- This update action overrides all existing references. If you want to
-- keep existing references, you must specify them in the call. If you
-- don\'t, this action removes them and enters only new references.
updateTimelineEvent_eventReferences :: Lens.Lens' UpdateTimelineEvent (Prelude.Maybe [EventReference])
updateTimelineEvent_eventReferences :: Lens' UpdateTimelineEvent (Maybe [EventReference])
updateTimelineEvent_eventReferences = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateTimelineEvent' {Maybe [EventReference]
eventReferences :: Maybe [EventReference]
$sel:eventReferences:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe [EventReference]
eventReferences} -> Maybe [EventReference]
eventReferences) (\s :: UpdateTimelineEvent
s@UpdateTimelineEvent' {} Maybe [EventReference]
a -> UpdateTimelineEvent
s {$sel:eventReferences:UpdateTimelineEvent' :: Maybe [EventReference]
eventReferences = Maybe [EventReference]
a} :: UpdateTimelineEvent) 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 time that the event occurred.
updateTimelineEvent_eventTime :: Lens.Lens' UpdateTimelineEvent (Prelude.Maybe Prelude.UTCTime)
updateTimelineEvent_eventTime :: Lens' UpdateTimelineEvent (Maybe UTCTime)
updateTimelineEvent_eventTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateTimelineEvent' {Maybe POSIX
eventTime :: Maybe POSIX
$sel:eventTime:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe POSIX
eventTime} -> Maybe POSIX
eventTime) (\s :: UpdateTimelineEvent
s@UpdateTimelineEvent' {} Maybe POSIX
a -> UpdateTimelineEvent
s {$sel:eventTime:UpdateTimelineEvent' :: Maybe POSIX
eventTime = Maybe POSIX
a} :: UpdateTimelineEvent) 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 type of the event. You can update events of type @Custom Event@.
updateTimelineEvent_eventType :: Lens.Lens' UpdateTimelineEvent (Prelude.Maybe Prelude.Text)
updateTimelineEvent_eventType :: Lens' UpdateTimelineEvent (Maybe Text)
updateTimelineEvent_eventType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateTimelineEvent' {Maybe Text
eventType :: Maybe Text
$sel:eventType:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
eventType} -> Maybe Text
eventType) (\s :: UpdateTimelineEvent
s@UpdateTimelineEvent' {} Maybe Text
a -> UpdateTimelineEvent
s {$sel:eventType:UpdateTimelineEvent' :: Maybe Text
eventType = Maybe Text
a} :: UpdateTimelineEvent)

-- | The ID of the event you are updating. You can find this by using
-- @ListTimelineEvents@.
updateTimelineEvent_eventId :: Lens.Lens' UpdateTimelineEvent Prelude.Text
updateTimelineEvent_eventId :: Lens' UpdateTimelineEvent Text
updateTimelineEvent_eventId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateTimelineEvent' {Text
eventId :: Text
$sel:eventId:UpdateTimelineEvent' :: UpdateTimelineEvent -> Text
eventId} -> Text
eventId) (\s :: UpdateTimelineEvent
s@UpdateTimelineEvent' {} Text
a -> UpdateTimelineEvent
s {$sel:eventId:UpdateTimelineEvent' :: Text
eventId = Text
a} :: UpdateTimelineEvent)

-- | The Amazon Resource Name (ARN) of the incident that includes the
-- timeline event.
updateTimelineEvent_incidentRecordArn :: Lens.Lens' UpdateTimelineEvent Prelude.Text
updateTimelineEvent_incidentRecordArn :: Lens' UpdateTimelineEvent Text
updateTimelineEvent_incidentRecordArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateTimelineEvent' {Text
incidentRecordArn :: Text
$sel:incidentRecordArn:UpdateTimelineEvent' :: UpdateTimelineEvent -> Text
incidentRecordArn} -> Text
incidentRecordArn) (\s :: UpdateTimelineEvent
s@UpdateTimelineEvent' {} Text
a -> UpdateTimelineEvent
s {$sel:incidentRecordArn:UpdateTimelineEvent' :: Text
incidentRecordArn = Text
a} :: UpdateTimelineEvent)

instance Core.AWSRequest UpdateTimelineEvent where
  type
    AWSResponse UpdateTimelineEvent =
      UpdateTimelineEventResponse
  request :: (Service -> Service)
-> UpdateTimelineEvent -> Request UpdateTimelineEvent
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 UpdateTimelineEvent
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse UpdateTimelineEvent)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> UpdateTimelineEventResponse
UpdateTimelineEventResponse'
            forall (f :: * -> *) a b. Functor 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 UpdateTimelineEvent where
  hashWithSalt :: Int -> UpdateTimelineEvent -> Int
hashWithSalt Int
_salt UpdateTimelineEvent' {Maybe [EventReference]
Maybe Text
Maybe POSIX
Text
incidentRecordArn :: Text
eventId :: Text
eventType :: Maybe Text
eventTime :: Maybe POSIX
eventReferences :: Maybe [EventReference]
eventData :: Maybe Text
clientToken :: Maybe Text
$sel:incidentRecordArn:UpdateTimelineEvent' :: UpdateTimelineEvent -> Text
$sel:eventId:UpdateTimelineEvent' :: UpdateTimelineEvent -> Text
$sel:eventType:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
$sel:eventTime:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe POSIX
$sel:eventReferences:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe [EventReference]
$sel:eventData:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
$sel:clientToken:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
eventData
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [EventReference]
eventReferences
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
eventTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
eventType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
eventId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
incidentRecordArn

instance Prelude.NFData UpdateTimelineEvent where
  rnf :: UpdateTimelineEvent -> ()
rnf UpdateTimelineEvent' {Maybe [EventReference]
Maybe Text
Maybe POSIX
Text
incidentRecordArn :: Text
eventId :: Text
eventType :: Maybe Text
eventTime :: Maybe POSIX
eventReferences :: Maybe [EventReference]
eventData :: Maybe Text
clientToken :: Maybe Text
$sel:incidentRecordArn:UpdateTimelineEvent' :: UpdateTimelineEvent -> Text
$sel:eventId:UpdateTimelineEvent' :: UpdateTimelineEvent -> Text
$sel:eventType:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
$sel:eventTime:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe POSIX
$sel:eventReferences:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe [EventReference]
$sel:eventData:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
$sel:clientToken:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
eventData
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [EventReference]
eventReferences
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
eventTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
eventType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
eventId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
incidentRecordArn

instance Data.ToHeaders UpdateTimelineEvent where
  toHeaders :: UpdateTimelineEvent -> 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 UpdateTimelineEvent where
  toJSON :: UpdateTimelineEvent -> Value
toJSON UpdateTimelineEvent' {Maybe [EventReference]
Maybe Text
Maybe POSIX
Text
incidentRecordArn :: Text
eventId :: Text
eventType :: Maybe Text
eventTime :: Maybe POSIX
eventReferences :: Maybe [EventReference]
eventData :: Maybe Text
clientToken :: Maybe Text
$sel:incidentRecordArn:UpdateTimelineEvent' :: UpdateTimelineEvent -> Text
$sel:eventId:UpdateTimelineEvent' :: UpdateTimelineEvent -> Text
$sel:eventType:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
$sel:eventTime:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe POSIX
$sel:eventReferences:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe [EventReference]
$sel:eventData:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
$sel:clientToken:UpdateTimelineEvent' :: UpdateTimelineEvent -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"clientToken" 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
clientToken,
            (Key
"eventData" 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
eventData,
            (Key
"eventReferences" 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 [EventReference]
eventReferences,
            (Key
"eventTime" 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 POSIX
eventTime,
            (Key
"eventType" 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
eventType,
            forall a. a -> Maybe a
Prelude.Just (Key
"eventId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
eventId),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"incidentRecordArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
incidentRecordArn)
          ]
      )

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

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

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

-- |
-- Create a value of 'UpdateTimelineEventResponse' 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:
--
-- 'httpStatus', 'updateTimelineEventResponse_httpStatus' - The response's http status code.
newUpdateTimelineEventResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateTimelineEventResponse
newUpdateTimelineEventResponse :: Int -> UpdateTimelineEventResponse
newUpdateTimelineEventResponse Int
pHttpStatus_ =
  UpdateTimelineEventResponse'
    { $sel:httpStatus:UpdateTimelineEventResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

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

instance Prelude.NFData UpdateTimelineEventResponse where
  rnf :: UpdateTimelineEventResponse -> ()
rnf UpdateTimelineEventResponse' {Int
httpStatus :: Int
$sel:httpStatus:UpdateTimelineEventResponse' :: UpdateTimelineEventResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus