{-# 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.Rekognition.CreateProjectVersion
-- 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 new version of a model and begins training. Models are managed
-- as part of an Amazon Rekognition Custom Labels project. The response
-- from @CreateProjectVersion@ is an Amazon Resource Name (ARN) for the
-- version of the model.
--
-- Training uses the training and test datasets associated with the
-- project. For more information, see Creating training and test dataset in
-- the /Amazon Rekognition Custom Labels Developer Guide/.
--
-- You can train a model in a project that doesn\'t have associated
-- datasets by specifying manifest files in the @TrainingData@ and
-- @TestingData@ fields.
--
-- If you open the console after training a model with manifest files,
-- Amazon Rekognition Custom Labels creates the datasets for you using the
-- most recent manifest files. You can no longer train a model version for
-- the project by specifying manifest files.
--
-- Instead of training with a project without associated datasets, we
-- recommend that you use the manifest files to create training and test
-- datasets for the project.
--
-- Training takes a while to complete. You can get the current status by
-- calling DescribeProjectVersions. Training completed successfully if the
-- value of the @Status@ field is @TRAINING_COMPLETED@.
--
-- If training fails, see Debugging a failed model training in the /Amazon
-- Rekognition Custom Labels/ developer guide.
--
-- Once training has successfully completed, call DescribeProjectVersions
-- to get the training results and evaluate the model. For more
-- information, see Improving a trained Amazon Rekognition Custom Labels
-- model in the /Amazon Rekognition Custom Labels/ developers guide.
--
-- After evaluating the model, you start the model by calling
-- StartProjectVersion.
--
-- This operation requires permissions to perform the
-- @rekognition:CreateProjectVersion@ action.
module Amazonka.Rekognition.CreateProjectVersion
  ( -- * Creating a Request
    CreateProjectVersion (..),
    newCreateProjectVersion,

    -- * Request Lenses
    createProjectVersion_kmsKeyId,
    createProjectVersion_tags,
    createProjectVersion_testingData,
    createProjectVersion_trainingData,
    createProjectVersion_projectArn,
    createProjectVersion_versionName,
    createProjectVersion_outputConfig,

    -- * Destructuring the Response
    CreateProjectVersionResponse (..),
    newCreateProjectVersionResponse,

    -- * Response Lenses
    createProjectVersionResponse_projectVersionArn,
    createProjectVersionResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateProjectVersion' smart constructor.
data CreateProjectVersion = CreateProjectVersion'
  { -- | The identifier for your AWS Key Management Service key (AWS KMS key).
    -- You can supply the Amazon Resource Name (ARN) of your KMS key, the ID of
    -- your KMS key, an alias for your KMS key, or an alias ARN. The key is
    -- used to encrypt training and test images copied into the service for
    -- model training. Your source images are unaffected. The key is also used
    -- to encrypt training results and manifest files written to the output
    -- Amazon S3 bucket (@OutputConfig@).
    --
    -- If you choose to use your own KMS key, you need the following
    -- permissions on the KMS key.
    --
    -- -   kms:CreateGrant
    --
    -- -   kms:DescribeKey
    --
    -- -   kms:GenerateDataKey
    --
    -- -   kms:Decrypt
    --
    -- If you don\'t specify a value for @KmsKeyId@, images copied into the
    -- service are encrypted using a key that AWS owns and manages.
    CreateProjectVersion -> Maybe Text
kmsKeyId :: Prelude.Maybe Prelude.Text,
    -- | A set of tags (key-value pairs) that you want to attach to the model.
    CreateProjectVersion -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | Specifies an external manifest that the service uses to test the model.
    -- If you specify @TestingData@ you must also specify @TrainingData@. The
    -- project must not have any associated datasets.
    CreateProjectVersion -> Maybe TestingData
testingData :: Prelude.Maybe TestingData,
    -- | Specifies an external manifest that the services uses to train the
    -- model. If you specify @TrainingData@ you must also specify
    -- @TestingData@. The project must not have any associated datasets.
    CreateProjectVersion -> Maybe TrainingData
trainingData :: Prelude.Maybe TrainingData,
    -- | The ARN of the Amazon Rekognition Custom Labels project that manages the
    -- model that you want to train.
    CreateProjectVersion -> Text
projectArn :: Prelude.Text,
    -- | A name for the version of the model. This value must be unique.
    CreateProjectVersion -> Text
versionName :: Prelude.Text,
    -- | The Amazon S3 bucket location to store the results of training. The S3
    -- bucket can be in any AWS account as long as the caller has
    -- @s3:PutObject@ permissions on the S3 bucket.
    CreateProjectVersion -> OutputConfig
outputConfig :: OutputConfig
  }
  deriving (CreateProjectVersion -> CreateProjectVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateProjectVersion -> CreateProjectVersion -> Bool
$c/= :: CreateProjectVersion -> CreateProjectVersion -> Bool
== :: CreateProjectVersion -> CreateProjectVersion -> Bool
$c== :: CreateProjectVersion -> CreateProjectVersion -> Bool
Prelude.Eq, ReadPrec [CreateProjectVersion]
ReadPrec CreateProjectVersion
Int -> ReadS CreateProjectVersion
ReadS [CreateProjectVersion]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateProjectVersion]
$creadListPrec :: ReadPrec [CreateProjectVersion]
readPrec :: ReadPrec CreateProjectVersion
$creadPrec :: ReadPrec CreateProjectVersion
readList :: ReadS [CreateProjectVersion]
$creadList :: ReadS [CreateProjectVersion]
readsPrec :: Int -> ReadS CreateProjectVersion
$creadsPrec :: Int -> ReadS CreateProjectVersion
Prelude.Read, Int -> CreateProjectVersion -> ShowS
[CreateProjectVersion] -> ShowS
CreateProjectVersion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateProjectVersion] -> ShowS
$cshowList :: [CreateProjectVersion] -> ShowS
show :: CreateProjectVersion -> String
$cshow :: CreateProjectVersion -> String
showsPrec :: Int -> CreateProjectVersion -> ShowS
$cshowsPrec :: Int -> CreateProjectVersion -> ShowS
Prelude.Show, forall x. Rep CreateProjectVersion x -> CreateProjectVersion
forall x. CreateProjectVersion -> Rep CreateProjectVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateProjectVersion x -> CreateProjectVersion
$cfrom :: forall x. CreateProjectVersion -> Rep CreateProjectVersion x
Prelude.Generic)

-- |
-- Create a value of 'CreateProjectVersion' 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:
--
-- 'kmsKeyId', 'createProjectVersion_kmsKeyId' - The identifier for your AWS Key Management Service key (AWS KMS key).
-- You can supply the Amazon Resource Name (ARN) of your KMS key, the ID of
-- your KMS key, an alias for your KMS key, or an alias ARN. The key is
-- used to encrypt training and test images copied into the service for
-- model training. Your source images are unaffected. The key is also used
-- to encrypt training results and manifest files written to the output
-- Amazon S3 bucket (@OutputConfig@).
--
-- If you choose to use your own KMS key, you need the following
-- permissions on the KMS key.
--
-- -   kms:CreateGrant
--
-- -   kms:DescribeKey
--
-- -   kms:GenerateDataKey
--
-- -   kms:Decrypt
--
-- If you don\'t specify a value for @KmsKeyId@, images copied into the
-- service are encrypted using a key that AWS owns and manages.
--
-- 'tags', 'createProjectVersion_tags' - A set of tags (key-value pairs) that you want to attach to the model.
--
-- 'testingData', 'createProjectVersion_testingData' - Specifies an external manifest that the service uses to test the model.
-- If you specify @TestingData@ you must also specify @TrainingData@. The
-- project must not have any associated datasets.
--
-- 'trainingData', 'createProjectVersion_trainingData' - Specifies an external manifest that the services uses to train the
-- model. If you specify @TrainingData@ you must also specify
-- @TestingData@. The project must not have any associated datasets.
--
-- 'projectArn', 'createProjectVersion_projectArn' - The ARN of the Amazon Rekognition Custom Labels project that manages the
-- model that you want to train.
--
-- 'versionName', 'createProjectVersion_versionName' - A name for the version of the model. This value must be unique.
--
-- 'outputConfig', 'createProjectVersion_outputConfig' - The Amazon S3 bucket location to store the results of training. The S3
-- bucket can be in any AWS account as long as the caller has
-- @s3:PutObject@ permissions on the S3 bucket.
newCreateProjectVersion ::
  -- | 'projectArn'
  Prelude.Text ->
  -- | 'versionName'
  Prelude.Text ->
  -- | 'outputConfig'
  OutputConfig ->
  CreateProjectVersion
newCreateProjectVersion :: Text -> Text -> OutputConfig -> CreateProjectVersion
newCreateProjectVersion
  Text
pProjectArn_
  Text
pVersionName_
  OutputConfig
pOutputConfig_ =
    CreateProjectVersion'
      { $sel:kmsKeyId:CreateProjectVersion' :: Maybe Text
kmsKeyId = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateProjectVersion' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:testingData:CreateProjectVersion' :: Maybe TestingData
testingData = forall a. Maybe a
Prelude.Nothing,
        $sel:trainingData:CreateProjectVersion' :: Maybe TrainingData
trainingData = forall a. Maybe a
Prelude.Nothing,
        $sel:projectArn:CreateProjectVersion' :: Text
projectArn = Text
pProjectArn_,
        $sel:versionName:CreateProjectVersion' :: Text
versionName = Text
pVersionName_,
        $sel:outputConfig:CreateProjectVersion' :: OutputConfig
outputConfig = OutputConfig
pOutputConfig_
      }

-- | The identifier for your AWS Key Management Service key (AWS KMS key).
-- You can supply the Amazon Resource Name (ARN) of your KMS key, the ID of
-- your KMS key, an alias for your KMS key, or an alias ARN. The key is
-- used to encrypt training and test images copied into the service for
-- model training. Your source images are unaffected. The key is also used
-- to encrypt training results and manifest files written to the output
-- Amazon S3 bucket (@OutputConfig@).
--
-- If you choose to use your own KMS key, you need the following
-- permissions on the KMS key.
--
-- -   kms:CreateGrant
--
-- -   kms:DescribeKey
--
-- -   kms:GenerateDataKey
--
-- -   kms:Decrypt
--
-- If you don\'t specify a value for @KmsKeyId@, images copied into the
-- service are encrypted using a key that AWS owns and manages.
createProjectVersion_kmsKeyId :: Lens.Lens' CreateProjectVersion (Prelude.Maybe Prelude.Text)
createProjectVersion_kmsKeyId :: Lens' CreateProjectVersion (Maybe Text)
createProjectVersion_kmsKeyId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateProjectVersion' {Maybe Text
kmsKeyId :: Maybe Text
$sel:kmsKeyId:CreateProjectVersion' :: CreateProjectVersion -> Maybe Text
kmsKeyId} -> Maybe Text
kmsKeyId) (\s :: CreateProjectVersion
s@CreateProjectVersion' {} Maybe Text
a -> CreateProjectVersion
s {$sel:kmsKeyId:CreateProjectVersion' :: Maybe Text
kmsKeyId = Maybe Text
a} :: CreateProjectVersion)

-- | A set of tags (key-value pairs) that you want to attach to the model.
createProjectVersion_tags :: Lens.Lens' CreateProjectVersion (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createProjectVersion_tags :: Lens' CreateProjectVersion (Maybe (HashMap Text Text))
createProjectVersion_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateProjectVersion' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateProjectVersion' :: CreateProjectVersion -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateProjectVersion
s@CreateProjectVersion' {} Maybe (HashMap Text Text)
a -> CreateProjectVersion
s {$sel:tags:CreateProjectVersion' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateProjectVersion) 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

-- | Specifies an external manifest that the service uses to test the model.
-- If you specify @TestingData@ you must also specify @TrainingData@. The
-- project must not have any associated datasets.
createProjectVersion_testingData :: Lens.Lens' CreateProjectVersion (Prelude.Maybe TestingData)
createProjectVersion_testingData :: Lens' CreateProjectVersion (Maybe TestingData)
createProjectVersion_testingData = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateProjectVersion' {Maybe TestingData
testingData :: Maybe TestingData
$sel:testingData:CreateProjectVersion' :: CreateProjectVersion -> Maybe TestingData
testingData} -> Maybe TestingData
testingData) (\s :: CreateProjectVersion
s@CreateProjectVersion' {} Maybe TestingData
a -> CreateProjectVersion
s {$sel:testingData:CreateProjectVersion' :: Maybe TestingData
testingData = Maybe TestingData
a} :: CreateProjectVersion)

-- | Specifies an external manifest that the services uses to train the
-- model. If you specify @TrainingData@ you must also specify
-- @TestingData@. The project must not have any associated datasets.
createProjectVersion_trainingData :: Lens.Lens' CreateProjectVersion (Prelude.Maybe TrainingData)
createProjectVersion_trainingData :: Lens' CreateProjectVersion (Maybe TrainingData)
createProjectVersion_trainingData = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateProjectVersion' {Maybe TrainingData
trainingData :: Maybe TrainingData
$sel:trainingData:CreateProjectVersion' :: CreateProjectVersion -> Maybe TrainingData
trainingData} -> Maybe TrainingData
trainingData) (\s :: CreateProjectVersion
s@CreateProjectVersion' {} Maybe TrainingData
a -> CreateProjectVersion
s {$sel:trainingData:CreateProjectVersion' :: Maybe TrainingData
trainingData = Maybe TrainingData
a} :: CreateProjectVersion)

-- | The ARN of the Amazon Rekognition Custom Labels project that manages the
-- model that you want to train.
createProjectVersion_projectArn :: Lens.Lens' CreateProjectVersion Prelude.Text
createProjectVersion_projectArn :: Lens' CreateProjectVersion Text
createProjectVersion_projectArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateProjectVersion' {Text
projectArn :: Text
$sel:projectArn:CreateProjectVersion' :: CreateProjectVersion -> Text
projectArn} -> Text
projectArn) (\s :: CreateProjectVersion
s@CreateProjectVersion' {} Text
a -> CreateProjectVersion
s {$sel:projectArn:CreateProjectVersion' :: Text
projectArn = Text
a} :: CreateProjectVersion)

-- | A name for the version of the model. This value must be unique.
createProjectVersion_versionName :: Lens.Lens' CreateProjectVersion Prelude.Text
createProjectVersion_versionName :: Lens' CreateProjectVersion Text
createProjectVersion_versionName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateProjectVersion' {Text
versionName :: Text
$sel:versionName:CreateProjectVersion' :: CreateProjectVersion -> Text
versionName} -> Text
versionName) (\s :: CreateProjectVersion
s@CreateProjectVersion' {} Text
a -> CreateProjectVersion
s {$sel:versionName:CreateProjectVersion' :: Text
versionName = Text
a} :: CreateProjectVersion)

-- | The Amazon S3 bucket location to store the results of training. The S3
-- bucket can be in any AWS account as long as the caller has
-- @s3:PutObject@ permissions on the S3 bucket.
createProjectVersion_outputConfig :: Lens.Lens' CreateProjectVersion OutputConfig
createProjectVersion_outputConfig :: Lens' CreateProjectVersion OutputConfig
createProjectVersion_outputConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateProjectVersion' {OutputConfig
outputConfig :: OutputConfig
$sel:outputConfig:CreateProjectVersion' :: CreateProjectVersion -> OutputConfig
outputConfig} -> OutputConfig
outputConfig) (\s :: CreateProjectVersion
s@CreateProjectVersion' {} OutputConfig
a -> CreateProjectVersion
s {$sel:outputConfig:CreateProjectVersion' :: OutputConfig
outputConfig = OutputConfig
a} :: CreateProjectVersion)

instance Core.AWSRequest CreateProjectVersion where
  type
    AWSResponse CreateProjectVersion =
      CreateProjectVersionResponse
  request :: (Service -> Service)
-> CreateProjectVersion -> Request CreateProjectVersion
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 CreateProjectVersion
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateProjectVersion)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text -> Int -> CreateProjectVersionResponse
CreateProjectVersionResponse'
            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
"ProjectVersionArn")
            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 CreateProjectVersion where
  hashWithSalt :: Int -> CreateProjectVersion -> Int
hashWithSalt Int
_salt CreateProjectVersion' {Maybe Text
Maybe (HashMap Text Text)
Maybe TestingData
Maybe TrainingData
Text
OutputConfig
outputConfig :: OutputConfig
versionName :: Text
projectArn :: Text
trainingData :: Maybe TrainingData
testingData :: Maybe TestingData
tags :: Maybe (HashMap Text Text)
kmsKeyId :: Maybe Text
$sel:outputConfig:CreateProjectVersion' :: CreateProjectVersion -> OutputConfig
$sel:versionName:CreateProjectVersion' :: CreateProjectVersion -> Text
$sel:projectArn:CreateProjectVersion' :: CreateProjectVersion -> Text
$sel:trainingData:CreateProjectVersion' :: CreateProjectVersion -> Maybe TrainingData
$sel:testingData:CreateProjectVersion' :: CreateProjectVersion -> Maybe TestingData
$sel:tags:CreateProjectVersion' :: CreateProjectVersion -> Maybe (HashMap Text Text)
$sel:kmsKeyId:CreateProjectVersion' :: CreateProjectVersion -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
kmsKeyId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TestingData
testingData
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TrainingData
trainingData
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
projectArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
versionName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` OutputConfig
outputConfig

instance Prelude.NFData CreateProjectVersion where
  rnf :: CreateProjectVersion -> ()
rnf CreateProjectVersion' {Maybe Text
Maybe (HashMap Text Text)
Maybe TestingData
Maybe TrainingData
Text
OutputConfig
outputConfig :: OutputConfig
versionName :: Text
projectArn :: Text
trainingData :: Maybe TrainingData
testingData :: Maybe TestingData
tags :: Maybe (HashMap Text Text)
kmsKeyId :: Maybe Text
$sel:outputConfig:CreateProjectVersion' :: CreateProjectVersion -> OutputConfig
$sel:versionName:CreateProjectVersion' :: CreateProjectVersion -> Text
$sel:projectArn:CreateProjectVersion' :: CreateProjectVersion -> Text
$sel:trainingData:CreateProjectVersion' :: CreateProjectVersion -> Maybe TrainingData
$sel:testingData:CreateProjectVersion' :: CreateProjectVersion -> Maybe TestingData
$sel:tags:CreateProjectVersion' :: CreateProjectVersion -> Maybe (HashMap Text Text)
$sel:kmsKeyId:CreateProjectVersion' :: CreateProjectVersion -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
kmsKeyId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TestingData
testingData
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TrainingData
trainingData
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
projectArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
versionName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf OutputConfig
outputConfig

instance Data.ToHeaders CreateProjectVersion where
  toHeaders :: CreateProjectVersion -> 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
"RekognitionService.CreateProjectVersion" ::
                          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 CreateProjectVersion where
  toJSON :: CreateProjectVersion -> Value
toJSON CreateProjectVersion' {Maybe Text
Maybe (HashMap Text Text)
Maybe TestingData
Maybe TrainingData
Text
OutputConfig
outputConfig :: OutputConfig
versionName :: Text
projectArn :: Text
trainingData :: Maybe TrainingData
testingData :: Maybe TestingData
tags :: Maybe (HashMap Text Text)
kmsKeyId :: Maybe Text
$sel:outputConfig:CreateProjectVersion' :: CreateProjectVersion -> OutputConfig
$sel:versionName:CreateProjectVersion' :: CreateProjectVersion -> Text
$sel:projectArn:CreateProjectVersion' :: CreateProjectVersion -> Text
$sel:trainingData:CreateProjectVersion' :: CreateProjectVersion -> Maybe TrainingData
$sel:testingData:CreateProjectVersion' :: CreateProjectVersion -> Maybe TestingData
$sel:tags:CreateProjectVersion' :: CreateProjectVersion -> Maybe (HashMap Text Text)
$sel:kmsKeyId:CreateProjectVersion' :: CreateProjectVersion -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"KmsKeyId" 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
kmsKeyId,
            (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 (HashMap Text Text)
tags,
            (Key
"TestingData" 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 TestingData
testingData,
            (Key
"TrainingData" 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 TrainingData
trainingData,
            forall a. a -> Maybe a
Prelude.Just (Key
"ProjectArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
projectArn),
            forall a. a -> Maybe a
Prelude.Just (Key
"VersionName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
versionName),
            forall a. a -> Maybe a
Prelude.Just (Key
"OutputConfig" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= OutputConfig
outputConfig)
          ]
      )

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

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

-- | /See:/ 'newCreateProjectVersionResponse' smart constructor.
data CreateProjectVersionResponse = CreateProjectVersionResponse'
  { -- | The ARN of the model version that was created. Use
    -- @DescribeProjectVersion@ to get the current status of the training
    -- operation.
    CreateProjectVersionResponse -> Maybe Text
projectVersionArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CreateProjectVersionResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateProjectVersionResponse
-> CreateProjectVersionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateProjectVersionResponse
-> CreateProjectVersionResponse -> Bool
$c/= :: CreateProjectVersionResponse
-> CreateProjectVersionResponse -> Bool
== :: CreateProjectVersionResponse
-> CreateProjectVersionResponse -> Bool
$c== :: CreateProjectVersionResponse
-> CreateProjectVersionResponse -> Bool
Prelude.Eq, ReadPrec [CreateProjectVersionResponse]
ReadPrec CreateProjectVersionResponse
Int -> ReadS CreateProjectVersionResponse
ReadS [CreateProjectVersionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateProjectVersionResponse]
$creadListPrec :: ReadPrec [CreateProjectVersionResponse]
readPrec :: ReadPrec CreateProjectVersionResponse
$creadPrec :: ReadPrec CreateProjectVersionResponse
readList :: ReadS [CreateProjectVersionResponse]
$creadList :: ReadS [CreateProjectVersionResponse]
readsPrec :: Int -> ReadS CreateProjectVersionResponse
$creadsPrec :: Int -> ReadS CreateProjectVersionResponse
Prelude.Read, Int -> CreateProjectVersionResponse -> ShowS
[CreateProjectVersionResponse] -> ShowS
CreateProjectVersionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateProjectVersionResponse] -> ShowS
$cshowList :: [CreateProjectVersionResponse] -> ShowS
show :: CreateProjectVersionResponse -> String
$cshow :: CreateProjectVersionResponse -> String
showsPrec :: Int -> CreateProjectVersionResponse -> ShowS
$cshowsPrec :: Int -> CreateProjectVersionResponse -> ShowS
Prelude.Show, forall x.
Rep CreateProjectVersionResponse x -> CreateProjectVersionResponse
forall x.
CreateProjectVersionResponse -> Rep CreateProjectVersionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateProjectVersionResponse x -> CreateProjectVersionResponse
$cfrom :: forall x.
CreateProjectVersionResponse -> Rep CreateProjectVersionResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateProjectVersionResponse' 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:
--
-- 'projectVersionArn', 'createProjectVersionResponse_projectVersionArn' - The ARN of the model version that was created. Use
-- @DescribeProjectVersion@ to get the current status of the training
-- operation.
--
-- 'httpStatus', 'createProjectVersionResponse_httpStatus' - The response's http status code.
newCreateProjectVersionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateProjectVersionResponse
newCreateProjectVersionResponse :: Int -> CreateProjectVersionResponse
newCreateProjectVersionResponse Int
pHttpStatus_ =
  CreateProjectVersionResponse'
    { $sel:projectVersionArn:CreateProjectVersionResponse' :: Maybe Text
projectVersionArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateProjectVersionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the model version that was created. Use
-- @DescribeProjectVersion@ to get the current status of the training
-- operation.
createProjectVersionResponse_projectVersionArn :: Lens.Lens' CreateProjectVersionResponse (Prelude.Maybe Prelude.Text)
createProjectVersionResponse_projectVersionArn :: Lens' CreateProjectVersionResponse (Maybe Text)
createProjectVersionResponse_projectVersionArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateProjectVersionResponse' {Maybe Text
projectVersionArn :: Maybe Text
$sel:projectVersionArn:CreateProjectVersionResponse' :: CreateProjectVersionResponse -> Maybe Text
projectVersionArn} -> Maybe Text
projectVersionArn) (\s :: CreateProjectVersionResponse
s@CreateProjectVersionResponse' {} Maybe Text
a -> CreateProjectVersionResponse
s {$sel:projectVersionArn:CreateProjectVersionResponse' :: Maybe Text
projectVersionArn = Maybe Text
a} :: CreateProjectVersionResponse)

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

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