{-# 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.Config.StartResourceEvaluation
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Runs an on-demand evaluation for the specified resource to determine
-- whether the resource details will comply with configured Config rules.
-- You can also use it for evaluation purposes. Config recommends using an
-- evaluation context. It runs an execution against the resource details
-- with all of the Config rules in your account that match with the
-- specified proactive mode and resource type.
--
-- Ensure you have the @cloudformation:DescribeType@ role setup to validate
-- the resource type schema.
module Amazonka.Config.StartResourceEvaluation
  ( -- * Creating a Request
    StartResourceEvaluation (..),
    newStartResourceEvaluation,

    -- * Request Lenses
    startResourceEvaluation_clientToken,
    startResourceEvaluation_evaluationContext,
    startResourceEvaluation_evaluationTimeout,
    startResourceEvaluation_resourceDetails,
    startResourceEvaluation_evaluationMode,

    -- * Destructuring the Response
    StartResourceEvaluationResponse (..),
    newStartResourceEvaluationResponse,

    -- * Response Lenses
    startResourceEvaluationResponse_resourceEvaluationId,
    startResourceEvaluationResponse_httpStatus,
  )
where

import Amazonka.Config.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:/ 'newStartResourceEvaluation' smart constructor.
data StartResourceEvaluation = StartResourceEvaluation'
  { -- | A client token is a unique, case-sensitive string of up to 64 ASCII
    -- characters. To make an idempotent API request using one of these
    -- actions, specify a client token in the request.
    --
    -- Avoid reusing the same client token for other API requests. If you retry
    -- a request that completed successfully using the same client token and
    -- the same parameters, the retry succeeds without performing any further
    -- actions. If you retry a successful request using the same client token,
    -- but one or more of the parameters are different, other than the Region
    -- or Availability Zone, the retry fails with an
    -- IdempotentParameterMismatch error.
    StartResourceEvaluation -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | Returns an @EvaluationContext@ object.
    StartResourceEvaluation -> Maybe EvaluationContext
evaluationContext :: Prelude.Maybe EvaluationContext,
    -- | The timeout for an evaluation. The default is 900 seconds. You cannot
    -- specify a number greater than 3600. If you specify 0, Config uses the
    -- default.
    StartResourceEvaluation -> Maybe Natural
evaluationTimeout :: Prelude.Maybe Prelude.Natural,
    -- | Returns a @ResourceDetails@ object.
    StartResourceEvaluation -> ResourceDetails
resourceDetails :: ResourceDetails,
    -- | The mode of an evaluation. The valid value for this API is @Proactive@.
    StartResourceEvaluation -> EvaluationMode
evaluationMode :: EvaluationMode
  }
  deriving (StartResourceEvaluation -> StartResourceEvaluation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartResourceEvaluation -> StartResourceEvaluation -> Bool
$c/= :: StartResourceEvaluation -> StartResourceEvaluation -> Bool
== :: StartResourceEvaluation -> StartResourceEvaluation -> Bool
$c== :: StartResourceEvaluation -> StartResourceEvaluation -> Bool
Prelude.Eq, ReadPrec [StartResourceEvaluation]
ReadPrec StartResourceEvaluation
Int -> ReadS StartResourceEvaluation
ReadS [StartResourceEvaluation]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartResourceEvaluation]
$creadListPrec :: ReadPrec [StartResourceEvaluation]
readPrec :: ReadPrec StartResourceEvaluation
$creadPrec :: ReadPrec StartResourceEvaluation
readList :: ReadS [StartResourceEvaluation]
$creadList :: ReadS [StartResourceEvaluation]
readsPrec :: Int -> ReadS StartResourceEvaluation
$creadsPrec :: Int -> ReadS StartResourceEvaluation
Prelude.Read, Int -> StartResourceEvaluation -> ShowS
[StartResourceEvaluation] -> ShowS
StartResourceEvaluation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartResourceEvaluation] -> ShowS
$cshowList :: [StartResourceEvaluation] -> ShowS
show :: StartResourceEvaluation -> String
$cshow :: StartResourceEvaluation -> String
showsPrec :: Int -> StartResourceEvaluation -> ShowS
$cshowsPrec :: Int -> StartResourceEvaluation -> ShowS
Prelude.Show, forall x. Rep StartResourceEvaluation x -> StartResourceEvaluation
forall x. StartResourceEvaluation -> Rep StartResourceEvaluation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartResourceEvaluation x -> StartResourceEvaluation
$cfrom :: forall x. StartResourceEvaluation -> Rep StartResourceEvaluation x
Prelude.Generic)

-- |
-- Create a value of 'StartResourceEvaluation' 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:
--
-- 'clientToken', 'startResourceEvaluation_clientToken' - A client token is a unique, case-sensitive string of up to 64 ASCII
-- characters. To make an idempotent API request using one of these
-- actions, specify a client token in the request.
--
-- Avoid reusing the same client token for other API requests. If you retry
-- a request that completed successfully using the same client token and
-- the same parameters, the retry succeeds without performing any further
-- actions. If you retry a successful request using the same client token,
-- but one or more of the parameters are different, other than the Region
-- or Availability Zone, the retry fails with an
-- IdempotentParameterMismatch error.
--
-- 'evaluationContext', 'startResourceEvaluation_evaluationContext' - Returns an @EvaluationContext@ object.
--
-- 'evaluationTimeout', 'startResourceEvaluation_evaluationTimeout' - The timeout for an evaluation. The default is 900 seconds. You cannot
-- specify a number greater than 3600. If you specify 0, Config uses the
-- default.
--
-- 'resourceDetails', 'startResourceEvaluation_resourceDetails' - Returns a @ResourceDetails@ object.
--
-- 'evaluationMode', 'startResourceEvaluation_evaluationMode' - The mode of an evaluation. The valid value for this API is @Proactive@.
newStartResourceEvaluation ::
  -- | 'resourceDetails'
  ResourceDetails ->
  -- | 'evaluationMode'
  EvaluationMode ->
  StartResourceEvaluation
newStartResourceEvaluation :: ResourceDetails -> EvaluationMode -> StartResourceEvaluation
newStartResourceEvaluation
  ResourceDetails
pResourceDetails_
  EvaluationMode
pEvaluationMode_ =
    StartResourceEvaluation'
      { $sel:clientToken:StartResourceEvaluation' :: Maybe Text
clientToken =
          forall a. Maybe a
Prelude.Nothing,
        $sel:evaluationContext:StartResourceEvaluation' :: Maybe EvaluationContext
evaluationContext = forall a. Maybe a
Prelude.Nothing,
        $sel:evaluationTimeout:StartResourceEvaluation' :: Maybe Natural
evaluationTimeout = forall a. Maybe a
Prelude.Nothing,
        $sel:resourceDetails:StartResourceEvaluation' :: ResourceDetails
resourceDetails = ResourceDetails
pResourceDetails_,
        $sel:evaluationMode:StartResourceEvaluation' :: EvaluationMode
evaluationMode = EvaluationMode
pEvaluationMode_
      }

-- | A client token is a unique, case-sensitive string of up to 64 ASCII
-- characters. To make an idempotent API request using one of these
-- actions, specify a client token in the request.
--
-- Avoid reusing the same client token for other API requests. If you retry
-- a request that completed successfully using the same client token and
-- the same parameters, the retry succeeds without performing any further
-- actions. If you retry a successful request using the same client token,
-- but one or more of the parameters are different, other than the Region
-- or Availability Zone, the retry fails with an
-- IdempotentParameterMismatch error.
startResourceEvaluation_clientToken :: Lens.Lens' StartResourceEvaluation (Prelude.Maybe Prelude.Text)
startResourceEvaluation_clientToken :: Lens' StartResourceEvaluation (Maybe Text)
startResourceEvaluation_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartResourceEvaluation' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: StartResourceEvaluation
s@StartResourceEvaluation' {} Maybe Text
a -> StartResourceEvaluation
s {$sel:clientToken:StartResourceEvaluation' :: Maybe Text
clientToken = Maybe Text
a} :: StartResourceEvaluation)

-- | Returns an @EvaluationContext@ object.
startResourceEvaluation_evaluationContext :: Lens.Lens' StartResourceEvaluation (Prelude.Maybe EvaluationContext)
startResourceEvaluation_evaluationContext :: Lens' StartResourceEvaluation (Maybe EvaluationContext)
startResourceEvaluation_evaluationContext = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartResourceEvaluation' {Maybe EvaluationContext
evaluationContext :: Maybe EvaluationContext
$sel:evaluationContext:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe EvaluationContext
evaluationContext} -> Maybe EvaluationContext
evaluationContext) (\s :: StartResourceEvaluation
s@StartResourceEvaluation' {} Maybe EvaluationContext
a -> StartResourceEvaluation
s {$sel:evaluationContext:StartResourceEvaluation' :: Maybe EvaluationContext
evaluationContext = Maybe EvaluationContext
a} :: StartResourceEvaluation)

-- | The timeout for an evaluation. The default is 900 seconds. You cannot
-- specify a number greater than 3600. If you specify 0, Config uses the
-- default.
startResourceEvaluation_evaluationTimeout :: Lens.Lens' StartResourceEvaluation (Prelude.Maybe Prelude.Natural)
startResourceEvaluation_evaluationTimeout :: Lens' StartResourceEvaluation (Maybe Natural)
startResourceEvaluation_evaluationTimeout = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartResourceEvaluation' {Maybe Natural
evaluationTimeout :: Maybe Natural
$sel:evaluationTimeout:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe Natural
evaluationTimeout} -> Maybe Natural
evaluationTimeout) (\s :: StartResourceEvaluation
s@StartResourceEvaluation' {} Maybe Natural
a -> StartResourceEvaluation
s {$sel:evaluationTimeout:StartResourceEvaluation' :: Maybe Natural
evaluationTimeout = Maybe Natural
a} :: StartResourceEvaluation)

-- | Returns a @ResourceDetails@ object.
startResourceEvaluation_resourceDetails :: Lens.Lens' StartResourceEvaluation ResourceDetails
startResourceEvaluation_resourceDetails :: Lens' StartResourceEvaluation ResourceDetails
startResourceEvaluation_resourceDetails = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartResourceEvaluation' {ResourceDetails
resourceDetails :: ResourceDetails
$sel:resourceDetails:StartResourceEvaluation' :: StartResourceEvaluation -> ResourceDetails
resourceDetails} -> ResourceDetails
resourceDetails) (\s :: StartResourceEvaluation
s@StartResourceEvaluation' {} ResourceDetails
a -> StartResourceEvaluation
s {$sel:resourceDetails:StartResourceEvaluation' :: ResourceDetails
resourceDetails = ResourceDetails
a} :: StartResourceEvaluation)

-- | The mode of an evaluation. The valid value for this API is @Proactive@.
startResourceEvaluation_evaluationMode :: Lens.Lens' StartResourceEvaluation EvaluationMode
startResourceEvaluation_evaluationMode :: Lens' StartResourceEvaluation EvaluationMode
startResourceEvaluation_evaluationMode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartResourceEvaluation' {EvaluationMode
evaluationMode :: EvaluationMode
$sel:evaluationMode:StartResourceEvaluation' :: StartResourceEvaluation -> EvaluationMode
evaluationMode} -> EvaluationMode
evaluationMode) (\s :: StartResourceEvaluation
s@StartResourceEvaluation' {} EvaluationMode
a -> StartResourceEvaluation
s {$sel:evaluationMode:StartResourceEvaluation' :: EvaluationMode
evaluationMode = EvaluationMode
a} :: StartResourceEvaluation)

instance Core.AWSRequest StartResourceEvaluation where
  type
    AWSResponse StartResourceEvaluation =
      StartResourceEvaluationResponse
  request :: (Service -> Service)
-> StartResourceEvaluation -> Request StartResourceEvaluation
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 StartResourceEvaluation
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse StartResourceEvaluation)))
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 -> Int -> StartResourceEvaluationResponse
StartResourceEvaluationResponse'
            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
"ResourceEvaluationId")
            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 StartResourceEvaluation where
  hashWithSalt :: Int -> StartResourceEvaluation -> Int
hashWithSalt Int
_salt StartResourceEvaluation' {Maybe Natural
Maybe Text
Maybe EvaluationContext
EvaluationMode
ResourceDetails
evaluationMode :: EvaluationMode
resourceDetails :: ResourceDetails
evaluationTimeout :: Maybe Natural
evaluationContext :: Maybe EvaluationContext
clientToken :: Maybe Text
$sel:evaluationMode:StartResourceEvaluation' :: StartResourceEvaluation -> EvaluationMode
$sel:resourceDetails:StartResourceEvaluation' :: StartResourceEvaluation -> ResourceDetails
$sel:evaluationTimeout:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe Natural
$sel:evaluationContext:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe EvaluationContext
$sel:clientToken:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EvaluationContext
evaluationContext
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
evaluationTimeout
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ResourceDetails
resourceDetails
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` EvaluationMode
evaluationMode

instance Prelude.NFData StartResourceEvaluation where
  rnf :: StartResourceEvaluation -> ()
rnf StartResourceEvaluation' {Maybe Natural
Maybe Text
Maybe EvaluationContext
EvaluationMode
ResourceDetails
evaluationMode :: EvaluationMode
resourceDetails :: ResourceDetails
evaluationTimeout :: Maybe Natural
evaluationContext :: Maybe EvaluationContext
clientToken :: Maybe Text
$sel:evaluationMode:StartResourceEvaluation' :: StartResourceEvaluation -> EvaluationMode
$sel:resourceDetails:StartResourceEvaluation' :: StartResourceEvaluation -> ResourceDetails
$sel:evaluationTimeout:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe Natural
$sel:evaluationContext:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe EvaluationContext
$sel:clientToken:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EvaluationContext
evaluationContext
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
evaluationTimeout
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ResourceDetails
resourceDetails
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf EvaluationMode
evaluationMode

instance Data.ToHeaders StartResourceEvaluation where
  toHeaders :: StartResourceEvaluation -> 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
"StarlingDoveService.StartResourceEvaluation" ::
                          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 StartResourceEvaluation where
  toJSON :: StartResourceEvaluation -> Value
toJSON StartResourceEvaluation' {Maybe Natural
Maybe Text
Maybe EvaluationContext
EvaluationMode
ResourceDetails
evaluationMode :: EvaluationMode
resourceDetails :: ResourceDetails
evaluationTimeout :: Maybe Natural
evaluationContext :: Maybe EvaluationContext
clientToken :: Maybe Text
$sel:evaluationMode:StartResourceEvaluation' :: StartResourceEvaluation -> EvaluationMode
$sel:resourceDetails:StartResourceEvaluation' :: StartResourceEvaluation -> ResourceDetails
$sel:evaluationTimeout:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe Natural
$sel:evaluationContext:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe EvaluationContext
$sel:clientToken:StartResourceEvaluation' :: StartResourceEvaluation -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientToken" 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
clientToken,
            (Key
"EvaluationContext" 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 EvaluationContext
evaluationContext,
            (Key
"EvaluationTimeout" 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 Natural
evaluationTimeout,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ResourceDetails" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ResourceDetails
resourceDetails),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"EvaluationMode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= EvaluationMode
evaluationMode)
          ]
      )

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

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

-- | /See:/ 'newStartResourceEvaluationResponse' smart constructor.
data StartResourceEvaluationResponse = StartResourceEvaluationResponse'
  { -- | A unique ResourceEvaluationId that is associated with a single
    -- execution.
    StartResourceEvaluationResponse -> Maybe Text
resourceEvaluationId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    StartResourceEvaluationResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (StartResourceEvaluationResponse
-> StartResourceEvaluationResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartResourceEvaluationResponse
-> StartResourceEvaluationResponse -> Bool
$c/= :: StartResourceEvaluationResponse
-> StartResourceEvaluationResponse -> Bool
== :: StartResourceEvaluationResponse
-> StartResourceEvaluationResponse -> Bool
$c== :: StartResourceEvaluationResponse
-> StartResourceEvaluationResponse -> Bool
Prelude.Eq, ReadPrec [StartResourceEvaluationResponse]
ReadPrec StartResourceEvaluationResponse
Int -> ReadS StartResourceEvaluationResponse
ReadS [StartResourceEvaluationResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartResourceEvaluationResponse]
$creadListPrec :: ReadPrec [StartResourceEvaluationResponse]
readPrec :: ReadPrec StartResourceEvaluationResponse
$creadPrec :: ReadPrec StartResourceEvaluationResponse
readList :: ReadS [StartResourceEvaluationResponse]
$creadList :: ReadS [StartResourceEvaluationResponse]
readsPrec :: Int -> ReadS StartResourceEvaluationResponse
$creadsPrec :: Int -> ReadS StartResourceEvaluationResponse
Prelude.Read, Int -> StartResourceEvaluationResponse -> ShowS
[StartResourceEvaluationResponse] -> ShowS
StartResourceEvaluationResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartResourceEvaluationResponse] -> ShowS
$cshowList :: [StartResourceEvaluationResponse] -> ShowS
show :: StartResourceEvaluationResponse -> String
$cshow :: StartResourceEvaluationResponse -> String
showsPrec :: Int -> StartResourceEvaluationResponse -> ShowS
$cshowsPrec :: Int -> StartResourceEvaluationResponse -> ShowS
Prelude.Show, forall x.
Rep StartResourceEvaluationResponse x
-> StartResourceEvaluationResponse
forall x.
StartResourceEvaluationResponse
-> Rep StartResourceEvaluationResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep StartResourceEvaluationResponse x
-> StartResourceEvaluationResponse
$cfrom :: forall x.
StartResourceEvaluationResponse
-> Rep StartResourceEvaluationResponse x
Prelude.Generic)

-- |
-- Create a value of 'StartResourceEvaluationResponse' 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:
--
-- 'resourceEvaluationId', 'startResourceEvaluationResponse_resourceEvaluationId' - A unique ResourceEvaluationId that is associated with a single
-- execution.
--
-- 'httpStatus', 'startResourceEvaluationResponse_httpStatus' - The response's http status code.
newStartResourceEvaluationResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  StartResourceEvaluationResponse
newStartResourceEvaluationResponse :: Int -> StartResourceEvaluationResponse
newStartResourceEvaluationResponse Int
pHttpStatus_ =
  StartResourceEvaluationResponse'
    { $sel:resourceEvaluationId:StartResourceEvaluationResponse' :: Maybe Text
resourceEvaluationId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:StartResourceEvaluationResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A unique ResourceEvaluationId that is associated with a single
-- execution.
startResourceEvaluationResponse_resourceEvaluationId :: Lens.Lens' StartResourceEvaluationResponse (Prelude.Maybe Prelude.Text)
startResourceEvaluationResponse_resourceEvaluationId :: Lens' StartResourceEvaluationResponse (Maybe Text)
startResourceEvaluationResponse_resourceEvaluationId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartResourceEvaluationResponse' {Maybe Text
resourceEvaluationId :: Maybe Text
$sel:resourceEvaluationId:StartResourceEvaluationResponse' :: StartResourceEvaluationResponse -> Maybe Text
resourceEvaluationId} -> Maybe Text
resourceEvaluationId) (\s :: StartResourceEvaluationResponse
s@StartResourceEvaluationResponse' {} Maybe Text
a -> StartResourceEvaluationResponse
s {$sel:resourceEvaluationId:StartResourceEvaluationResponse' :: Maybe Text
resourceEvaluationId = Maybe Text
a} :: StartResourceEvaluationResponse)

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

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