{-# 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.DataPipeline.SetTaskStatus
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Task runners call @SetTaskStatus@ to notify AWS Data Pipeline that a
-- task is completed and provide information about the final status. A task
-- runner makes this call regardless of whether the task was sucessful. A
-- task runner does not need to call @SetTaskStatus@ for tasks that are
-- canceled by the web service during a call to ReportTaskProgress.
module Amazonka.DataPipeline.SetTaskStatus
  ( -- * Creating a Request
    SetTaskStatus (..),
    newSetTaskStatus,

    -- * Request Lenses
    setTaskStatus_errorId,
    setTaskStatus_errorMessage,
    setTaskStatus_errorStackTrace,
    setTaskStatus_taskId,
    setTaskStatus_taskStatus,

    -- * Destructuring the Response
    SetTaskStatusResponse (..),
    newSetTaskStatusResponse,

    -- * Response Lenses
    setTaskStatusResponse_httpStatus,
  )
where

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

-- | Contains the parameters for SetTaskStatus.
--
-- /See:/ 'newSetTaskStatus' smart constructor.
data SetTaskStatus = SetTaskStatus'
  { -- | If an error occurred during the task, this value specifies the error
    -- code. This value is set on the physical attempt object. It is used to
    -- display error information to the user. It should not start with string
    -- \"Service_\" which is reserved by the system.
    SetTaskStatus -> Maybe Text
errorId :: Prelude.Maybe Prelude.Text,
    -- | If an error occurred during the task, this value specifies a text
    -- description of the error. This value is set on the physical attempt
    -- object. It is used to display error information to the user. The web
    -- service does not parse this value.
    SetTaskStatus -> Maybe Text
errorMessage :: Prelude.Maybe Prelude.Text,
    -- | If an error occurred during the task, this value specifies the stack
    -- trace associated with the error. This value is set on the physical
    -- attempt object. It is used to display error information to the user. The
    -- web service does not parse this value.
    SetTaskStatus -> Maybe Text
errorStackTrace :: Prelude.Maybe Prelude.Text,
    -- | The ID of the task assigned to the task runner. This value is provided
    -- in the response for PollForTask.
    SetTaskStatus -> Text
taskId :: Prelude.Text,
    -- | If @FINISHED@, the task successfully completed. If @FAILED@, the task
    -- ended unsuccessfully. Preconditions use false.
    SetTaskStatus -> TaskStatus
taskStatus :: TaskStatus
  }
  deriving (SetTaskStatus -> SetTaskStatus -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SetTaskStatus -> SetTaskStatus -> Bool
$c/= :: SetTaskStatus -> SetTaskStatus -> Bool
== :: SetTaskStatus -> SetTaskStatus -> Bool
$c== :: SetTaskStatus -> SetTaskStatus -> Bool
Prelude.Eq, ReadPrec [SetTaskStatus]
ReadPrec SetTaskStatus
Int -> ReadS SetTaskStatus
ReadS [SetTaskStatus]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SetTaskStatus]
$creadListPrec :: ReadPrec [SetTaskStatus]
readPrec :: ReadPrec SetTaskStatus
$creadPrec :: ReadPrec SetTaskStatus
readList :: ReadS [SetTaskStatus]
$creadList :: ReadS [SetTaskStatus]
readsPrec :: Int -> ReadS SetTaskStatus
$creadsPrec :: Int -> ReadS SetTaskStatus
Prelude.Read, Int -> SetTaskStatus -> ShowS
[SetTaskStatus] -> ShowS
SetTaskStatus -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SetTaskStatus] -> ShowS
$cshowList :: [SetTaskStatus] -> ShowS
show :: SetTaskStatus -> String
$cshow :: SetTaskStatus -> String
showsPrec :: Int -> SetTaskStatus -> ShowS
$cshowsPrec :: Int -> SetTaskStatus -> ShowS
Prelude.Show, forall x. Rep SetTaskStatus x -> SetTaskStatus
forall x. SetTaskStatus -> Rep SetTaskStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SetTaskStatus x -> SetTaskStatus
$cfrom :: forall x. SetTaskStatus -> Rep SetTaskStatus x
Prelude.Generic)

-- |
-- Create a value of 'SetTaskStatus' 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:
--
-- 'errorId', 'setTaskStatus_errorId' - If an error occurred during the task, this value specifies the error
-- code. This value is set on the physical attempt object. It is used to
-- display error information to the user. It should not start with string
-- \"Service_\" which is reserved by the system.
--
-- 'errorMessage', 'setTaskStatus_errorMessage' - If an error occurred during the task, this value specifies a text
-- description of the error. This value is set on the physical attempt
-- object. It is used to display error information to the user. The web
-- service does not parse this value.
--
-- 'errorStackTrace', 'setTaskStatus_errorStackTrace' - If an error occurred during the task, this value specifies the stack
-- trace associated with the error. This value is set on the physical
-- attempt object. It is used to display error information to the user. The
-- web service does not parse this value.
--
-- 'taskId', 'setTaskStatus_taskId' - The ID of the task assigned to the task runner. This value is provided
-- in the response for PollForTask.
--
-- 'taskStatus', 'setTaskStatus_taskStatus' - If @FINISHED@, the task successfully completed. If @FAILED@, the task
-- ended unsuccessfully. Preconditions use false.
newSetTaskStatus ::
  -- | 'taskId'
  Prelude.Text ->
  -- | 'taskStatus'
  TaskStatus ->
  SetTaskStatus
newSetTaskStatus :: Text -> TaskStatus -> SetTaskStatus
newSetTaskStatus Text
pTaskId_ TaskStatus
pTaskStatus_ =
  SetTaskStatus'
    { $sel:errorId:SetTaskStatus' :: Maybe Text
errorId = forall a. Maybe a
Prelude.Nothing,
      $sel:errorMessage:SetTaskStatus' :: Maybe Text
errorMessage = forall a. Maybe a
Prelude.Nothing,
      $sel:errorStackTrace:SetTaskStatus' :: Maybe Text
errorStackTrace = forall a. Maybe a
Prelude.Nothing,
      $sel:taskId:SetTaskStatus' :: Text
taskId = Text
pTaskId_,
      $sel:taskStatus:SetTaskStatus' :: TaskStatus
taskStatus = TaskStatus
pTaskStatus_
    }

-- | If an error occurred during the task, this value specifies the error
-- code. This value is set on the physical attempt object. It is used to
-- display error information to the user. It should not start with string
-- \"Service_\" which is reserved by the system.
setTaskStatus_errorId :: Lens.Lens' SetTaskStatus (Prelude.Maybe Prelude.Text)
setTaskStatus_errorId :: Lens' SetTaskStatus (Maybe Text)
setTaskStatus_errorId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetTaskStatus' {Maybe Text
errorId :: Maybe Text
$sel:errorId:SetTaskStatus' :: SetTaskStatus -> Maybe Text
errorId} -> Maybe Text
errorId) (\s :: SetTaskStatus
s@SetTaskStatus' {} Maybe Text
a -> SetTaskStatus
s {$sel:errorId:SetTaskStatus' :: Maybe Text
errorId = Maybe Text
a} :: SetTaskStatus)

-- | If an error occurred during the task, this value specifies a text
-- description of the error. This value is set on the physical attempt
-- object. It is used to display error information to the user. The web
-- service does not parse this value.
setTaskStatus_errorMessage :: Lens.Lens' SetTaskStatus (Prelude.Maybe Prelude.Text)
setTaskStatus_errorMessage :: Lens' SetTaskStatus (Maybe Text)
setTaskStatus_errorMessage = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetTaskStatus' {Maybe Text
errorMessage :: Maybe Text
$sel:errorMessage:SetTaskStatus' :: SetTaskStatus -> Maybe Text
errorMessage} -> Maybe Text
errorMessage) (\s :: SetTaskStatus
s@SetTaskStatus' {} Maybe Text
a -> SetTaskStatus
s {$sel:errorMessage:SetTaskStatus' :: Maybe Text
errorMessage = Maybe Text
a} :: SetTaskStatus)

-- | If an error occurred during the task, this value specifies the stack
-- trace associated with the error. This value is set on the physical
-- attempt object. It is used to display error information to the user. The
-- web service does not parse this value.
setTaskStatus_errorStackTrace :: Lens.Lens' SetTaskStatus (Prelude.Maybe Prelude.Text)
setTaskStatus_errorStackTrace :: Lens' SetTaskStatus (Maybe Text)
setTaskStatus_errorStackTrace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetTaskStatus' {Maybe Text
errorStackTrace :: Maybe Text
$sel:errorStackTrace:SetTaskStatus' :: SetTaskStatus -> Maybe Text
errorStackTrace} -> Maybe Text
errorStackTrace) (\s :: SetTaskStatus
s@SetTaskStatus' {} Maybe Text
a -> SetTaskStatus
s {$sel:errorStackTrace:SetTaskStatus' :: Maybe Text
errorStackTrace = Maybe Text
a} :: SetTaskStatus)

-- | The ID of the task assigned to the task runner. This value is provided
-- in the response for PollForTask.
setTaskStatus_taskId :: Lens.Lens' SetTaskStatus Prelude.Text
setTaskStatus_taskId :: Lens' SetTaskStatus Text
setTaskStatus_taskId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetTaskStatus' {Text
taskId :: Text
$sel:taskId:SetTaskStatus' :: SetTaskStatus -> Text
taskId} -> Text
taskId) (\s :: SetTaskStatus
s@SetTaskStatus' {} Text
a -> SetTaskStatus
s {$sel:taskId:SetTaskStatus' :: Text
taskId = Text
a} :: SetTaskStatus)

-- | If @FINISHED@, the task successfully completed. If @FAILED@, the task
-- ended unsuccessfully. Preconditions use false.
setTaskStatus_taskStatus :: Lens.Lens' SetTaskStatus TaskStatus
setTaskStatus_taskStatus :: Lens' SetTaskStatus TaskStatus
setTaskStatus_taskStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetTaskStatus' {TaskStatus
taskStatus :: TaskStatus
$sel:taskStatus:SetTaskStatus' :: SetTaskStatus -> TaskStatus
taskStatus} -> TaskStatus
taskStatus) (\s :: SetTaskStatus
s@SetTaskStatus' {} TaskStatus
a -> SetTaskStatus
s {$sel:taskStatus:SetTaskStatus' :: TaskStatus
taskStatus = TaskStatus
a} :: SetTaskStatus)

instance Core.AWSRequest SetTaskStatus where
  type
    AWSResponse SetTaskStatus =
      SetTaskStatusResponse
  request :: (Service -> Service) -> SetTaskStatus -> Request SetTaskStatus
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 SetTaskStatus
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse SetTaskStatus)))
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 -> SetTaskStatusResponse
SetTaskStatusResponse'
            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 SetTaskStatus where
  hashWithSalt :: Int -> SetTaskStatus -> Int
hashWithSalt Int
_salt SetTaskStatus' {Maybe Text
Text
TaskStatus
taskStatus :: TaskStatus
taskId :: Text
errorStackTrace :: Maybe Text
errorMessage :: Maybe Text
errorId :: Maybe Text
$sel:taskStatus:SetTaskStatus' :: SetTaskStatus -> TaskStatus
$sel:taskId:SetTaskStatus' :: SetTaskStatus -> Text
$sel:errorStackTrace:SetTaskStatus' :: SetTaskStatus -> Maybe Text
$sel:errorMessage:SetTaskStatus' :: SetTaskStatus -> Maybe Text
$sel:errorId:SetTaskStatus' :: SetTaskStatus -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
errorId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
errorMessage
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
errorStackTrace
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
taskId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` TaskStatus
taskStatus

instance Prelude.NFData SetTaskStatus where
  rnf :: SetTaskStatus -> ()
rnf SetTaskStatus' {Maybe Text
Text
TaskStatus
taskStatus :: TaskStatus
taskId :: Text
errorStackTrace :: Maybe Text
errorMessage :: Maybe Text
errorId :: Maybe Text
$sel:taskStatus:SetTaskStatus' :: SetTaskStatus -> TaskStatus
$sel:taskId:SetTaskStatus' :: SetTaskStatus -> Text
$sel:errorStackTrace:SetTaskStatus' :: SetTaskStatus -> Maybe Text
$sel:errorMessage:SetTaskStatus' :: SetTaskStatus -> Maybe Text
$sel:errorId:SetTaskStatus' :: SetTaskStatus -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
errorId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
errorMessage
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
errorStackTrace
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
taskId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf TaskStatus
taskStatus

instance Data.ToHeaders SetTaskStatus where
  toHeaders :: SetTaskStatus -> 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
"DataPipeline.SetTaskStatus" :: 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 SetTaskStatus where
  toJSON :: SetTaskStatus -> Value
toJSON SetTaskStatus' {Maybe Text
Text
TaskStatus
taskStatus :: TaskStatus
taskId :: Text
errorStackTrace :: Maybe Text
errorMessage :: Maybe Text
errorId :: Maybe Text
$sel:taskStatus:SetTaskStatus' :: SetTaskStatus -> TaskStatus
$sel:taskId:SetTaskStatus' :: SetTaskStatus -> Text
$sel:errorStackTrace:SetTaskStatus' :: SetTaskStatus -> Maybe Text
$sel:errorMessage:SetTaskStatus' :: SetTaskStatus -> Maybe Text
$sel:errorId:SetTaskStatus' :: SetTaskStatus -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"errorId" 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
errorId,
            (Key
"errorMessage" 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
errorMessage,
            (Key
"errorStackTrace" 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
errorStackTrace,
            forall a. a -> Maybe a
Prelude.Just (Key
"taskId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
taskId),
            forall a. a -> Maybe a
Prelude.Just (Key
"taskStatus" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= TaskStatus
taskStatus)
          ]
      )

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

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

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

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

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

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