{-# 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.MigrationHubOrchestrator.UpdateWorkflowStep
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Update a step in a migration workflow.
module Amazonka.MigrationHubOrchestrator.UpdateWorkflowStep
  ( -- * Creating a Request
    UpdateWorkflowStep (..),
    newUpdateWorkflowStep,

    -- * Request Lenses
    updateWorkflowStep_description,
    updateWorkflowStep_name,
    updateWorkflowStep_next,
    updateWorkflowStep_outputs,
    updateWorkflowStep_previous,
    updateWorkflowStep_status,
    updateWorkflowStep_stepActionType,
    updateWorkflowStep_stepTarget,
    updateWorkflowStep_workflowStepAutomationConfiguration,
    updateWorkflowStep_id,
    updateWorkflowStep_stepGroupId,
    updateWorkflowStep_workflowId,

    -- * Destructuring the Response
    UpdateWorkflowStepResponse (..),
    newUpdateWorkflowStepResponse,

    -- * Response Lenses
    updateWorkflowStepResponse_id,
    updateWorkflowStepResponse_name,
    updateWorkflowStepResponse_stepGroupId,
    updateWorkflowStepResponse_workflowId,
    updateWorkflowStepResponse_httpStatus,
  )
where

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

-- | /See:/ 'newUpdateWorkflowStep' smart constructor.
data UpdateWorkflowStep = UpdateWorkflowStep'
  { -- | The description of the step.
    UpdateWorkflowStep -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The name of the step.
    UpdateWorkflowStep -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The next step.
    UpdateWorkflowStep -> Maybe [Text]
next :: Prelude.Maybe [Prelude.Text],
    -- | The outputs of a step.
    UpdateWorkflowStep -> Maybe [WorkflowStepOutput]
outputs :: Prelude.Maybe [WorkflowStepOutput],
    -- | The previous step.
    UpdateWorkflowStep -> Maybe [Text]
previous :: Prelude.Maybe [Prelude.Text],
    -- | The status of the step.
    UpdateWorkflowStep -> Maybe StepStatus
status :: Prelude.Maybe StepStatus,
    -- | The action type of the step. You must run and update the status of a
    -- manual step for the workflow to continue after the completion of the
    -- step.
    UpdateWorkflowStep -> Maybe StepActionType
stepActionType :: Prelude.Maybe StepActionType,
    -- | The servers on which a step will be run.
    UpdateWorkflowStep -> Maybe [Text]
stepTarget :: Prelude.Maybe [Prelude.Text],
    -- | The custom script to run tests on the source and target environments.
    UpdateWorkflowStep -> Maybe WorkflowStepAutomationConfiguration
workflowStepAutomationConfiguration :: Prelude.Maybe WorkflowStepAutomationConfiguration,
    -- | The ID of the step.
    UpdateWorkflowStep -> Text
id :: Prelude.Text,
    -- | The ID of the step group.
    UpdateWorkflowStep -> Text
stepGroupId :: Prelude.Text,
    -- | The ID of the migration workflow.
    UpdateWorkflowStep -> Text
workflowId :: Prelude.Text
  }
  deriving (UpdateWorkflowStep -> UpdateWorkflowStep -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateWorkflowStep -> UpdateWorkflowStep -> Bool
$c/= :: UpdateWorkflowStep -> UpdateWorkflowStep -> Bool
== :: UpdateWorkflowStep -> UpdateWorkflowStep -> Bool
$c== :: UpdateWorkflowStep -> UpdateWorkflowStep -> Bool
Prelude.Eq, ReadPrec [UpdateWorkflowStep]
ReadPrec UpdateWorkflowStep
Int -> ReadS UpdateWorkflowStep
ReadS [UpdateWorkflowStep]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateWorkflowStep]
$creadListPrec :: ReadPrec [UpdateWorkflowStep]
readPrec :: ReadPrec UpdateWorkflowStep
$creadPrec :: ReadPrec UpdateWorkflowStep
readList :: ReadS [UpdateWorkflowStep]
$creadList :: ReadS [UpdateWorkflowStep]
readsPrec :: Int -> ReadS UpdateWorkflowStep
$creadsPrec :: Int -> ReadS UpdateWorkflowStep
Prelude.Read, Int -> UpdateWorkflowStep -> ShowS
[UpdateWorkflowStep] -> ShowS
UpdateWorkflowStep -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateWorkflowStep] -> ShowS
$cshowList :: [UpdateWorkflowStep] -> ShowS
show :: UpdateWorkflowStep -> String
$cshow :: UpdateWorkflowStep -> String
showsPrec :: Int -> UpdateWorkflowStep -> ShowS
$cshowsPrec :: Int -> UpdateWorkflowStep -> ShowS
Prelude.Show, forall x. Rep UpdateWorkflowStep x -> UpdateWorkflowStep
forall x. UpdateWorkflowStep -> Rep UpdateWorkflowStep x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateWorkflowStep x -> UpdateWorkflowStep
$cfrom :: forall x. UpdateWorkflowStep -> Rep UpdateWorkflowStep x
Prelude.Generic)

-- |
-- Create a value of 'UpdateWorkflowStep' 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:
--
-- 'description', 'updateWorkflowStep_description' - The description of the step.
--
-- 'name', 'updateWorkflowStep_name' - The name of the step.
--
-- 'next', 'updateWorkflowStep_next' - The next step.
--
-- 'outputs', 'updateWorkflowStep_outputs' - The outputs of a step.
--
-- 'previous', 'updateWorkflowStep_previous' - The previous step.
--
-- 'status', 'updateWorkflowStep_status' - The status of the step.
--
-- 'stepActionType', 'updateWorkflowStep_stepActionType' - The action type of the step. You must run and update the status of a
-- manual step for the workflow to continue after the completion of the
-- step.
--
-- 'stepTarget', 'updateWorkflowStep_stepTarget' - The servers on which a step will be run.
--
-- 'workflowStepAutomationConfiguration', 'updateWorkflowStep_workflowStepAutomationConfiguration' - The custom script to run tests on the source and target environments.
--
-- 'id', 'updateWorkflowStep_id' - The ID of the step.
--
-- 'stepGroupId', 'updateWorkflowStep_stepGroupId' - The ID of the step group.
--
-- 'workflowId', 'updateWorkflowStep_workflowId' - The ID of the migration workflow.
newUpdateWorkflowStep ::
  -- | 'id'
  Prelude.Text ->
  -- | 'stepGroupId'
  Prelude.Text ->
  -- | 'workflowId'
  Prelude.Text ->
  UpdateWorkflowStep
newUpdateWorkflowStep :: Text -> Text -> Text -> UpdateWorkflowStep
newUpdateWorkflowStep Text
pId_ Text
pStepGroupId_ Text
pWorkflowId_ =
  UpdateWorkflowStep'
    { $sel:description:UpdateWorkflowStep' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:name:UpdateWorkflowStep' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:next:UpdateWorkflowStep' :: Maybe [Text]
next = forall a. Maybe a
Prelude.Nothing,
      $sel:outputs:UpdateWorkflowStep' :: Maybe [WorkflowStepOutput]
outputs = forall a. Maybe a
Prelude.Nothing,
      $sel:previous:UpdateWorkflowStep' :: Maybe [Text]
previous = forall a. Maybe a
Prelude.Nothing,
      $sel:status:UpdateWorkflowStep' :: Maybe StepStatus
status = forall a. Maybe a
Prelude.Nothing,
      $sel:stepActionType:UpdateWorkflowStep' :: Maybe StepActionType
stepActionType = forall a. Maybe a
Prelude.Nothing,
      $sel:stepTarget:UpdateWorkflowStep' :: Maybe [Text]
stepTarget = forall a. Maybe a
Prelude.Nothing,
      $sel:workflowStepAutomationConfiguration:UpdateWorkflowStep' :: Maybe WorkflowStepAutomationConfiguration
workflowStepAutomationConfiguration =
        forall a. Maybe a
Prelude.Nothing,
      $sel:id:UpdateWorkflowStep' :: Text
id = Text
pId_,
      $sel:stepGroupId:UpdateWorkflowStep' :: Text
stepGroupId = Text
pStepGroupId_,
      $sel:workflowId:UpdateWorkflowStep' :: Text
workflowId = Text
pWorkflowId_
    }

-- | The description of the step.
updateWorkflowStep_description :: Lens.Lens' UpdateWorkflowStep (Prelude.Maybe Prelude.Text)
updateWorkflowStep_description :: Lens' UpdateWorkflowStep (Maybe Text)
updateWorkflowStep_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Maybe Text
description :: Maybe Text
$sel:description:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe Text
description} -> Maybe Text
description) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Maybe Text
a -> UpdateWorkflowStep
s {$sel:description:UpdateWorkflowStep' :: Maybe Text
description = Maybe Text
a} :: UpdateWorkflowStep)

-- | The name of the step.
updateWorkflowStep_name :: Lens.Lens' UpdateWorkflowStep (Prelude.Maybe Prelude.Text)
updateWorkflowStep_name :: Lens' UpdateWorkflowStep (Maybe Text)
updateWorkflowStep_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Maybe Text
name :: Maybe Text
$sel:name:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe Text
name} -> Maybe Text
name) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Maybe Text
a -> UpdateWorkflowStep
s {$sel:name:UpdateWorkflowStep' :: Maybe Text
name = Maybe Text
a} :: UpdateWorkflowStep)

-- | The next step.
updateWorkflowStep_next :: Lens.Lens' UpdateWorkflowStep (Prelude.Maybe [Prelude.Text])
updateWorkflowStep_next :: Lens' UpdateWorkflowStep (Maybe [Text])
updateWorkflowStep_next = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Maybe [Text]
next :: Maybe [Text]
$sel:next:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
next} -> Maybe [Text]
next) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Maybe [Text]
a -> UpdateWorkflowStep
s {$sel:next:UpdateWorkflowStep' :: Maybe [Text]
next = Maybe [Text]
a} :: UpdateWorkflowStep) 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 outputs of a step.
updateWorkflowStep_outputs :: Lens.Lens' UpdateWorkflowStep (Prelude.Maybe [WorkflowStepOutput])
updateWorkflowStep_outputs :: Lens' UpdateWorkflowStep (Maybe [WorkflowStepOutput])
updateWorkflowStep_outputs = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Maybe [WorkflowStepOutput]
outputs :: Maybe [WorkflowStepOutput]
$sel:outputs:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [WorkflowStepOutput]
outputs} -> Maybe [WorkflowStepOutput]
outputs) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Maybe [WorkflowStepOutput]
a -> UpdateWorkflowStep
s {$sel:outputs:UpdateWorkflowStep' :: Maybe [WorkflowStepOutput]
outputs = Maybe [WorkflowStepOutput]
a} :: UpdateWorkflowStep) 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 previous step.
updateWorkflowStep_previous :: Lens.Lens' UpdateWorkflowStep (Prelude.Maybe [Prelude.Text])
updateWorkflowStep_previous :: Lens' UpdateWorkflowStep (Maybe [Text])
updateWorkflowStep_previous = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Maybe [Text]
previous :: Maybe [Text]
$sel:previous:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
previous} -> Maybe [Text]
previous) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Maybe [Text]
a -> UpdateWorkflowStep
s {$sel:previous:UpdateWorkflowStep' :: Maybe [Text]
previous = Maybe [Text]
a} :: UpdateWorkflowStep) 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 status of the step.
updateWorkflowStep_status :: Lens.Lens' UpdateWorkflowStep (Prelude.Maybe StepStatus)
updateWorkflowStep_status :: Lens' UpdateWorkflowStep (Maybe StepStatus)
updateWorkflowStep_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Maybe StepStatus
status :: Maybe StepStatus
$sel:status:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe StepStatus
status} -> Maybe StepStatus
status) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Maybe StepStatus
a -> UpdateWorkflowStep
s {$sel:status:UpdateWorkflowStep' :: Maybe StepStatus
status = Maybe StepStatus
a} :: UpdateWorkflowStep)

-- | The action type of the step. You must run and update the status of a
-- manual step for the workflow to continue after the completion of the
-- step.
updateWorkflowStep_stepActionType :: Lens.Lens' UpdateWorkflowStep (Prelude.Maybe StepActionType)
updateWorkflowStep_stepActionType :: Lens' UpdateWorkflowStep (Maybe StepActionType)
updateWorkflowStep_stepActionType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Maybe StepActionType
stepActionType :: Maybe StepActionType
$sel:stepActionType:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe StepActionType
stepActionType} -> Maybe StepActionType
stepActionType) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Maybe StepActionType
a -> UpdateWorkflowStep
s {$sel:stepActionType:UpdateWorkflowStep' :: Maybe StepActionType
stepActionType = Maybe StepActionType
a} :: UpdateWorkflowStep)

-- | The servers on which a step will be run.
updateWorkflowStep_stepTarget :: Lens.Lens' UpdateWorkflowStep (Prelude.Maybe [Prelude.Text])
updateWorkflowStep_stepTarget :: Lens' UpdateWorkflowStep (Maybe [Text])
updateWorkflowStep_stepTarget = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Maybe [Text]
stepTarget :: Maybe [Text]
$sel:stepTarget:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
stepTarget} -> Maybe [Text]
stepTarget) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Maybe [Text]
a -> UpdateWorkflowStep
s {$sel:stepTarget:UpdateWorkflowStep' :: Maybe [Text]
stepTarget = Maybe [Text]
a} :: UpdateWorkflowStep) 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 custom script to run tests on the source and target environments.
updateWorkflowStep_workflowStepAutomationConfiguration :: Lens.Lens' UpdateWorkflowStep (Prelude.Maybe WorkflowStepAutomationConfiguration)
updateWorkflowStep_workflowStepAutomationConfiguration :: Lens'
  UpdateWorkflowStep (Maybe WorkflowStepAutomationConfiguration)
updateWorkflowStep_workflowStepAutomationConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Maybe WorkflowStepAutomationConfiguration
workflowStepAutomationConfiguration :: Maybe WorkflowStepAutomationConfiguration
$sel:workflowStepAutomationConfiguration:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe WorkflowStepAutomationConfiguration
workflowStepAutomationConfiguration} -> Maybe WorkflowStepAutomationConfiguration
workflowStepAutomationConfiguration) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Maybe WorkflowStepAutomationConfiguration
a -> UpdateWorkflowStep
s {$sel:workflowStepAutomationConfiguration:UpdateWorkflowStep' :: Maybe WorkflowStepAutomationConfiguration
workflowStepAutomationConfiguration = Maybe WorkflowStepAutomationConfiguration
a} :: UpdateWorkflowStep)

-- | The ID of the step.
updateWorkflowStep_id :: Lens.Lens' UpdateWorkflowStep Prelude.Text
updateWorkflowStep_id :: Lens' UpdateWorkflowStep Text
updateWorkflowStep_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Text
id :: Text
$sel:id:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
id} -> Text
id) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Text
a -> UpdateWorkflowStep
s {$sel:id:UpdateWorkflowStep' :: Text
id = Text
a} :: UpdateWorkflowStep)

-- | The ID of the step group.
updateWorkflowStep_stepGroupId :: Lens.Lens' UpdateWorkflowStep Prelude.Text
updateWorkflowStep_stepGroupId :: Lens' UpdateWorkflowStep Text
updateWorkflowStep_stepGroupId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Text
stepGroupId :: Text
$sel:stepGroupId:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
stepGroupId} -> Text
stepGroupId) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Text
a -> UpdateWorkflowStep
s {$sel:stepGroupId:UpdateWorkflowStep' :: Text
stepGroupId = Text
a} :: UpdateWorkflowStep)

-- | The ID of the migration workflow.
updateWorkflowStep_workflowId :: Lens.Lens' UpdateWorkflowStep Prelude.Text
updateWorkflowStep_workflowId :: Lens' UpdateWorkflowStep Text
updateWorkflowStep_workflowId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStep' {Text
workflowId :: Text
$sel:workflowId:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
workflowId} -> Text
workflowId) (\s :: UpdateWorkflowStep
s@UpdateWorkflowStep' {} Text
a -> UpdateWorkflowStep
s {$sel:workflowId:UpdateWorkflowStep' :: Text
workflowId = Text
a} :: UpdateWorkflowStep)

instance Core.AWSRequest UpdateWorkflowStep where
  type
    AWSResponse UpdateWorkflowStep =
      UpdateWorkflowStepResponse
  request :: (Service -> Service)
-> UpdateWorkflowStep -> Request UpdateWorkflowStep
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 UpdateWorkflowStep
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse UpdateWorkflowStep)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Int
-> UpdateWorkflowStepResponse
UpdateWorkflowStepResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"id")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"name")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"stepGroupId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"workflowId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable UpdateWorkflowStep where
  hashWithSalt :: Int -> UpdateWorkflowStep -> Int
hashWithSalt Int
_salt UpdateWorkflowStep' {Maybe [Text]
Maybe [WorkflowStepOutput]
Maybe Text
Maybe StepActionType
Maybe StepStatus
Maybe WorkflowStepAutomationConfiguration
Text
workflowId :: Text
stepGroupId :: Text
id :: Text
workflowStepAutomationConfiguration :: Maybe WorkflowStepAutomationConfiguration
stepTarget :: Maybe [Text]
stepActionType :: Maybe StepActionType
status :: Maybe StepStatus
previous :: Maybe [Text]
outputs :: Maybe [WorkflowStepOutput]
next :: Maybe [Text]
name :: Maybe Text
description :: Maybe Text
$sel:workflowId:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:stepGroupId:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:id:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:workflowStepAutomationConfiguration:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe WorkflowStepAutomationConfiguration
$sel:stepTarget:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:stepActionType:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe StepActionType
$sel:status:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe StepStatus
$sel:previous:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:outputs:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [WorkflowStepOutput]
$sel:next:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:name:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe Text
$sel:description:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
next
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [WorkflowStepOutput]
outputs
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
previous
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe StepStatus
status
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe StepActionType
stepActionType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
stepTarget
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe WorkflowStepAutomationConfiguration
workflowStepAutomationConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
id
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
stepGroupId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
workflowId

instance Prelude.NFData UpdateWorkflowStep where
  rnf :: UpdateWorkflowStep -> ()
rnf UpdateWorkflowStep' {Maybe [Text]
Maybe [WorkflowStepOutput]
Maybe Text
Maybe StepActionType
Maybe StepStatus
Maybe WorkflowStepAutomationConfiguration
Text
workflowId :: Text
stepGroupId :: Text
id :: Text
workflowStepAutomationConfiguration :: Maybe WorkflowStepAutomationConfiguration
stepTarget :: Maybe [Text]
stepActionType :: Maybe StepActionType
status :: Maybe StepStatus
previous :: Maybe [Text]
outputs :: Maybe [WorkflowStepOutput]
next :: Maybe [Text]
name :: Maybe Text
description :: Maybe Text
$sel:workflowId:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:stepGroupId:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:id:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:workflowStepAutomationConfiguration:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe WorkflowStepAutomationConfiguration
$sel:stepTarget:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:stepActionType:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe StepActionType
$sel:status:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe StepStatus
$sel:previous:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:outputs:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [WorkflowStepOutput]
$sel:next:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:name:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe Text
$sel:description:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
next
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [WorkflowStepOutput]
outputs
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
previous
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StepStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StepActionType
stepActionType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
stepTarget
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe WorkflowStepAutomationConfiguration
workflowStepAutomationConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
stepGroupId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
workflowId

instance Data.ToHeaders UpdateWorkflowStep where
  toHeaders :: UpdateWorkflowStep -> 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 UpdateWorkflowStep where
  toJSON :: UpdateWorkflowStep -> Value
toJSON UpdateWorkflowStep' {Maybe [Text]
Maybe [WorkflowStepOutput]
Maybe Text
Maybe StepActionType
Maybe StepStatus
Maybe WorkflowStepAutomationConfiguration
Text
workflowId :: Text
stepGroupId :: Text
id :: Text
workflowStepAutomationConfiguration :: Maybe WorkflowStepAutomationConfiguration
stepTarget :: Maybe [Text]
stepActionType :: Maybe StepActionType
status :: Maybe StepStatus
previous :: Maybe [Text]
outputs :: Maybe [WorkflowStepOutput]
next :: Maybe [Text]
name :: Maybe Text
description :: Maybe Text
$sel:workflowId:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:stepGroupId:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:id:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:workflowStepAutomationConfiguration:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe WorkflowStepAutomationConfiguration
$sel:stepTarget:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:stepActionType:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe StepActionType
$sel:status:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe StepStatus
$sel:previous:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:outputs:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [WorkflowStepOutput]
$sel:next:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:name:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe Text
$sel:description:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"description" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
description,
            (Key
"name" 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
name,
            (Key
"next" 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]
next,
            (Key
"outputs" 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 [WorkflowStepOutput]
outputs,
            (Key
"previous" 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]
previous,
            (Key
"status" 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 StepStatus
status,
            (Key
"stepActionType" 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 StepActionType
stepActionType,
            (Key
"stepTarget" 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]
stepTarget,
            (Key
"workflowStepAutomationConfiguration" 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 WorkflowStepAutomationConfiguration
workflowStepAutomationConfiguration,
            forall a. a -> Maybe a
Prelude.Just (Key
"stepGroupId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
stepGroupId),
            forall a. a -> Maybe a
Prelude.Just (Key
"workflowId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
workflowId)
          ]
      )

instance Data.ToPath UpdateWorkflowStep where
  toPath :: UpdateWorkflowStep -> ByteString
toPath UpdateWorkflowStep' {Maybe [Text]
Maybe [WorkflowStepOutput]
Maybe Text
Maybe StepActionType
Maybe StepStatus
Maybe WorkflowStepAutomationConfiguration
Text
workflowId :: Text
stepGroupId :: Text
id :: Text
workflowStepAutomationConfiguration :: Maybe WorkflowStepAutomationConfiguration
stepTarget :: Maybe [Text]
stepActionType :: Maybe StepActionType
status :: Maybe StepStatus
previous :: Maybe [Text]
outputs :: Maybe [WorkflowStepOutput]
next :: Maybe [Text]
name :: Maybe Text
description :: Maybe Text
$sel:workflowId:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:stepGroupId:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:id:UpdateWorkflowStep' :: UpdateWorkflowStep -> Text
$sel:workflowStepAutomationConfiguration:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe WorkflowStepAutomationConfiguration
$sel:stepTarget:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:stepActionType:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe StepActionType
$sel:status:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe StepStatus
$sel:previous:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:outputs:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [WorkflowStepOutput]
$sel:next:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe [Text]
$sel:name:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe Text
$sel:description:UpdateWorkflowStep' :: UpdateWorkflowStep -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat [ByteString
"/workflowstep/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
id]

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

-- | /See:/ 'newUpdateWorkflowStepResponse' smart constructor.
data UpdateWorkflowStepResponse = UpdateWorkflowStepResponse'
  { -- | The ID of the step.
    UpdateWorkflowStepResponse -> Maybe Text
id :: Prelude.Maybe Prelude.Text,
    -- | The name of the step.
    UpdateWorkflowStepResponse -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The ID of the step group.
    UpdateWorkflowStepResponse -> Maybe Text
stepGroupId :: Prelude.Maybe Prelude.Text,
    -- | The ID of the migration workflow.
    UpdateWorkflowStepResponse -> Maybe Text
workflowId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    UpdateWorkflowStepResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (UpdateWorkflowStepResponse -> UpdateWorkflowStepResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateWorkflowStepResponse -> UpdateWorkflowStepResponse -> Bool
$c/= :: UpdateWorkflowStepResponse -> UpdateWorkflowStepResponse -> Bool
== :: UpdateWorkflowStepResponse -> UpdateWorkflowStepResponse -> Bool
$c== :: UpdateWorkflowStepResponse -> UpdateWorkflowStepResponse -> Bool
Prelude.Eq, ReadPrec [UpdateWorkflowStepResponse]
ReadPrec UpdateWorkflowStepResponse
Int -> ReadS UpdateWorkflowStepResponse
ReadS [UpdateWorkflowStepResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateWorkflowStepResponse]
$creadListPrec :: ReadPrec [UpdateWorkflowStepResponse]
readPrec :: ReadPrec UpdateWorkflowStepResponse
$creadPrec :: ReadPrec UpdateWorkflowStepResponse
readList :: ReadS [UpdateWorkflowStepResponse]
$creadList :: ReadS [UpdateWorkflowStepResponse]
readsPrec :: Int -> ReadS UpdateWorkflowStepResponse
$creadsPrec :: Int -> ReadS UpdateWorkflowStepResponse
Prelude.Read, Int -> UpdateWorkflowStepResponse -> ShowS
[UpdateWorkflowStepResponse] -> ShowS
UpdateWorkflowStepResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateWorkflowStepResponse] -> ShowS
$cshowList :: [UpdateWorkflowStepResponse] -> ShowS
show :: UpdateWorkflowStepResponse -> String
$cshow :: UpdateWorkflowStepResponse -> String
showsPrec :: Int -> UpdateWorkflowStepResponse -> ShowS
$cshowsPrec :: Int -> UpdateWorkflowStepResponse -> ShowS
Prelude.Show, forall x.
Rep UpdateWorkflowStepResponse x -> UpdateWorkflowStepResponse
forall x.
UpdateWorkflowStepResponse -> Rep UpdateWorkflowStepResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep UpdateWorkflowStepResponse x -> UpdateWorkflowStepResponse
$cfrom :: forall x.
UpdateWorkflowStepResponse -> Rep UpdateWorkflowStepResponse x
Prelude.Generic)

-- |
-- Create a value of 'UpdateWorkflowStepResponse' 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:
--
-- 'id', 'updateWorkflowStepResponse_id' - The ID of the step.
--
-- 'name', 'updateWorkflowStepResponse_name' - The name of the step.
--
-- 'stepGroupId', 'updateWorkflowStepResponse_stepGroupId' - The ID of the step group.
--
-- 'workflowId', 'updateWorkflowStepResponse_workflowId' - The ID of the migration workflow.
--
-- 'httpStatus', 'updateWorkflowStepResponse_httpStatus' - The response's http status code.
newUpdateWorkflowStepResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateWorkflowStepResponse
newUpdateWorkflowStepResponse :: Int -> UpdateWorkflowStepResponse
newUpdateWorkflowStepResponse Int
pHttpStatus_ =
  UpdateWorkflowStepResponse'
    { $sel:id:UpdateWorkflowStepResponse' :: Maybe Text
id = forall a. Maybe a
Prelude.Nothing,
      $sel:name:UpdateWorkflowStepResponse' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:stepGroupId:UpdateWorkflowStepResponse' :: Maybe Text
stepGroupId = forall a. Maybe a
Prelude.Nothing,
      $sel:workflowId:UpdateWorkflowStepResponse' :: Maybe Text
workflowId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateWorkflowStepResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ID of the step.
updateWorkflowStepResponse_id :: Lens.Lens' UpdateWorkflowStepResponse (Prelude.Maybe Prelude.Text)
updateWorkflowStepResponse_id :: Lens' UpdateWorkflowStepResponse (Maybe Text)
updateWorkflowStepResponse_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStepResponse' {Maybe Text
id :: Maybe Text
$sel:id:UpdateWorkflowStepResponse' :: UpdateWorkflowStepResponse -> Maybe Text
id} -> Maybe Text
id) (\s :: UpdateWorkflowStepResponse
s@UpdateWorkflowStepResponse' {} Maybe Text
a -> UpdateWorkflowStepResponse
s {$sel:id:UpdateWorkflowStepResponse' :: Maybe Text
id = Maybe Text
a} :: UpdateWorkflowStepResponse)

-- | The name of the step.
updateWorkflowStepResponse_name :: Lens.Lens' UpdateWorkflowStepResponse (Prelude.Maybe Prelude.Text)
updateWorkflowStepResponse_name :: Lens' UpdateWorkflowStepResponse (Maybe Text)
updateWorkflowStepResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStepResponse' {Maybe Text
name :: Maybe Text
$sel:name:UpdateWorkflowStepResponse' :: UpdateWorkflowStepResponse -> Maybe Text
name} -> Maybe Text
name) (\s :: UpdateWorkflowStepResponse
s@UpdateWorkflowStepResponse' {} Maybe Text
a -> UpdateWorkflowStepResponse
s {$sel:name:UpdateWorkflowStepResponse' :: Maybe Text
name = Maybe Text
a} :: UpdateWorkflowStepResponse)

-- | The ID of the step group.
updateWorkflowStepResponse_stepGroupId :: Lens.Lens' UpdateWorkflowStepResponse (Prelude.Maybe Prelude.Text)
updateWorkflowStepResponse_stepGroupId :: Lens' UpdateWorkflowStepResponse (Maybe Text)
updateWorkflowStepResponse_stepGroupId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStepResponse' {Maybe Text
stepGroupId :: Maybe Text
$sel:stepGroupId:UpdateWorkflowStepResponse' :: UpdateWorkflowStepResponse -> Maybe Text
stepGroupId} -> Maybe Text
stepGroupId) (\s :: UpdateWorkflowStepResponse
s@UpdateWorkflowStepResponse' {} Maybe Text
a -> UpdateWorkflowStepResponse
s {$sel:stepGroupId:UpdateWorkflowStepResponse' :: Maybe Text
stepGroupId = Maybe Text
a} :: UpdateWorkflowStepResponse)

-- | The ID of the migration workflow.
updateWorkflowStepResponse_workflowId :: Lens.Lens' UpdateWorkflowStepResponse (Prelude.Maybe Prelude.Text)
updateWorkflowStepResponse_workflowId :: Lens' UpdateWorkflowStepResponse (Maybe Text)
updateWorkflowStepResponse_workflowId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateWorkflowStepResponse' {Maybe Text
workflowId :: Maybe Text
$sel:workflowId:UpdateWorkflowStepResponse' :: UpdateWorkflowStepResponse -> Maybe Text
workflowId} -> Maybe Text
workflowId) (\s :: UpdateWorkflowStepResponse
s@UpdateWorkflowStepResponse' {} Maybe Text
a -> UpdateWorkflowStepResponse
s {$sel:workflowId:UpdateWorkflowStepResponse' :: Maybe Text
workflowId = Maybe Text
a} :: UpdateWorkflowStepResponse)

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

instance Prelude.NFData UpdateWorkflowStepResponse where
  rnf :: UpdateWorkflowStepResponse -> ()
rnf UpdateWorkflowStepResponse' {Int
Maybe Text
httpStatus :: Int
workflowId :: Maybe Text
stepGroupId :: Maybe Text
name :: Maybe Text
id :: Maybe Text
$sel:httpStatus:UpdateWorkflowStepResponse' :: UpdateWorkflowStepResponse -> Int
$sel:workflowId:UpdateWorkflowStepResponse' :: UpdateWorkflowStepResponse -> Maybe Text
$sel:stepGroupId:UpdateWorkflowStepResponse' :: UpdateWorkflowStepResponse -> Maybe Text
$sel:name:UpdateWorkflowStepResponse' :: UpdateWorkflowStepResponse -> Maybe Text
$sel:id:UpdateWorkflowStepResponse' :: UpdateWorkflowStepResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
stepGroupId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
workflowId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus