{-# 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.SageMaker.CreateTransformJob
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Starts a transform job. A transform job uses a trained model to get
-- inferences on a dataset and saves these results to an Amazon S3 location
-- that you specify.
--
-- To perform batch transformations, you create a transform job and use the
-- data that you have readily available.
--
-- In the request body, you provide the following:
--
-- -   @TransformJobName@ - Identifies the transform job. The name must be
--     unique within an Amazon Web Services Region in an Amazon Web
--     Services account.
--
-- -   @ModelName@ - Identifies the model to use. @ModelName@ must be the
--     name of an existing Amazon SageMaker model in the same Amazon Web
--     Services Region and Amazon Web Services account. For information on
--     creating a model, see CreateModel.
--
-- -   @TransformInput@ - Describes the dataset to be transformed and the
--     Amazon S3 location where it is stored.
--
-- -   @TransformOutput@ - Identifies the Amazon S3 location where you want
--     Amazon SageMaker to save the results from the transform job.
--
-- -   @TransformResources@ - Identifies the ML compute instances for the
--     transform job.
--
-- For more information about how batch transformation works, see
-- <https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html Batch Transform>.
module Amazonka.SageMaker.CreateTransformJob
  ( -- * Creating a Request
    CreateTransformJob (..),
    newCreateTransformJob,

    -- * Request Lenses
    createTransformJob_modelClientConfig,
    createTransformJob_batchStrategy,
    createTransformJob_maxPayloadInMB,
    createTransformJob_environment,
    createTransformJob_experimentConfig,
    createTransformJob_maxConcurrentTransforms,
    createTransformJob_dataProcessing,
    createTransformJob_tags,
    createTransformJob_transformJobName,
    createTransformJob_modelName,
    createTransformJob_transformInput,
    createTransformJob_transformOutput,
    createTransformJob_transformResources,

    -- * Destructuring the Response
    CreateTransformJobResponse (..),
    newCreateTransformJobResponse,

    -- * Response Lenses
    createTransformJobResponse_httpStatus,
    createTransformJobResponse_transformJobArn,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.SageMaker.Types

-- | /See:/ 'newCreateTransformJob' smart constructor.
data CreateTransformJob = CreateTransformJob'
  { -- | Configures the timeout and maximum number of retries for processing a
    -- transform job invocation.
    CreateTransformJob -> Maybe ModelClientConfig
modelClientConfig :: Prelude.Maybe ModelClientConfig,
    -- | Specifies the number of records to include in a mini-batch for an HTTP
    -- inference request. A /record/ // is a single unit of input data that
    -- inference can be made on. For example, a single line in a CSV file is a
    -- record.
    --
    -- To enable the batch strategy, you must set the @SplitType@ property to
    -- @Line@, @RecordIO@, or @TFRecord@.
    --
    -- To use only one record when making an HTTP invocation request to a
    -- container, set @BatchStrategy@ to @SingleRecord@ and @SplitType@ to
    -- @Line@.
    --
    -- To fit as many records in a mini-batch as can fit within the
    -- @MaxPayloadInMB@ limit, set @BatchStrategy@ to @MultiRecord@ and
    -- @SplitType@ to @Line@.
    CreateTransformJob -> Maybe BatchStrategy
batchStrategy :: Prelude.Maybe BatchStrategy,
    -- | The maximum allowed size of the payload, in MB. A /payload/ is the data
    -- portion of a record (without metadata). The value in @MaxPayloadInMB@
    -- must be greater than, or equal to, the size of a single record. To
    -- estimate the size of a record in MB, divide the size of your dataset by
    -- the number of records. To ensure that the records fit within the maximum
    -- payload size, we recommend using a slightly larger value. The default
    -- value is @6@ MB.
    --
    -- For cases where the payload might be arbitrarily large and is
    -- transmitted using HTTP chunked encoding, set the value to @0@. This
    -- feature works only in supported algorithms. Currently, Amazon SageMaker
    -- built-in algorithms do not support HTTP chunked encoding.
    CreateTransformJob -> Maybe Natural
maxPayloadInMB :: Prelude.Maybe Prelude.Natural,
    -- | The environment variables to set in the Docker container. We support up
    -- to 16 key and values entries in the map.
    CreateTransformJob -> Maybe (HashMap Text Text)
environment :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    CreateTransformJob -> Maybe ExperimentConfig
experimentConfig :: Prelude.Maybe ExperimentConfig,
    -- | The maximum number of parallel requests that can be sent to each
    -- instance in a transform job. If @MaxConcurrentTransforms@ is set to @0@
    -- or left unset, Amazon SageMaker checks the optional execution-parameters
    -- to determine the settings for your chosen algorithm. If the
    -- execution-parameters endpoint is not enabled, the default value is @1@.
    -- For more information on execution-parameters, see
    -- <https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-batch-code.html#your-algorithms-batch-code-how-containe-serves-requests How Containers Serve Requests>.
    -- For built-in algorithms, you don\'t need to set a value for
    -- @MaxConcurrentTransforms@.
    CreateTransformJob -> Maybe Natural
maxConcurrentTransforms :: Prelude.Maybe Prelude.Natural,
    -- | The data structure used to specify the data to be used for inference in
    -- a batch transform job and to associate the data that is relevant to the
    -- prediction results in the output. The input filter provided allows you
    -- to exclude input data that is not needed for inference in a batch
    -- transform job. The output filter provided allows you to include input
    -- data relevant to interpreting the predictions in the output from the
    -- job. For more information, see
    -- <https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-data-processing.html Associate Prediction Results with their Corresponding Input Records>.
    CreateTransformJob -> Maybe DataProcessing
dataProcessing :: Prelude.Maybe DataProcessing,
    -- | (Optional) An array of key-value pairs. For more information, see
    -- <https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what Using Cost Allocation Tags>
    -- in the /Amazon Web Services Billing and Cost Management User Guide/.
    CreateTransformJob -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of the transform job. The name must be unique within an Amazon
    -- Web Services Region in an Amazon Web Services account.
    CreateTransformJob -> Text
transformJobName :: Prelude.Text,
    -- | The name of the model that you want to use for the transform job.
    -- @ModelName@ must be the name of an existing Amazon SageMaker model
    -- within an Amazon Web Services Region in an Amazon Web Services account.
    CreateTransformJob -> Text
modelName :: Prelude.Text,
    -- | Describes the input source and the way the transform job consumes it.
    CreateTransformJob -> TransformInput
transformInput :: TransformInput,
    -- | Describes the results of the transform job.
    CreateTransformJob -> TransformOutput
transformOutput :: TransformOutput,
    -- | Describes the resources, including ML instance types and ML instance
    -- count, to use for the transform job.
    CreateTransformJob -> TransformResources
transformResources :: TransformResources
  }
  deriving (CreateTransformJob -> CreateTransformJob -> Bool
(CreateTransformJob -> CreateTransformJob -> Bool)
-> (CreateTransformJob -> CreateTransformJob -> Bool)
-> Eq CreateTransformJob
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateTransformJob -> CreateTransformJob -> Bool
$c/= :: CreateTransformJob -> CreateTransformJob -> Bool
== :: CreateTransformJob -> CreateTransformJob -> Bool
$c== :: CreateTransformJob -> CreateTransformJob -> Bool
Prelude.Eq, ReadPrec [CreateTransformJob]
ReadPrec CreateTransformJob
Int -> ReadS CreateTransformJob
ReadS [CreateTransformJob]
(Int -> ReadS CreateTransformJob)
-> ReadS [CreateTransformJob]
-> ReadPrec CreateTransformJob
-> ReadPrec [CreateTransformJob]
-> Read CreateTransformJob
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateTransformJob]
$creadListPrec :: ReadPrec [CreateTransformJob]
readPrec :: ReadPrec CreateTransformJob
$creadPrec :: ReadPrec CreateTransformJob
readList :: ReadS [CreateTransformJob]
$creadList :: ReadS [CreateTransformJob]
readsPrec :: Int -> ReadS CreateTransformJob
$creadsPrec :: Int -> ReadS CreateTransformJob
Prelude.Read, Int -> CreateTransformJob -> ShowS
[CreateTransformJob] -> ShowS
CreateTransformJob -> String
(Int -> CreateTransformJob -> ShowS)
-> (CreateTransformJob -> String)
-> ([CreateTransformJob] -> ShowS)
-> Show CreateTransformJob
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateTransformJob] -> ShowS
$cshowList :: [CreateTransformJob] -> ShowS
show :: CreateTransformJob -> String
$cshow :: CreateTransformJob -> String
showsPrec :: Int -> CreateTransformJob -> ShowS
$cshowsPrec :: Int -> CreateTransformJob -> ShowS
Prelude.Show, (forall x. CreateTransformJob -> Rep CreateTransformJob x)
-> (forall x. Rep CreateTransformJob x -> CreateTransformJob)
-> Generic CreateTransformJob
forall x. Rep CreateTransformJob x -> CreateTransformJob
forall x. CreateTransformJob -> Rep CreateTransformJob x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateTransformJob x -> CreateTransformJob
$cfrom :: forall x. CreateTransformJob -> Rep CreateTransformJob x
Prelude.Generic)

-- |
-- Create a value of 'CreateTransformJob' 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:
--
-- 'modelClientConfig', 'createTransformJob_modelClientConfig' - Configures the timeout and maximum number of retries for processing a
-- transform job invocation.
--
-- 'batchStrategy', 'createTransformJob_batchStrategy' - Specifies the number of records to include in a mini-batch for an HTTP
-- inference request. A /record/ // is a single unit of input data that
-- inference can be made on. For example, a single line in a CSV file is a
-- record.
--
-- To enable the batch strategy, you must set the @SplitType@ property to
-- @Line@, @RecordIO@, or @TFRecord@.
--
-- To use only one record when making an HTTP invocation request to a
-- container, set @BatchStrategy@ to @SingleRecord@ and @SplitType@ to
-- @Line@.
--
-- To fit as many records in a mini-batch as can fit within the
-- @MaxPayloadInMB@ limit, set @BatchStrategy@ to @MultiRecord@ and
-- @SplitType@ to @Line@.
--
-- 'maxPayloadInMB', 'createTransformJob_maxPayloadInMB' - The maximum allowed size of the payload, in MB. A /payload/ is the data
-- portion of a record (without metadata). The value in @MaxPayloadInMB@
-- must be greater than, or equal to, the size of a single record. To
-- estimate the size of a record in MB, divide the size of your dataset by
-- the number of records. To ensure that the records fit within the maximum
-- payload size, we recommend using a slightly larger value. The default
-- value is @6@ MB.
--
-- For cases where the payload might be arbitrarily large and is
-- transmitted using HTTP chunked encoding, set the value to @0@. This
-- feature works only in supported algorithms. Currently, Amazon SageMaker
-- built-in algorithms do not support HTTP chunked encoding.
--
-- 'environment', 'createTransformJob_environment' - The environment variables to set in the Docker container. We support up
-- to 16 key and values entries in the map.
--
-- 'experimentConfig', 'createTransformJob_experimentConfig' - Undocumented member.
--
-- 'maxConcurrentTransforms', 'createTransformJob_maxConcurrentTransforms' - The maximum number of parallel requests that can be sent to each
-- instance in a transform job. If @MaxConcurrentTransforms@ is set to @0@
-- or left unset, Amazon SageMaker checks the optional execution-parameters
-- to determine the settings for your chosen algorithm. If the
-- execution-parameters endpoint is not enabled, the default value is @1@.
-- For more information on execution-parameters, see
-- <https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-batch-code.html#your-algorithms-batch-code-how-containe-serves-requests How Containers Serve Requests>.
-- For built-in algorithms, you don\'t need to set a value for
-- @MaxConcurrentTransforms@.
--
-- 'dataProcessing', 'createTransformJob_dataProcessing' - The data structure used to specify the data to be used for inference in
-- a batch transform job and to associate the data that is relevant to the
-- prediction results in the output. The input filter provided allows you
-- to exclude input data that is not needed for inference in a batch
-- transform job. The output filter provided allows you to include input
-- data relevant to interpreting the predictions in the output from the
-- job. For more information, see
-- <https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-data-processing.html Associate Prediction Results with their Corresponding Input Records>.
--
-- 'tags', 'createTransformJob_tags' - (Optional) An array of key-value pairs. For more information, see
-- <https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what Using Cost Allocation Tags>
-- in the /Amazon Web Services Billing and Cost Management User Guide/.
--
-- 'transformJobName', 'createTransformJob_transformJobName' - The name of the transform job. The name must be unique within an Amazon
-- Web Services Region in an Amazon Web Services account.
--
-- 'modelName', 'createTransformJob_modelName' - The name of the model that you want to use for the transform job.
-- @ModelName@ must be the name of an existing Amazon SageMaker model
-- within an Amazon Web Services Region in an Amazon Web Services account.
--
-- 'transformInput', 'createTransformJob_transformInput' - Describes the input source and the way the transform job consumes it.
--
-- 'transformOutput', 'createTransformJob_transformOutput' - Describes the results of the transform job.
--
-- 'transformResources', 'createTransformJob_transformResources' - Describes the resources, including ML instance types and ML instance
-- count, to use for the transform job.
newCreateTransformJob ::
  -- | 'transformJobName'
  Prelude.Text ->
  -- | 'modelName'
  Prelude.Text ->
  -- | 'transformInput'
  TransformInput ->
  -- | 'transformOutput'
  TransformOutput ->
  -- | 'transformResources'
  TransformResources ->
  CreateTransformJob
newCreateTransformJob :: Text
-> Text
-> TransformInput
-> TransformOutput
-> TransformResources
-> CreateTransformJob
newCreateTransformJob
  Text
pTransformJobName_
  Text
pModelName_
  TransformInput
pTransformInput_
  TransformOutput
pTransformOutput_
  TransformResources
pTransformResources_ =
    CreateTransformJob' :: Maybe ModelClientConfig
-> Maybe BatchStrategy
-> Maybe Natural
-> Maybe (HashMap Text Text)
-> Maybe ExperimentConfig
-> Maybe Natural
-> Maybe DataProcessing
-> Maybe [Tag]
-> Text
-> Text
-> TransformInput
-> TransformOutput
-> TransformResources
-> CreateTransformJob
CreateTransformJob'
      { $sel:modelClientConfig:CreateTransformJob' :: Maybe ModelClientConfig
modelClientConfig =
          Maybe ModelClientConfig
forall a. Maybe a
Prelude.Nothing,
        $sel:batchStrategy:CreateTransformJob' :: Maybe BatchStrategy
batchStrategy = Maybe BatchStrategy
forall a. Maybe a
Prelude.Nothing,
        $sel:maxPayloadInMB:CreateTransformJob' :: Maybe Natural
maxPayloadInMB = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:environment:CreateTransformJob' :: Maybe (HashMap Text Text)
environment = Maybe (HashMap Text Text)
forall a. Maybe a
Prelude.Nothing,
        $sel:experimentConfig:CreateTransformJob' :: Maybe ExperimentConfig
experimentConfig = Maybe ExperimentConfig
forall a. Maybe a
Prelude.Nothing,
        $sel:maxConcurrentTransforms:CreateTransformJob' :: Maybe Natural
maxConcurrentTransforms = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:dataProcessing:CreateTransformJob' :: Maybe DataProcessing
dataProcessing = Maybe DataProcessing
forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateTransformJob' :: Maybe [Tag]
tags = Maybe [Tag]
forall a. Maybe a
Prelude.Nothing,
        $sel:transformJobName:CreateTransformJob' :: Text
transformJobName = Text
pTransformJobName_,
        $sel:modelName:CreateTransformJob' :: Text
modelName = Text
pModelName_,
        $sel:transformInput:CreateTransformJob' :: TransformInput
transformInput = TransformInput
pTransformInput_,
        $sel:transformOutput:CreateTransformJob' :: TransformOutput
transformOutput = TransformOutput
pTransformOutput_,
        $sel:transformResources:CreateTransformJob' :: TransformResources
transformResources = TransformResources
pTransformResources_
      }

-- | Configures the timeout and maximum number of retries for processing a
-- transform job invocation.
createTransformJob_modelClientConfig :: Lens.Lens' CreateTransformJob (Prelude.Maybe ModelClientConfig)
createTransformJob_modelClientConfig :: (Maybe ModelClientConfig -> f (Maybe ModelClientConfig))
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_modelClientConfig = (CreateTransformJob -> Maybe ModelClientConfig)
-> (CreateTransformJob
    -> Maybe ModelClientConfig -> CreateTransformJob)
-> Lens
     CreateTransformJob
     CreateTransformJob
     (Maybe ModelClientConfig)
     (Maybe ModelClientConfig)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {Maybe ModelClientConfig
modelClientConfig :: Maybe ModelClientConfig
$sel:modelClientConfig:CreateTransformJob' :: CreateTransformJob -> Maybe ModelClientConfig
modelClientConfig} -> Maybe ModelClientConfig
modelClientConfig) (\s :: CreateTransformJob
s@CreateTransformJob' {} Maybe ModelClientConfig
a -> CreateTransformJob
s {$sel:modelClientConfig:CreateTransformJob' :: Maybe ModelClientConfig
modelClientConfig = Maybe ModelClientConfig
a} :: CreateTransformJob)

-- | Specifies the number of records to include in a mini-batch for an HTTP
-- inference request. A /record/ // is a single unit of input data that
-- inference can be made on. For example, a single line in a CSV file is a
-- record.
--
-- To enable the batch strategy, you must set the @SplitType@ property to
-- @Line@, @RecordIO@, or @TFRecord@.
--
-- To use only one record when making an HTTP invocation request to a
-- container, set @BatchStrategy@ to @SingleRecord@ and @SplitType@ to
-- @Line@.
--
-- To fit as many records in a mini-batch as can fit within the
-- @MaxPayloadInMB@ limit, set @BatchStrategy@ to @MultiRecord@ and
-- @SplitType@ to @Line@.
createTransformJob_batchStrategy :: Lens.Lens' CreateTransformJob (Prelude.Maybe BatchStrategy)
createTransformJob_batchStrategy :: (Maybe BatchStrategy -> f (Maybe BatchStrategy))
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_batchStrategy = (CreateTransformJob -> Maybe BatchStrategy)
-> (CreateTransformJob
    -> Maybe BatchStrategy -> CreateTransformJob)
-> Lens
     CreateTransformJob
     CreateTransformJob
     (Maybe BatchStrategy)
     (Maybe BatchStrategy)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {Maybe BatchStrategy
batchStrategy :: Maybe BatchStrategy
$sel:batchStrategy:CreateTransformJob' :: CreateTransformJob -> Maybe BatchStrategy
batchStrategy} -> Maybe BatchStrategy
batchStrategy) (\s :: CreateTransformJob
s@CreateTransformJob' {} Maybe BatchStrategy
a -> CreateTransformJob
s {$sel:batchStrategy:CreateTransformJob' :: Maybe BatchStrategy
batchStrategy = Maybe BatchStrategy
a} :: CreateTransformJob)

-- | The maximum allowed size of the payload, in MB. A /payload/ is the data
-- portion of a record (without metadata). The value in @MaxPayloadInMB@
-- must be greater than, or equal to, the size of a single record. To
-- estimate the size of a record in MB, divide the size of your dataset by
-- the number of records. To ensure that the records fit within the maximum
-- payload size, we recommend using a slightly larger value. The default
-- value is @6@ MB.
--
-- For cases where the payload might be arbitrarily large and is
-- transmitted using HTTP chunked encoding, set the value to @0@. This
-- feature works only in supported algorithms. Currently, Amazon SageMaker
-- built-in algorithms do not support HTTP chunked encoding.
createTransformJob_maxPayloadInMB :: Lens.Lens' CreateTransformJob (Prelude.Maybe Prelude.Natural)
createTransformJob_maxPayloadInMB :: (Maybe Natural -> f (Maybe Natural))
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_maxPayloadInMB = (CreateTransformJob -> Maybe Natural)
-> (CreateTransformJob -> Maybe Natural -> CreateTransformJob)
-> Lens
     CreateTransformJob
     CreateTransformJob
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {Maybe Natural
maxPayloadInMB :: Maybe Natural
$sel:maxPayloadInMB:CreateTransformJob' :: CreateTransformJob -> Maybe Natural
maxPayloadInMB} -> Maybe Natural
maxPayloadInMB) (\s :: CreateTransformJob
s@CreateTransformJob' {} Maybe Natural
a -> CreateTransformJob
s {$sel:maxPayloadInMB:CreateTransformJob' :: Maybe Natural
maxPayloadInMB = Maybe Natural
a} :: CreateTransformJob)

-- | The environment variables to set in the Docker container. We support up
-- to 16 key and values entries in the map.
createTransformJob_environment :: Lens.Lens' CreateTransformJob (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createTransformJob_environment :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_environment = (CreateTransformJob -> Maybe (HashMap Text Text))
-> (CreateTransformJob
    -> Maybe (HashMap Text Text) -> CreateTransformJob)
-> Lens
     CreateTransformJob
     CreateTransformJob
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {Maybe (HashMap Text Text)
environment :: Maybe (HashMap Text Text)
$sel:environment:CreateTransformJob' :: CreateTransformJob -> Maybe (HashMap Text Text)
environment} -> Maybe (HashMap Text Text)
environment) (\s :: CreateTransformJob
s@CreateTransformJob' {} Maybe (HashMap Text Text)
a -> CreateTransformJob
s {$sel:environment:CreateTransformJob' :: Maybe (HashMap Text Text)
environment = Maybe (HashMap Text Text)
a} :: CreateTransformJob) ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
 -> CreateTransformJob -> f CreateTransformJob)
-> ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
    -> Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> CreateTransformJob
-> f CreateTransformJob
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
-> Iso
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
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 AnIso
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Undocumented member.
createTransformJob_experimentConfig :: Lens.Lens' CreateTransformJob (Prelude.Maybe ExperimentConfig)
createTransformJob_experimentConfig :: (Maybe ExperimentConfig -> f (Maybe ExperimentConfig))
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_experimentConfig = (CreateTransformJob -> Maybe ExperimentConfig)
-> (CreateTransformJob
    -> Maybe ExperimentConfig -> CreateTransformJob)
-> Lens
     CreateTransformJob
     CreateTransformJob
     (Maybe ExperimentConfig)
     (Maybe ExperimentConfig)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {Maybe ExperimentConfig
experimentConfig :: Maybe ExperimentConfig
$sel:experimentConfig:CreateTransformJob' :: CreateTransformJob -> Maybe ExperimentConfig
experimentConfig} -> Maybe ExperimentConfig
experimentConfig) (\s :: CreateTransformJob
s@CreateTransformJob' {} Maybe ExperimentConfig
a -> CreateTransformJob
s {$sel:experimentConfig:CreateTransformJob' :: Maybe ExperimentConfig
experimentConfig = Maybe ExperimentConfig
a} :: CreateTransformJob)

-- | The maximum number of parallel requests that can be sent to each
-- instance in a transform job. If @MaxConcurrentTransforms@ is set to @0@
-- or left unset, Amazon SageMaker checks the optional execution-parameters
-- to determine the settings for your chosen algorithm. If the
-- execution-parameters endpoint is not enabled, the default value is @1@.
-- For more information on execution-parameters, see
-- <https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-batch-code.html#your-algorithms-batch-code-how-containe-serves-requests How Containers Serve Requests>.
-- For built-in algorithms, you don\'t need to set a value for
-- @MaxConcurrentTransforms@.
createTransformJob_maxConcurrentTransforms :: Lens.Lens' CreateTransformJob (Prelude.Maybe Prelude.Natural)
createTransformJob_maxConcurrentTransforms :: (Maybe Natural -> f (Maybe Natural))
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_maxConcurrentTransforms = (CreateTransformJob -> Maybe Natural)
-> (CreateTransformJob -> Maybe Natural -> CreateTransformJob)
-> Lens
     CreateTransformJob
     CreateTransformJob
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {Maybe Natural
maxConcurrentTransforms :: Maybe Natural
$sel:maxConcurrentTransforms:CreateTransformJob' :: CreateTransformJob -> Maybe Natural
maxConcurrentTransforms} -> Maybe Natural
maxConcurrentTransforms) (\s :: CreateTransformJob
s@CreateTransformJob' {} Maybe Natural
a -> CreateTransformJob
s {$sel:maxConcurrentTransforms:CreateTransformJob' :: Maybe Natural
maxConcurrentTransforms = Maybe Natural
a} :: CreateTransformJob)

-- | The data structure used to specify the data to be used for inference in
-- a batch transform job and to associate the data that is relevant to the
-- prediction results in the output. The input filter provided allows you
-- to exclude input data that is not needed for inference in a batch
-- transform job. The output filter provided allows you to include input
-- data relevant to interpreting the predictions in the output from the
-- job. For more information, see
-- <https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-data-processing.html Associate Prediction Results with their Corresponding Input Records>.
createTransformJob_dataProcessing :: Lens.Lens' CreateTransformJob (Prelude.Maybe DataProcessing)
createTransformJob_dataProcessing :: (Maybe DataProcessing -> f (Maybe DataProcessing))
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_dataProcessing = (CreateTransformJob -> Maybe DataProcessing)
-> (CreateTransformJob
    -> Maybe DataProcessing -> CreateTransformJob)
-> Lens
     CreateTransformJob
     CreateTransformJob
     (Maybe DataProcessing)
     (Maybe DataProcessing)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {Maybe DataProcessing
dataProcessing :: Maybe DataProcessing
$sel:dataProcessing:CreateTransformJob' :: CreateTransformJob -> Maybe DataProcessing
dataProcessing} -> Maybe DataProcessing
dataProcessing) (\s :: CreateTransformJob
s@CreateTransformJob' {} Maybe DataProcessing
a -> CreateTransformJob
s {$sel:dataProcessing:CreateTransformJob' :: Maybe DataProcessing
dataProcessing = Maybe DataProcessing
a} :: CreateTransformJob)

-- | (Optional) An array of key-value pairs. For more information, see
-- <https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what Using Cost Allocation Tags>
-- in the /Amazon Web Services Billing and Cost Management User Guide/.
createTransformJob_tags :: Lens.Lens' CreateTransformJob (Prelude.Maybe [Tag])
createTransformJob_tags :: (Maybe [Tag] -> f (Maybe [Tag]))
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_tags = (CreateTransformJob -> Maybe [Tag])
-> (CreateTransformJob -> Maybe [Tag] -> CreateTransformJob)
-> Lens
     CreateTransformJob CreateTransformJob (Maybe [Tag]) (Maybe [Tag])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateTransformJob' :: CreateTransformJob -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateTransformJob
s@CreateTransformJob' {} Maybe [Tag]
a -> CreateTransformJob
s {$sel:tags:CreateTransformJob' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateTransformJob) ((Maybe [Tag] -> f (Maybe [Tag]))
 -> CreateTransformJob -> f CreateTransformJob)
-> ((Maybe [Tag] -> f (Maybe [Tag]))
    -> Maybe [Tag] -> f (Maybe [Tag]))
-> (Maybe [Tag] -> f (Maybe [Tag]))
-> CreateTransformJob
-> f CreateTransformJob
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Tag] [Tag] [Tag] [Tag]
-> Iso (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag])
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 AnIso [Tag] [Tag] [Tag] [Tag]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of the transform job. The name must be unique within an Amazon
-- Web Services Region in an Amazon Web Services account.
createTransformJob_transformJobName :: Lens.Lens' CreateTransformJob Prelude.Text
createTransformJob_transformJobName :: (Text -> f Text) -> CreateTransformJob -> f CreateTransformJob
createTransformJob_transformJobName = (CreateTransformJob -> Text)
-> (CreateTransformJob -> Text -> CreateTransformJob)
-> Lens CreateTransformJob CreateTransformJob Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {Text
transformJobName :: Text
$sel:transformJobName:CreateTransformJob' :: CreateTransformJob -> Text
transformJobName} -> Text
transformJobName) (\s :: CreateTransformJob
s@CreateTransformJob' {} Text
a -> CreateTransformJob
s {$sel:transformJobName:CreateTransformJob' :: Text
transformJobName = Text
a} :: CreateTransformJob)

-- | The name of the model that you want to use for the transform job.
-- @ModelName@ must be the name of an existing Amazon SageMaker model
-- within an Amazon Web Services Region in an Amazon Web Services account.
createTransformJob_modelName :: Lens.Lens' CreateTransformJob Prelude.Text
createTransformJob_modelName :: (Text -> f Text) -> CreateTransformJob -> f CreateTransformJob
createTransformJob_modelName = (CreateTransformJob -> Text)
-> (CreateTransformJob -> Text -> CreateTransformJob)
-> Lens CreateTransformJob CreateTransformJob Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {Text
modelName :: Text
$sel:modelName:CreateTransformJob' :: CreateTransformJob -> Text
modelName} -> Text
modelName) (\s :: CreateTransformJob
s@CreateTransformJob' {} Text
a -> CreateTransformJob
s {$sel:modelName:CreateTransformJob' :: Text
modelName = Text
a} :: CreateTransformJob)

-- | Describes the input source and the way the transform job consumes it.
createTransformJob_transformInput :: Lens.Lens' CreateTransformJob TransformInput
createTransformJob_transformInput :: (TransformInput -> f TransformInput)
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_transformInput = (CreateTransformJob -> TransformInput)
-> (CreateTransformJob -> TransformInput -> CreateTransformJob)
-> Lens
     CreateTransformJob CreateTransformJob TransformInput TransformInput
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {TransformInput
transformInput :: TransformInput
$sel:transformInput:CreateTransformJob' :: CreateTransformJob -> TransformInput
transformInput} -> TransformInput
transformInput) (\s :: CreateTransformJob
s@CreateTransformJob' {} TransformInput
a -> CreateTransformJob
s {$sel:transformInput:CreateTransformJob' :: TransformInput
transformInput = TransformInput
a} :: CreateTransformJob)

-- | Describes the results of the transform job.
createTransformJob_transformOutput :: Lens.Lens' CreateTransformJob TransformOutput
createTransformJob_transformOutput :: (TransformOutput -> f TransformOutput)
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_transformOutput = (CreateTransformJob -> TransformOutput)
-> (CreateTransformJob -> TransformOutput -> CreateTransformJob)
-> Lens
     CreateTransformJob
     CreateTransformJob
     TransformOutput
     TransformOutput
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {TransformOutput
transformOutput :: TransformOutput
$sel:transformOutput:CreateTransformJob' :: CreateTransformJob -> TransformOutput
transformOutput} -> TransformOutput
transformOutput) (\s :: CreateTransformJob
s@CreateTransformJob' {} TransformOutput
a -> CreateTransformJob
s {$sel:transformOutput:CreateTransformJob' :: TransformOutput
transformOutput = TransformOutput
a} :: CreateTransformJob)

-- | Describes the resources, including ML instance types and ML instance
-- count, to use for the transform job.
createTransformJob_transformResources :: Lens.Lens' CreateTransformJob TransformResources
createTransformJob_transformResources :: (TransformResources -> f TransformResources)
-> CreateTransformJob -> f CreateTransformJob
createTransformJob_transformResources = (CreateTransformJob -> TransformResources)
-> (CreateTransformJob -> TransformResources -> CreateTransformJob)
-> Lens
     CreateTransformJob
     CreateTransformJob
     TransformResources
     TransformResources
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJob' {TransformResources
transformResources :: TransformResources
$sel:transformResources:CreateTransformJob' :: CreateTransformJob -> TransformResources
transformResources} -> TransformResources
transformResources) (\s :: CreateTransformJob
s@CreateTransformJob' {} TransformResources
a -> CreateTransformJob
s {$sel:transformResources:CreateTransformJob' :: TransformResources
transformResources = TransformResources
a} :: CreateTransformJob)

instance Core.AWSRequest CreateTransformJob where
  type
    AWSResponse CreateTransformJob =
      CreateTransformJobResponse
  request :: CreateTransformJob -> Request CreateTransformJob
request = Service -> CreateTransformJob -> Request CreateTransformJob
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy CreateTransformJob
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateTransformJob)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse CreateTransformJob))
-> Logger
-> Service
-> Proxy CreateTransformJob
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateTransformJob)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Int -> Text -> CreateTransformJobResponse
CreateTransformJobResponse'
            (Int -> Text -> CreateTransformJobResponse)
-> Either String Int
-> Either String (Text -> CreateTransformJobResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
            Either String (Text -> CreateTransformJobResponse)
-> Either String Text -> Either String CreateTransformJobResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String Text
forall a. FromJSON a => Object -> Text -> Either String a
Core..:> Text
"TransformJobArn")
      )

instance Prelude.Hashable CreateTransformJob

instance Prelude.NFData CreateTransformJob

instance Core.ToHeaders CreateTransformJob where
  toHeaders :: CreateTransformJob -> ResponseHeaders
toHeaders =
    ResponseHeaders -> CreateTransformJob -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"SageMaker.CreateTransformJob" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON CreateTransformJob where
  toJSON :: CreateTransformJob -> Value
toJSON CreateTransformJob' {Maybe Natural
Maybe [Tag]
Maybe (HashMap Text Text)
Maybe BatchStrategy
Maybe ExperimentConfig
Maybe DataProcessing
Maybe ModelClientConfig
Text
TransformOutput
TransformResources
TransformInput
transformResources :: TransformResources
transformOutput :: TransformOutput
transformInput :: TransformInput
modelName :: Text
transformJobName :: Text
tags :: Maybe [Tag]
dataProcessing :: Maybe DataProcessing
maxConcurrentTransforms :: Maybe Natural
experimentConfig :: Maybe ExperimentConfig
environment :: Maybe (HashMap Text Text)
maxPayloadInMB :: Maybe Natural
batchStrategy :: Maybe BatchStrategy
modelClientConfig :: Maybe ModelClientConfig
$sel:transformResources:CreateTransformJob' :: CreateTransformJob -> TransformResources
$sel:transformOutput:CreateTransformJob' :: CreateTransformJob -> TransformOutput
$sel:transformInput:CreateTransformJob' :: CreateTransformJob -> TransformInput
$sel:modelName:CreateTransformJob' :: CreateTransformJob -> Text
$sel:transformJobName:CreateTransformJob' :: CreateTransformJob -> Text
$sel:tags:CreateTransformJob' :: CreateTransformJob -> Maybe [Tag]
$sel:dataProcessing:CreateTransformJob' :: CreateTransformJob -> Maybe DataProcessing
$sel:maxConcurrentTransforms:CreateTransformJob' :: CreateTransformJob -> Maybe Natural
$sel:experimentConfig:CreateTransformJob' :: CreateTransformJob -> Maybe ExperimentConfig
$sel:environment:CreateTransformJob' :: CreateTransformJob -> Maybe (HashMap Text Text)
$sel:maxPayloadInMB:CreateTransformJob' :: CreateTransformJob -> Maybe Natural
$sel:batchStrategy:CreateTransformJob' :: CreateTransformJob -> Maybe BatchStrategy
$sel:modelClientConfig:CreateTransformJob' :: CreateTransformJob -> Maybe ModelClientConfig
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"ModelClientConfig" Text -> ModelClientConfig -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ModelClientConfig -> Pair)
-> Maybe ModelClientConfig -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ModelClientConfig
modelClientConfig,
            (Text
"BatchStrategy" Text -> BatchStrategy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BatchStrategy -> Pair) -> Maybe BatchStrategy -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BatchStrategy
batchStrategy,
            (Text
"MaxPayloadInMB" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxPayloadInMB,
            (Text
"Environment" Text -> HashMap Text Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (HashMap Text Text -> Pair)
-> Maybe (HashMap Text Text) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text Text)
environment,
            (Text
"ExperimentConfig" Text -> ExperimentConfig -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ExperimentConfig -> Pair) -> Maybe ExperimentConfig -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ExperimentConfig
experimentConfig,
            (Text
"MaxConcurrentTransforms" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxConcurrentTransforms,
            (Text
"DataProcessing" Text -> DataProcessing -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (DataProcessing -> Pair) -> Maybe DataProcessing -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe DataProcessing
dataProcessing,
            (Text
"Tags" Text -> [Tag] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) ([Tag] -> Pair) -> Maybe [Tag] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tags,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"TransformJobName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
transformJobName),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"ModelName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
modelName),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"TransformInput" Text -> TransformInput -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= TransformInput
transformInput),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"TransformOutput" Text -> TransformOutput -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= TransformOutput
transformOutput),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"TransformResources" Text -> TransformResources -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= TransformResources
transformResources)
          ]
      )

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

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

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

-- |
-- Create a value of 'CreateTransformJobResponse' 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', 'createTransformJobResponse_httpStatus' - The response's http status code.
--
-- 'transformJobArn', 'createTransformJobResponse_transformJobArn' - The Amazon Resource Name (ARN) of the transform job.
newCreateTransformJobResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'transformJobArn'
  Prelude.Text ->
  CreateTransformJobResponse
newCreateTransformJobResponse :: Int -> Text -> CreateTransformJobResponse
newCreateTransformJobResponse
  Int
pHttpStatus_
  Text
pTransformJobArn_ =
    CreateTransformJobResponse' :: Int -> Text -> CreateTransformJobResponse
CreateTransformJobResponse'
      { $sel:httpStatus:CreateTransformJobResponse' :: Int
httpStatus =
          Int
pHttpStatus_,
        $sel:transformJobArn:CreateTransformJobResponse' :: Text
transformJobArn = Text
pTransformJobArn_
      }

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

-- | The Amazon Resource Name (ARN) of the transform job.
createTransformJobResponse_transformJobArn :: Lens.Lens' CreateTransformJobResponse Prelude.Text
createTransformJobResponse_transformJobArn :: (Text -> f Text)
-> CreateTransformJobResponse -> f CreateTransformJobResponse
createTransformJobResponse_transformJobArn = (CreateTransformJobResponse -> Text)
-> (CreateTransformJobResponse
    -> Text -> CreateTransformJobResponse)
-> Lens
     CreateTransformJobResponse CreateTransformJobResponse Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransformJobResponse' {Text
transformJobArn :: Text
$sel:transformJobArn:CreateTransformJobResponse' :: CreateTransformJobResponse -> Text
transformJobArn} -> Text
transformJobArn) (\s :: CreateTransformJobResponse
s@CreateTransformJobResponse' {} Text
a -> CreateTransformJobResponse
s {$sel:transformJobArn:CreateTransformJobResponse' :: Text
transformJobArn = Text
a} :: CreateTransformJobResponse)

instance Prelude.NFData CreateTransformJobResponse