{-# 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.MigrationHub.NotifyMigrationTaskState
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Notifies Migration Hub of the current status, progress, or other detail
-- regarding a migration task. This API has the following traits:
--
-- -   Migration tools will call the @NotifyMigrationTaskState@ API to
--     share the latest progress and status.
--
-- -   @MigrationTaskName@ is used for addressing updates to the correct
--     target.
--
-- -   @ProgressUpdateStream@ is used for access control and to provide a
--     namespace for each migration tool.
module Amazonka.MigrationHub.NotifyMigrationTaskState
  ( -- * Creating a Request
    NotifyMigrationTaskState (..),
    newNotifyMigrationTaskState,

    -- * Request Lenses
    notifyMigrationTaskState_dryRun,
    notifyMigrationTaskState_progressUpdateStream,
    notifyMigrationTaskState_migrationTaskName,
    notifyMigrationTaskState_task,
    notifyMigrationTaskState_updateDateTime,
    notifyMigrationTaskState_nextUpdateSeconds,

    -- * Destructuring the Response
    NotifyMigrationTaskStateResponse (..),
    newNotifyMigrationTaskStateResponse,

    -- * Response Lenses
    notifyMigrationTaskStateResponse_httpStatus,
  )
where

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

-- | /See:/ 'newNotifyMigrationTaskState' smart constructor.
data NotifyMigrationTaskState = NotifyMigrationTaskState'
  { -- | Optional boolean flag to indicate whether any effect should take place.
    -- Used to test if the caller has permission to make the call.
    NotifyMigrationTaskState -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The name of the ProgressUpdateStream.
    NotifyMigrationTaskState -> Text
progressUpdateStream :: Prelude.Text,
    -- | Unique identifier that references the migration task. /Do not store
    -- personal data in this field./
    NotifyMigrationTaskState -> Text
migrationTaskName :: Prelude.Text,
    -- | Information about the task\'s progress and status.
    NotifyMigrationTaskState -> Task
task :: Task,
    -- | The timestamp when the task was gathered.
    NotifyMigrationTaskState -> POSIX
updateDateTime :: Data.POSIX,
    -- | Number of seconds after the UpdateDateTime within which the Migration
    -- Hub can expect an update. If Migration Hub does not receive an update
    -- within the specified interval, then the migration task will be
    -- considered stale.
    NotifyMigrationTaskState -> Natural
nextUpdateSeconds :: Prelude.Natural
  }
  deriving (NotifyMigrationTaskState -> NotifyMigrationTaskState -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotifyMigrationTaskState -> NotifyMigrationTaskState -> Bool
$c/= :: NotifyMigrationTaskState -> NotifyMigrationTaskState -> Bool
== :: NotifyMigrationTaskState -> NotifyMigrationTaskState -> Bool
$c== :: NotifyMigrationTaskState -> NotifyMigrationTaskState -> Bool
Prelude.Eq, ReadPrec [NotifyMigrationTaskState]
ReadPrec NotifyMigrationTaskState
Int -> ReadS NotifyMigrationTaskState
ReadS [NotifyMigrationTaskState]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NotifyMigrationTaskState]
$creadListPrec :: ReadPrec [NotifyMigrationTaskState]
readPrec :: ReadPrec NotifyMigrationTaskState
$creadPrec :: ReadPrec NotifyMigrationTaskState
readList :: ReadS [NotifyMigrationTaskState]
$creadList :: ReadS [NotifyMigrationTaskState]
readsPrec :: Int -> ReadS NotifyMigrationTaskState
$creadsPrec :: Int -> ReadS NotifyMigrationTaskState
Prelude.Read, Int -> NotifyMigrationTaskState -> ShowS
[NotifyMigrationTaskState] -> ShowS
NotifyMigrationTaskState -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NotifyMigrationTaskState] -> ShowS
$cshowList :: [NotifyMigrationTaskState] -> ShowS
show :: NotifyMigrationTaskState -> String
$cshow :: NotifyMigrationTaskState -> String
showsPrec :: Int -> NotifyMigrationTaskState -> ShowS
$cshowsPrec :: Int -> NotifyMigrationTaskState -> ShowS
Prelude.Show, forall x.
Rep NotifyMigrationTaskState x -> NotifyMigrationTaskState
forall x.
NotifyMigrationTaskState -> Rep NotifyMigrationTaskState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep NotifyMigrationTaskState x -> NotifyMigrationTaskState
$cfrom :: forall x.
NotifyMigrationTaskState -> Rep NotifyMigrationTaskState x
Prelude.Generic)

-- |
-- Create a value of 'NotifyMigrationTaskState' 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:
--
-- 'dryRun', 'notifyMigrationTaskState_dryRun' - Optional boolean flag to indicate whether any effect should take place.
-- Used to test if the caller has permission to make the call.
--
-- 'progressUpdateStream', 'notifyMigrationTaskState_progressUpdateStream' - The name of the ProgressUpdateStream.
--
-- 'migrationTaskName', 'notifyMigrationTaskState_migrationTaskName' - Unique identifier that references the migration task. /Do not store
-- personal data in this field./
--
-- 'task', 'notifyMigrationTaskState_task' - Information about the task\'s progress and status.
--
-- 'updateDateTime', 'notifyMigrationTaskState_updateDateTime' - The timestamp when the task was gathered.
--
-- 'nextUpdateSeconds', 'notifyMigrationTaskState_nextUpdateSeconds' - Number of seconds after the UpdateDateTime within which the Migration
-- Hub can expect an update. If Migration Hub does not receive an update
-- within the specified interval, then the migration task will be
-- considered stale.
newNotifyMigrationTaskState ::
  -- | 'progressUpdateStream'
  Prelude.Text ->
  -- | 'migrationTaskName'
  Prelude.Text ->
  -- | 'task'
  Task ->
  -- | 'updateDateTime'
  Prelude.UTCTime ->
  -- | 'nextUpdateSeconds'
  Prelude.Natural ->
  NotifyMigrationTaskState
newNotifyMigrationTaskState :: Text
-> Text -> Task -> UTCTime -> Natural -> NotifyMigrationTaskState
newNotifyMigrationTaskState
  Text
pProgressUpdateStream_
  Text
pMigrationTaskName_
  Task
pTask_
  UTCTime
pUpdateDateTime_
  Natural
pNextUpdateSeconds_ =
    NotifyMigrationTaskState'
      { $sel:dryRun:NotifyMigrationTaskState' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
        $sel:progressUpdateStream:NotifyMigrationTaskState' :: Text
progressUpdateStream = Text
pProgressUpdateStream_,
        $sel:migrationTaskName:NotifyMigrationTaskState' :: Text
migrationTaskName = Text
pMigrationTaskName_,
        $sel:task:NotifyMigrationTaskState' :: Task
task = Task
pTask_,
        $sel:updateDateTime:NotifyMigrationTaskState' :: POSIX
updateDateTime =
          forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pUpdateDateTime_,
        $sel:nextUpdateSeconds:NotifyMigrationTaskState' :: Natural
nextUpdateSeconds = Natural
pNextUpdateSeconds_
      }

-- | Optional boolean flag to indicate whether any effect should take place.
-- Used to test if the caller has permission to make the call.
notifyMigrationTaskState_dryRun :: Lens.Lens' NotifyMigrationTaskState (Prelude.Maybe Prelude.Bool)
notifyMigrationTaskState_dryRun :: Lens' NotifyMigrationTaskState (Maybe Bool)
notifyMigrationTaskState_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NotifyMigrationTaskState' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: NotifyMigrationTaskState
s@NotifyMigrationTaskState' {} Maybe Bool
a -> NotifyMigrationTaskState
s {$sel:dryRun:NotifyMigrationTaskState' :: Maybe Bool
dryRun = Maybe Bool
a} :: NotifyMigrationTaskState)

-- | The name of the ProgressUpdateStream.
notifyMigrationTaskState_progressUpdateStream :: Lens.Lens' NotifyMigrationTaskState Prelude.Text
notifyMigrationTaskState_progressUpdateStream :: Lens' NotifyMigrationTaskState Text
notifyMigrationTaskState_progressUpdateStream = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NotifyMigrationTaskState' {Text
progressUpdateStream :: Text
$sel:progressUpdateStream:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Text
progressUpdateStream} -> Text
progressUpdateStream) (\s :: NotifyMigrationTaskState
s@NotifyMigrationTaskState' {} Text
a -> NotifyMigrationTaskState
s {$sel:progressUpdateStream:NotifyMigrationTaskState' :: Text
progressUpdateStream = Text
a} :: NotifyMigrationTaskState)

-- | Unique identifier that references the migration task. /Do not store
-- personal data in this field./
notifyMigrationTaskState_migrationTaskName :: Lens.Lens' NotifyMigrationTaskState Prelude.Text
notifyMigrationTaskState_migrationTaskName :: Lens' NotifyMigrationTaskState Text
notifyMigrationTaskState_migrationTaskName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NotifyMigrationTaskState' {Text
migrationTaskName :: Text
$sel:migrationTaskName:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Text
migrationTaskName} -> Text
migrationTaskName) (\s :: NotifyMigrationTaskState
s@NotifyMigrationTaskState' {} Text
a -> NotifyMigrationTaskState
s {$sel:migrationTaskName:NotifyMigrationTaskState' :: Text
migrationTaskName = Text
a} :: NotifyMigrationTaskState)

-- | Information about the task\'s progress and status.
notifyMigrationTaskState_task :: Lens.Lens' NotifyMigrationTaskState Task
notifyMigrationTaskState_task :: Lens' NotifyMigrationTaskState Task
notifyMigrationTaskState_task = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NotifyMigrationTaskState' {Task
task :: Task
$sel:task:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Task
task} -> Task
task) (\s :: NotifyMigrationTaskState
s@NotifyMigrationTaskState' {} Task
a -> NotifyMigrationTaskState
s {$sel:task:NotifyMigrationTaskState' :: Task
task = Task
a} :: NotifyMigrationTaskState)

-- | The timestamp when the task was gathered.
notifyMigrationTaskState_updateDateTime :: Lens.Lens' NotifyMigrationTaskState Prelude.UTCTime
notifyMigrationTaskState_updateDateTime :: Lens' NotifyMigrationTaskState UTCTime
notifyMigrationTaskState_updateDateTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NotifyMigrationTaskState' {POSIX
updateDateTime :: POSIX
$sel:updateDateTime:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> POSIX
updateDateTime} -> POSIX
updateDateTime) (\s :: NotifyMigrationTaskState
s@NotifyMigrationTaskState' {} POSIX
a -> NotifyMigrationTaskState
s {$sel:updateDateTime:NotifyMigrationTaskState' :: POSIX
updateDateTime = POSIX
a} :: NotifyMigrationTaskState) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | Number of seconds after the UpdateDateTime within which the Migration
-- Hub can expect an update. If Migration Hub does not receive an update
-- within the specified interval, then the migration task will be
-- considered stale.
notifyMigrationTaskState_nextUpdateSeconds :: Lens.Lens' NotifyMigrationTaskState Prelude.Natural
notifyMigrationTaskState_nextUpdateSeconds :: Lens' NotifyMigrationTaskState Natural
notifyMigrationTaskState_nextUpdateSeconds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NotifyMigrationTaskState' {Natural
nextUpdateSeconds :: Natural
$sel:nextUpdateSeconds:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Natural
nextUpdateSeconds} -> Natural
nextUpdateSeconds) (\s :: NotifyMigrationTaskState
s@NotifyMigrationTaskState' {} Natural
a -> NotifyMigrationTaskState
s {$sel:nextUpdateSeconds:NotifyMigrationTaskState' :: Natural
nextUpdateSeconds = Natural
a} :: NotifyMigrationTaskState)

instance Core.AWSRequest NotifyMigrationTaskState where
  type
    AWSResponse NotifyMigrationTaskState =
      NotifyMigrationTaskStateResponse
  request :: (Service -> Service)
-> NotifyMigrationTaskState -> Request NotifyMigrationTaskState
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 NotifyMigrationTaskState
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse NotifyMigrationTaskState)))
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 -> NotifyMigrationTaskStateResponse
NotifyMigrationTaskStateResponse'
            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 NotifyMigrationTaskState where
  hashWithSalt :: Int -> NotifyMigrationTaskState -> Int
hashWithSalt Int
_salt NotifyMigrationTaskState' {Natural
Maybe Bool
Text
POSIX
Task
nextUpdateSeconds :: Natural
updateDateTime :: POSIX
task :: Task
migrationTaskName :: Text
progressUpdateStream :: Text
dryRun :: Maybe Bool
$sel:nextUpdateSeconds:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Natural
$sel:updateDateTime:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> POSIX
$sel:task:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Task
$sel:migrationTaskName:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Text
$sel:progressUpdateStream:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Text
$sel:dryRun:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
progressUpdateStream
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
migrationTaskName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Task
task
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` POSIX
updateDateTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Natural
nextUpdateSeconds

instance Prelude.NFData NotifyMigrationTaskState where
  rnf :: NotifyMigrationTaskState -> ()
rnf NotifyMigrationTaskState' {Natural
Maybe Bool
Text
POSIX
Task
nextUpdateSeconds :: Natural
updateDateTime :: POSIX
task :: Task
migrationTaskName :: Text
progressUpdateStream :: Text
dryRun :: Maybe Bool
$sel:nextUpdateSeconds:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Natural
$sel:updateDateTime:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> POSIX
$sel:task:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Task
$sel:migrationTaskName:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Text
$sel:progressUpdateStream:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Text
$sel:dryRun:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
dryRun
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
progressUpdateStream
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
migrationTaskName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Task
task
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf POSIX
updateDateTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Natural
nextUpdateSeconds

instance Data.ToHeaders NotifyMigrationTaskState where
  toHeaders :: NotifyMigrationTaskState -> 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
"AWSMigrationHub.NotifyMigrationTaskState" ::
                          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 NotifyMigrationTaskState where
  toJSON :: NotifyMigrationTaskState -> Value
toJSON NotifyMigrationTaskState' {Natural
Maybe Bool
Text
POSIX
Task
nextUpdateSeconds :: Natural
updateDateTime :: POSIX
task :: Task
migrationTaskName :: Text
progressUpdateStream :: Text
dryRun :: Maybe Bool
$sel:nextUpdateSeconds:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Natural
$sel:updateDateTime:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> POSIX
$sel:task:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Task
$sel:migrationTaskName:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Text
$sel:progressUpdateStream:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Text
$sel:dryRun:NotifyMigrationTaskState' :: NotifyMigrationTaskState -> Maybe Bool
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"DryRun" 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 Bool
dryRun,
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"ProgressUpdateStream"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
progressUpdateStream
              ),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"MigrationTaskName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
migrationTaskName),
            forall a. a -> Maybe a
Prelude.Just (Key
"Task" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Task
task),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"UpdateDateTime" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= POSIX
updateDateTime),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"NextUpdateSeconds" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Natural
nextUpdateSeconds)
          ]
      )

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

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

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

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

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

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