{-# 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.Athena.StartCalculationExecution
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Submits calculations for execution within a session. You can supply the
-- code to run as an inline code block within the request or as an Amazon
-- S3 URL.
module Amazonka.Athena.StartCalculationExecution
  ( -- * Creating a Request
    StartCalculationExecution (..),
    newStartCalculationExecution,

    -- * Request Lenses
    startCalculationExecution_calculationConfiguration,
    startCalculationExecution_clientRequestToken,
    startCalculationExecution_codeBlock,
    startCalculationExecution_description,
    startCalculationExecution_sessionId,

    -- * Destructuring the Response
    StartCalculationExecutionResponse (..),
    newStartCalculationExecutionResponse,

    -- * Response Lenses
    startCalculationExecutionResponse_calculationExecutionId,
    startCalculationExecutionResponse_state,
    startCalculationExecutionResponse_httpStatus,
  )
where

import Amazonka.Athena.Types
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

-- | /See:/ 'newStartCalculationExecution' smart constructor.
data StartCalculationExecution = StartCalculationExecution'
  { -- | Contains configuration information for the calculation.
    StartCalculationExecution -> Maybe CalculationConfiguration
calculationConfiguration :: Prelude.Maybe CalculationConfiguration,
    -- | A unique case-sensitive string used to ensure the request to create the
    -- calculation is idempotent (executes only once). If another
    -- @StartCalculationExecutionRequest@ is received, the same response is
    -- returned and another calculation is not created. If a parameter has
    -- changed, an error is returned.
    --
    -- This token is listed as not required because Amazon Web Services SDKs
    -- (for example the Amazon Web Services SDK for Java) auto-generate the
    -- token for users. If you are not using the Amazon Web Services SDK or the
    -- Amazon Web Services CLI, you must provide this token or the action will
    -- fail.
    StartCalculationExecution -> Maybe Text
clientRequestToken :: Prelude.Maybe Prelude.Text,
    -- | A string that contains the code of the calculation.
    StartCalculationExecution -> Maybe Text
codeBlock :: Prelude.Maybe Prelude.Text,
    -- | A description of the calculation.
    StartCalculationExecution -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The session ID.
    StartCalculationExecution -> Text
sessionId :: Prelude.Text
  }
  deriving (StartCalculationExecution -> StartCalculationExecution -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartCalculationExecution -> StartCalculationExecution -> Bool
$c/= :: StartCalculationExecution -> StartCalculationExecution -> Bool
== :: StartCalculationExecution -> StartCalculationExecution -> Bool
$c== :: StartCalculationExecution -> StartCalculationExecution -> Bool
Prelude.Eq, ReadPrec [StartCalculationExecution]
ReadPrec StartCalculationExecution
Int -> ReadS StartCalculationExecution
ReadS [StartCalculationExecution]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartCalculationExecution]
$creadListPrec :: ReadPrec [StartCalculationExecution]
readPrec :: ReadPrec StartCalculationExecution
$creadPrec :: ReadPrec StartCalculationExecution
readList :: ReadS [StartCalculationExecution]
$creadList :: ReadS [StartCalculationExecution]
readsPrec :: Int -> ReadS StartCalculationExecution
$creadsPrec :: Int -> ReadS StartCalculationExecution
Prelude.Read, Int -> StartCalculationExecution -> ShowS
[StartCalculationExecution] -> ShowS
StartCalculationExecution -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartCalculationExecution] -> ShowS
$cshowList :: [StartCalculationExecution] -> ShowS
show :: StartCalculationExecution -> String
$cshow :: StartCalculationExecution -> String
showsPrec :: Int -> StartCalculationExecution -> ShowS
$cshowsPrec :: Int -> StartCalculationExecution -> ShowS
Prelude.Show, forall x.
Rep StartCalculationExecution x -> StartCalculationExecution
forall x.
StartCalculationExecution -> Rep StartCalculationExecution x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep StartCalculationExecution x -> StartCalculationExecution
$cfrom :: forall x.
StartCalculationExecution -> Rep StartCalculationExecution x
Prelude.Generic)

-- |
-- Create a value of 'StartCalculationExecution' 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:
--
-- 'calculationConfiguration', 'startCalculationExecution_calculationConfiguration' - Contains configuration information for the calculation.
--
-- 'clientRequestToken', 'startCalculationExecution_clientRequestToken' - A unique case-sensitive string used to ensure the request to create the
-- calculation is idempotent (executes only once). If another
-- @StartCalculationExecutionRequest@ is received, the same response is
-- returned and another calculation is not created. If a parameter has
-- changed, an error is returned.
--
-- This token is listed as not required because Amazon Web Services SDKs
-- (for example the Amazon Web Services SDK for Java) auto-generate the
-- token for users. If you are not using the Amazon Web Services SDK or the
-- Amazon Web Services CLI, you must provide this token or the action will
-- fail.
--
-- 'codeBlock', 'startCalculationExecution_codeBlock' - A string that contains the code of the calculation.
--
-- 'description', 'startCalculationExecution_description' - A description of the calculation.
--
-- 'sessionId', 'startCalculationExecution_sessionId' - The session ID.
newStartCalculationExecution ::
  -- | 'sessionId'
  Prelude.Text ->
  StartCalculationExecution
newStartCalculationExecution :: Text -> StartCalculationExecution
newStartCalculationExecution Text
pSessionId_ =
  StartCalculationExecution'
    { $sel:calculationConfiguration:StartCalculationExecution' :: Maybe CalculationConfiguration
calculationConfiguration =
        forall a. Maybe a
Prelude.Nothing,
      $sel:clientRequestToken:StartCalculationExecution' :: Maybe Text
clientRequestToken = forall a. Maybe a
Prelude.Nothing,
      $sel:codeBlock:StartCalculationExecution' :: Maybe Text
codeBlock = forall a. Maybe a
Prelude.Nothing,
      $sel:description:StartCalculationExecution' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:sessionId:StartCalculationExecution' :: Text
sessionId = Text
pSessionId_
    }

-- | Contains configuration information for the calculation.
startCalculationExecution_calculationConfiguration :: Lens.Lens' StartCalculationExecution (Prelude.Maybe CalculationConfiguration)
startCalculationExecution_calculationConfiguration :: Lens' StartCalculationExecution (Maybe CalculationConfiguration)
startCalculationExecution_calculationConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartCalculationExecution' {Maybe CalculationConfiguration
calculationConfiguration :: Maybe CalculationConfiguration
$sel:calculationConfiguration:StartCalculationExecution' :: StartCalculationExecution -> Maybe CalculationConfiguration
calculationConfiguration} -> Maybe CalculationConfiguration
calculationConfiguration) (\s :: StartCalculationExecution
s@StartCalculationExecution' {} Maybe CalculationConfiguration
a -> StartCalculationExecution
s {$sel:calculationConfiguration:StartCalculationExecution' :: Maybe CalculationConfiguration
calculationConfiguration = Maybe CalculationConfiguration
a} :: StartCalculationExecution)

-- | A unique case-sensitive string used to ensure the request to create the
-- calculation is idempotent (executes only once). If another
-- @StartCalculationExecutionRequest@ is received, the same response is
-- returned and another calculation is not created. If a parameter has
-- changed, an error is returned.
--
-- This token is listed as not required because Amazon Web Services SDKs
-- (for example the Amazon Web Services SDK for Java) auto-generate the
-- token for users. If you are not using the Amazon Web Services SDK or the
-- Amazon Web Services CLI, you must provide this token or the action will
-- fail.
startCalculationExecution_clientRequestToken :: Lens.Lens' StartCalculationExecution (Prelude.Maybe Prelude.Text)
startCalculationExecution_clientRequestToken :: Lens' StartCalculationExecution (Maybe Text)
startCalculationExecution_clientRequestToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartCalculationExecution' {Maybe Text
clientRequestToken :: Maybe Text
$sel:clientRequestToken:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
clientRequestToken} -> Maybe Text
clientRequestToken) (\s :: StartCalculationExecution
s@StartCalculationExecution' {} Maybe Text
a -> StartCalculationExecution
s {$sel:clientRequestToken:StartCalculationExecution' :: Maybe Text
clientRequestToken = Maybe Text
a} :: StartCalculationExecution)

-- | A string that contains the code of the calculation.
startCalculationExecution_codeBlock :: Lens.Lens' StartCalculationExecution (Prelude.Maybe Prelude.Text)
startCalculationExecution_codeBlock :: Lens' StartCalculationExecution (Maybe Text)
startCalculationExecution_codeBlock = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartCalculationExecution' {Maybe Text
codeBlock :: Maybe Text
$sel:codeBlock:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
codeBlock} -> Maybe Text
codeBlock) (\s :: StartCalculationExecution
s@StartCalculationExecution' {} Maybe Text
a -> StartCalculationExecution
s {$sel:codeBlock:StartCalculationExecution' :: Maybe Text
codeBlock = Maybe Text
a} :: StartCalculationExecution)

-- | A description of the calculation.
startCalculationExecution_description :: Lens.Lens' StartCalculationExecution (Prelude.Maybe Prelude.Text)
startCalculationExecution_description :: Lens' StartCalculationExecution (Maybe Text)
startCalculationExecution_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartCalculationExecution' {Maybe Text
description :: Maybe Text
$sel:description:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
description} -> Maybe Text
description) (\s :: StartCalculationExecution
s@StartCalculationExecution' {} Maybe Text
a -> StartCalculationExecution
s {$sel:description:StartCalculationExecution' :: Maybe Text
description = Maybe Text
a} :: StartCalculationExecution)

-- | The session ID.
startCalculationExecution_sessionId :: Lens.Lens' StartCalculationExecution Prelude.Text
startCalculationExecution_sessionId :: Lens' StartCalculationExecution Text
startCalculationExecution_sessionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartCalculationExecution' {Text
sessionId :: Text
$sel:sessionId:StartCalculationExecution' :: StartCalculationExecution -> Text
sessionId} -> Text
sessionId) (\s :: StartCalculationExecution
s@StartCalculationExecution' {} Text
a -> StartCalculationExecution
s {$sel:sessionId:StartCalculationExecution' :: Text
sessionId = Text
a} :: StartCalculationExecution)

instance Core.AWSRequest StartCalculationExecution where
  type
    AWSResponse StartCalculationExecution =
      StartCalculationExecutionResponse
  request :: (Service -> Service)
-> StartCalculationExecution -> Request StartCalculationExecution
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 StartCalculationExecution
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse StartCalculationExecution)))
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 CalculationExecutionState
-> Int
-> StartCalculationExecutionResponse
StartCalculationExecutionResponse'
            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
"CalculationExecutionId")
            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
"State")
            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 StartCalculationExecution where
  hashWithSalt :: Int -> StartCalculationExecution -> Int
hashWithSalt Int
_salt StartCalculationExecution' {Maybe Text
Maybe CalculationConfiguration
Text
sessionId :: Text
description :: Maybe Text
codeBlock :: Maybe Text
clientRequestToken :: Maybe Text
calculationConfiguration :: Maybe CalculationConfiguration
$sel:sessionId:StartCalculationExecution' :: StartCalculationExecution -> Text
$sel:description:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
$sel:codeBlock:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
$sel:clientRequestToken:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
$sel:calculationConfiguration:StartCalculationExecution' :: StartCalculationExecution -> Maybe CalculationConfiguration
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CalculationConfiguration
calculationConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientRequestToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
codeBlock
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
sessionId

instance Prelude.NFData StartCalculationExecution where
  rnf :: StartCalculationExecution -> ()
rnf StartCalculationExecution' {Maybe Text
Maybe CalculationConfiguration
Text
sessionId :: Text
description :: Maybe Text
codeBlock :: Maybe Text
clientRequestToken :: Maybe Text
calculationConfiguration :: Maybe CalculationConfiguration
$sel:sessionId:StartCalculationExecution' :: StartCalculationExecution -> Text
$sel:description:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
$sel:codeBlock:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
$sel:clientRequestToken:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
$sel:calculationConfiguration:StartCalculationExecution' :: StartCalculationExecution -> Maybe CalculationConfiguration
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe CalculationConfiguration
calculationConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientRequestToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
codeBlock
      seq :: forall a b. a -> b -> b
`Prelude.seq` 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 Text
sessionId

instance Data.ToHeaders StartCalculationExecution where
  toHeaders :: StartCalculationExecution -> 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
"AmazonAthena.StartCalculationExecution" ::
                          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 StartCalculationExecution where
  toJSON :: StartCalculationExecution -> Value
toJSON StartCalculationExecution' {Maybe Text
Maybe CalculationConfiguration
Text
sessionId :: Text
description :: Maybe Text
codeBlock :: Maybe Text
clientRequestToken :: Maybe Text
calculationConfiguration :: Maybe CalculationConfiguration
$sel:sessionId:StartCalculationExecution' :: StartCalculationExecution -> Text
$sel:description:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
$sel:codeBlock:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
$sel:clientRequestToken:StartCalculationExecution' :: StartCalculationExecution -> Maybe Text
$sel:calculationConfiguration:StartCalculationExecution' :: StartCalculationExecution -> Maybe CalculationConfiguration
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"CalculationConfiguration" 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 CalculationConfiguration
calculationConfiguration,
            (Key
"ClientRequestToken" 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
clientRequestToken,
            (Key
"CodeBlock" 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
codeBlock,
            (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,
            forall a. a -> Maybe a
Prelude.Just (Key
"SessionId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
sessionId)
          ]
      )

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

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

-- | /See:/ 'newStartCalculationExecutionResponse' smart constructor.
data StartCalculationExecutionResponse = StartCalculationExecutionResponse'
  { -- | The calculation execution UUID.
    StartCalculationExecutionResponse -> Maybe Text
calculationExecutionId :: Prelude.Maybe Prelude.Text,
    -- | @CREATING@ - The calculation is in the process of being created.
    --
    -- @CREATED@ - The calculation has been created and is ready to run.
    --
    -- @QUEUED@ - The calculation has been queued for processing.
    --
    -- @RUNNING@ - The calculation is running.
    --
    -- @CANCELING@ - A request to cancel the calculation has been received and
    -- the system is working to stop it.
    --
    -- @CANCELED@ - The calculation is no longer running as the result of a
    -- cancel request.
    --
    -- @COMPLETED@ - The calculation has completed without error.
    --
    -- @FAILED@ - The calculation failed and is no longer running.
    StartCalculationExecutionResponse
-> Maybe CalculationExecutionState
state :: Prelude.Maybe CalculationExecutionState,
    -- | The response's http status code.
    StartCalculationExecutionResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (StartCalculationExecutionResponse
-> StartCalculationExecutionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartCalculationExecutionResponse
-> StartCalculationExecutionResponse -> Bool
$c/= :: StartCalculationExecutionResponse
-> StartCalculationExecutionResponse -> Bool
== :: StartCalculationExecutionResponse
-> StartCalculationExecutionResponse -> Bool
$c== :: StartCalculationExecutionResponse
-> StartCalculationExecutionResponse -> Bool
Prelude.Eq, ReadPrec [StartCalculationExecutionResponse]
ReadPrec StartCalculationExecutionResponse
Int -> ReadS StartCalculationExecutionResponse
ReadS [StartCalculationExecutionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartCalculationExecutionResponse]
$creadListPrec :: ReadPrec [StartCalculationExecutionResponse]
readPrec :: ReadPrec StartCalculationExecutionResponse
$creadPrec :: ReadPrec StartCalculationExecutionResponse
readList :: ReadS [StartCalculationExecutionResponse]
$creadList :: ReadS [StartCalculationExecutionResponse]
readsPrec :: Int -> ReadS StartCalculationExecutionResponse
$creadsPrec :: Int -> ReadS StartCalculationExecutionResponse
Prelude.Read, Int -> StartCalculationExecutionResponse -> ShowS
[StartCalculationExecutionResponse] -> ShowS
StartCalculationExecutionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartCalculationExecutionResponse] -> ShowS
$cshowList :: [StartCalculationExecutionResponse] -> ShowS
show :: StartCalculationExecutionResponse -> String
$cshow :: StartCalculationExecutionResponse -> String
showsPrec :: Int -> StartCalculationExecutionResponse -> ShowS
$cshowsPrec :: Int -> StartCalculationExecutionResponse -> ShowS
Prelude.Show, forall x.
Rep StartCalculationExecutionResponse x
-> StartCalculationExecutionResponse
forall x.
StartCalculationExecutionResponse
-> Rep StartCalculationExecutionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep StartCalculationExecutionResponse x
-> StartCalculationExecutionResponse
$cfrom :: forall x.
StartCalculationExecutionResponse
-> Rep StartCalculationExecutionResponse x
Prelude.Generic)

-- |
-- Create a value of 'StartCalculationExecutionResponse' 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:
--
-- 'calculationExecutionId', 'startCalculationExecutionResponse_calculationExecutionId' - The calculation execution UUID.
--
-- 'state', 'startCalculationExecutionResponse_state' - @CREATING@ - The calculation is in the process of being created.
--
-- @CREATED@ - The calculation has been created and is ready to run.
--
-- @QUEUED@ - The calculation has been queued for processing.
--
-- @RUNNING@ - The calculation is running.
--
-- @CANCELING@ - A request to cancel the calculation has been received and
-- the system is working to stop it.
--
-- @CANCELED@ - The calculation is no longer running as the result of a
-- cancel request.
--
-- @COMPLETED@ - The calculation has completed without error.
--
-- @FAILED@ - The calculation failed and is no longer running.
--
-- 'httpStatus', 'startCalculationExecutionResponse_httpStatus' - The response's http status code.
newStartCalculationExecutionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  StartCalculationExecutionResponse
newStartCalculationExecutionResponse :: Int -> StartCalculationExecutionResponse
newStartCalculationExecutionResponse Int
pHttpStatus_ =
  StartCalculationExecutionResponse'
    { $sel:calculationExecutionId:StartCalculationExecutionResponse' :: Maybe Text
calculationExecutionId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:state:StartCalculationExecutionResponse' :: Maybe CalculationExecutionState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:StartCalculationExecutionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The calculation execution UUID.
startCalculationExecutionResponse_calculationExecutionId :: Lens.Lens' StartCalculationExecutionResponse (Prelude.Maybe Prelude.Text)
startCalculationExecutionResponse_calculationExecutionId :: Lens' StartCalculationExecutionResponse (Maybe Text)
startCalculationExecutionResponse_calculationExecutionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartCalculationExecutionResponse' {Maybe Text
calculationExecutionId :: Maybe Text
$sel:calculationExecutionId:StartCalculationExecutionResponse' :: StartCalculationExecutionResponse -> Maybe Text
calculationExecutionId} -> Maybe Text
calculationExecutionId) (\s :: StartCalculationExecutionResponse
s@StartCalculationExecutionResponse' {} Maybe Text
a -> StartCalculationExecutionResponse
s {$sel:calculationExecutionId:StartCalculationExecutionResponse' :: Maybe Text
calculationExecutionId = Maybe Text
a} :: StartCalculationExecutionResponse)

-- | @CREATING@ - The calculation is in the process of being created.
--
-- @CREATED@ - The calculation has been created and is ready to run.
--
-- @QUEUED@ - The calculation has been queued for processing.
--
-- @RUNNING@ - The calculation is running.
--
-- @CANCELING@ - A request to cancel the calculation has been received and
-- the system is working to stop it.
--
-- @CANCELED@ - The calculation is no longer running as the result of a
-- cancel request.
--
-- @COMPLETED@ - The calculation has completed without error.
--
-- @FAILED@ - The calculation failed and is no longer running.
startCalculationExecutionResponse_state :: Lens.Lens' StartCalculationExecutionResponse (Prelude.Maybe CalculationExecutionState)
startCalculationExecutionResponse_state :: Lens'
  StartCalculationExecutionResponse (Maybe CalculationExecutionState)
startCalculationExecutionResponse_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartCalculationExecutionResponse' {Maybe CalculationExecutionState
state :: Maybe CalculationExecutionState
$sel:state:StartCalculationExecutionResponse' :: StartCalculationExecutionResponse
-> Maybe CalculationExecutionState
state} -> Maybe CalculationExecutionState
state) (\s :: StartCalculationExecutionResponse
s@StartCalculationExecutionResponse' {} Maybe CalculationExecutionState
a -> StartCalculationExecutionResponse
s {$sel:state:StartCalculationExecutionResponse' :: Maybe CalculationExecutionState
state = Maybe CalculationExecutionState
a} :: StartCalculationExecutionResponse)

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

instance
  Prelude.NFData
    StartCalculationExecutionResponse
  where
  rnf :: StartCalculationExecutionResponse -> ()
rnf StartCalculationExecutionResponse' {Int
Maybe Text
Maybe CalculationExecutionState
httpStatus :: Int
state :: Maybe CalculationExecutionState
calculationExecutionId :: Maybe Text
$sel:httpStatus:StartCalculationExecutionResponse' :: StartCalculationExecutionResponse -> Int
$sel:state:StartCalculationExecutionResponse' :: StartCalculationExecutionResponse
-> Maybe CalculationExecutionState
$sel:calculationExecutionId:StartCalculationExecutionResponse' :: StartCalculationExecutionResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
calculationExecutionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CalculationExecutionState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus