{-# 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.AppSync.EvaluateMappingTemplate
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Evaluates a given template and returns the response. The mapping
-- template can be a request or response template.
--
-- Request templates take the incoming request after a GraphQL operation is
-- parsed and convert it into a request configuration for the selected data
-- source operation. Response templates interpret responses from the data
-- source and map it to the shape of the GraphQL field output type.
--
-- Mapping templates are written in the Apache Velocity Template Language
-- (VTL).
module Amazonka.AppSync.EvaluateMappingTemplate
  ( -- * Creating a Request
    EvaluateMappingTemplate (..),
    newEvaluateMappingTemplate,

    -- * Request Lenses
    evaluateMappingTemplate_template,
    evaluateMappingTemplate_context,

    -- * Destructuring the Response
    EvaluateMappingTemplateResponse (..),
    newEvaluateMappingTemplateResponse,

    -- * Response Lenses
    evaluateMappingTemplateResponse_error,
    evaluateMappingTemplateResponse_evaluationResult,
    evaluateMappingTemplateResponse_logs,
    evaluateMappingTemplateResponse_httpStatus,
  )
where

import Amazonka.AppSync.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:/ 'newEvaluateMappingTemplate' smart constructor.
data EvaluateMappingTemplate = EvaluateMappingTemplate'
  { -- | The mapping template; this can be a request or response template. A
    -- @template@ is required for this action.
    EvaluateMappingTemplate -> Text
template :: Prelude.Text,
    -- | The map that holds all of the contextual information for your resolver
    -- invocation. A @context@ is required for this action.
    EvaluateMappingTemplate -> Text
context :: Prelude.Text
  }
  deriving (EvaluateMappingTemplate -> EvaluateMappingTemplate -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EvaluateMappingTemplate -> EvaluateMappingTemplate -> Bool
$c/= :: EvaluateMappingTemplate -> EvaluateMappingTemplate -> Bool
== :: EvaluateMappingTemplate -> EvaluateMappingTemplate -> Bool
$c== :: EvaluateMappingTemplate -> EvaluateMappingTemplate -> Bool
Prelude.Eq, ReadPrec [EvaluateMappingTemplate]
ReadPrec EvaluateMappingTemplate
Int -> ReadS EvaluateMappingTemplate
ReadS [EvaluateMappingTemplate]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EvaluateMappingTemplate]
$creadListPrec :: ReadPrec [EvaluateMappingTemplate]
readPrec :: ReadPrec EvaluateMappingTemplate
$creadPrec :: ReadPrec EvaluateMappingTemplate
readList :: ReadS [EvaluateMappingTemplate]
$creadList :: ReadS [EvaluateMappingTemplate]
readsPrec :: Int -> ReadS EvaluateMappingTemplate
$creadsPrec :: Int -> ReadS EvaluateMappingTemplate
Prelude.Read, Int -> EvaluateMappingTemplate -> ShowS
[EvaluateMappingTemplate] -> ShowS
EvaluateMappingTemplate -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EvaluateMappingTemplate] -> ShowS
$cshowList :: [EvaluateMappingTemplate] -> ShowS
show :: EvaluateMappingTemplate -> String
$cshow :: EvaluateMappingTemplate -> String
showsPrec :: Int -> EvaluateMappingTemplate -> ShowS
$cshowsPrec :: Int -> EvaluateMappingTemplate -> ShowS
Prelude.Show, forall x. Rep EvaluateMappingTemplate x -> EvaluateMappingTemplate
forall x. EvaluateMappingTemplate -> Rep EvaluateMappingTemplate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep EvaluateMappingTemplate x -> EvaluateMappingTemplate
$cfrom :: forall x. EvaluateMappingTemplate -> Rep EvaluateMappingTemplate x
Prelude.Generic)

-- |
-- Create a value of 'EvaluateMappingTemplate' 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:
--
-- 'template', 'evaluateMappingTemplate_template' - The mapping template; this can be a request or response template. A
-- @template@ is required for this action.
--
-- 'context', 'evaluateMappingTemplate_context' - The map that holds all of the contextual information for your resolver
-- invocation. A @context@ is required for this action.
newEvaluateMappingTemplate ::
  -- | 'template'
  Prelude.Text ->
  -- | 'context'
  Prelude.Text ->
  EvaluateMappingTemplate
newEvaluateMappingTemplate :: Text -> Text -> EvaluateMappingTemplate
newEvaluateMappingTemplate Text
pTemplate_ Text
pContext_ =
  EvaluateMappingTemplate'
    { $sel:template:EvaluateMappingTemplate' :: Text
template = Text
pTemplate_,
      $sel:context:EvaluateMappingTemplate' :: Text
context = Text
pContext_
    }

-- | The mapping template; this can be a request or response template. A
-- @template@ is required for this action.
evaluateMappingTemplate_template :: Lens.Lens' EvaluateMappingTemplate Prelude.Text
evaluateMappingTemplate_template :: Lens' EvaluateMappingTemplate Text
evaluateMappingTemplate_template = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EvaluateMappingTemplate' {Text
template :: Text
$sel:template:EvaluateMappingTemplate' :: EvaluateMappingTemplate -> Text
template} -> Text
template) (\s :: EvaluateMappingTemplate
s@EvaluateMappingTemplate' {} Text
a -> EvaluateMappingTemplate
s {$sel:template:EvaluateMappingTemplate' :: Text
template = Text
a} :: EvaluateMappingTemplate)

-- | The map that holds all of the contextual information for your resolver
-- invocation. A @context@ is required for this action.
evaluateMappingTemplate_context :: Lens.Lens' EvaluateMappingTemplate Prelude.Text
evaluateMappingTemplate_context :: Lens' EvaluateMappingTemplate Text
evaluateMappingTemplate_context = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EvaluateMappingTemplate' {Text
context :: Text
$sel:context:EvaluateMappingTemplate' :: EvaluateMappingTemplate -> Text
context} -> Text
context) (\s :: EvaluateMappingTemplate
s@EvaluateMappingTemplate' {} Text
a -> EvaluateMappingTemplate
s {$sel:context:EvaluateMappingTemplate' :: Text
context = Text
a} :: EvaluateMappingTemplate)

instance Core.AWSRequest EvaluateMappingTemplate where
  type
    AWSResponse EvaluateMappingTemplate =
      EvaluateMappingTemplateResponse
  request :: (Service -> Service)
-> EvaluateMappingTemplate -> Request EvaluateMappingTemplate
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 EvaluateMappingTemplate
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse EvaluateMappingTemplate)))
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 ErrorDetail
-> Maybe Text
-> Maybe [Text]
-> Int
-> EvaluateMappingTemplateResponse
EvaluateMappingTemplateResponse'
            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
"error")
            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
"evaluationResult")
            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
"logs" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            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 EvaluateMappingTemplate where
  hashWithSalt :: Int -> EvaluateMappingTemplate -> Int
hashWithSalt Int
_salt EvaluateMappingTemplate' {Text
context :: Text
template :: Text
$sel:context:EvaluateMappingTemplate' :: EvaluateMappingTemplate -> Text
$sel:template:EvaluateMappingTemplate' :: EvaluateMappingTemplate -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
template
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
context

instance Prelude.NFData EvaluateMappingTemplate where
  rnf :: EvaluateMappingTemplate -> ()
rnf EvaluateMappingTemplate' {Text
context :: Text
template :: Text
$sel:context:EvaluateMappingTemplate' :: EvaluateMappingTemplate -> Text
$sel:template:EvaluateMappingTemplate' :: EvaluateMappingTemplate -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
template
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
context

instance Data.ToHeaders EvaluateMappingTemplate where
  toHeaders :: EvaluateMappingTemplate -> 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 EvaluateMappingTemplate where
  toJSON :: EvaluateMappingTemplate -> Value
toJSON EvaluateMappingTemplate' {Text
context :: Text
template :: Text
$sel:context:EvaluateMappingTemplate' :: EvaluateMappingTemplate -> Text
$sel:template:EvaluateMappingTemplate' :: EvaluateMappingTemplate -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"template" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
template),
            forall a. a -> Maybe a
Prelude.Just (Key
"context" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
context)
          ]
      )

instance Data.ToPath EvaluateMappingTemplate where
  toPath :: EvaluateMappingTemplate -> ByteString
toPath =
    forall a b. a -> b -> a
Prelude.const ByteString
"/v1/dataplane-evaluatetemplate"

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

-- | /See:/ 'newEvaluateMappingTemplateResponse' smart constructor.
data EvaluateMappingTemplateResponse = EvaluateMappingTemplateResponse'
  { -- | The @ErrorDetail@ object.
    EvaluateMappingTemplateResponse -> Maybe ErrorDetail
error :: Prelude.Maybe ErrorDetail,
    -- | The mapping template; this can be a request or response template.
    EvaluateMappingTemplateResponse -> Maybe Text
evaluationResult :: Prelude.Maybe Prelude.Text,
    -- | A list of logs that were generated by calls to @util.log.info@ and
    -- @util.log.error@ in the evaluated code.
    EvaluateMappingTemplateResponse -> Maybe [Text]
logs :: Prelude.Maybe [Prelude.Text],
    -- | The response's http status code.
    EvaluateMappingTemplateResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (EvaluateMappingTemplateResponse
-> EvaluateMappingTemplateResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EvaluateMappingTemplateResponse
-> EvaluateMappingTemplateResponse -> Bool
$c/= :: EvaluateMappingTemplateResponse
-> EvaluateMappingTemplateResponse -> Bool
== :: EvaluateMappingTemplateResponse
-> EvaluateMappingTemplateResponse -> Bool
$c== :: EvaluateMappingTemplateResponse
-> EvaluateMappingTemplateResponse -> Bool
Prelude.Eq, ReadPrec [EvaluateMappingTemplateResponse]
ReadPrec EvaluateMappingTemplateResponse
Int -> ReadS EvaluateMappingTemplateResponse
ReadS [EvaluateMappingTemplateResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EvaluateMappingTemplateResponse]
$creadListPrec :: ReadPrec [EvaluateMappingTemplateResponse]
readPrec :: ReadPrec EvaluateMappingTemplateResponse
$creadPrec :: ReadPrec EvaluateMappingTemplateResponse
readList :: ReadS [EvaluateMappingTemplateResponse]
$creadList :: ReadS [EvaluateMappingTemplateResponse]
readsPrec :: Int -> ReadS EvaluateMappingTemplateResponse
$creadsPrec :: Int -> ReadS EvaluateMappingTemplateResponse
Prelude.Read, Int -> EvaluateMappingTemplateResponse -> ShowS
[EvaluateMappingTemplateResponse] -> ShowS
EvaluateMappingTemplateResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EvaluateMappingTemplateResponse] -> ShowS
$cshowList :: [EvaluateMappingTemplateResponse] -> ShowS
show :: EvaluateMappingTemplateResponse -> String
$cshow :: EvaluateMappingTemplateResponse -> String
showsPrec :: Int -> EvaluateMappingTemplateResponse -> ShowS
$cshowsPrec :: Int -> EvaluateMappingTemplateResponse -> ShowS
Prelude.Show, forall x.
Rep EvaluateMappingTemplateResponse x
-> EvaluateMappingTemplateResponse
forall x.
EvaluateMappingTemplateResponse
-> Rep EvaluateMappingTemplateResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep EvaluateMappingTemplateResponse x
-> EvaluateMappingTemplateResponse
$cfrom :: forall x.
EvaluateMappingTemplateResponse
-> Rep EvaluateMappingTemplateResponse x
Prelude.Generic)

-- |
-- Create a value of 'EvaluateMappingTemplateResponse' 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:
--
-- 'error', 'evaluateMappingTemplateResponse_error' - The @ErrorDetail@ object.
--
-- 'evaluationResult', 'evaluateMappingTemplateResponse_evaluationResult' - The mapping template; this can be a request or response template.
--
-- 'logs', 'evaluateMappingTemplateResponse_logs' - A list of logs that were generated by calls to @util.log.info@ and
-- @util.log.error@ in the evaluated code.
--
-- 'httpStatus', 'evaluateMappingTemplateResponse_httpStatus' - The response's http status code.
newEvaluateMappingTemplateResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  EvaluateMappingTemplateResponse
newEvaluateMappingTemplateResponse :: Int -> EvaluateMappingTemplateResponse
newEvaluateMappingTemplateResponse Int
pHttpStatus_ =
  EvaluateMappingTemplateResponse'
    { $sel:error:EvaluateMappingTemplateResponse' :: Maybe ErrorDetail
error =
        forall a. Maybe a
Prelude.Nothing,
      $sel:evaluationResult:EvaluateMappingTemplateResponse' :: Maybe Text
evaluationResult = forall a. Maybe a
Prelude.Nothing,
      $sel:logs:EvaluateMappingTemplateResponse' :: Maybe [Text]
logs = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:EvaluateMappingTemplateResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The @ErrorDetail@ object.
evaluateMappingTemplateResponse_error :: Lens.Lens' EvaluateMappingTemplateResponse (Prelude.Maybe ErrorDetail)
evaluateMappingTemplateResponse_error :: Lens' EvaluateMappingTemplateResponse (Maybe ErrorDetail)
evaluateMappingTemplateResponse_error = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EvaluateMappingTemplateResponse' {Maybe ErrorDetail
error :: Maybe ErrorDetail
$sel:error:EvaluateMappingTemplateResponse' :: EvaluateMappingTemplateResponse -> Maybe ErrorDetail
error} -> Maybe ErrorDetail
error) (\s :: EvaluateMappingTemplateResponse
s@EvaluateMappingTemplateResponse' {} Maybe ErrorDetail
a -> EvaluateMappingTemplateResponse
s {$sel:error:EvaluateMappingTemplateResponse' :: Maybe ErrorDetail
error = Maybe ErrorDetail
a} :: EvaluateMappingTemplateResponse)

-- | The mapping template; this can be a request or response template.
evaluateMappingTemplateResponse_evaluationResult :: Lens.Lens' EvaluateMappingTemplateResponse (Prelude.Maybe Prelude.Text)
evaluateMappingTemplateResponse_evaluationResult :: Lens' EvaluateMappingTemplateResponse (Maybe Text)
evaluateMappingTemplateResponse_evaluationResult = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EvaluateMappingTemplateResponse' {Maybe Text
evaluationResult :: Maybe Text
$sel:evaluationResult:EvaluateMappingTemplateResponse' :: EvaluateMappingTemplateResponse -> Maybe Text
evaluationResult} -> Maybe Text
evaluationResult) (\s :: EvaluateMappingTemplateResponse
s@EvaluateMappingTemplateResponse' {} Maybe Text
a -> EvaluateMappingTemplateResponse
s {$sel:evaluationResult:EvaluateMappingTemplateResponse' :: Maybe Text
evaluationResult = Maybe Text
a} :: EvaluateMappingTemplateResponse)

-- | A list of logs that were generated by calls to @util.log.info@ and
-- @util.log.error@ in the evaluated code.
evaluateMappingTemplateResponse_logs :: Lens.Lens' EvaluateMappingTemplateResponse (Prelude.Maybe [Prelude.Text])
evaluateMappingTemplateResponse_logs :: Lens' EvaluateMappingTemplateResponse (Maybe [Text])
evaluateMappingTemplateResponse_logs = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EvaluateMappingTemplateResponse' {Maybe [Text]
logs :: Maybe [Text]
$sel:logs:EvaluateMappingTemplateResponse' :: EvaluateMappingTemplateResponse -> Maybe [Text]
logs} -> Maybe [Text]
logs) (\s :: EvaluateMappingTemplateResponse
s@EvaluateMappingTemplateResponse' {} Maybe [Text]
a -> EvaluateMappingTemplateResponse
s {$sel:logs:EvaluateMappingTemplateResponse' :: Maybe [Text]
logs = Maybe [Text]
a} :: EvaluateMappingTemplateResponse) 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 response's http status code.
evaluateMappingTemplateResponse_httpStatus :: Lens.Lens' EvaluateMappingTemplateResponse Prelude.Int
evaluateMappingTemplateResponse_httpStatus :: Lens' EvaluateMappingTemplateResponse Int
evaluateMappingTemplateResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EvaluateMappingTemplateResponse' {Int
httpStatus :: Int
$sel:httpStatus:EvaluateMappingTemplateResponse' :: EvaluateMappingTemplateResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: EvaluateMappingTemplateResponse
s@EvaluateMappingTemplateResponse' {} Int
a -> EvaluateMappingTemplateResponse
s {$sel:httpStatus:EvaluateMappingTemplateResponse' :: Int
httpStatus = Int
a} :: EvaluateMappingTemplateResponse)

instance
  Prelude.NFData
    EvaluateMappingTemplateResponse
  where
  rnf :: EvaluateMappingTemplateResponse -> ()
rnf EvaluateMappingTemplateResponse' {Int
Maybe [Text]
Maybe Text
Maybe ErrorDetail
httpStatus :: Int
logs :: Maybe [Text]
evaluationResult :: Maybe Text
error :: Maybe ErrorDetail
$sel:httpStatus:EvaluateMappingTemplateResponse' :: EvaluateMappingTemplateResponse -> Int
$sel:logs:EvaluateMappingTemplateResponse' :: EvaluateMappingTemplateResponse -> Maybe [Text]
$sel:evaluationResult:EvaluateMappingTemplateResponse' :: EvaluateMappingTemplateResponse -> Maybe Text
$sel:error:EvaluateMappingTemplateResponse' :: EvaluateMappingTemplateResponse -> Maybe ErrorDetail
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe ErrorDetail
error
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
evaluationResult
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
logs
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus