{-# 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.FraudDetector.GetEventPredictionMetadata
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Gets details of the past fraud predictions for the specified event ID,
-- event type, detector ID, and detector version ID that was generated in
-- the specified time period.
module Amazonka.FraudDetector.GetEventPredictionMetadata
  ( -- * Creating a Request
    GetEventPredictionMetadata (..),
    newGetEventPredictionMetadata,

    -- * Request Lenses
    getEventPredictionMetadata_eventId,
    getEventPredictionMetadata_eventTypeName,
    getEventPredictionMetadata_detectorId,
    getEventPredictionMetadata_detectorVersionId,
    getEventPredictionMetadata_predictionTimestamp,

    -- * Destructuring the Response
    GetEventPredictionMetadataResponse (..),
    newGetEventPredictionMetadataResponse,

    -- * Response Lenses
    getEventPredictionMetadataResponse_detectorId,
    getEventPredictionMetadataResponse_detectorVersionId,
    getEventPredictionMetadataResponse_detectorVersionStatus,
    getEventPredictionMetadataResponse_entityId,
    getEventPredictionMetadataResponse_entityType,
    getEventPredictionMetadataResponse_evaluatedExternalModels,
    getEventPredictionMetadataResponse_evaluatedModelVersions,
    getEventPredictionMetadataResponse_eventId,
    getEventPredictionMetadataResponse_eventTimestamp,
    getEventPredictionMetadataResponse_eventTypeName,
    getEventPredictionMetadataResponse_eventVariables,
    getEventPredictionMetadataResponse_outcomes,
    getEventPredictionMetadataResponse_predictionTimestamp,
    getEventPredictionMetadataResponse_ruleExecutionMode,
    getEventPredictionMetadataResponse_rules,
    getEventPredictionMetadataResponse_httpStatus,
  )
where

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

-- | /See:/ 'newGetEventPredictionMetadata' smart constructor.
data GetEventPredictionMetadata = GetEventPredictionMetadata'
  { -- | The event ID.
    GetEventPredictionMetadata -> Text
eventId :: Prelude.Text,
    -- | The event type associated with the detector specified for the
    -- prediction.
    GetEventPredictionMetadata -> Text
eventTypeName :: Prelude.Text,
    -- | The detector ID.
    GetEventPredictionMetadata -> Text
detectorId :: Prelude.Text,
    -- | The detector version ID.
    GetEventPredictionMetadata -> Text
detectorVersionId :: Prelude.Text,
    -- | The timestamp that defines when the prediction was generated. The
    -- timestamp must be specified using ISO 8601 standard in UTC.
    --
    -- We recommend calling
    -- <https://docs.aws.amazon.com/frauddetector/latest/api/API_ListEventPredictions.html ListEventPredictions>
    -- first, and using the @predictionTimestamp@ value in the response to
    -- provide an accurate prediction timestamp value.
    GetEventPredictionMetadata -> Text
predictionTimestamp :: Prelude.Text
  }
  deriving (GetEventPredictionMetadata -> GetEventPredictionMetadata -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetEventPredictionMetadata -> GetEventPredictionMetadata -> Bool
$c/= :: GetEventPredictionMetadata -> GetEventPredictionMetadata -> Bool
== :: GetEventPredictionMetadata -> GetEventPredictionMetadata -> Bool
$c== :: GetEventPredictionMetadata -> GetEventPredictionMetadata -> Bool
Prelude.Eq, ReadPrec [GetEventPredictionMetadata]
ReadPrec GetEventPredictionMetadata
Int -> ReadS GetEventPredictionMetadata
ReadS [GetEventPredictionMetadata]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetEventPredictionMetadata]
$creadListPrec :: ReadPrec [GetEventPredictionMetadata]
readPrec :: ReadPrec GetEventPredictionMetadata
$creadPrec :: ReadPrec GetEventPredictionMetadata
readList :: ReadS [GetEventPredictionMetadata]
$creadList :: ReadS [GetEventPredictionMetadata]
readsPrec :: Int -> ReadS GetEventPredictionMetadata
$creadsPrec :: Int -> ReadS GetEventPredictionMetadata
Prelude.Read, Int -> GetEventPredictionMetadata -> ShowS
[GetEventPredictionMetadata] -> ShowS
GetEventPredictionMetadata -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetEventPredictionMetadata] -> ShowS
$cshowList :: [GetEventPredictionMetadata] -> ShowS
show :: GetEventPredictionMetadata -> String
$cshow :: GetEventPredictionMetadata -> String
showsPrec :: Int -> GetEventPredictionMetadata -> ShowS
$cshowsPrec :: Int -> GetEventPredictionMetadata -> ShowS
Prelude.Show, forall x.
Rep GetEventPredictionMetadata x -> GetEventPredictionMetadata
forall x.
GetEventPredictionMetadata -> Rep GetEventPredictionMetadata x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetEventPredictionMetadata x -> GetEventPredictionMetadata
$cfrom :: forall x.
GetEventPredictionMetadata -> Rep GetEventPredictionMetadata x
Prelude.Generic)

-- |
-- Create a value of 'GetEventPredictionMetadata' 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:
--
-- 'eventId', 'getEventPredictionMetadata_eventId' - The event ID.
--
-- 'eventTypeName', 'getEventPredictionMetadata_eventTypeName' - The event type associated with the detector specified for the
-- prediction.
--
-- 'detectorId', 'getEventPredictionMetadata_detectorId' - The detector ID.
--
-- 'detectorVersionId', 'getEventPredictionMetadata_detectorVersionId' - The detector version ID.
--
-- 'predictionTimestamp', 'getEventPredictionMetadata_predictionTimestamp' - The timestamp that defines when the prediction was generated. The
-- timestamp must be specified using ISO 8601 standard in UTC.
--
-- We recommend calling
-- <https://docs.aws.amazon.com/frauddetector/latest/api/API_ListEventPredictions.html ListEventPredictions>
-- first, and using the @predictionTimestamp@ value in the response to
-- provide an accurate prediction timestamp value.
newGetEventPredictionMetadata ::
  -- | 'eventId'
  Prelude.Text ->
  -- | 'eventTypeName'
  Prelude.Text ->
  -- | 'detectorId'
  Prelude.Text ->
  -- | 'detectorVersionId'
  Prelude.Text ->
  -- | 'predictionTimestamp'
  Prelude.Text ->
  GetEventPredictionMetadata
newGetEventPredictionMetadata :: Text -> Text -> Text -> Text -> Text -> GetEventPredictionMetadata
newGetEventPredictionMetadata
  Text
pEventId_
  Text
pEventTypeName_
  Text
pDetectorId_
  Text
pDetectorVersionId_
  Text
pPredictionTimestamp_ =
    GetEventPredictionMetadata'
      { $sel:eventId:GetEventPredictionMetadata' :: Text
eventId = Text
pEventId_,
        $sel:eventTypeName:GetEventPredictionMetadata' :: Text
eventTypeName = Text
pEventTypeName_,
        $sel:detectorId:GetEventPredictionMetadata' :: Text
detectorId = Text
pDetectorId_,
        $sel:detectorVersionId:GetEventPredictionMetadata' :: Text
detectorVersionId = Text
pDetectorVersionId_,
        $sel:predictionTimestamp:GetEventPredictionMetadata' :: Text
predictionTimestamp = Text
pPredictionTimestamp_
      }

-- | The event ID.
getEventPredictionMetadata_eventId :: Lens.Lens' GetEventPredictionMetadata Prelude.Text
getEventPredictionMetadata_eventId :: Lens' GetEventPredictionMetadata Text
getEventPredictionMetadata_eventId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadata' {Text
eventId :: Text
$sel:eventId:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
eventId} -> Text
eventId) (\s :: GetEventPredictionMetadata
s@GetEventPredictionMetadata' {} Text
a -> GetEventPredictionMetadata
s {$sel:eventId:GetEventPredictionMetadata' :: Text
eventId = Text
a} :: GetEventPredictionMetadata)

-- | The event type associated with the detector specified for the
-- prediction.
getEventPredictionMetadata_eventTypeName :: Lens.Lens' GetEventPredictionMetadata Prelude.Text
getEventPredictionMetadata_eventTypeName :: Lens' GetEventPredictionMetadata Text
getEventPredictionMetadata_eventTypeName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadata' {Text
eventTypeName :: Text
$sel:eventTypeName:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
eventTypeName} -> Text
eventTypeName) (\s :: GetEventPredictionMetadata
s@GetEventPredictionMetadata' {} Text
a -> GetEventPredictionMetadata
s {$sel:eventTypeName:GetEventPredictionMetadata' :: Text
eventTypeName = Text
a} :: GetEventPredictionMetadata)

-- | The detector ID.
getEventPredictionMetadata_detectorId :: Lens.Lens' GetEventPredictionMetadata Prelude.Text
getEventPredictionMetadata_detectorId :: Lens' GetEventPredictionMetadata Text
getEventPredictionMetadata_detectorId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadata' {Text
detectorId :: Text
$sel:detectorId:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
detectorId} -> Text
detectorId) (\s :: GetEventPredictionMetadata
s@GetEventPredictionMetadata' {} Text
a -> GetEventPredictionMetadata
s {$sel:detectorId:GetEventPredictionMetadata' :: Text
detectorId = Text
a} :: GetEventPredictionMetadata)

-- | The detector version ID.
getEventPredictionMetadata_detectorVersionId :: Lens.Lens' GetEventPredictionMetadata Prelude.Text
getEventPredictionMetadata_detectorVersionId :: Lens' GetEventPredictionMetadata Text
getEventPredictionMetadata_detectorVersionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadata' {Text
detectorVersionId :: Text
$sel:detectorVersionId:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
detectorVersionId} -> Text
detectorVersionId) (\s :: GetEventPredictionMetadata
s@GetEventPredictionMetadata' {} Text
a -> GetEventPredictionMetadata
s {$sel:detectorVersionId:GetEventPredictionMetadata' :: Text
detectorVersionId = Text
a} :: GetEventPredictionMetadata)

-- | The timestamp that defines when the prediction was generated. The
-- timestamp must be specified using ISO 8601 standard in UTC.
--
-- We recommend calling
-- <https://docs.aws.amazon.com/frauddetector/latest/api/API_ListEventPredictions.html ListEventPredictions>
-- first, and using the @predictionTimestamp@ value in the response to
-- provide an accurate prediction timestamp value.
getEventPredictionMetadata_predictionTimestamp :: Lens.Lens' GetEventPredictionMetadata Prelude.Text
getEventPredictionMetadata_predictionTimestamp :: Lens' GetEventPredictionMetadata Text
getEventPredictionMetadata_predictionTimestamp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadata' {Text
predictionTimestamp :: Text
$sel:predictionTimestamp:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
predictionTimestamp} -> Text
predictionTimestamp) (\s :: GetEventPredictionMetadata
s@GetEventPredictionMetadata' {} Text
a -> GetEventPredictionMetadata
s {$sel:predictionTimestamp:GetEventPredictionMetadata' :: Text
predictionTimestamp = Text
a} :: GetEventPredictionMetadata)

instance Core.AWSRequest GetEventPredictionMetadata where
  type
    AWSResponse GetEventPredictionMetadata =
      GetEventPredictionMetadataResponse
  request :: (Service -> Service)
-> GetEventPredictionMetadata -> Request GetEventPredictionMetadata
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 GetEventPredictionMetadata
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetEventPredictionMetadata)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe [EvaluatedExternalModel]
-> Maybe [EvaluatedModelVersion]
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe [EventVariableSummary]
-> Maybe [Text]
-> Maybe Text
-> Maybe RuleExecutionMode
-> Maybe [EvaluatedRule]
-> Int
-> GetEventPredictionMetadataResponse
GetEventPredictionMetadataResponse'
            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
"detectorId")
            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
"detectorVersionId")
            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
"detectorVersionStatus")
            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
"entityId")
            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
"entityType")
            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
"evaluatedExternalModels"
                            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.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"evaluatedModelVersions"
                            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.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"eventId")
            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
"eventTimestamp")
            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
"eventTypeName")
            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
"eventVariables" 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.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"outcomes" 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.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"predictionTimestamp")
            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
"ruleExecutionMode")
            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
"rules" 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 GetEventPredictionMetadata where
  hashWithSalt :: Int -> GetEventPredictionMetadata -> Int
hashWithSalt Int
_salt GetEventPredictionMetadata' {Text
predictionTimestamp :: Text
detectorVersionId :: Text
detectorId :: Text
eventTypeName :: Text
eventId :: Text
$sel:predictionTimestamp:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
$sel:detectorVersionId:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
$sel:detectorId:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
$sel:eventTypeName:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
$sel:eventId:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
eventId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
eventTypeName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
detectorId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
detectorVersionId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
predictionTimestamp

instance Prelude.NFData GetEventPredictionMetadata where
  rnf :: GetEventPredictionMetadata -> ()
rnf GetEventPredictionMetadata' {Text
predictionTimestamp :: Text
detectorVersionId :: Text
detectorId :: Text
eventTypeName :: Text
eventId :: Text
$sel:predictionTimestamp:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
$sel:detectorVersionId:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
$sel:detectorId:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
$sel:eventTypeName:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
$sel:eventId:GetEventPredictionMetadata' :: GetEventPredictionMetadata -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
eventId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
eventTypeName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
detectorId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
detectorVersionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
predictionTimestamp

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

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

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

-- | /See:/ 'newGetEventPredictionMetadataResponse' smart constructor.
data GetEventPredictionMetadataResponse = GetEventPredictionMetadataResponse'
  { -- | The detector ID.
    GetEventPredictionMetadataResponse -> Maybe Text
detectorId :: Prelude.Maybe Prelude.Text,
    -- | The detector version ID.
    GetEventPredictionMetadataResponse -> Maybe Text
detectorVersionId :: Prelude.Maybe Prelude.Text,
    -- | The status of the detector version.
    GetEventPredictionMetadataResponse -> Maybe Text
detectorVersionStatus :: Prelude.Maybe Prelude.Text,
    -- | The entity ID.
    GetEventPredictionMetadataResponse -> Maybe Text
entityId :: Prelude.Maybe Prelude.Text,
    -- | The entity type.
    GetEventPredictionMetadataResponse -> Maybe Text
entityType :: Prelude.Maybe Prelude.Text,
    -- | External (Amazon SageMaker) models that were evaluated for generating
    -- predictions.
    GetEventPredictionMetadataResponse
-> Maybe [EvaluatedExternalModel]
evaluatedExternalModels :: Prelude.Maybe [EvaluatedExternalModel],
    -- | Model versions that were evaluated for generating predictions.
    GetEventPredictionMetadataResponse -> Maybe [EvaluatedModelVersion]
evaluatedModelVersions :: Prelude.Maybe [EvaluatedModelVersion],
    -- | The event ID.
    GetEventPredictionMetadataResponse -> Maybe Text
eventId :: Prelude.Maybe Prelude.Text,
    -- | The timestamp for when the prediction was generated for the associated
    -- event ID.
    GetEventPredictionMetadataResponse -> Maybe Text
eventTimestamp :: Prelude.Maybe Prelude.Text,
    -- | The event type associated with the detector specified for this
    -- prediction.
    GetEventPredictionMetadataResponse -> Maybe Text
eventTypeName :: Prelude.Maybe Prelude.Text,
    -- | A list of event variables that influenced the prediction scores.
    GetEventPredictionMetadataResponse -> Maybe [EventVariableSummary]
eventVariables :: Prelude.Maybe [EventVariableSummary],
    -- | The outcomes of the matched rule, based on the rule execution mode.
    GetEventPredictionMetadataResponse -> Maybe [Text]
outcomes :: Prelude.Maybe [Prelude.Text],
    -- | The timestamp that defines when the prediction was generated.
    GetEventPredictionMetadataResponse -> Maybe Text
predictionTimestamp :: Prelude.Maybe Prelude.Text,
    -- | The execution mode of the rule used for evaluating variable values.
    GetEventPredictionMetadataResponse -> Maybe RuleExecutionMode
ruleExecutionMode :: Prelude.Maybe RuleExecutionMode,
    -- | List of rules associated with the detector version that were used for
    -- evaluating variable values.
    GetEventPredictionMetadataResponse -> Maybe [EvaluatedRule]
rules :: Prelude.Maybe [EvaluatedRule],
    -- | The response's http status code.
    GetEventPredictionMetadataResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetEventPredictionMetadataResponse
-> GetEventPredictionMetadataResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetEventPredictionMetadataResponse
-> GetEventPredictionMetadataResponse -> Bool
$c/= :: GetEventPredictionMetadataResponse
-> GetEventPredictionMetadataResponse -> Bool
== :: GetEventPredictionMetadataResponse
-> GetEventPredictionMetadataResponse -> Bool
$c== :: GetEventPredictionMetadataResponse
-> GetEventPredictionMetadataResponse -> Bool
Prelude.Eq, Int -> GetEventPredictionMetadataResponse -> ShowS
[GetEventPredictionMetadataResponse] -> ShowS
GetEventPredictionMetadataResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetEventPredictionMetadataResponse] -> ShowS
$cshowList :: [GetEventPredictionMetadataResponse] -> ShowS
show :: GetEventPredictionMetadataResponse -> String
$cshow :: GetEventPredictionMetadataResponse -> String
showsPrec :: Int -> GetEventPredictionMetadataResponse -> ShowS
$cshowsPrec :: Int -> GetEventPredictionMetadataResponse -> ShowS
Prelude.Show, forall x.
Rep GetEventPredictionMetadataResponse x
-> GetEventPredictionMetadataResponse
forall x.
GetEventPredictionMetadataResponse
-> Rep GetEventPredictionMetadataResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetEventPredictionMetadataResponse x
-> GetEventPredictionMetadataResponse
$cfrom :: forall x.
GetEventPredictionMetadataResponse
-> Rep GetEventPredictionMetadataResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetEventPredictionMetadataResponse' 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:
--
-- 'detectorId', 'getEventPredictionMetadataResponse_detectorId' - The detector ID.
--
-- 'detectorVersionId', 'getEventPredictionMetadataResponse_detectorVersionId' - The detector version ID.
--
-- 'detectorVersionStatus', 'getEventPredictionMetadataResponse_detectorVersionStatus' - The status of the detector version.
--
-- 'entityId', 'getEventPredictionMetadataResponse_entityId' - The entity ID.
--
-- 'entityType', 'getEventPredictionMetadataResponse_entityType' - The entity type.
--
-- 'evaluatedExternalModels', 'getEventPredictionMetadataResponse_evaluatedExternalModels' - External (Amazon SageMaker) models that were evaluated for generating
-- predictions.
--
-- 'evaluatedModelVersions', 'getEventPredictionMetadataResponse_evaluatedModelVersions' - Model versions that were evaluated for generating predictions.
--
-- 'eventId', 'getEventPredictionMetadataResponse_eventId' - The event ID.
--
-- 'eventTimestamp', 'getEventPredictionMetadataResponse_eventTimestamp' - The timestamp for when the prediction was generated for the associated
-- event ID.
--
-- 'eventTypeName', 'getEventPredictionMetadataResponse_eventTypeName' - The event type associated with the detector specified for this
-- prediction.
--
-- 'eventVariables', 'getEventPredictionMetadataResponse_eventVariables' - A list of event variables that influenced the prediction scores.
--
-- 'outcomes', 'getEventPredictionMetadataResponse_outcomes' - The outcomes of the matched rule, based on the rule execution mode.
--
-- 'predictionTimestamp', 'getEventPredictionMetadataResponse_predictionTimestamp' - The timestamp that defines when the prediction was generated.
--
-- 'ruleExecutionMode', 'getEventPredictionMetadataResponse_ruleExecutionMode' - The execution mode of the rule used for evaluating variable values.
--
-- 'rules', 'getEventPredictionMetadataResponse_rules' - List of rules associated with the detector version that were used for
-- evaluating variable values.
--
-- 'httpStatus', 'getEventPredictionMetadataResponse_httpStatus' - The response's http status code.
newGetEventPredictionMetadataResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetEventPredictionMetadataResponse
newGetEventPredictionMetadataResponse :: Int -> GetEventPredictionMetadataResponse
newGetEventPredictionMetadataResponse Int
pHttpStatus_ =
  GetEventPredictionMetadataResponse'
    { $sel:detectorId:GetEventPredictionMetadataResponse' :: Maybe Text
detectorId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:detectorVersionId:GetEventPredictionMetadataResponse' :: Maybe Text
detectorVersionId = forall a. Maybe a
Prelude.Nothing,
      $sel:detectorVersionStatus:GetEventPredictionMetadataResponse' :: Maybe Text
detectorVersionStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:entityId:GetEventPredictionMetadataResponse' :: Maybe Text
entityId = forall a. Maybe a
Prelude.Nothing,
      $sel:entityType:GetEventPredictionMetadataResponse' :: Maybe Text
entityType = forall a. Maybe a
Prelude.Nothing,
      $sel:evaluatedExternalModels:GetEventPredictionMetadataResponse' :: Maybe [EvaluatedExternalModel]
evaluatedExternalModels =
        forall a. Maybe a
Prelude.Nothing,
      $sel:evaluatedModelVersions:GetEventPredictionMetadataResponse' :: Maybe [EvaluatedModelVersion]
evaluatedModelVersions =
        forall a. Maybe a
Prelude.Nothing,
      $sel:eventId:GetEventPredictionMetadataResponse' :: Maybe Text
eventId = forall a. Maybe a
Prelude.Nothing,
      $sel:eventTimestamp:GetEventPredictionMetadataResponse' :: Maybe Text
eventTimestamp = forall a. Maybe a
Prelude.Nothing,
      $sel:eventTypeName:GetEventPredictionMetadataResponse' :: Maybe Text
eventTypeName = forall a. Maybe a
Prelude.Nothing,
      $sel:eventVariables:GetEventPredictionMetadataResponse' :: Maybe [EventVariableSummary]
eventVariables = forall a. Maybe a
Prelude.Nothing,
      $sel:outcomes:GetEventPredictionMetadataResponse' :: Maybe [Text]
outcomes = forall a. Maybe a
Prelude.Nothing,
      $sel:predictionTimestamp:GetEventPredictionMetadataResponse' :: Maybe Text
predictionTimestamp = forall a. Maybe a
Prelude.Nothing,
      $sel:ruleExecutionMode:GetEventPredictionMetadataResponse' :: Maybe RuleExecutionMode
ruleExecutionMode = forall a. Maybe a
Prelude.Nothing,
      $sel:rules:GetEventPredictionMetadataResponse' :: Maybe [EvaluatedRule]
rules = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetEventPredictionMetadataResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The detector ID.
getEventPredictionMetadataResponse_detectorId :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe Prelude.Text)
getEventPredictionMetadataResponse_detectorId :: Lens' GetEventPredictionMetadataResponse (Maybe Text)
getEventPredictionMetadataResponse_detectorId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe Text
detectorId :: Maybe Text
$sel:detectorId:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
detectorId} -> Maybe Text
detectorId) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe Text
a -> GetEventPredictionMetadataResponse
s {$sel:detectorId:GetEventPredictionMetadataResponse' :: Maybe Text
detectorId = Maybe Text
a} :: GetEventPredictionMetadataResponse)

-- | The detector version ID.
getEventPredictionMetadataResponse_detectorVersionId :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe Prelude.Text)
getEventPredictionMetadataResponse_detectorVersionId :: Lens' GetEventPredictionMetadataResponse (Maybe Text)
getEventPredictionMetadataResponse_detectorVersionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe Text
detectorVersionId :: Maybe Text
$sel:detectorVersionId:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
detectorVersionId} -> Maybe Text
detectorVersionId) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe Text
a -> GetEventPredictionMetadataResponse
s {$sel:detectorVersionId:GetEventPredictionMetadataResponse' :: Maybe Text
detectorVersionId = Maybe Text
a} :: GetEventPredictionMetadataResponse)

-- | The status of the detector version.
getEventPredictionMetadataResponse_detectorVersionStatus :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe Prelude.Text)
getEventPredictionMetadataResponse_detectorVersionStatus :: Lens' GetEventPredictionMetadataResponse (Maybe Text)
getEventPredictionMetadataResponse_detectorVersionStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe Text
detectorVersionStatus :: Maybe Text
$sel:detectorVersionStatus:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
detectorVersionStatus} -> Maybe Text
detectorVersionStatus) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe Text
a -> GetEventPredictionMetadataResponse
s {$sel:detectorVersionStatus:GetEventPredictionMetadataResponse' :: Maybe Text
detectorVersionStatus = Maybe Text
a} :: GetEventPredictionMetadataResponse)

-- | The entity ID.
getEventPredictionMetadataResponse_entityId :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe Prelude.Text)
getEventPredictionMetadataResponse_entityId :: Lens' GetEventPredictionMetadataResponse (Maybe Text)
getEventPredictionMetadataResponse_entityId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe Text
entityId :: Maybe Text
$sel:entityId:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
entityId} -> Maybe Text
entityId) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe Text
a -> GetEventPredictionMetadataResponse
s {$sel:entityId:GetEventPredictionMetadataResponse' :: Maybe Text
entityId = Maybe Text
a} :: GetEventPredictionMetadataResponse)

-- | The entity type.
getEventPredictionMetadataResponse_entityType :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe Prelude.Text)
getEventPredictionMetadataResponse_entityType :: Lens' GetEventPredictionMetadataResponse (Maybe Text)
getEventPredictionMetadataResponse_entityType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe Text
entityType :: Maybe Text
$sel:entityType:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
entityType} -> Maybe Text
entityType) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe Text
a -> GetEventPredictionMetadataResponse
s {$sel:entityType:GetEventPredictionMetadataResponse' :: Maybe Text
entityType = Maybe Text
a} :: GetEventPredictionMetadataResponse)

-- | External (Amazon SageMaker) models that were evaluated for generating
-- predictions.
getEventPredictionMetadataResponse_evaluatedExternalModels :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe [EvaluatedExternalModel])
getEventPredictionMetadataResponse_evaluatedExternalModels :: Lens'
  GetEventPredictionMetadataResponse (Maybe [EvaluatedExternalModel])
getEventPredictionMetadataResponse_evaluatedExternalModels = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe [EvaluatedExternalModel]
evaluatedExternalModels :: Maybe [EvaluatedExternalModel]
$sel:evaluatedExternalModels:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse
-> Maybe [EvaluatedExternalModel]
evaluatedExternalModels} -> Maybe [EvaluatedExternalModel]
evaluatedExternalModels) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe [EvaluatedExternalModel]
a -> GetEventPredictionMetadataResponse
s {$sel:evaluatedExternalModels:GetEventPredictionMetadataResponse' :: Maybe [EvaluatedExternalModel]
evaluatedExternalModels = Maybe [EvaluatedExternalModel]
a} :: GetEventPredictionMetadataResponse) 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

-- | Model versions that were evaluated for generating predictions.
getEventPredictionMetadataResponse_evaluatedModelVersions :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe [EvaluatedModelVersion])
getEventPredictionMetadataResponse_evaluatedModelVersions :: Lens'
  GetEventPredictionMetadataResponse (Maybe [EvaluatedModelVersion])
getEventPredictionMetadataResponse_evaluatedModelVersions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe [EvaluatedModelVersion]
evaluatedModelVersions :: Maybe [EvaluatedModelVersion]
$sel:evaluatedModelVersions:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe [EvaluatedModelVersion]
evaluatedModelVersions} -> Maybe [EvaluatedModelVersion]
evaluatedModelVersions) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe [EvaluatedModelVersion]
a -> GetEventPredictionMetadataResponse
s {$sel:evaluatedModelVersions:GetEventPredictionMetadataResponse' :: Maybe [EvaluatedModelVersion]
evaluatedModelVersions = Maybe [EvaluatedModelVersion]
a} :: GetEventPredictionMetadataResponse) 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 event ID.
getEventPredictionMetadataResponse_eventId :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe Prelude.Text)
getEventPredictionMetadataResponse_eventId :: Lens' GetEventPredictionMetadataResponse (Maybe Text)
getEventPredictionMetadataResponse_eventId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe Text
eventId :: Maybe Text
$sel:eventId:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
eventId} -> Maybe Text
eventId) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe Text
a -> GetEventPredictionMetadataResponse
s {$sel:eventId:GetEventPredictionMetadataResponse' :: Maybe Text
eventId = Maybe Text
a} :: GetEventPredictionMetadataResponse)

-- | The timestamp for when the prediction was generated for the associated
-- event ID.
getEventPredictionMetadataResponse_eventTimestamp :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe Prelude.Text)
getEventPredictionMetadataResponse_eventTimestamp :: Lens' GetEventPredictionMetadataResponse (Maybe Text)
getEventPredictionMetadataResponse_eventTimestamp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe Text
eventTimestamp :: Maybe Text
$sel:eventTimestamp:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
eventTimestamp} -> Maybe Text
eventTimestamp) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe Text
a -> GetEventPredictionMetadataResponse
s {$sel:eventTimestamp:GetEventPredictionMetadataResponse' :: Maybe Text
eventTimestamp = Maybe Text
a} :: GetEventPredictionMetadataResponse)

-- | The event type associated with the detector specified for this
-- prediction.
getEventPredictionMetadataResponse_eventTypeName :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe Prelude.Text)
getEventPredictionMetadataResponse_eventTypeName :: Lens' GetEventPredictionMetadataResponse (Maybe Text)
getEventPredictionMetadataResponse_eventTypeName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe Text
eventTypeName :: Maybe Text
$sel:eventTypeName:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
eventTypeName} -> Maybe Text
eventTypeName) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe Text
a -> GetEventPredictionMetadataResponse
s {$sel:eventTypeName:GetEventPredictionMetadataResponse' :: Maybe Text
eventTypeName = Maybe Text
a} :: GetEventPredictionMetadataResponse)

-- | A list of event variables that influenced the prediction scores.
getEventPredictionMetadataResponse_eventVariables :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe [EventVariableSummary])
getEventPredictionMetadataResponse_eventVariables :: Lens'
  GetEventPredictionMetadataResponse (Maybe [EventVariableSummary])
getEventPredictionMetadataResponse_eventVariables = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe [EventVariableSummary]
eventVariables :: Maybe [EventVariableSummary]
$sel:eventVariables:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe [EventVariableSummary]
eventVariables} -> Maybe [EventVariableSummary]
eventVariables) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe [EventVariableSummary]
a -> GetEventPredictionMetadataResponse
s {$sel:eventVariables:GetEventPredictionMetadataResponse' :: Maybe [EventVariableSummary]
eventVariables = Maybe [EventVariableSummary]
a} :: GetEventPredictionMetadataResponse) 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 outcomes of the matched rule, based on the rule execution mode.
getEventPredictionMetadataResponse_outcomes :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe [Prelude.Text])
getEventPredictionMetadataResponse_outcomes :: Lens' GetEventPredictionMetadataResponse (Maybe [Text])
getEventPredictionMetadataResponse_outcomes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe [Text]
outcomes :: Maybe [Text]
$sel:outcomes:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe [Text]
outcomes} -> Maybe [Text]
outcomes) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe [Text]
a -> GetEventPredictionMetadataResponse
s {$sel:outcomes:GetEventPredictionMetadataResponse' :: Maybe [Text]
outcomes = Maybe [Text]
a} :: GetEventPredictionMetadataResponse) 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 timestamp that defines when the prediction was generated.
getEventPredictionMetadataResponse_predictionTimestamp :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe Prelude.Text)
getEventPredictionMetadataResponse_predictionTimestamp :: Lens' GetEventPredictionMetadataResponse (Maybe Text)
getEventPredictionMetadataResponse_predictionTimestamp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe Text
predictionTimestamp :: Maybe Text
$sel:predictionTimestamp:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
predictionTimestamp} -> Maybe Text
predictionTimestamp) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe Text
a -> GetEventPredictionMetadataResponse
s {$sel:predictionTimestamp:GetEventPredictionMetadataResponse' :: Maybe Text
predictionTimestamp = Maybe Text
a} :: GetEventPredictionMetadataResponse)

-- | The execution mode of the rule used for evaluating variable values.
getEventPredictionMetadataResponse_ruleExecutionMode :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe RuleExecutionMode)
getEventPredictionMetadataResponse_ruleExecutionMode :: Lens' GetEventPredictionMetadataResponse (Maybe RuleExecutionMode)
getEventPredictionMetadataResponse_ruleExecutionMode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe RuleExecutionMode
ruleExecutionMode :: Maybe RuleExecutionMode
$sel:ruleExecutionMode:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe RuleExecutionMode
ruleExecutionMode} -> Maybe RuleExecutionMode
ruleExecutionMode) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe RuleExecutionMode
a -> GetEventPredictionMetadataResponse
s {$sel:ruleExecutionMode:GetEventPredictionMetadataResponse' :: Maybe RuleExecutionMode
ruleExecutionMode = Maybe RuleExecutionMode
a} :: GetEventPredictionMetadataResponse)

-- | List of rules associated with the detector version that were used for
-- evaluating variable values.
getEventPredictionMetadataResponse_rules :: Lens.Lens' GetEventPredictionMetadataResponse (Prelude.Maybe [EvaluatedRule])
getEventPredictionMetadataResponse_rules :: Lens' GetEventPredictionMetadataResponse (Maybe [EvaluatedRule])
getEventPredictionMetadataResponse_rules = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Maybe [EvaluatedRule]
rules :: Maybe [EvaluatedRule]
$sel:rules:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe [EvaluatedRule]
rules} -> Maybe [EvaluatedRule]
rules) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Maybe [EvaluatedRule]
a -> GetEventPredictionMetadataResponse
s {$sel:rules:GetEventPredictionMetadataResponse' :: Maybe [EvaluatedRule]
rules = Maybe [EvaluatedRule]
a} :: GetEventPredictionMetadataResponse) 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.
getEventPredictionMetadataResponse_httpStatus :: Lens.Lens' GetEventPredictionMetadataResponse Prelude.Int
getEventPredictionMetadataResponse_httpStatus :: Lens' GetEventPredictionMetadataResponse Int
getEventPredictionMetadataResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventPredictionMetadataResponse' {Int
httpStatus :: Int
$sel:httpStatus:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: GetEventPredictionMetadataResponse
s@GetEventPredictionMetadataResponse' {} Int
a -> GetEventPredictionMetadataResponse
s {$sel:httpStatus:GetEventPredictionMetadataResponse' :: Int
httpStatus = Int
a} :: GetEventPredictionMetadataResponse)

instance
  Prelude.NFData
    GetEventPredictionMetadataResponse
  where
  rnf :: GetEventPredictionMetadataResponse -> ()
rnf GetEventPredictionMetadataResponse' {Int
Maybe [Text]
Maybe [EvaluatedExternalModel]
Maybe [EvaluatedRule]
Maybe [EventVariableSummary]
Maybe [EvaluatedModelVersion]
Maybe Text
Maybe RuleExecutionMode
httpStatus :: Int
rules :: Maybe [EvaluatedRule]
ruleExecutionMode :: Maybe RuleExecutionMode
predictionTimestamp :: Maybe Text
outcomes :: Maybe [Text]
eventVariables :: Maybe [EventVariableSummary]
eventTypeName :: Maybe Text
eventTimestamp :: Maybe Text
eventId :: Maybe Text
evaluatedModelVersions :: Maybe [EvaluatedModelVersion]
evaluatedExternalModels :: Maybe [EvaluatedExternalModel]
entityType :: Maybe Text
entityId :: Maybe Text
detectorVersionStatus :: Maybe Text
detectorVersionId :: Maybe Text
detectorId :: Maybe Text
$sel:httpStatus:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Int
$sel:rules:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe [EvaluatedRule]
$sel:ruleExecutionMode:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe RuleExecutionMode
$sel:predictionTimestamp:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
$sel:outcomes:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe [Text]
$sel:eventVariables:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe [EventVariableSummary]
$sel:eventTypeName:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
$sel:eventTimestamp:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
$sel:eventId:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
$sel:evaluatedModelVersions:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe [EvaluatedModelVersion]
$sel:evaluatedExternalModels:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse
-> Maybe [EvaluatedExternalModel]
$sel:entityType:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
$sel:entityId:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
$sel:detectorVersionStatus:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
$sel:detectorVersionId:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
$sel:detectorId:GetEventPredictionMetadataResponse' :: GetEventPredictionMetadataResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
detectorId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
detectorVersionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
detectorVersionStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
entityId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
entityType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [EvaluatedExternalModel]
evaluatedExternalModels
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [EvaluatedModelVersion]
evaluatedModelVersions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
eventId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
eventTimestamp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
eventTypeName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [EventVariableSummary]
eventVariables
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
outcomes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
predictionTimestamp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RuleExecutionMode
ruleExecutionMode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [EvaluatedRule]
rules
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus