{-# 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.CreateBatchPredictionJob
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a batch prediction job.
module Amazonka.FraudDetector.CreateBatchPredictionJob
  ( -- * Creating a Request
    CreateBatchPredictionJob (..),
    newCreateBatchPredictionJob,

    -- * Request Lenses
    createBatchPredictionJob_detectorVersion,
    createBatchPredictionJob_tags,
    createBatchPredictionJob_jobId,
    createBatchPredictionJob_inputPath,
    createBatchPredictionJob_outputPath,
    createBatchPredictionJob_eventTypeName,
    createBatchPredictionJob_detectorName,
    createBatchPredictionJob_iamRoleArn,

    -- * Destructuring the Response
    CreateBatchPredictionJobResponse (..),
    newCreateBatchPredictionJobResponse,

    -- * Response Lenses
    createBatchPredictionJobResponse_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:/ 'newCreateBatchPredictionJob' smart constructor.
data CreateBatchPredictionJob = CreateBatchPredictionJob'
  { -- | The detector version.
    CreateBatchPredictionJob -> Maybe Text
detectorVersion :: Prelude.Maybe Prelude.Text,
    -- | A collection of key and value pairs.
    CreateBatchPredictionJob -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The ID of the batch prediction job.
    CreateBatchPredictionJob -> Text
jobId :: Prelude.Text,
    -- | The Amazon S3 location of your training file.
    CreateBatchPredictionJob -> Text
inputPath :: Prelude.Text,
    -- | The Amazon S3 location of your output file.
    CreateBatchPredictionJob -> Text
outputPath :: Prelude.Text,
    -- | The name of the event type.
    CreateBatchPredictionJob -> Text
eventTypeName :: Prelude.Text,
    -- | The name of the detector.
    CreateBatchPredictionJob -> Text
detectorName :: Prelude.Text,
    -- | The ARN of the IAM role to use for this job request.
    --
    -- The IAM Role must have read permissions to your input S3 bucket and
    -- write permissions to your output S3 bucket. For more information about
    -- bucket permissions, see
    -- <https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-policies-s3.html User policy examples>
    -- in the /Amazon S3 User Guide/.
    CreateBatchPredictionJob -> Text
iamRoleArn :: Prelude.Text
  }
  deriving (CreateBatchPredictionJob -> CreateBatchPredictionJob -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateBatchPredictionJob -> CreateBatchPredictionJob -> Bool
$c/= :: CreateBatchPredictionJob -> CreateBatchPredictionJob -> Bool
== :: CreateBatchPredictionJob -> CreateBatchPredictionJob -> Bool
$c== :: CreateBatchPredictionJob -> CreateBatchPredictionJob -> Bool
Prelude.Eq, ReadPrec [CreateBatchPredictionJob]
ReadPrec CreateBatchPredictionJob
Int -> ReadS CreateBatchPredictionJob
ReadS [CreateBatchPredictionJob]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateBatchPredictionJob]
$creadListPrec :: ReadPrec [CreateBatchPredictionJob]
readPrec :: ReadPrec CreateBatchPredictionJob
$creadPrec :: ReadPrec CreateBatchPredictionJob
readList :: ReadS [CreateBatchPredictionJob]
$creadList :: ReadS [CreateBatchPredictionJob]
readsPrec :: Int -> ReadS CreateBatchPredictionJob
$creadsPrec :: Int -> ReadS CreateBatchPredictionJob
Prelude.Read, Int -> CreateBatchPredictionJob -> ShowS
[CreateBatchPredictionJob] -> ShowS
CreateBatchPredictionJob -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateBatchPredictionJob] -> ShowS
$cshowList :: [CreateBatchPredictionJob] -> ShowS
show :: CreateBatchPredictionJob -> String
$cshow :: CreateBatchPredictionJob -> String
showsPrec :: Int -> CreateBatchPredictionJob -> ShowS
$cshowsPrec :: Int -> CreateBatchPredictionJob -> ShowS
Prelude.Show, forall x.
Rep CreateBatchPredictionJob x -> CreateBatchPredictionJob
forall x.
CreateBatchPredictionJob -> Rep CreateBatchPredictionJob x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateBatchPredictionJob x -> CreateBatchPredictionJob
$cfrom :: forall x.
CreateBatchPredictionJob -> Rep CreateBatchPredictionJob x
Prelude.Generic)

-- |
-- Create a value of 'CreateBatchPredictionJob' 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:
--
-- 'detectorVersion', 'createBatchPredictionJob_detectorVersion' - The detector version.
--
-- 'tags', 'createBatchPredictionJob_tags' - A collection of key and value pairs.
--
-- 'jobId', 'createBatchPredictionJob_jobId' - The ID of the batch prediction job.
--
-- 'inputPath', 'createBatchPredictionJob_inputPath' - The Amazon S3 location of your training file.
--
-- 'outputPath', 'createBatchPredictionJob_outputPath' - The Amazon S3 location of your output file.
--
-- 'eventTypeName', 'createBatchPredictionJob_eventTypeName' - The name of the event type.
--
-- 'detectorName', 'createBatchPredictionJob_detectorName' - The name of the detector.
--
-- 'iamRoleArn', 'createBatchPredictionJob_iamRoleArn' - The ARN of the IAM role to use for this job request.
--
-- The IAM Role must have read permissions to your input S3 bucket and
-- write permissions to your output S3 bucket. For more information about
-- bucket permissions, see
-- <https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-policies-s3.html User policy examples>
-- in the /Amazon S3 User Guide/.
newCreateBatchPredictionJob ::
  -- | 'jobId'
  Prelude.Text ->
  -- | 'inputPath'
  Prelude.Text ->
  -- | 'outputPath'
  Prelude.Text ->
  -- | 'eventTypeName'
  Prelude.Text ->
  -- | 'detectorName'
  Prelude.Text ->
  -- | 'iamRoleArn'
  Prelude.Text ->
  CreateBatchPredictionJob
newCreateBatchPredictionJob :: Text
-> Text -> Text -> Text -> Text -> Text -> CreateBatchPredictionJob
newCreateBatchPredictionJob
  Text
pJobId_
  Text
pInputPath_
  Text
pOutputPath_
  Text
pEventTypeName_
  Text
pDetectorName_
  Text
pIamRoleArn_ =
    CreateBatchPredictionJob'
      { $sel:detectorVersion:CreateBatchPredictionJob' :: Maybe Text
detectorVersion =
          forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateBatchPredictionJob' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:jobId:CreateBatchPredictionJob' :: Text
jobId = Text
pJobId_,
        $sel:inputPath:CreateBatchPredictionJob' :: Text
inputPath = Text
pInputPath_,
        $sel:outputPath:CreateBatchPredictionJob' :: Text
outputPath = Text
pOutputPath_,
        $sel:eventTypeName:CreateBatchPredictionJob' :: Text
eventTypeName = Text
pEventTypeName_,
        $sel:detectorName:CreateBatchPredictionJob' :: Text
detectorName = Text
pDetectorName_,
        $sel:iamRoleArn:CreateBatchPredictionJob' :: Text
iamRoleArn = Text
pIamRoleArn_
      }

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

-- | A collection of key and value pairs.
createBatchPredictionJob_tags :: Lens.Lens' CreateBatchPredictionJob (Prelude.Maybe [Tag])
createBatchPredictionJob_tags :: Lens' CreateBatchPredictionJob (Maybe [Tag])
createBatchPredictionJob_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBatchPredictionJob' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateBatchPredictionJob
s@CreateBatchPredictionJob' {} Maybe [Tag]
a -> CreateBatchPredictionJob
s {$sel:tags:CreateBatchPredictionJob' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateBatchPredictionJob) 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 ID of the batch prediction job.
createBatchPredictionJob_jobId :: Lens.Lens' CreateBatchPredictionJob Prelude.Text
createBatchPredictionJob_jobId :: Lens' CreateBatchPredictionJob Text
createBatchPredictionJob_jobId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBatchPredictionJob' {Text
jobId :: Text
$sel:jobId:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
jobId} -> Text
jobId) (\s :: CreateBatchPredictionJob
s@CreateBatchPredictionJob' {} Text
a -> CreateBatchPredictionJob
s {$sel:jobId:CreateBatchPredictionJob' :: Text
jobId = Text
a} :: CreateBatchPredictionJob)

-- | The Amazon S3 location of your training file.
createBatchPredictionJob_inputPath :: Lens.Lens' CreateBatchPredictionJob Prelude.Text
createBatchPredictionJob_inputPath :: Lens' CreateBatchPredictionJob Text
createBatchPredictionJob_inputPath = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBatchPredictionJob' {Text
inputPath :: Text
$sel:inputPath:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
inputPath} -> Text
inputPath) (\s :: CreateBatchPredictionJob
s@CreateBatchPredictionJob' {} Text
a -> CreateBatchPredictionJob
s {$sel:inputPath:CreateBatchPredictionJob' :: Text
inputPath = Text
a} :: CreateBatchPredictionJob)

-- | The Amazon S3 location of your output file.
createBatchPredictionJob_outputPath :: Lens.Lens' CreateBatchPredictionJob Prelude.Text
createBatchPredictionJob_outputPath :: Lens' CreateBatchPredictionJob Text
createBatchPredictionJob_outputPath = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBatchPredictionJob' {Text
outputPath :: Text
$sel:outputPath:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
outputPath} -> Text
outputPath) (\s :: CreateBatchPredictionJob
s@CreateBatchPredictionJob' {} Text
a -> CreateBatchPredictionJob
s {$sel:outputPath:CreateBatchPredictionJob' :: Text
outputPath = Text
a} :: CreateBatchPredictionJob)

-- | The name of the event type.
createBatchPredictionJob_eventTypeName :: Lens.Lens' CreateBatchPredictionJob Prelude.Text
createBatchPredictionJob_eventTypeName :: Lens' CreateBatchPredictionJob Text
createBatchPredictionJob_eventTypeName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBatchPredictionJob' {Text
eventTypeName :: Text
$sel:eventTypeName:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
eventTypeName} -> Text
eventTypeName) (\s :: CreateBatchPredictionJob
s@CreateBatchPredictionJob' {} Text
a -> CreateBatchPredictionJob
s {$sel:eventTypeName:CreateBatchPredictionJob' :: Text
eventTypeName = Text
a} :: CreateBatchPredictionJob)

-- | The name of the detector.
createBatchPredictionJob_detectorName :: Lens.Lens' CreateBatchPredictionJob Prelude.Text
createBatchPredictionJob_detectorName :: Lens' CreateBatchPredictionJob Text
createBatchPredictionJob_detectorName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBatchPredictionJob' {Text
detectorName :: Text
$sel:detectorName:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
detectorName} -> Text
detectorName) (\s :: CreateBatchPredictionJob
s@CreateBatchPredictionJob' {} Text
a -> CreateBatchPredictionJob
s {$sel:detectorName:CreateBatchPredictionJob' :: Text
detectorName = Text
a} :: CreateBatchPredictionJob)

-- | The ARN of the IAM role to use for this job request.
--
-- The IAM Role must have read permissions to your input S3 bucket and
-- write permissions to your output S3 bucket. For more information about
-- bucket permissions, see
-- <https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-policies-s3.html User policy examples>
-- in the /Amazon S3 User Guide/.
createBatchPredictionJob_iamRoleArn :: Lens.Lens' CreateBatchPredictionJob Prelude.Text
createBatchPredictionJob_iamRoleArn :: Lens' CreateBatchPredictionJob Text
createBatchPredictionJob_iamRoleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBatchPredictionJob' {Text
iamRoleArn :: Text
$sel:iamRoleArn:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
iamRoleArn} -> Text
iamRoleArn) (\s :: CreateBatchPredictionJob
s@CreateBatchPredictionJob' {} Text
a -> CreateBatchPredictionJob
s {$sel:iamRoleArn:CreateBatchPredictionJob' :: Text
iamRoleArn = Text
a} :: CreateBatchPredictionJob)

instance Core.AWSRequest CreateBatchPredictionJob where
  type
    AWSResponse CreateBatchPredictionJob =
      CreateBatchPredictionJobResponse
  request :: (Service -> Service)
-> CreateBatchPredictionJob -> Request CreateBatchPredictionJob
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 CreateBatchPredictionJob
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateBatchPredictionJob)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> CreateBatchPredictionJobResponse
CreateBatchPredictionJobResponse'
            forall (f :: * -> *) a b. Functor 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 CreateBatchPredictionJob where
  hashWithSalt :: Int -> CreateBatchPredictionJob -> Int
hashWithSalt Int
_salt CreateBatchPredictionJob' {Maybe [Tag]
Maybe Text
Text
iamRoleArn :: Text
detectorName :: Text
eventTypeName :: Text
outputPath :: Text
inputPath :: Text
jobId :: Text
tags :: Maybe [Tag]
detectorVersion :: Maybe Text
$sel:iamRoleArn:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:detectorName:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:eventTypeName:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:outputPath:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:inputPath:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:jobId:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:tags:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Maybe [Tag]
$sel:detectorVersion:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
detectorVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
jobId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
inputPath
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
outputPath
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
eventTypeName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
detectorName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
iamRoleArn

instance Prelude.NFData CreateBatchPredictionJob where
  rnf :: CreateBatchPredictionJob -> ()
rnf CreateBatchPredictionJob' {Maybe [Tag]
Maybe Text
Text
iamRoleArn :: Text
detectorName :: Text
eventTypeName :: Text
outputPath :: Text
inputPath :: Text
jobId :: Text
tags :: Maybe [Tag]
detectorVersion :: Maybe Text
$sel:iamRoleArn:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:detectorName:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:eventTypeName:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:outputPath:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:inputPath:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:jobId:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:tags:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Maybe [Tag]
$sel:detectorVersion:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
detectorVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
jobId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
inputPath
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
outputPath
      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
detectorName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
iamRoleArn

instance Data.ToHeaders CreateBatchPredictionJob where
  toHeaders :: CreateBatchPredictionJob -> 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.CreateBatchPredictionJob" ::
                          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 CreateBatchPredictionJob where
  toJSON :: CreateBatchPredictionJob -> Value
toJSON CreateBatchPredictionJob' {Maybe [Tag]
Maybe Text
Text
iamRoleArn :: Text
detectorName :: Text
eventTypeName :: Text
outputPath :: Text
inputPath :: Text
jobId :: Text
tags :: Maybe [Tag]
detectorVersion :: Maybe Text
$sel:iamRoleArn:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:detectorName:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:eventTypeName:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:outputPath:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:inputPath:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:jobId:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Text
$sel:tags:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Maybe [Tag]
$sel:detectorVersion:CreateBatchPredictionJob' :: CreateBatchPredictionJob -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"detectorVersion" 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
detectorVersion,
            (Key
"tags" 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 [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"jobId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
jobId),
            forall a. a -> Maybe a
Prelude.Just (Key
"inputPath" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
inputPath),
            forall a. a -> Maybe a
Prelude.Just (Key
"outputPath" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
outputPath),
            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
"detectorName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
detectorName),
            forall a. a -> Maybe a
Prelude.Just (Key
"iamRoleArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
iamRoleArn)
          ]
      )

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

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

-- | /See:/ 'newCreateBatchPredictionJobResponse' smart constructor.
data CreateBatchPredictionJobResponse = CreateBatchPredictionJobResponse'
  { -- | The response's http status code.
    CreateBatchPredictionJobResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateBatchPredictionJobResponse
-> CreateBatchPredictionJobResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateBatchPredictionJobResponse
-> CreateBatchPredictionJobResponse -> Bool
$c/= :: CreateBatchPredictionJobResponse
-> CreateBatchPredictionJobResponse -> Bool
== :: CreateBatchPredictionJobResponse
-> CreateBatchPredictionJobResponse -> Bool
$c== :: CreateBatchPredictionJobResponse
-> CreateBatchPredictionJobResponse -> Bool
Prelude.Eq, ReadPrec [CreateBatchPredictionJobResponse]
ReadPrec CreateBatchPredictionJobResponse
Int -> ReadS CreateBatchPredictionJobResponse
ReadS [CreateBatchPredictionJobResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateBatchPredictionJobResponse]
$creadListPrec :: ReadPrec [CreateBatchPredictionJobResponse]
readPrec :: ReadPrec CreateBatchPredictionJobResponse
$creadPrec :: ReadPrec CreateBatchPredictionJobResponse
readList :: ReadS [CreateBatchPredictionJobResponse]
$creadList :: ReadS [CreateBatchPredictionJobResponse]
readsPrec :: Int -> ReadS CreateBatchPredictionJobResponse
$creadsPrec :: Int -> ReadS CreateBatchPredictionJobResponse
Prelude.Read, Int -> CreateBatchPredictionJobResponse -> ShowS
[CreateBatchPredictionJobResponse] -> ShowS
CreateBatchPredictionJobResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateBatchPredictionJobResponse] -> ShowS
$cshowList :: [CreateBatchPredictionJobResponse] -> ShowS
show :: CreateBatchPredictionJobResponse -> String
$cshow :: CreateBatchPredictionJobResponse -> String
showsPrec :: Int -> CreateBatchPredictionJobResponse -> ShowS
$cshowsPrec :: Int -> CreateBatchPredictionJobResponse -> ShowS
Prelude.Show, forall x.
Rep CreateBatchPredictionJobResponse x
-> CreateBatchPredictionJobResponse
forall x.
CreateBatchPredictionJobResponse
-> Rep CreateBatchPredictionJobResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateBatchPredictionJobResponse x
-> CreateBatchPredictionJobResponse
$cfrom :: forall x.
CreateBatchPredictionJobResponse
-> Rep CreateBatchPredictionJobResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateBatchPredictionJobResponse' 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:
--
-- 'httpStatus', 'createBatchPredictionJobResponse_httpStatus' - The response's http status code.
newCreateBatchPredictionJobResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateBatchPredictionJobResponse
newCreateBatchPredictionJobResponse :: Int -> CreateBatchPredictionJobResponse
newCreateBatchPredictionJobResponse Int
pHttpStatus_ =
  CreateBatchPredictionJobResponse'
    { $sel:httpStatus:CreateBatchPredictionJobResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

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

instance
  Prelude.NFData
    CreateBatchPredictionJobResponse
  where
  rnf :: CreateBatchPredictionJobResponse -> ()
rnf CreateBatchPredictionJobResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateBatchPredictionJobResponse' :: CreateBatchPredictionJobResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus