{-# 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.StepFunctions.DescribeStateMachine
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Provides information about a state machine\'s definition, its IAM role
-- Amazon Resource Name (ARN), and configuration. If the state machine ARN
-- is a qualified state machine ARN, the response returned includes the
-- @Map@ state\'s label.
--
-- A qualified state machine ARN refers to a /Distributed Map state/
-- defined within a state machine. For example, the qualified state machine
-- ARN
-- @arn:partition:states:region:account-id:stateMachine:stateMachineName\/mapStateLabel@
-- refers to a /Distributed Map state/ with a label @mapStateLabel@ in the
-- state machine named @stateMachineName@.
--
-- This operation is eventually consistent. The results are best effort and
-- may not reflect very recent updates and changes.
module Amazonka.StepFunctions.DescribeStateMachine
  ( -- * Creating a Request
    DescribeStateMachine (..),
    newDescribeStateMachine,

    -- * Request Lenses
    describeStateMachine_stateMachineArn,

    -- * Destructuring the Response
    DescribeStateMachineResponse (..),
    newDescribeStateMachineResponse,

    -- * Response Lenses
    describeStateMachineResponse_label,
    describeStateMachineResponse_loggingConfiguration,
    describeStateMachineResponse_status,
    describeStateMachineResponse_tracingConfiguration,
    describeStateMachineResponse_httpStatus,
    describeStateMachineResponse_stateMachineArn,
    describeStateMachineResponse_name,
    describeStateMachineResponse_definition,
    describeStateMachineResponse_roleArn,
    describeStateMachineResponse_type,
    describeStateMachineResponse_creationDate,
  )
where

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

-- | /See:/ 'newDescribeStateMachine' smart constructor.
data DescribeStateMachine = DescribeStateMachine'
  { -- | The Amazon Resource Name (ARN) of the state machine to describe.
    DescribeStateMachine -> Text
stateMachineArn :: Prelude.Text
  }
  deriving (DescribeStateMachine -> DescribeStateMachine -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeStateMachine -> DescribeStateMachine -> Bool
$c/= :: DescribeStateMachine -> DescribeStateMachine -> Bool
== :: DescribeStateMachine -> DescribeStateMachine -> Bool
$c== :: DescribeStateMachine -> DescribeStateMachine -> Bool
Prelude.Eq, ReadPrec [DescribeStateMachine]
ReadPrec DescribeStateMachine
Int -> ReadS DescribeStateMachine
ReadS [DescribeStateMachine]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeStateMachine]
$creadListPrec :: ReadPrec [DescribeStateMachine]
readPrec :: ReadPrec DescribeStateMachine
$creadPrec :: ReadPrec DescribeStateMachine
readList :: ReadS [DescribeStateMachine]
$creadList :: ReadS [DescribeStateMachine]
readsPrec :: Int -> ReadS DescribeStateMachine
$creadsPrec :: Int -> ReadS DescribeStateMachine
Prelude.Read, Int -> DescribeStateMachine -> ShowS
[DescribeStateMachine] -> ShowS
DescribeStateMachine -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeStateMachine] -> ShowS
$cshowList :: [DescribeStateMachine] -> ShowS
show :: DescribeStateMachine -> String
$cshow :: DescribeStateMachine -> String
showsPrec :: Int -> DescribeStateMachine -> ShowS
$cshowsPrec :: Int -> DescribeStateMachine -> ShowS
Prelude.Show, forall x. Rep DescribeStateMachine x -> DescribeStateMachine
forall x. DescribeStateMachine -> Rep DescribeStateMachine x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeStateMachine x -> DescribeStateMachine
$cfrom :: forall x. DescribeStateMachine -> Rep DescribeStateMachine x
Prelude.Generic)

-- |
-- Create a value of 'DescribeStateMachine' 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:
--
-- 'stateMachineArn', 'describeStateMachine_stateMachineArn' - The Amazon Resource Name (ARN) of the state machine to describe.
newDescribeStateMachine ::
  -- | 'stateMachineArn'
  Prelude.Text ->
  DescribeStateMachine
newDescribeStateMachine :: Text -> DescribeStateMachine
newDescribeStateMachine Text
pStateMachineArn_ =
  DescribeStateMachine'
    { $sel:stateMachineArn:DescribeStateMachine' :: Text
stateMachineArn =
        Text
pStateMachineArn_
    }

-- | The Amazon Resource Name (ARN) of the state machine to describe.
describeStateMachine_stateMachineArn :: Lens.Lens' DescribeStateMachine Prelude.Text
describeStateMachine_stateMachineArn :: Lens' DescribeStateMachine Text
describeStateMachine_stateMachineArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachine' {Text
stateMachineArn :: Text
$sel:stateMachineArn:DescribeStateMachine' :: DescribeStateMachine -> Text
stateMachineArn} -> Text
stateMachineArn) (\s :: DescribeStateMachine
s@DescribeStateMachine' {} Text
a -> DescribeStateMachine
s {$sel:stateMachineArn:DescribeStateMachine' :: Text
stateMachineArn = Text
a} :: DescribeStateMachine)

instance Core.AWSRequest DescribeStateMachine where
  type
    AWSResponse DescribeStateMachine =
      DescribeStateMachineResponse
  request :: (Service -> Service)
-> DescribeStateMachine -> Request DescribeStateMachine
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 DescribeStateMachine
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DescribeStateMachine)))
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 LoggingConfiguration
-> Maybe StateMachineStatus
-> Maybe TracingConfiguration
-> Int
-> Text
-> Text
-> Sensitive Text
-> Text
-> StateMachineType
-> POSIX
-> DescribeStateMachineResponse
DescribeStateMachineResponse'
            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
"label")
            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
"loggingConfiguration")
            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
"status")
            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
"tracingConfiguration")
            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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"stateMachineArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String 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 a
Data..:> Key
"definition")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"roleArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"type")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"creationDate")
      )

instance Prelude.Hashable DescribeStateMachine where
  hashWithSalt :: Int -> DescribeStateMachine -> Int
hashWithSalt Int
_salt DescribeStateMachine' {Text
stateMachineArn :: Text
$sel:stateMachineArn:DescribeStateMachine' :: DescribeStateMachine -> Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
stateMachineArn

instance Prelude.NFData DescribeStateMachine where
  rnf :: DescribeStateMachine -> ()
rnf DescribeStateMachine' {Text
stateMachineArn :: Text
$sel:stateMachineArn:DescribeStateMachine' :: DescribeStateMachine -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
stateMachineArn

instance Data.ToHeaders DescribeStateMachine where
  toHeaders :: DescribeStateMachine -> 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
"AWSStepFunctions.DescribeStateMachine" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON DescribeStateMachine where
  toJSON :: DescribeStateMachine -> Value
toJSON DescribeStateMachine' {Text
stateMachineArn :: Text
$sel:stateMachineArn:DescribeStateMachine' :: DescribeStateMachine -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just
              (Key
"stateMachineArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
stateMachineArn)
          ]
      )

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

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

-- | /See:/ 'newDescribeStateMachineResponse' smart constructor.
data DescribeStateMachineResponse = DescribeStateMachineResponse'
  { -- | A user-defined or an auto-generated string that identifies a @Map@
    -- state. This parameter is present only if the @stateMachineArn@ specified
    -- in input is a qualified state machine ARN.
    DescribeStateMachineResponse -> Maybe Text
label :: Prelude.Maybe Prelude.Text,
    DescribeStateMachineResponse -> Maybe LoggingConfiguration
loggingConfiguration :: Prelude.Maybe LoggingConfiguration,
    -- | The current status of the state machine.
    DescribeStateMachineResponse -> Maybe StateMachineStatus
status :: Prelude.Maybe StateMachineStatus,
    -- | Selects whether X-Ray tracing is enabled.
    DescribeStateMachineResponse -> Maybe TracingConfiguration
tracingConfiguration :: Prelude.Maybe TracingConfiguration,
    -- | The response's http status code.
    DescribeStateMachineResponse -> Int
httpStatus :: Prelude.Int,
    -- | The Amazon Resource Name (ARN) that identifies the state machine.
    DescribeStateMachineResponse -> Text
stateMachineArn :: Prelude.Text,
    -- | The name of the state machine.
    --
    -- A name must /not/ contain:
    --
    -- -   white space
    --
    -- -   brackets @\< > { } [ ]@
    --
    -- -   wildcard characters @? *@
    --
    -- -   special characters @\" # % \\ ^ | ~ \` $ & , ; : \/@
    --
    -- -   control characters (@U+0000-001F@, @U+007F-009F@)
    --
    -- To enable logging with CloudWatch Logs, the name should only contain
    -- 0-9, A-Z, a-z, - and _.
    DescribeStateMachineResponse -> Text
name :: Prelude.Text,
    -- | The Amazon States Language definition of the state machine. See
    -- <https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html Amazon States Language>.
    DescribeStateMachineResponse -> Sensitive Text
definition :: Data.Sensitive Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the IAM role used when creating this
    -- state machine. (The IAM role maintains security by granting Step
    -- Functions access to Amazon Web Services resources.)
    DescribeStateMachineResponse -> Text
roleArn :: Prelude.Text,
    -- | The @type@ of the state machine (@STANDARD@ or @EXPRESS@).
    DescribeStateMachineResponse -> StateMachineType
type' :: StateMachineType,
    -- | The date the state machine is created.
    DescribeStateMachineResponse -> POSIX
creationDate :: Data.POSIX
  }
  deriving (DescribeStateMachineResponse
-> DescribeStateMachineResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeStateMachineResponse
-> DescribeStateMachineResponse -> Bool
$c/= :: DescribeStateMachineResponse
-> DescribeStateMachineResponse -> Bool
== :: DescribeStateMachineResponse
-> DescribeStateMachineResponse -> Bool
$c== :: DescribeStateMachineResponse
-> DescribeStateMachineResponse -> Bool
Prelude.Eq, Int -> DescribeStateMachineResponse -> ShowS
[DescribeStateMachineResponse] -> ShowS
DescribeStateMachineResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeStateMachineResponse] -> ShowS
$cshowList :: [DescribeStateMachineResponse] -> ShowS
show :: DescribeStateMachineResponse -> String
$cshow :: DescribeStateMachineResponse -> String
showsPrec :: Int -> DescribeStateMachineResponse -> ShowS
$cshowsPrec :: Int -> DescribeStateMachineResponse -> ShowS
Prelude.Show, forall x.
Rep DescribeStateMachineResponse x -> DescribeStateMachineResponse
forall x.
DescribeStateMachineResponse -> Rep DescribeStateMachineResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeStateMachineResponse x -> DescribeStateMachineResponse
$cfrom :: forall x.
DescribeStateMachineResponse -> Rep DescribeStateMachineResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeStateMachineResponse' 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:
--
-- 'label', 'describeStateMachineResponse_label' - A user-defined or an auto-generated string that identifies a @Map@
-- state. This parameter is present only if the @stateMachineArn@ specified
-- in input is a qualified state machine ARN.
--
-- 'loggingConfiguration', 'describeStateMachineResponse_loggingConfiguration' - Undocumented member.
--
-- 'status', 'describeStateMachineResponse_status' - The current status of the state machine.
--
-- 'tracingConfiguration', 'describeStateMachineResponse_tracingConfiguration' - Selects whether X-Ray tracing is enabled.
--
-- 'httpStatus', 'describeStateMachineResponse_httpStatus' - The response's http status code.
--
-- 'stateMachineArn', 'describeStateMachineResponse_stateMachineArn' - The Amazon Resource Name (ARN) that identifies the state machine.
--
-- 'name', 'describeStateMachineResponse_name' - The name of the state machine.
--
-- A name must /not/ contain:
--
-- -   white space
--
-- -   brackets @\< > { } [ ]@
--
-- -   wildcard characters @? *@
--
-- -   special characters @\" # % \\ ^ | ~ \` $ & , ; : \/@
--
-- -   control characters (@U+0000-001F@, @U+007F-009F@)
--
-- To enable logging with CloudWatch Logs, the name should only contain
-- 0-9, A-Z, a-z, - and _.
--
-- 'definition', 'describeStateMachineResponse_definition' - The Amazon States Language definition of the state machine. See
-- <https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html Amazon States Language>.
--
-- 'roleArn', 'describeStateMachineResponse_roleArn' - The Amazon Resource Name (ARN) of the IAM role used when creating this
-- state machine. (The IAM role maintains security by granting Step
-- Functions access to Amazon Web Services resources.)
--
-- 'type'', 'describeStateMachineResponse_type' - The @type@ of the state machine (@STANDARD@ or @EXPRESS@).
--
-- 'creationDate', 'describeStateMachineResponse_creationDate' - The date the state machine is created.
newDescribeStateMachineResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'stateMachineArn'
  Prelude.Text ->
  -- | 'name'
  Prelude.Text ->
  -- | 'definition'
  Prelude.Text ->
  -- | 'roleArn'
  Prelude.Text ->
  -- | 'type''
  StateMachineType ->
  -- | 'creationDate'
  Prelude.UTCTime ->
  DescribeStateMachineResponse
newDescribeStateMachineResponse :: Int
-> Text
-> Text
-> Text
-> Text
-> StateMachineType
-> UTCTime
-> DescribeStateMachineResponse
newDescribeStateMachineResponse
  Int
pHttpStatus_
  Text
pStateMachineArn_
  Text
pName_
  Text
pDefinition_
  Text
pRoleArn_
  StateMachineType
pType_
  UTCTime
pCreationDate_ =
    DescribeStateMachineResponse'
      { $sel:label:DescribeStateMachineResponse' :: Maybe Text
label =
          forall a. Maybe a
Prelude.Nothing,
        $sel:loggingConfiguration:DescribeStateMachineResponse' :: Maybe LoggingConfiguration
loggingConfiguration = forall a. Maybe a
Prelude.Nothing,
        $sel:status:DescribeStateMachineResponse' :: Maybe StateMachineStatus
status = forall a. Maybe a
Prelude.Nothing,
        $sel:tracingConfiguration:DescribeStateMachineResponse' :: Maybe TracingConfiguration
tracingConfiguration = forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:DescribeStateMachineResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:stateMachineArn:DescribeStateMachineResponse' :: Text
stateMachineArn = Text
pStateMachineArn_,
        $sel:name:DescribeStateMachineResponse' :: Text
name = Text
pName_,
        $sel:definition:DescribeStateMachineResponse' :: Sensitive Text
definition =
          forall a. Iso' (Sensitive a) a
Data._Sensitive forall t b. AReview t b -> b -> t
Lens.# Text
pDefinition_,
        $sel:roleArn:DescribeStateMachineResponse' :: Text
roleArn = Text
pRoleArn_,
        $sel:type':DescribeStateMachineResponse' :: StateMachineType
type' = StateMachineType
pType_,
        $sel:creationDate:DescribeStateMachineResponse' :: POSIX
creationDate =
          forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pCreationDate_
      }

-- | A user-defined or an auto-generated string that identifies a @Map@
-- state. This parameter is present only if the @stateMachineArn@ specified
-- in input is a qualified state machine ARN.
describeStateMachineResponse_label :: Lens.Lens' DescribeStateMachineResponse (Prelude.Maybe Prelude.Text)
describeStateMachineResponse_label :: Lens' DescribeStateMachineResponse (Maybe Text)
describeStateMachineResponse_label = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachineResponse' {Maybe Text
label :: Maybe Text
$sel:label:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Maybe Text
label} -> Maybe Text
label) (\s :: DescribeStateMachineResponse
s@DescribeStateMachineResponse' {} Maybe Text
a -> DescribeStateMachineResponse
s {$sel:label:DescribeStateMachineResponse' :: Maybe Text
label = Maybe Text
a} :: DescribeStateMachineResponse)

-- | Undocumented member.
describeStateMachineResponse_loggingConfiguration :: Lens.Lens' DescribeStateMachineResponse (Prelude.Maybe LoggingConfiguration)
describeStateMachineResponse_loggingConfiguration :: Lens' DescribeStateMachineResponse (Maybe LoggingConfiguration)
describeStateMachineResponse_loggingConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachineResponse' {Maybe LoggingConfiguration
loggingConfiguration :: Maybe LoggingConfiguration
$sel:loggingConfiguration:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Maybe LoggingConfiguration
loggingConfiguration} -> Maybe LoggingConfiguration
loggingConfiguration) (\s :: DescribeStateMachineResponse
s@DescribeStateMachineResponse' {} Maybe LoggingConfiguration
a -> DescribeStateMachineResponse
s {$sel:loggingConfiguration:DescribeStateMachineResponse' :: Maybe LoggingConfiguration
loggingConfiguration = Maybe LoggingConfiguration
a} :: DescribeStateMachineResponse)

-- | The current status of the state machine.
describeStateMachineResponse_status :: Lens.Lens' DescribeStateMachineResponse (Prelude.Maybe StateMachineStatus)
describeStateMachineResponse_status :: Lens' DescribeStateMachineResponse (Maybe StateMachineStatus)
describeStateMachineResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachineResponse' {Maybe StateMachineStatus
status :: Maybe StateMachineStatus
$sel:status:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Maybe StateMachineStatus
status} -> Maybe StateMachineStatus
status) (\s :: DescribeStateMachineResponse
s@DescribeStateMachineResponse' {} Maybe StateMachineStatus
a -> DescribeStateMachineResponse
s {$sel:status:DescribeStateMachineResponse' :: Maybe StateMachineStatus
status = Maybe StateMachineStatus
a} :: DescribeStateMachineResponse)

-- | Selects whether X-Ray tracing is enabled.
describeStateMachineResponse_tracingConfiguration :: Lens.Lens' DescribeStateMachineResponse (Prelude.Maybe TracingConfiguration)
describeStateMachineResponse_tracingConfiguration :: Lens' DescribeStateMachineResponse (Maybe TracingConfiguration)
describeStateMachineResponse_tracingConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachineResponse' {Maybe TracingConfiguration
tracingConfiguration :: Maybe TracingConfiguration
$sel:tracingConfiguration:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Maybe TracingConfiguration
tracingConfiguration} -> Maybe TracingConfiguration
tracingConfiguration) (\s :: DescribeStateMachineResponse
s@DescribeStateMachineResponse' {} Maybe TracingConfiguration
a -> DescribeStateMachineResponse
s {$sel:tracingConfiguration:DescribeStateMachineResponse' :: Maybe TracingConfiguration
tracingConfiguration = Maybe TracingConfiguration
a} :: DescribeStateMachineResponse)

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

-- | The Amazon Resource Name (ARN) that identifies the state machine.
describeStateMachineResponse_stateMachineArn :: Lens.Lens' DescribeStateMachineResponse Prelude.Text
describeStateMachineResponse_stateMachineArn :: Lens' DescribeStateMachineResponse Text
describeStateMachineResponse_stateMachineArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachineResponse' {Text
stateMachineArn :: Text
$sel:stateMachineArn:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Text
stateMachineArn} -> Text
stateMachineArn) (\s :: DescribeStateMachineResponse
s@DescribeStateMachineResponse' {} Text
a -> DescribeStateMachineResponse
s {$sel:stateMachineArn:DescribeStateMachineResponse' :: Text
stateMachineArn = Text
a} :: DescribeStateMachineResponse)

-- | The name of the state machine.
--
-- A name must /not/ contain:
--
-- -   white space
--
-- -   brackets @\< > { } [ ]@
--
-- -   wildcard characters @? *@
--
-- -   special characters @\" # % \\ ^ | ~ \` $ & , ; : \/@
--
-- -   control characters (@U+0000-001F@, @U+007F-009F@)
--
-- To enable logging with CloudWatch Logs, the name should only contain
-- 0-9, A-Z, a-z, - and _.
describeStateMachineResponse_name :: Lens.Lens' DescribeStateMachineResponse Prelude.Text
describeStateMachineResponse_name :: Lens' DescribeStateMachineResponse Text
describeStateMachineResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachineResponse' {Text
name :: Text
$sel:name:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Text
name} -> Text
name) (\s :: DescribeStateMachineResponse
s@DescribeStateMachineResponse' {} Text
a -> DescribeStateMachineResponse
s {$sel:name:DescribeStateMachineResponse' :: Text
name = Text
a} :: DescribeStateMachineResponse)

-- | The Amazon States Language definition of the state machine. See
-- <https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html Amazon States Language>.
describeStateMachineResponse_definition :: Lens.Lens' DescribeStateMachineResponse Prelude.Text
describeStateMachineResponse_definition :: Lens' DescribeStateMachineResponse Text
describeStateMachineResponse_definition = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachineResponse' {Sensitive Text
definition :: Sensitive Text
$sel:definition:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Sensitive Text
definition} -> Sensitive Text
definition) (\s :: DescribeStateMachineResponse
s@DescribeStateMachineResponse' {} Sensitive Text
a -> DescribeStateMachineResponse
s {$sel:definition:DescribeStateMachineResponse' :: Sensitive Text
definition = Sensitive Text
a} :: DescribeStateMachineResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a. Iso' (Sensitive a) a
Data._Sensitive

-- | The Amazon Resource Name (ARN) of the IAM role used when creating this
-- state machine. (The IAM role maintains security by granting Step
-- Functions access to Amazon Web Services resources.)
describeStateMachineResponse_roleArn :: Lens.Lens' DescribeStateMachineResponse Prelude.Text
describeStateMachineResponse_roleArn :: Lens' DescribeStateMachineResponse Text
describeStateMachineResponse_roleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachineResponse' {Text
roleArn :: Text
$sel:roleArn:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Text
roleArn} -> Text
roleArn) (\s :: DescribeStateMachineResponse
s@DescribeStateMachineResponse' {} Text
a -> DescribeStateMachineResponse
s {$sel:roleArn:DescribeStateMachineResponse' :: Text
roleArn = Text
a} :: DescribeStateMachineResponse)

-- | The @type@ of the state machine (@STANDARD@ or @EXPRESS@).
describeStateMachineResponse_type :: Lens.Lens' DescribeStateMachineResponse StateMachineType
describeStateMachineResponse_type :: Lens' DescribeStateMachineResponse StateMachineType
describeStateMachineResponse_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachineResponse' {StateMachineType
type' :: StateMachineType
$sel:type':DescribeStateMachineResponse' :: DescribeStateMachineResponse -> StateMachineType
type'} -> StateMachineType
type') (\s :: DescribeStateMachineResponse
s@DescribeStateMachineResponse' {} StateMachineType
a -> DescribeStateMachineResponse
s {$sel:type':DescribeStateMachineResponse' :: StateMachineType
type' = StateMachineType
a} :: DescribeStateMachineResponse)

-- | The date the state machine is created.
describeStateMachineResponse_creationDate :: Lens.Lens' DescribeStateMachineResponse Prelude.UTCTime
describeStateMachineResponse_creationDate :: Lens' DescribeStateMachineResponse UTCTime
describeStateMachineResponse_creationDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeStateMachineResponse' {POSIX
creationDate :: POSIX
$sel:creationDate:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> POSIX
creationDate} -> POSIX
creationDate) (\s :: DescribeStateMachineResponse
s@DescribeStateMachineResponse' {} POSIX
a -> DescribeStateMachineResponse
s {$sel:creationDate:DescribeStateMachineResponse' :: POSIX
creationDate = POSIX
a} :: DescribeStateMachineResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

instance Prelude.NFData DescribeStateMachineResponse where
  rnf :: DescribeStateMachineResponse -> ()
rnf DescribeStateMachineResponse' {Int
Maybe Text
Maybe LoggingConfiguration
Maybe StateMachineStatus
Maybe TracingConfiguration
Text
Sensitive Text
POSIX
StateMachineType
creationDate :: POSIX
type' :: StateMachineType
roleArn :: Text
definition :: Sensitive Text
name :: Text
stateMachineArn :: Text
httpStatus :: Int
tracingConfiguration :: Maybe TracingConfiguration
status :: Maybe StateMachineStatus
loggingConfiguration :: Maybe LoggingConfiguration
label :: Maybe Text
$sel:creationDate:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> POSIX
$sel:type':DescribeStateMachineResponse' :: DescribeStateMachineResponse -> StateMachineType
$sel:roleArn:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Text
$sel:definition:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Sensitive Text
$sel:name:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Text
$sel:stateMachineArn:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Text
$sel:httpStatus:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Int
$sel:tracingConfiguration:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Maybe TracingConfiguration
$sel:status:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Maybe StateMachineStatus
$sel:loggingConfiguration:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Maybe LoggingConfiguration
$sel:label:DescribeStateMachineResponse' :: DescribeStateMachineResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
label
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LoggingConfiguration
loggingConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StateMachineStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TracingConfiguration
tracingConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
stateMachineArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Sensitive Text
definition
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
roleArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf StateMachineType
type'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf POSIX
creationDate