{-# 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.Transcribe.CreateLanguageModel
-- 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 custom language model.
--
-- When creating a new custom language model, you must specify:
--
-- -   If you want a Wideband (audio sample rates over 16,000 Hz) or
--     Narrowband (audio sample rates under 16,000 Hz) base model
--
-- -   The location of your training and tuning files (this must be an
--     Amazon S3 URI)
--
-- -   The language of your model
--
-- -   A unique name for your model
module Amazonka.Transcribe.CreateLanguageModel
  ( -- * Creating a Request
    CreateLanguageModel (..),
    newCreateLanguageModel,

    -- * Request Lenses
    createLanguageModel_tags,
    createLanguageModel_languageCode,
    createLanguageModel_baseModelName,
    createLanguageModel_modelName,
    createLanguageModel_inputDataConfig,

    -- * Destructuring the Response
    CreateLanguageModelResponse (..),
    newCreateLanguageModelResponse,

    -- * Response Lenses
    createLanguageModelResponse_baseModelName,
    createLanguageModelResponse_inputDataConfig,
    createLanguageModelResponse_languageCode,
    createLanguageModelResponse_modelName,
    createLanguageModelResponse_modelStatus,
    createLanguageModelResponse_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 qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.Transcribe.Types

-- | /See:/ 'newCreateLanguageModel' smart constructor.
data CreateLanguageModel = CreateLanguageModel'
  { -- | Adds one or more custom tags, each in the form of a key:value pair, to a
    -- new custom language model at the time you create this new model.
    --
    -- To learn more about using tags with Amazon Transcribe, refer to
    -- <https://docs.aws.amazon.com/transcribe/latest/dg/tagging.html Tagging resources>.
    CreateLanguageModel -> Maybe (NonEmpty Tag)
tags :: Prelude.Maybe (Prelude.NonEmpty Tag),
    -- | The language code that represents the language of your model. Each
    -- custom language model must contain terms in only one language, and the
    -- language you select for your custom language model must match the
    -- language of your training and tuning data.
    --
    -- For a list of supported languages and their associated language codes,
    -- refer to the
    -- <https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html Supported languages>
    -- table. Note that US English (@en-US@) is the only language supported
    -- with Amazon Transcribe Medical.
    --
    -- A custom language model can only be used to transcribe files in the same
    -- language as the model. For example, if you create a custom language
    -- model using US English (@en-US@), you can only apply this model to files
    -- that contain English audio.
    CreateLanguageModel -> CLMLanguageCode
languageCode :: CLMLanguageCode,
    -- | The Amazon Transcribe standard language model, or base model, used to
    -- create your custom language model. Amazon Transcribe offers two options
    -- for base models: Wideband and Narrowband.
    --
    -- If the audio you want to transcribe has a sample rate of 16,000 Hz or
    -- greater, choose @WideBand@. To transcribe audio with a sample rate less
    -- than 16,000 Hz, choose @NarrowBand@.
    CreateLanguageModel -> BaseModelName
baseModelName :: BaseModelName,
    -- | A unique name, chosen by you, for your custom language model.
    --
    -- This name is case sensitive, cannot contain spaces, and must be unique
    -- within an Amazon Web Services account. If you try to create a new custom
    -- language model with the same name as an existing custom language model,
    -- you get a @ConflictException@ error.
    CreateLanguageModel -> Text
modelName :: Prelude.Text,
    -- | Contains the Amazon S3 location of the training data you want to use to
    -- create a new custom language model, and permissions to access this
    -- location.
    --
    -- When using @InputDataConfig@, you must include these sub-parameters:
    -- @S3Uri@, which is the Amazon S3 location of your training data, and
    -- @DataAccessRoleArn@, which is the Amazon Resource Name (ARN) of the role
    -- that has permission to access your specified Amazon S3 location. You can
    -- optionally include @TuningDataS3Uri@, which is the Amazon S3 location of
    -- your tuning data. If you specify different Amazon S3 locations for
    -- training and tuning data, the ARN you use must have permissions to
    -- access both locations.
    CreateLanguageModel -> InputDataConfig
inputDataConfig :: InputDataConfig
  }
  deriving (CreateLanguageModel -> CreateLanguageModel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateLanguageModel -> CreateLanguageModel -> Bool
$c/= :: CreateLanguageModel -> CreateLanguageModel -> Bool
== :: CreateLanguageModel -> CreateLanguageModel -> Bool
$c== :: CreateLanguageModel -> CreateLanguageModel -> Bool
Prelude.Eq, ReadPrec [CreateLanguageModel]
ReadPrec CreateLanguageModel
Int -> ReadS CreateLanguageModel
ReadS [CreateLanguageModel]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateLanguageModel]
$creadListPrec :: ReadPrec [CreateLanguageModel]
readPrec :: ReadPrec CreateLanguageModel
$creadPrec :: ReadPrec CreateLanguageModel
readList :: ReadS [CreateLanguageModel]
$creadList :: ReadS [CreateLanguageModel]
readsPrec :: Int -> ReadS CreateLanguageModel
$creadsPrec :: Int -> ReadS CreateLanguageModel
Prelude.Read, Int -> CreateLanguageModel -> ShowS
[CreateLanguageModel] -> ShowS
CreateLanguageModel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateLanguageModel] -> ShowS
$cshowList :: [CreateLanguageModel] -> ShowS
show :: CreateLanguageModel -> String
$cshow :: CreateLanguageModel -> String
showsPrec :: Int -> CreateLanguageModel -> ShowS
$cshowsPrec :: Int -> CreateLanguageModel -> ShowS
Prelude.Show, forall x. Rep CreateLanguageModel x -> CreateLanguageModel
forall x. CreateLanguageModel -> Rep CreateLanguageModel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateLanguageModel x -> CreateLanguageModel
$cfrom :: forall x. CreateLanguageModel -> Rep CreateLanguageModel x
Prelude.Generic)

-- |
-- Create a value of 'CreateLanguageModel' 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:
--
-- 'tags', 'createLanguageModel_tags' - Adds one or more custom tags, each in the form of a key:value pair, to a
-- new custom language model at the time you create this new model.
--
-- To learn more about using tags with Amazon Transcribe, refer to
-- <https://docs.aws.amazon.com/transcribe/latest/dg/tagging.html Tagging resources>.
--
-- 'languageCode', 'createLanguageModel_languageCode' - The language code that represents the language of your model. Each
-- custom language model must contain terms in only one language, and the
-- language you select for your custom language model must match the
-- language of your training and tuning data.
--
-- For a list of supported languages and their associated language codes,
-- refer to the
-- <https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html Supported languages>
-- table. Note that US English (@en-US@) is the only language supported
-- with Amazon Transcribe Medical.
--
-- A custom language model can only be used to transcribe files in the same
-- language as the model. For example, if you create a custom language
-- model using US English (@en-US@), you can only apply this model to files
-- that contain English audio.
--
-- 'baseModelName', 'createLanguageModel_baseModelName' - The Amazon Transcribe standard language model, or base model, used to
-- create your custom language model. Amazon Transcribe offers two options
-- for base models: Wideband and Narrowband.
--
-- If the audio you want to transcribe has a sample rate of 16,000 Hz or
-- greater, choose @WideBand@. To transcribe audio with a sample rate less
-- than 16,000 Hz, choose @NarrowBand@.
--
-- 'modelName', 'createLanguageModel_modelName' - A unique name, chosen by you, for your custom language model.
--
-- This name is case sensitive, cannot contain spaces, and must be unique
-- within an Amazon Web Services account. If you try to create a new custom
-- language model with the same name as an existing custom language model,
-- you get a @ConflictException@ error.
--
-- 'inputDataConfig', 'createLanguageModel_inputDataConfig' - Contains the Amazon S3 location of the training data you want to use to
-- create a new custom language model, and permissions to access this
-- location.
--
-- When using @InputDataConfig@, you must include these sub-parameters:
-- @S3Uri@, which is the Amazon S3 location of your training data, and
-- @DataAccessRoleArn@, which is the Amazon Resource Name (ARN) of the role
-- that has permission to access your specified Amazon S3 location. You can
-- optionally include @TuningDataS3Uri@, which is the Amazon S3 location of
-- your tuning data. If you specify different Amazon S3 locations for
-- training and tuning data, the ARN you use must have permissions to
-- access both locations.
newCreateLanguageModel ::
  -- | 'languageCode'
  CLMLanguageCode ->
  -- | 'baseModelName'
  BaseModelName ->
  -- | 'modelName'
  Prelude.Text ->
  -- | 'inputDataConfig'
  InputDataConfig ->
  CreateLanguageModel
newCreateLanguageModel :: CLMLanguageCode
-> BaseModelName -> Text -> InputDataConfig -> CreateLanguageModel
newCreateLanguageModel
  CLMLanguageCode
pLanguageCode_
  BaseModelName
pBaseModelName_
  Text
pModelName_
  InputDataConfig
pInputDataConfig_ =
    CreateLanguageModel'
      { $sel:tags:CreateLanguageModel' :: Maybe (NonEmpty Tag)
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:languageCode:CreateLanguageModel' :: CLMLanguageCode
languageCode = CLMLanguageCode
pLanguageCode_,
        $sel:baseModelName:CreateLanguageModel' :: BaseModelName
baseModelName = BaseModelName
pBaseModelName_,
        $sel:modelName:CreateLanguageModel' :: Text
modelName = Text
pModelName_,
        $sel:inputDataConfig:CreateLanguageModel' :: InputDataConfig
inputDataConfig = InputDataConfig
pInputDataConfig_
      }

-- | Adds one or more custom tags, each in the form of a key:value pair, to a
-- new custom language model at the time you create this new model.
--
-- To learn more about using tags with Amazon Transcribe, refer to
-- <https://docs.aws.amazon.com/transcribe/latest/dg/tagging.html Tagging resources>.
createLanguageModel_tags :: Lens.Lens' CreateLanguageModel (Prelude.Maybe (Prelude.NonEmpty Tag))
createLanguageModel_tags :: Lens' CreateLanguageModel (Maybe (NonEmpty Tag))
createLanguageModel_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLanguageModel' {Maybe (NonEmpty Tag)
tags :: Maybe (NonEmpty Tag)
$sel:tags:CreateLanguageModel' :: CreateLanguageModel -> Maybe (NonEmpty Tag)
tags} -> Maybe (NonEmpty Tag)
tags) (\s :: CreateLanguageModel
s@CreateLanguageModel' {} Maybe (NonEmpty Tag)
a -> CreateLanguageModel
s {$sel:tags:CreateLanguageModel' :: Maybe (NonEmpty Tag)
tags = Maybe (NonEmpty Tag)
a} :: CreateLanguageModel) 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 language code that represents the language of your model. Each
-- custom language model must contain terms in only one language, and the
-- language you select for your custom language model must match the
-- language of your training and tuning data.
--
-- For a list of supported languages and their associated language codes,
-- refer to the
-- <https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html Supported languages>
-- table. Note that US English (@en-US@) is the only language supported
-- with Amazon Transcribe Medical.
--
-- A custom language model can only be used to transcribe files in the same
-- language as the model. For example, if you create a custom language
-- model using US English (@en-US@), you can only apply this model to files
-- that contain English audio.
createLanguageModel_languageCode :: Lens.Lens' CreateLanguageModel CLMLanguageCode
createLanguageModel_languageCode :: Lens' CreateLanguageModel CLMLanguageCode
createLanguageModel_languageCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLanguageModel' {CLMLanguageCode
languageCode :: CLMLanguageCode
$sel:languageCode:CreateLanguageModel' :: CreateLanguageModel -> CLMLanguageCode
languageCode} -> CLMLanguageCode
languageCode) (\s :: CreateLanguageModel
s@CreateLanguageModel' {} CLMLanguageCode
a -> CreateLanguageModel
s {$sel:languageCode:CreateLanguageModel' :: CLMLanguageCode
languageCode = CLMLanguageCode
a} :: CreateLanguageModel)

-- | The Amazon Transcribe standard language model, or base model, used to
-- create your custom language model. Amazon Transcribe offers two options
-- for base models: Wideband and Narrowband.
--
-- If the audio you want to transcribe has a sample rate of 16,000 Hz or
-- greater, choose @WideBand@. To transcribe audio with a sample rate less
-- than 16,000 Hz, choose @NarrowBand@.
createLanguageModel_baseModelName :: Lens.Lens' CreateLanguageModel BaseModelName
createLanguageModel_baseModelName :: Lens' CreateLanguageModel BaseModelName
createLanguageModel_baseModelName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLanguageModel' {BaseModelName
baseModelName :: BaseModelName
$sel:baseModelName:CreateLanguageModel' :: CreateLanguageModel -> BaseModelName
baseModelName} -> BaseModelName
baseModelName) (\s :: CreateLanguageModel
s@CreateLanguageModel' {} BaseModelName
a -> CreateLanguageModel
s {$sel:baseModelName:CreateLanguageModel' :: BaseModelName
baseModelName = BaseModelName
a} :: CreateLanguageModel)

-- | A unique name, chosen by you, for your custom language model.
--
-- This name is case sensitive, cannot contain spaces, and must be unique
-- within an Amazon Web Services account. If you try to create a new custom
-- language model with the same name as an existing custom language model,
-- you get a @ConflictException@ error.
createLanguageModel_modelName :: Lens.Lens' CreateLanguageModel Prelude.Text
createLanguageModel_modelName :: Lens' CreateLanguageModel Text
createLanguageModel_modelName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLanguageModel' {Text
modelName :: Text
$sel:modelName:CreateLanguageModel' :: CreateLanguageModel -> Text
modelName} -> Text
modelName) (\s :: CreateLanguageModel
s@CreateLanguageModel' {} Text
a -> CreateLanguageModel
s {$sel:modelName:CreateLanguageModel' :: Text
modelName = Text
a} :: CreateLanguageModel)

-- | Contains the Amazon S3 location of the training data you want to use to
-- create a new custom language model, and permissions to access this
-- location.
--
-- When using @InputDataConfig@, you must include these sub-parameters:
-- @S3Uri@, which is the Amazon S3 location of your training data, and
-- @DataAccessRoleArn@, which is the Amazon Resource Name (ARN) of the role
-- that has permission to access your specified Amazon S3 location. You can
-- optionally include @TuningDataS3Uri@, which is the Amazon S3 location of
-- your tuning data. If you specify different Amazon S3 locations for
-- training and tuning data, the ARN you use must have permissions to
-- access both locations.
createLanguageModel_inputDataConfig :: Lens.Lens' CreateLanguageModel InputDataConfig
createLanguageModel_inputDataConfig :: Lens' CreateLanguageModel InputDataConfig
createLanguageModel_inputDataConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLanguageModel' {InputDataConfig
inputDataConfig :: InputDataConfig
$sel:inputDataConfig:CreateLanguageModel' :: CreateLanguageModel -> InputDataConfig
inputDataConfig} -> InputDataConfig
inputDataConfig) (\s :: CreateLanguageModel
s@CreateLanguageModel' {} InputDataConfig
a -> CreateLanguageModel
s {$sel:inputDataConfig:CreateLanguageModel' :: InputDataConfig
inputDataConfig = InputDataConfig
a} :: CreateLanguageModel)

instance Core.AWSRequest CreateLanguageModel where
  type
    AWSResponse CreateLanguageModel =
      CreateLanguageModelResponse
  request :: (Service -> Service)
-> CreateLanguageModel -> Request CreateLanguageModel
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 CreateLanguageModel
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateLanguageModel)))
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 BaseModelName
-> Maybe InputDataConfig
-> Maybe CLMLanguageCode
-> Maybe Text
-> Maybe ModelStatus
-> Int
-> CreateLanguageModelResponse
CreateLanguageModelResponse'
            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
"BaseModelName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"InputDataConfig")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"LanguageCode")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"ModelName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"ModelStatus")
            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 CreateLanguageModel where
  hashWithSalt :: Int -> CreateLanguageModel -> Int
hashWithSalt Int
_salt CreateLanguageModel' {Maybe (NonEmpty Tag)
Text
BaseModelName
CLMLanguageCode
InputDataConfig
inputDataConfig :: InputDataConfig
modelName :: Text
baseModelName :: BaseModelName
languageCode :: CLMLanguageCode
tags :: Maybe (NonEmpty Tag)
$sel:inputDataConfig:CreateLanguageModel' :: CreateLanguageModel -> InputDataConfig
$sel:modelName:CreateLanguageModel' :: CreateLanguageModel -> Text
$sel:baseModelName:CreateLanguageModel' :: CreateLanguageModel -> BaseModelName
$sel:languageCode:CreateLanguageModel' :: CreateLanguageModel -> CLMLanguageCode
$sel:tags:CreateLanguageModel' :: CreateLanguageModel -> Maybe (NonEmpty Tag)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Tag)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` CLMLanguageCode
languageCode
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` BaseModelName
baseModelName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
modelName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` InputDataConfig
inputDataConfig

instance Prelude.NFData CreateLanguageModel where
  rnf :: CreateLanguageModel -> ()
rnf CreateLanguageModel' {Maybe (NonEmpty Tag)
Text
BaseModelName
CLMLanguageCode
InputDataConfig
inputDataConfig :: InputDataConfig
modelName :: Text
baseModelName :: BaseModelName
languageCode :: CLMLanguageCode
tags :: Maybe (NonEmpty Tag)
$sel:inputDataConfig:CreateLanguageModel' :: CreateLanguageModel -> InputDataConfig
$sel:modelName:CreateLanguageModel' :: CreateLanguageModel -> Text
$sel:baseModelName:CreateLanguageModel' :: CreateLanguageModel -> BaseModelName
$sel:languageCode:CreateLanguageModel' :: CreateLanguageModel -> CLMLanguageCode
$sel:tags:CreateLanguageModel' :: CreateLanguageModel -> Maybe (NonEmpty Tag)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Tag)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf CLMLanguageCode
languageCode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf BaseModelName
baseModelName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
modelName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf InputDataConfig
inputDataConfig

instance Data.ToHeaders CreateLanguageModel where
  toHeaders :: CreateLanguageModel -> 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
"Transcribe.CreateLanguageModel" ::
                          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 CreateLanguageModel where
  toJSON :: CreateLanguageModel -> Value
toJSON CreateLanguageModel' {Maybe (NonEmpty Tag)
Text
BaseModelName
CLMLanguageCode
InputDataConfig
inputDataConfig :: InputDataConfig
modelName :: Text
baseModelName :: BaseModelName
languageCode :: CLMLanguageCode
tags :: Maybe (NonEmpty Tag)
$sel:inputDataConfig:CreateLanguageModel' :: CreateLanguageModel -> InputDataConfig
$sel:modelName:CreateLanguageModel' :: CreateLanguageModel -> Text
$sel:baseModelName:CreateLanguageModel' :: CreateLanguageModel -> BaseModelName
$sel:languageCode:CreateLanguageModel' :: CreateLanguageModel -> CLMLanguageCode
$sel:tags:CreateLanguageModel' :: CreateLanguageModel -> Maybe (NonEmpty Tag)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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 (NonEmpty Tag)
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"LanguageCode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= CLMLanguageCode
languageCode),
            forall a. a -> Maybe a
Prelude.Just (Key
"BaseModelName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= BaseModelName
baseModelName),
            forall a. a -> Maybe a
Prelude.Just (Key
"ModelName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
modelName),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"InputDataConfig" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= InputDataConfig
inputDataConfig)
          ]
      )

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

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

-- | /See:/ 'newCreateLanguageModelResponse' smart constructor.
data CreateLanguageModelResponse = CreateLanguageModelResponse'
  { -- | The Amazon Transcribe standard language model, or base model, you
    -- specified when creating your custom language model.
    CreateLanguageModelResponse -> Maybe BaseModelName
baseModelName :: Prelude.Maybe BaseModelName,
    -- | Lists your data access role ARN (Amazon Resource Name) and the Amazon S3
    -- locations you provided for your training (@S3Uri@) and tuning
    -- (@TuningDataS3Uri@) data.
    CreateLanguageModelResponse -> Maybe InputDataConfig
inputDataConfig :: Prelude.Maybe InputDataConfig,
    -- | The language code you selected for your custom language model.
    CreateLanguageModelResponse -> Maybe CLMLanguageCode
languageCode :: Prelude.Maybe CLMLanguageCode,
    -- | The name of your custom language model.
    CreateLanguageModelResponse -> Maybe Text
modelName :: Prelude.Maybe Prelude.Text,
    -- | The status of your custom language model. When the status displays as
    -- @COMPLETED@, your model is ready to use.
    CreateLanguageModelResponse -> Maybe ModelStatus
modelStatus :: Prelude.Maybe ModelStatus,
    -- | The response's http status code.
    CreateLanguageModelResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateLanguageModelResponse -> CreateLanguageModelResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateLanguageModelResponse -> CreateLanguageModelResponse -> Bool
$c/= :: CreateLanguageModelResponse -> CreateLanguageModelResponse -> Bool
== :: CreateLanguageModelResponse -> CreateLanguageModelResponse -> Bool
$c== :: CreateLanguageModelResponse -> CreateLanguageModelResponse -> Bool
Prelude.Eq, ReadPrec [CreateLanguageModelResponse]
ReadPrec CreateLanguageModelResponse
Int -> ReadS CreateLanguageModelResponse
ReadS [CreateLanguageModelResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateLanguageModelResponse]
$creadListPrec :: ReadPrec [CreateLanguageModelResponse]
readPrec :: ReadPrec CreateLanguageModelResponse
$creadPrec :: ReadPrec CreateLanguageModelResponse
readList :: ReadS [CreateLanguageModelResponse]
$creadList :: ReadS [CreateLanguageModelResponse]
readsPrec :: Int -> ReadS CreateLanguageModelResponse
$creadsPrec :: Int -> ReadS CreateLanguageModelResponse
Prelude.Read, Int -> CreateLanguageModelResponse -> ShowS
[CreateLanguageModelResponse] -> ShowS
CreateLanguageModelResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateLanguageModelResponse] -> ShowS
$cshowList :: [CreateLanguageModelResponse] -> ShowS
show :: CreateLanguageModelResponse -> String
$cshow :: CreateLanguageModelResponse -> String
showsPrec :: Int -> CreateLanguageModelResponse -> ShowS
$cshowsPrec :: Int -> CreateLanguageModelResponse -> ShowS
Prelude.Show, forall x.
Rep CreateLanguageModelResponse x -> CreateLanguageModelResponse
forall x.
CreateLanguageModelResponse -> Rep CreateLanguageModelResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateLanguageModelResponse x -> CreateLanguageModelResponse
$cfrom :: forall x.
CreateLanguageModelResponse -> Rep CreateLanguageModelResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateLanguageModelResponse' 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:
--
-- 'baseModelName', 'createLanguageModelResponse_baseModelName' - The Amazon Transcribe standard language model, or base model, you
-- specified when creating your custom language model.
--
-- 'inputDataConfig', 'createLanguageModelResponse_inputDataConfig' - Lists your data access role ARN (Amazon Resource Name) and the Amazon S3
-- locations you provided for your training (@S3Uri@) and tuning
-- (@TuningDataS3Uri@) data.
--
-- 'languageCode', 'createLanguageModelResponse_languageCode' - The language code you selected for your custom language model.
--
-- 'modelName', 'createLanguageModelResponse_modelName' - The name of your custom language model.
--
-- 'modelStatus', 'createLanguageModelResponse_modelStatus' - The status of your custom language model. When the status displays as
-- @COMPLETED@, your model is ready to use.
--
-- 'httpStatus', 'createLanguageModelResponse_httpStatus' - The response's http status code.
newCreateLanguageModelResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateLanguageModelResponse
newCreateLanguageModelResponse :: Int -> CreateLanguageModelResponse
newCreateLanguageModelResponse Int
pHttpStatus_ =
  CreateLanguageModelResponse'
    { $sel:baseModelName:CreateLanguageModelResponse' :: Maybe BaseModelName
baseModelName =
        forall a. Maybe a
Prelude.Nothing,
      $sel:inputDataConfig:CreateLanguageModelResponse' :: Maybe InputDataConfig
inputDataConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:languageCode:CreateLanguageModelResponse' :: Maybe CLMLanguageCode
languageCode = forall a. Maybe a
Prelude.Nothing,
      $sel:modelName:CreateLanguageModelResponse' :: Maybe Text
modelName = forall a. Maybe a
Prelude.Nothing,
      $sel:modelStatus:CreateLanguageModelResponse' :: Maybe ModelStatus
modelStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateLanguageModelResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Amazon Transcribe standard language model, or base model, you
-- specified when creating your custom language model.
createLanguageModelResponse_baseModelName :: Lens.Lens' CreateLanguageModelResponse (Prelude.Maybe BaseModelName)
createLanguageModelResponse_baseModelName :: Lens' CreateLanguageModelResponse (Maybe BaseModelName)
createLanguageModelResponse_baseModelName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLanguageModelResponse' {Maybe BaseModelName
baseModelName :: Maybe BaseModelName
$sel:baseModelName:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Maybe BaseModelName
baseModelName} -> Maybe BaseModelName
baseModelName) (\s :: CreateLanguageModelResponse
s@CreateLanguageModelResponse' {} Maybe BaseModelName
a -> CreateLanguageModelResponse
s {$sel:baseModelName:CreateLanguageModelResponse' :: Maybe BaseModelName
baseModelName = Maybe BaseModelName
a} :: CreateLanguageModelResponse)

-- | Lists your data access role ARN (Amazon Resource Name) and the Amazon S3
-- locations you provided for your training (@S3Uri@) and tuning
-- (@TuningDataS3Uri@) data.
createLanguageModelResponse_inputDataConfig :: Lens.Lens' CreateLanguageModelResponse (Prelude.Maybe InputDataConfig)
createLanguageModelResponse_inputDataConfig :: Lens' CreateLanguageModelResponse (Maybe InputDataConfig)
createLanguageModelResponse_inputDataConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLanguageModelResponse' {Maybe InputDataConfig
inputDataConfig :: Maybe InputDataConfig
$sel:inputDataConfig:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Maybe InputDataConfig
inputDataConfig} -> Maybe InputDataConfig
inputDataConfig) (\s :: CreateLanguageModelResponse
s@CreateLanguageModelResponse' {} Maybe InputDataConfig
a -> CreateLanguageModelResponse
s {$sel:inputDataConfig:CreateLanguageModelResponse' :: Maybe InputDataConfig
inputDataConfig = Maybe InputDataConfig
a} :: CreateLanguageModelResponse)

-- | The language code you selected for your custom language model.
createLanguageModelResponse_languageCode :: Lens.Lens' CreateLanguageModelResponse (Prelude.Maybe CLMLanguageCode)
createLanguageModelResponse_languageCode :: Lens' CreateLanguageModelResponse (Maybe CLMLanguageCode)
createLanguageModelResponse_languageCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLanguageModelResponse' {Maybe CLMLanguageCode
languageCode :: Maybe CLMLanguageCode
$sel:languageCode:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Maybe CLMLanguageCode
languageCode} -> Maybe CLMLanguageCode
languageCode) (\s :: CreateLanguageModelResponse
s@CreateLanguageModelResponse' {} Maybe CLMLanguageCode
a -> CreateLanguageModelResponse
s {$sel:languageCode:CreateLanguageModelResponse' :: Maybe CLMLanguageCode
languageCode = Maybe CLMLanguageCode
a} :: CreateLanguageModelResponse)

-- | The name of your custom language model.
createLanguageModelResponse_modelName :: Lens.Lens' CreateLanguageModelResponse (Prelude.Maybe Prelude.Text)
createLanguageModelResponse_modelName :: Lens' CreateLanguageModelResponse (Maybe Text)
createLanguageModelResponse_modelName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLanguageModelResponse' {Maybe Text
modelName :: Maybe Text
$sel:modelName:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Maybe Text
modelName} -> Maybe Text
modelName) (\s :: CreateLanguageModelResponse
s@CreateLanguageModelResponse' {} Maybe Text
a -> CreateLanguageModelResponse
s {$sel:modelName:CreateLanguageModelResponse' :: Maybe Text
modelName = Maybe Text
a} :: CreateLanguageModelResponse)

-- | The status of your custom language model. When the status displays as
-- @COMPLETED@, your model is ready to use.
createLanguageModelResponse_modelStatus :: Lens.Lens' CreateLanguageModelResponse (Prelude.Maybe ModelStatus)
createLanguageModelResponse_modelStatus :: Lens' CreateLanguageModelResponse (Maybe ModelStatus)
createLanguageModelResponse_modelStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLanguageModelResponse' {Maybe ModelStatus
modelStatus :: Maybe ModelStatus
$sel:modelStatus:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Maybe ModelStatus
modelStatus} -> Maybe ModelStatus
modelStatus) (\s :: CreateLanguageModelResponse
s@CreateLanguageModelResponse' {} Maybe ModelStatus
a -> CreateLanguageModelResponse
s {$sel:modelStatus:CreateLanguageModelResponse' :: Maybe ModelStatus
modelStatus = Maybe ModelStatus
a} :: CreateLanguageModelResponse)

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

instance Prelude.NFData CreateLanguageModelResponse where
  rnf :: CreateLanguageModelResponse -> ()
rnf CreateLanguageModelResponse' {Int
Maybe Text
Maybe BaseModelName
Maybe CLMLanguageCode
Maybe InputDataConfig
Maybe ModelStatus
httpStatus :: Int
modelStatus :: Maybe ModelStatus
modelName :: Maybe Text
languageCode :: Maybe CLMLanguageCode
inputDataConfig :: Maybe InputDataConfig
baseModelName :: Maybe BaseModelName
$sel:httpStatus:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Int
$sel:modelStatus:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Maybe ModelStatus
$sel:modelName:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Maybe Text
$sel:languageCode:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Maybe CLMLanguageCode
$sel:inputDataConfig:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Maybe InputDataConfig
$sel:baseModelName:CreateLanguageModelResponse' :: CreateLanguageModelResponse -> Maybe BaseModelName
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe BaseModelName
baseModelName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe InputDataConfig
inputDataConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CLMLanguageCode
languageCode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
modelName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ModelStatus
modelStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus