{-# 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-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- 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.Lens as Lens
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 :: Core.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
(NotifyMigrationTaskState -> NotifyMigrationTaskState -> Bool)
-> (NotifyMigrationTaskState -> NotifyMigrationTaskState -> Bool)
-> Eq NotifyMigrationTaskState
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]
(Int -> ReadS NotifyMigrationTaskState)
-> ReadS [NotifyMigrationTaskState]
-> ReadPrec NotifyMigrationTaskState
-> ReadPrec [NotifyMigrationTaskState]
-> Read 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
(Int -> NotifyMigrationTaskState -> ShowS)
-> (NotifyMigrationTaskState -> String)
-> ([NotifyMigrationTaskState] -> ShowS)
-> Show NotifyMigrationTaskState
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.
 NotifyMigrationTaskState -> Rep NotifyMigrationTaskState x)
-> (forall x.
    Rep NotifyMigrationTaskState x -> NotifyMigrationTaskState)
-> Generic NotifyMigrationTaskState
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' :: Maybe Bool
-> Text
-> Text
-> Task
-> POSIX
-> Natural
-> NotifyMigrationTaskState
NotifyMigrationTaskState'
      { $sel:dryRun:NotifyMigrationTaskState' :: Maybe Bool
dryRun = Maybe Bool
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 =
          Tagged UTCTime (Identity UTCTime) -> Tagged POSIX (Identity POSIX)
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time (Tagged UTCTime (Identity UTCTime)
 -> Tagged POSIX (Identity POSIX))
-> UTCTime -> POSIX
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 :: (Maybe Bool -> f (Maybe Bool))
-> NotifyMigrationTaskState -> f NotifyMigrationTaskState
notifyMigrationTaskState_dryRun = (NotifyMigrationTaskState -> Maybe Bool)
-> (NotifyMigrationTaskState
    -> Maybe Bool -> NotifyMigrationTaskState)
-> Lens
     NotifyMigrationTaskState
     NotifyMigrationTaskState
     (Maybe Bool)
     (Maybe Bool)
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 :: (Text -> f Text)
-> NotifyMigrationTaskState -> f NotifyMigrationTaskState
notifyMigrationTaskState_progressUpdateStream = (NotifyMigrationTaskState -> Text)
-> (NotifyMigrationTaskState -> Text -> NotifyMigrationTaskState)
-> Lens NotifyMigrationTaskState NotifyMigrationTaskState Text Text
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 :: (Text -> f Text)
-> NotifyMigrationTaskState -> f NotifyMigrationTaskState
notifyMigrationTaskState_migrationTaskName = (NotifyMigrationTaskState -> Text)
-> (NotifyMigrationTaskState -> Text -> NotifyMigrationTaskState)
-> Lens NotifyMigrationTaskState NotifyMigrationTaskState Text Text
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 :: (Task -> f Task)
-> NotifyMigrationTaskState -> f NotifyMigrationTaskState
notifyMigrationTaskState_task = (NotifyMigrationTaskState -> Task)
-> (NotifyMigrationTaskState -> Task -> NotifyMigrationTaskState)
-> Lens NotifyMigrationTaskState NotifyMigrationTaskState Task 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 :: (UTCTime -> f UTCTime)
-> NotifyMigrationTaskState -> f NotifyMigrationTaskState
notifyMigrationTaskState_updateDateTime = (NotifyMigrationTaskState -> POSIX)
-> (NotifyMigrationTaskState -> POSIX -> NotifyMigrationTaskState)
-> Lens
     NotifyMigrationTaskState NotifyMigrationTaskState POSIX POSIX
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) ((POSIX -> f POSIX)
 -> NotifyMigrationTaskState -> f NotifyMigrationTaskState)
-> ((UTCTime -> f UTCTime) -> POSIX -> f POSIX)
-> (UTCTime -> f UTCTime)
-> NotifyMigrationTaskState
-> f NotifyMigrationTaskState
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (UTCTime -> f UTCTime) -> POSIX -> f POSIX
forall (a :: Format). Iso' (Time a) UTCTime
Core._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 :: (Natural -> f Natural)
-> NotifyMigrationTaskState -> f NotifyMigrationTaskState
notifyMigrationTaskState_nextUpdateSeconds = (NotifyMigrationTaskState -> Natural)
-> (NotifyMigrationTaskState
    -> Natural -> NotifyMigrationTaskState)
-> Lens
     NotifyMigrationTaskState NotifyMigrationTaskState Natural Natural
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 :: NotifyMigrationTaskState -> Request NotifyMigrationTaskState
request = Service
-> NotifyMigrationTaskState -> Request NotifyMigrationTaskState
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy NotifyMigrationTaskState
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse NotifyMigrationTaskState)))
response =
    (Int
 -> ResponseHeaders
 -> ()
 -> Either String (AWSResponse NotifyMigrationTaskState))
-> Logger
-> Service
-> Proxy NotifyMigrationTaskState
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse NotifyMigrationTaskState)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> NotifyMigrationTaskStateResponse
NotifyMigrationTaskStateResponse'
            (Int -> NotifyMigrationTaskStateResponse)
-> Either String Int
-> Either String NotifyMigrationTaskStateResponse
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable NotifyMigrationTaskState

instance Prelude.NFData NotifyMigrationTaskState

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

instance Core.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
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"DryRun" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
dryRun,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              ( Text
"ProgressUpdateStream"
                  Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
progressUpdateStream
              ),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"MigrationTaskName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
migrationTaskName),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"Task" Text -> Task -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Task
task),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"UpdateDateTime" Text -> POSIX -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= POSIX
updateDateTime),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"NextUpdateSeconds" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Natural
nextUpdateSeconds)
          ]
      )

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

instance Core.ToQuery NotifyMigrationTaskState where
  toQuery :: NotifyMigrationTaskState -> QueryString
toQuery = QueryString -> NotifyMigrationTaskState -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
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
(NotifyMigrationTaskStateResponse
 -> NotifyMigrationTaskStateResponse -> Bool)
-> (NotifyMigrationTaskStateResponse
    -> NotifyMigrationTaskStateResponse -> Bool)
-> Eq NotifyMigrationTaskStateResponse
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]
(Int -> ReadS NotifyMigrationTaskStateResponse)
-> ReadS [NotifyMigrationTaskStateResponse]
-> ReadPrec NotifyMigrationTaskStateResponse
-> ReadPrec [NotifyMigrationTaskStateResponse]
-> Read 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
(Int -> NotifyMigrationTaskStateResponse -> ShowS)
-> (NotifyMigrationTaskStateResponse -> String)
-> ([NotifyMigrationTaskStateResponse] -> ShowS)
-> Show NotifyMigrationTaskStateResponse
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.
 NotifyMigrationTaskStateResponse
 -> Rep NotifyMigrationTaskStateResponse x)
-> (forall x.
    Rep NotifyMigrationTaskStateResponse x
    -> NotifyMigrationTaskStateResponse)
-> Generic NotifyMigrationTaskStateResponse
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' :: Int -> NotifyMigrationTaskStateResponse
NotifyMigrationTaskStateResponse'
    { $sel:httpStatus:NotifyMigrationTaskStateResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

-- | The response's http status code.
notifyMigrationTaskStateResponse_httpStatus :: Lens.Lens' NotifyMigrationTaskStateResponse Prelude.Int
notifyMigrationTaskStateResponse_httpStatus :: (Int -> f Int)
-> NotifyMigrationTaskStateResponse
-> f NotifyMigrationTaskStateResponse
notifyMigrationTaskStateResponse_httpStatus = (NotifyMigrationTaskStateResponse -> Int)
-> (NotifyMigrationTaskStateResponse
    -> Int -> NotifyMigrationTaskStateResponse)
-> Lens
     NotifyMigrationTaskStateResponse
     NotifyMigrationTaskStateResponse
     Int
     Int
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