{-# 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.CopyProjectVersion
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Copies a version of an Amazon Rekognition Custom Labels model from a
-- source project to a destination project. The source and destination
-- projects can be in different AWS accounts but must be in the same AWS
-- Region. You can\'t copy a model to another AWS service.
--
-- To copy a model version to a different AWS account, you need to create a
-- resource-based policy known as a /project policy/. You attach the
-- project policy to the source project by calling PutProjectPolicy. The
-- project policy gives permission to copy the model version from a
-- trusting AWS account to a trusted account.
--
-- For more information creating and attaching a project policy, see
-- Attaching a project policy (SDK) in the /Amazon Rekognition Custom
-- Labels Developer Guide/.
--
-- If you are copying a model version to a project in the same AWS account,
-- you don\'t need to create a project policy.
--
-- To copy a model, the destination project, source project, and source
-- model version must already exist.
--
-- Copying a model version takes a while to complete. To get the current
-- status, call DescribeProjectVersions and check the value of @Status@ in
-- the ProjectVersionDescription object. The copy operation has finished
-- when the value of @Status@ is @COPYING_COMPLETED@.
module Amazonka.Rekognition.CopyProjectVersion
  ( -- * Creating a Request
    CopyProjectVersion (..),
    newCopyProjectVersion,

    -- * Request Lenses
    copyProjectVersion_kmsKeyId,
    copyProjectVersion_tags,
    copyProjectVersion_sourceProjectArn,
    copyProjectVersion_sourceProjectVersionArn,
    copyProjectVersion_destinationProjectArn,
    copyProjectVersion_versionName,
    copyProjectVersion_outputConfig,

    -- * Destructuring the Response
    CopyProjectVersionResponse (..),
    newCopyProjectVersionResponse,

    -- * Response Lenses
    copyProjectVersionResponse_projectVersionArn,
    copyProjectVersionResponse_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:/ 'newCopyProjectVersion' smart constructor.
data CopyProjectVersion = CopyProjectVersion'
  { -- | 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 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.
    CopyProjectVersion -> Maybe Text
kmsKeyId :: Prelude.Maybe Prelude.Text,
    -- | The key-value tags to assign to the model version.
    CopyProjectVersion -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The ARN of the source project in the trusting AWS account.
    CopyProjectVersion -> Text
sourceProjectArn :: Prelude.Text,
    -- | The ARN of the model version in the source project that you want to copy
    -- to a destination project.
    CopyProjectVersion -> Text
sourceProjectVersionArn :: Prelude.Text,
    -- | The ARN of the project in the trusted AWS account that you want to copy
    -- the model version to.
    CopyProjectVersion -> Text
destinationProjectArn :: Prelude.Text,
    -- | A name for the version of the model that\'s copied to the destination
    -- project.
    CopyProjectVersion -> Text
versionName :: Prelude.Text,
    -- | The S3 bucket and folder location where the training output for the
    -- source model version is placed.
    CopyProjectVersion -> OutputConfig
outputConfig :: OutputConfig
  }
  deriving (CopyProjectVersion -> CopyProjectVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CopyProjectVersion -> CopyProjectVersion -> Bool
$c/= :: CopyProjectVersion -> CopyProjectVersion -> Bool
== :: CopyProjectVersion -> CopyProjectVersion -> Bool
$c== :: CopyProjectVersion -> CopyProjectVersion -> Bool
Prelude.Eq, ReadPrec [CopyProjectVersion]
ReadPrec CopyProjectVersion
Int -> ReadS CopyProjectVersion
ReadS [CopyProjectVersion]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CopyProjectVersion]
$creadListPrec :: ReadPrec [CopyProjectVersion]
readPrec :: ReadPrec CopyProjectVersion
$creadPrec :: ReadPrec CopyProjectVersion
readList :: ReadS [CopyProjectVersion]
$creadList :: ReadS [CopyProjectVersion]
readsPrec :: Int -> ReadS CopyProjectVersion
$creadsPrec :: Int -> ReadS CopyProjectVersion
Prelude.Read, Int -> CopyProjectVersion -> ShowS
[CopyProjectVersion] -> ShowS
CopyProjectVersion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CopyProjectVersion] -> ShowS
$cshowList :: [CopyProjectVersion] -> ShowS
show :: CopyProjectVersion -> String
$cshow :: CopyProjectVersion -> String
showsPrec :: Int -> CopyProjectVersion -> ShowS
$cshowsPrec :: Int -> CopyProjectVersion -> ShowS
Prelude.Show, forall x. Rep CopyProjectVersion x -> CopyProjectVersion
forall x. CopyProjectVersion -> Rep CopyProjectVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CopyProjectVersion x -> CopyProjectVersion
$cfrom :: forall x. CopyProjectVersion -> Rep CopyProjectVersion x
Prelude.Generic)

-- |
-- Create a value of 'CopyProjectVersion' 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', 'copyProjectVersion_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 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', 'copyProjectVersion_tags' - The key-value tags to assign to the model version.
--
-- 'sourceProjectArn', 'copyProjectVersion_sourceProjectArn' - The ARN of the source project in the trusting AWS account.
--
-- 'sourceProjectVersionArn', 'copyProjectVersion_sourceProjectVersionArn' - The ARN of the model version in the source project that you want to copy
-- to a destination project.
--
-- 'destinationProjectArn', 'copyProjectVersion_destinationProjectArn' - The ARN of the project in the trusted AWS account that you want to copy
-- the model version to.
--
-- 'versionName', 'copyProjectVersion_versionName' - A name for the version of the model that\'s copied to the destination
-- project.
--
-- 'outputConfig', 'copyProjectVersion_outputConfig' - The S3 bucket and folder location where the training output for the
-- source model version is placed.
newCopyProjectVersion ::
  -- | 'sourceProjectArn'
  Prelude.Text ->
  -- | 'sourceProjectVersionArn'
  Prelude.Text ->
  -- | 'destinationProjectArn'
  Prelude.Text ->
  -- | 'versionName'
  Prelude.Text ->
  -- | 'outputConfig'
  OutputConfig ->
  CopyProjectVersion
newCopyProjectVersion :: Text -> Text -> Text -> Text -> OutputConfig -> CopyProjectVersion
newCopyProjectVersion
  Text
pSourceProjectArn_
  Text
pSourceProjectVersionArn_
  Text
pDestinationProjectArn_
  Text
pVersionName_
  OutputConfig
pOutputConfig_ =
    CopyProjectVersion'
      { $sel:kmsKeyId:CopyProjectVersion' :: Maybe Text
kmsKeyId = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CopyProjectVersion' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:sourceProjectArn:CopyProjectVersion' :: Text
sourceProjectArn = Text
pSourceProjectArn_,
        $sel:sourceProjectVersionArn:CopyProjectVersion' :: Text
sourceProjectVersionArn = Text
pSourceProjectVersionArn_,
        $sel:destinationProjectArn:CopyProjectVersion' :: Text
destinationProjectArn = Text
pDestinationProjectArn_,
        $sel:versionName:CopyProjectVersion' :: Text
versionName = Text
pVersionName_,
        $sel:outputConfig:CopyProjectVersion' :: 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 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.
copyProjectVersion_kmsKeyId :: Lens.Lens' CopyProjectVersion (Prelude.Maybe Prelude.Text)
copyProjectVersion_kmsKeyId :: Lens' CopyProjectVersion (Maybe Text)
copyProjectVersion_kmsKeyId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyProjectVersion' {Maybe Text
kmsKeyId :: Maybe Text
$sel:kmsKeyId:CopyProjectVersion' :: CopyProjectVersion -> Maybe Text
kmsKeyId} -> Maybe Text
kmsKeyId) (\s :: CopyProjectVersion
s@CopyProjectVersion' {} Maybe Text
a -> CopyProjectVersion
s {$sel:kmsKeyId:CopyProjectVersion' :: Maybe Text
kmsKeyId = Maybe Text
a} :: CopyProjectVersion)

-- | The key-value tags to assign to the model version.
copyProjectVersion_tags :: Lens.Lens' CopyProjectVersion (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
copyProjectVersion_tags :: Lens' CopyProjectVersion (Maybe (HashMap Text Text))
copyProjectVersion_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyProjectVersion' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CopyProjectVersion' :: CopyProjectVersion -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CopyProjectVersion
s@CopyProjectVersion' {} Maybe (HashMap Text Text)
a -> CopyProjectVersion
s {$sel:tags:CopyProjectVersion' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CopyProjectVersion) 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 ARN of the source project in the trusting AWS account.
copyProjectVersion_sourceProjectArn :: Lens.Lens' CopyProjectVersion Prelude.Text
copyProjectVersion_sourceProjectArn :: Lens' CopyProjectVersion Text
copyProjectVersion_sourceProjectArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyProjectVersion' {Text
sourceProjectArn :: Text
$sel:sourceProjectArn:CopyProjectVersion' :: CopyProjectVersion -> Text
sourceProjectArn} -> Text
sourceProjectArn) (\s :: CopyProjectVersion
s@CopyProjectVersion' {} Text
a -> CopyProjectVersion
s {$sel:sourceProjectArn:CopyProjectVersion' :: Text
sourceProjectArn = Text
a} :: CopyProjectVersion)

-- | The ARN of the model version in the source project that you want to copy
-- to a destination project.
copyProjectVersion_sourceProjectVersionArn :: Lens.Lens' CopyProjectVersion Prelude.Text
copyProjectVersion_sourceProjectVersionArn :: Lens' CopyProjectVersion Text
copyProjectVersion_sourceProjectVersionArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyProjectVersion' {Text
sourceProjectVersionArn :: Text
$sel:sourceProjectVersionArn:CopyProjectVersion' :: CopyProjectVersion -> Text
sourceProjectVersionArn} -> Text
sourceProjectVersionArn) (\s :: CopyProjectVersion
s@CopyProjectVersion' {} Text
a -> CopyProjectVersion
s {$sel:sourceProjectVersionArn:CopyProjectVersion' :: Text
sourceProjectVersionArn = Text
a} :: CopyProjectVersion)

-- | The ARN of the project in the trusted AWS account that you want to copy
-- the model version to.
copyProjectVersion_destinationProjectArn :: Lens.Lens' CopyProjectVersion Prelude.Text
copyProjectVersion_destinationProjectArn :: Lens' CopyProjectVersion Text
copyProjectVersion_destinationProjectArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyProjectVersion' {Text
destinationProjectArn :: Text
$sel:destinationProjectArn:CopyProjectVersion' :: CopyProjectVersion -> Text
destinationProjectArn} -> Text
destinationProjectArn) (\s :: CopyProjectVersion
s@CopyProjectVersion' {} Text
a -> CopyProjectVersion
s {$sel:destinationProjectArn:CopyProjectVersion' :: Text
destinationProjectArn = Text
a} :: CopyProjectVersion)

-- | A name for the version of the model that\'s copied to the destination
-- project.
copyProjectVersion_versionName :: Lens.Lens' CopyProjectVersion Prelude.Text
copyProjectVersion_versionName :: Lens' CopyProjectVersion Text
copyProjectVersion_versionName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyProjectVersion' {Text
versionName :: Text
$sel:versionName:CopyProjectVersion' :: CopyProjectVersion -> Text
versionName} -> Text
versionName) (\s :: CopyProjectVersion
s@CopyProjectVersion' {} Text
a -> CopyProjectVersion
s {$sel:versionName:CopyProjectVersion' :: Text
versionName = Text
a} :: CopyProjectVersion)

-- | The S3 bucket and folder location where the training output for the
-- source model version is placed.
copyProjectVersion_outputConfig :: Lens.Lens' CopyProjectVersion OutputConfig
copyProjectVersion_outputConfig :: Lens' CopyProjectVersion OutputConfig
copyProjectVersion_outputConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyProjectVersion' {OutputConfig
outputConfig :: OutputConfig
$sel:outputConfig:CopyProjectVersion' :: CopyProjectVersion -> OutputConfig
outputConfig} -> OutputConfig
outputConfig) (\s :: CopyProjectVersion
s@CopyProjectVersion' {} OutputConfig
a -> CopyProjectVersion
s {$sel:outputConfig:CopyProjectVersion' :: OutputConfig
outputConfig = OutputConfig
a} :: CopyProjectVersion)

instance Core.AWSRequest CopyProjectVersion where
  type
    AWSResponse CopyProjectVersion =
      CopyProjectVersionResponse
  request :: (Service -> Service)
-> CopyProjectVersion -> Request CopyProjectVersion
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 CopyProjectVersion
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CopyProjectVersion)))
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 -> CopyProjectVersionResponse
CopyProjectVersionResponse'
            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 CopyProjectVersion where
  hashWithSalt :: Int -> CopyProjectVersion -> Int
hashWithSalt Int
_salt CopyProjectVersion' {Maybe Text
Maybe (HashMap Text Text)
Text
OutputConfig
outputConfig :: OutputConfig
versionName :: Text
destinationProjectArn :: Text
sourceProjectVersionArn :: Text
sourceProjectArn :: Text
tags :: Maybe (HashMap Text Text)
kmsKeyId :: Maybe Text
$sel:outputConfig:CopyProjectVersion' :: CopyProjectVersion -> OutputConfig
$sel:versionName:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:destinationProjectArn:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:sourceProjectVersionArn:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:sourceProjectArn:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:tags:CopyProjectVersion' :: CopyProjectVersion -> Maybe (HashMap Text Text)
$sel:kmsKeyId:CopyProjectVersion' :: CopyProjectVersion -> 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` Text
sourceProjectArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
sourceProjectVersionArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
destinationProjectArn
      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 CopyProjectVersion where
  rnf :: CopyProjectVersion -> ()
rnf CopyProjectVersion' {Maybe Text
Maybe (HashMap Text Text)
Text
OutputConfig
outputConfig :: OutputConfig
versionName :: Text
destinationProjectArn :: Text
sourceProjectVersionArn :: Text
sourceProjectArn :: Text
tags :: Maybe (HashMap Text Text)
kmsKeyId :: Maybe Text
$sel:outputConfig:CopyProjectVersion' :: CopyProjectVersion -> OutputConfig
$sel:versionName:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:destinationProjectArn:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:sourceProjectVersionArn:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:sourceProjectArn:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:tags:CopyProjectVersion' :: CopyProjectVersion -> Maybe (HashMap Text Text)
$sel:kmsKeyId:CopyProjectVersion' :: CopyProjectVersion -> 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 Text
sourceProjectArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
sourceProjectVersionArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
destinationProjectArn
      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 CopyProjectVersion where
  toHeaders :: CopyProjectVersion -> 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.CopyProjectVersion" ::
                          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 CopyProjectVersion where
  toJSON :: CopyProjectVersion -> Value
toJSON CopyProjectVersion' {Maybe Text
Maybe (HashMap Text Text)
Text
OutputConfig
outputConfig :: OutputConfig
versionName :: Text
destinationProjectArn :: Text
sourceProjectVersionArn :: Text
sourceProjectArn :: Text
tags :: Maybe (HashMap Text Text)
kmsKeyId :: Maybe Text
$sel:outputConfig:CopyProjectVersion' :: CopyProjectVersion -> OutputConfig
$sel:versionName:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:destinationProjectArn:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:sourceProjectVersionArn:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:sourceProjectArn:CopyProjectVersion' :: CopyProjectVersion -> Text
$sel:tags:CopyProjectVersion' :: CopyProjectVersion -> Maybe (HashMap Text Text)
$sel:kmsKeyId:CopyProjectVersion' :: CopyProjectVersion -> 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,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"SourceProjectArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
sourceProjectArn),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"SourceProjectVersionArn"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
sourceProjectVersionArn
              ),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"DestinationProjectArn"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
destinationProjectArn
              ),
            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 CopyProjectVersion where
  toPath :: CopyProjectVersion -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

-- | /See:/ 'newCopyProjectVersionResponse' smart constructor.
data CopyProjectVersionResponse = CopyProjectVersionResponse'
  { -- | The ARN of the copied model version in the destination project.
    CopyProjectVersionResponse -> Maybe Text
projectVersionArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CopyProjectVersionResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CopyProjectVersionResponse -> CopyProjectVersionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CopyProjectVersionResponse -> CopyProjectVersionResponse -> Bool
$c/= :: CopyProjectVersionResponse -> CopyProjectVersionResponse -> Bool
== :: CopyProjectVersionResponse -> CopyProjectVersionResponse -> Bool
$c== :: CopyProjectVersionResponse -> CopyProjectVersionResponse -> Bool
Prelude.Eq, ReadPrec [CopyProjectVersionResponse]
ReadPrec CopyProjectVersionResponse
Int -> ReadS CopyProjectVersionResponse
ReadS [CopyProjectVersionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CopyProjectVersionResponse]
$creadListPrec :: ReadPrec [CopyProjectVersionResponse]
readPrec :: ReadPrec CopyProjectVersionResponse
$creadPrec :: ReadPrec CopyProjectVersionResponse
readList :: ReadS [CopyProjectVersionResponse]
$creadList :: ReadS [CopyProjectVersionResponse]
readsPrec :: Int -> ReadS CopyProjectVersionResponse
$creadsPrec :: Int -> ReadS CopyProjectVersionResponse
Prelude.Read, Int -> CopyProjectVersionResponse -> ShowS
[CopyProjectVersionResponse] -> ShowS
CopyProjectVersionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CopyProjectVersionResponse] -> ShowS
$cshowList :: [CopyProjectVersionResponse] -> ShowS
show :: CopyProjectVersionResponse -> String
$cshow :: CopyProjectVersionResponse -> String
showsPrec :: Int -> CopyProjectVersionResponse -> ShowS
$cshowsPrec :: Int -> CopyProjectVersionResponse -> ShowS
Prelude.Show, forall x.
Rep CopyProjectVersionResponse x -> CopyProjectVersionResponse
forall x.
CopyProjectVersionResponse -> Rep CopyProjectVersionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CopyProjectVersionResponse x -> CopyProjectVersionResponse
$cfrom :: forall x.
CopyProjectVersionResponse -> Rep CopyProjectVersionResponse x
Prelude.Generic)

-- |
-- Create a value of 'CopyProjectVersionResponse' 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', 'copyProjectVersionResponse_projectVersionArn' - The ARN of the copied model version in the destination project.
--
-- 'httpStatus', 'copyProjectVersionResponse_httpStatus' - The response's http status code.
newCopyProjectVersionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CopyProjectVersionResponse
newCopyProjectVersionResponse :: Int -> CopyProjectVersionResponse
newCopyProjectVersionResponse Int
pHttpStatus_ =
  CopyProjectVersionResponse'
    { $sel:projectVersionArn:CopyProjectVersionResponse' :: Maybe Text
projectVersionArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CopyProjectVersionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the copied model version in the destination project.
copyProjectVersionResponse_projectVersionArn :: Lens.Lens' CopyProjectVersionResponse (Prelude.Maybe Prelude.Text)
copyProjectVersionResponse_projectVersionArn :: Lens' CopyProjectVersionResponse (Maybe Text)
copyProjectVersionResponse_projectVersionArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyProjectVersionResponse' {Maybe Text
projectVersionArn :: Maybe Text
$sel:projectVersionArn:CopyProjectVersionResponse' :: CopyProjectVersionResponse -> Maybe Text
projectVersionArn} -> Maybe Text
projectVersionArn) (\s :: CopyProjectVersionResponse
s@CopyProjectVersionResponse' {} Maybe Text
a -> CopyProjectVersionResponse
s {$sel:projectVersionArn:CopyProjectVersionResponse' :: Maybe Text
projectVersionArn = Maybe Text
a} :: CopyProjectVersionResponse)

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

instance Prelude.NFData CopyProjectVersionResponse where
  rnf :: CopyProjectVersionResponse -> ()
rnf CopyProjectVersionResponse' {Int
Maybe Text
httpStatus :: Int
projectVersionArn :: Maybe Text
$sel:httpStatus:CopyProjectVersionResponse' :: CopyProjectVersionResponse -> Int
$sel:projectVersionArn:CopyProjectVersionResponse' :: CopyProjectVersionResponse -> 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