{-# 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.StartTranscriptionJob
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Starts an asynchronous job to transcribe speech to text.
module Amazonka.Transcribe.StartTranscriptionJob
  ( -- * Creating a Request
    StartTranscriptionJob (..),
    newStartTranscriptionJob,

    -- * Request Lenses
    startTranscriptionJob_contentRedaction,
    startTranscriptionJob_subtitles,
    startTranscriptionJob_languageCode,
    startTranscriptionJob_languageOptions,
    startTranscriptionJob_settings,
    startTranscriptionJob_outputBucketName,
    startTranscriptionJob_mediaFormat,
    startTranscriptionJob_outputEncryptionKMSKeyId,
    startTranscriptionJob_modelSettings,
    startTranscriptionJob_kmsEncryptionContext,
    startTranscriptionJob_jobExecutionSettings,
    startTranscriptionJob_outputKey,
    startTranscriptionJob_identifyLanguage,
    startTranscriptionJob_tags,
    startTranscriptionJob_mediaSampleRateHertz,
    startTranscriptionJob_transcriptionJobName,
    startTranscriptionJob_media,

    -- * Destructuring the Response
    StartTranscriptionJobResponse (..),
    newStartTranscriptionJobResponse,

    -- * Response Lenses
    startTranscriptionJobResponse_transcriptionJob,
    startTranscriptionJobResponse_httpStatus,
  )
where

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

-- | /See:/ 'newStartTranscriptionJob' smart constructor.
data StartTranscriptionJob = StartTranscriptionJob'
  { -- | An object that contains the request parameters for content redaction.
    StartTranscriptionJob -> Maybe ContentRedaction
contentRedaction :: Prelude.Maybe ContentRedaction,
    -- | Add subtitles to your batch transcription job.
    StartTranscriptionJob -> Maybe Subtitles
subtitles :: Prelude.Maybe Subtitles,
    -- | The language code for the language used in the input media file.
    --
    -- To transcribe speech in Modern Standard Arabic (ar-SA), your audio or
    -- video file must be encoded at a sample rate of 16,000 Hz or higher.
    StartTranscriptionJob -> Maybe LanguageCode
languageCode :: Prelude.Maybe LanguageCode,
    -- | An object containing a list of languages that might be present in your
    -- collection of audio files. Automatic language identification chooses a
    -- language that best matches the source audio from that list.
    --
    -- To transcribe speech in Modern Standard Arabic (ar-SA), your audio or
    -- video file must be encoded at a sample rate of 16,000 Hz or higher.
    StartTranscriptionJob -> Maybe (NonEmpty LanguageCode)
languageOptions :: Prelude.Maybe (Prelude.NonEmpty LanguageCode),
    -- | A @Settings@ object that provides optional settings for a transcription
    -- job.
    StartTranscriptionJob -> Maybe Settings
settings :: Prelude.Maybe Settings,
    -- | The location where the transcription is stored.
    --
    -- If you set the @OutputBucketName@, Amazon Transcribe puts the transcript
    -- in the specified S3 bucket. When you call the GetTranscriptionJob
    -- operation, the operation returns this location in the
    -- @TranscriptFileUri@ field. If you enable content redaction, the redacted
    -- transcript appears in @RedactedTranscriptFileUri@. If you enable content
    -- redaction and choose to output an unredacted transcript, that
    -- transcript\'s location still appears in the @TranscriptFileUri@. The S3
    -- bucket must have permissions that allow Amazon Transcribe to put files
    -- in the bucket. For more information, see
    -- <https://docs.aws.amazon.com/transcribe/latest/dg/security_iam_id-based-policy-examples.html#auth-role-iam-user Permissions Required for IAM User Roles>.
    --
    -- You can specify an Amazon Web Services Key Management Service (KMS) key
    -- to encrypt the output of your transcription using the
    -- @OutputEncryptionKMSKeyId@ parameter. If you don\'t specify a KMS key,
    -- Amazon Transcribe uses the default Amazon S3 key for server-side
    -- encryption of transcripts that are placed in your S3 bucket.
    --
    -- If you don\'t set the @OutputBucketName@, Amazon Transcribe generates a
    -- pre-signed URL, a shareable URL that provides secure access to your
    -- transcription, and returns it in the @TranscriptFileUri@ field. Use this
    -- URL to download the transcription.
    StartTranscriptionJob -> Maybe Text
outputBucketName :: Prelude.Maybe Prelude.Text,
    -- | The format of the input media file.
    StartTranscriptionJob -> Maybe MediaFormat
mediaFormat :: Prelude.Maybe MediaFormat,
    -- | The Amazon Resource Name (ARN) of the Amazon Web Services Key Management
    -- Service (KMS) key used to encrypt the output of the transcription job.
    -- The user calling the @StartTranscriptionJob@ operation must have
    -- permission to use the specified KMS key.
    --
    -- You can use either of the following to identify a KMS key in the current
    -- account:
    --
    -- -   KMS Key ID: \"1234abcd-12ab-34cd-56ef-1234567890ab\"
    --
    -- -   KMS Key Alias: \"alias\/ExampleAlias\"
    --
    -- You can use either of the following to identify a KMS key in the current
    -- account or another account:
    --
    -- -   Amazon Resource Name (ARN) of a KMS Key:
    --     \"arn:aws:kms:region:account
    --     ID:key\/1234abcd-12ab-34cd-56ef-1234567890ab\"
    --
    -- -   ARN of a KMS Key Alias: \"arn:aws:kms:region:account
    --     ID:alias\/ExampleAlias\"
    --
    -- If you don\'t specify an encryption key, the output of the transcription
    -- job is encrypted with the default Amazon S3 key (SSE-S3).
    --
    -- If you specify a KMS key to encrypt your output, you must also specify
    -- an output location in the @OutputBucketName@ parameter.
    StartTranscriptionJob -> Maybe Text
outputEncryptionKMSKeyId :: Prelude.Maybe Prelude.Text,
    -- | Choose the custom language model you use for your transcription job in
    -- this parameter.
    StartTranscriptionJob -> Maybe ModelSettings
modelSettings :: Prelude.Maybe ModelSettings,
    -- | A map of plain text, non-secret key:value pairs, known as encryption
    -- context pairs, that provide an added layer of security for your data.
    StartTranscriptionJob -> Maybe (HashMap Text Text)
kmsEncryptionContext :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | Provides information about how a transcription job is executed. Use this
    -- field to indicate that the job can be queued for deferred execution if
    -- the concurrency limit is reached and there are no slots available to
    -- immediately run the job.
    StartTranscriptionJob -> Maybe JobExecutionSettings
jobExecutionSettings :: Prelude.Maybe JobExecutionSettings,
    -- | You can specify a location in an Amazon S3 bucket to store the output of
    -- your transcription job.
    --
    -- If you don\'t specify an output key, Amazon Transcribe stores the output
    -- of your transcription job in the Amazon S3 bucket you specified. By
    -- default, the object key is \"your-transcription-job-name.json\".
    --
    -- You can use output keys to specify the Amazon S3 prefix and file name of
    -- the transcription output. For example, specifying the Amazon S3 prefix,
    -- \"folder1\/folder2\/\", as an output key would lead to the output being
    -- stored as \"folder1\/folder2\/your-transcription-job-name.json\". If you
    -- specify \"my-other-job-name.json\" as the output key, the object key is
    -- changed to \"my-other-job-name.json\". You can use an output key to
    -- change both the prefix and the file name, for example
    -- \"folder\/my-other-job-name.json\".
    --
    -- If you specify an output key, you must also specify an S3 bucket in the
    -- @OutputBucketName@ parameter.
    StartTranscriptionJob -> Maybe Text
outputKey :: Prelude.Maybe Prelude.Text,
    -- | Set this field to @true@ to enable automatic language identification.
    -- Automatic language identification is disabled by default. You receive a
    -- @BadRequestException@ error if you enter a value for a @LanguageCode@.
    StartTranscriptionJob -> Maybe Bool
identifyLanguage :: Prelude.Maybe Prelude.Bool,
    -- | Add tags to an Amazon Transcribe transcription job.
    StartTranscriptionJob -> Maybe (NonEmpty Tag)
tags :: Prelude.Maybe (Prelude.NonEmpty Tag),
    -- | The sample rate, in Hertz, of the audio track in the input media file.
    --
    -- If you do not specify the media sample rate, Amazon Transcribe
    -- determines the sample rate. If you specify the sample rate, it must
    -- match the sample rate detected by Amazon Transcribe. In most cases, you
    -- should leave the @MediaSampleRateHertz@ field blank and let Amazon
    -- Transcribe determine the sample rate.
    StartTranscriptionJob -> Maybe Natural
mediaSampleRateHertz :: Prelude.Maybe Prelude.Natural,
    -- | The name of the job. You can\'t use the strings \"@.@\" or \"@..@\" by
    -- themselves as the job name. The name must also be unique within an
    -- Amazon Web Services account. If you try to create a transcription job
    -- with the same name as a previous transcription job, you get a
    -- @ConflictException@ error.
    StartTranscriptionJob -> Text
transcriptionJobName :: Prelude.Text,
    -- | An object that describes the input media for a transcription job.
    StartTranscriptionJob -> Media
media :: Media
  }
  deriving (StartTranscriptionJob -> StartTranscriptionJob -> Bool
(StartTranscriptionJob -> StartTranscriptionJob -> Bool)
-> (StartTranscriptionJob -> StartTranscriptionJob -> Bool)
-> Eq StartTranscriptionJob
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartTranscriptionJob -> StartTranscriptionJob -> Bool
$c/= :: StartTranscriptionJob -> StartTranscriptionJob -> Bool
== :: StartTranscriptionJob -> StartTranscriptionJob -> Bool
$c== :: StartTranscriptionJob -> StartTranscriptionJob -> Bool
Prelude.Eq, ReadPrec [StartTranscriptionJob]
ReadPrec StartTranscriptionJob
Int -> ReadS StartTranscriptionJob
ReadS [StartTranscriptionJob]
(Int -> ReadS StartTranscriptionJob)
-> ReadS [StartTranscriptionJob]
-> ReadPrec StartTranscriptionJob
-> ReadPrec [StartTranscriptionJob]
-> Read StartTranscriptionJob
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartTranscriptionJob]
$creadListPrec :: ReadPrec [StartTranscriptionJob]
readPrec :: ReadPrec StartTranscriptionJob
$creadPrec :: ReadPrec StartTranscriptionJob
readList :: ReadS [StartTranscriptionJob]
$creadList :: ReadS [StartTranscriptionJob]
readsPrec :: Int -> ReadS StartTranscriptionJob
$creadsPrec :: Int -> ReadS StartTranscriptionJob
Prelude.Read, Int -> StartTranscriptionJob -> ShowS
[StartTranscriptionJob] -> ShowS
StartTranscriptionJob -> String
(Int -> StartTranscriptionJob -> ShowS)
-> (StartTranscriptionJob -> String)
-> ([StartTranscriptionJob] -> ShowS)
-> Show StartTranscriptionJob
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartTranscriptionJob] -> ShowS
$cshowList :: [StartTranscriptionJob] -> ShowS
show :: StartTranscriptionJob -> String
$cshow :: StartTranscriptionJob -> String
showsPrec :: Int -> StartTranscriptionJob -> ShowS
$cshowsPrec :: Int -> StartTranscriptionJob -> ShowS
Prelude.Show, (forall x. StartTranscriptionJob -> Rep StartTranscriptionJob x)
-> (forall x. Rep StartTranscriptionJob x -> StartTranscriptionJob)
-> Generic StartTranscriptionJob
forall x. Rep StartTranscriptionJob x -> StartTranscriptionJob
forall x. StartTranscriptionJob -> Rep StartTranscriptionJob x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartTranscriptionJob x -> StartTranscriptionJob
$cfrom :: forall x. StartTranscriptionJob -> Rep StartTranscriptionJob x
Prelude.Generic)

-- |
-- Create a value of 'StartTranscriptionJob' 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:
--
-- 'contentRedaction', 'startTranscriptionJob_contentRedaction' - An object that contains the request parameters for content redaction.
--
-- 'subtitles', 'startTranscriptionJob_subtitles' - Add subtitles to your batch transcription job.
--
-- 'languageCode', 'startTranscriptionJob_languageCode' - The language code for the language used in the input media file.
--
-- To transcribe speech in Modern Standard Arabic (ar-SA), your audio or
-- video file must be encoded at a sample rate of 16,000 Hz or higher.
--
-- 'languageOptions', 'startTranscriptionJob_languageOptions' - An object containing a list of languages that might be present in your
-- collection of audio files. Automatic language identification chooses a
-- language that best matches the source audio from that list.
--
-- To transcribe speech in Modern Standard Arabic (ar-SA), your audio or
-- video file must be encoded at a sample rate of 16,000 Hz or higher.
--
-- 'settings', 'startTranscriptionJob_settings' - A @Settings@ object that provides optional settings for a transcription
-- job.
--
-- 'outputBucketName', 'startTranscriptionJob_outputBucketName' - The location where the transcription is stored.
--
-- If you set the @OutputBucketName@, Amazon Transcribe puts the transcript
-- in the specified S3 bucket. When you call the GetTranscriptionJob
-- operation, the operation returns this location in the
-- @TranscriptFileUri@ field. If you enable content redaction, the redacted
-- transcript appears in @RedactedTranscriptFileUri@. If you enable content
-- redaction and choose to output an unredacted transcript, that
-- transcript\'s location still appears in the @TranscriptFileUri@. The S3
-- bucket must have permissions that allow Amazon Transcribe to put files
-- in the bucket. For more information, see
-- <https://docs.aws.amazon.com/transcribe/latest/dg/security_iam_id-based-policy-examples.html#auth-role-iam-user Permissions Required for IAM User Roles>.
--
-- You can specify an Amazon Web Services Key Management Service (KMS) key
-- to encrypt the output of your transcription using the
-- @OutputEncryptionKMSKeyId@ parameter. If you don\'t specify a KMS key,
-- Amazon Transcribe uses the default Amazon S3 key for server-side
-- encryption of transcripts that are placed in your S3 bucket.
--
-- If you don\'t set the @OutputBucketName@, Amazon Transcribe generates a
-- pre-signed URL, a shareable URL that provides secure access to your
-- transcription, and returns it in the @TranscriptFileUri@ field. Use this
-- URL to download the transcription.
--
-- 'mediaFormat', 'startTranscriptionJob_mediaFormat' - The format of the input media file.
--
-- 'outputEncryptionKMSKeyId', 'startTranscriptionJob_outputEncryptionKMSKeyId' - The Amazon Resource Name (ARN) of the Amazon Web Services Key Management
-- Service (KMS) key used to encrypt the output of the transcription job.
-- The user calling the @StartTranscriptionJob@ operation must have
-- permission to use the specified KMS key.
--
-- You can use either of the following to identify a KMS key in the current
-- account:
--
-- -   KMS Key ID: \"1234abcd-12ab-34cd-56ef-1234567890ab\"
--
-- -   KMS Key Alias: \"alias\/ExampleAlias\"
--
-- You can use either of the following to identify a KMS key in the current
-- account or another account:
--
-- -   Amazon Resource Name (ARN) of a KMS Key:
--     \"arn:aws:kms:region:account
--     ID:key\/1234abcd-12ab-34cd-56ef-1234567890ab\"
--
-- -   ARN of a KMS Key Alias: \"arn:aws:kms:region:account
--     ID:alias\/ExampleAlias\"
--
-- If you don\'t specify an encryption key, the output of the transcription
-- job is encrypted with the default Amazon S3 key (SSE-S3).
--
-- If you specify a KMS key to encrypt your output, you must also specify
-- an output location in the @OutputBucketName@ parameter.
--
-- 'modelSettings', 'startTranscriptionJob_modelSettings' - Choose the custom language model you use for your transcription job in
-- this parameter.
--
-- 'kmsEncryptionContext', 'startTranscriptionJob_kmsEncryptionContext' - A map of plain text, non-secret key:value pairs, known as encryption
-- context pairs, that provide an added layer of security for your data.
--
-- 'jobExecutionSettings', 'startTranscriptionJob_jobExecutionSettings' - Provides information about how a transcription job is executed. Use this
-- field to indicate that the job can be queued for deferred execution if
-- the concurrency limit is reached and there are no slots available to
-- immediately run the job.
--
-- 'outputKey', 'startTranscriptionJob_outputKey' - You can specify a location in an Amazon S3 bucket to store the output of
-- your transcription job.
--
-- If you don\'t specify an output key, Amazon Transcribe stores the output
-- of your transcription job in the Amazon S3 bucket you specified. By
-- default, the object key is \"your-transcription-job-name.json\".
--
-- You can use output keys to specify the Amazon S3 prefix and file name of
-- the transcription output. For example, specifying the Amazon S3 prefix,
-- \"folder1\/folder2\/\", as an output key would lead to the output being
-- stored as \"folder1\/folder2\/your-transcription-job-name.json\". If you
-- specify \"my-other-job-name.json\" as the output key, the object key is
-- changed to \"my-other-job-name.json\". You can use an output key to
-- change both the prefix and the file name, for example
-- \"folder\/my-other-job-name.json\".
--
-- If you specify an output key, you must also specify an S3 bucket in the
-- @OutputBucketName@ parameter.
--
-- 'identifyLanguage', 'startTranscriptionJob_identifyLanguage' - Set this field to @true@ to enable automatic language identification.
-- Automatic language identification is disabled by default. You receive a
-- @BadRequestException@ error if you enter a value for a @LanguageCode@.
--
-- 'tags', 'startTranscriptionJob_tags' - Add tags to an Amazon Transcribe transcription job.
--
-- 'mediaSampleRateHertz', 'startTranscriptionJob_mediaSampleRateHertz' - The sample rate, in Hertz, of the audio track in the input media file.
--
-- If you do not specify the media sample rate, Amazon Transcribe
-- determines the sample rate. If you specify the sample rate, it must
-- match the sample rate detected by Amazon Transcribe. In most cases, you
-- should leave the @MediaSampleRateHertz@ field blank and let Amazon
-- Transcribe determine the sample rate.
--
-- 'transcriptionJobName', 'startTranscriptionJob_transcriptionJobName' - The name of the job. You can\'t use the strings \"@.@\" or \"@..@\" by
-- themselves as the job name. The name must also be unique within an
-- Amazon Web Services account. If you try to create a transcription job
-- with the same name as a previous transcription job, you get a
-- @ConflictException@ error.
--
-- 'media', 'startTranscriptionJob_media' - An object that describes the input media for a transcription job.
newStartTranscriptionJob ::
  -- | 'transcriptionJobName'
  Prelude.Text ->
  -- | 'media'
  Media ->
  StartTranscriptionJob
newStartTranscriptionJob :: Text -> Media -> StartTranscriptionJob
newStartTranscriptionJob
  Text
pTranscriptionJobName_
  Media
pMedia_ =
    StartTranscriptionJob' :: Maybe ContentRedaction
-> Maybe Subtitles
-> Maybe LanguageCode
-> Maybe (NonEmpty LanguageCode)
-> Maybe Settings
-> Maybe Text
-> Maybe MediaFormat
-> Maybe Text
-> Maybe ModelSettings
-> Maybe (HashMap Text Text)
-> Maybe JobExecutionSettings
-> Maybe Text
-> Maybe Bool
-> Maybe (NonEmpty Tag)
-> Maybe Natural
-> Text
-> Media
-> StartTranscriptionJob
StartTranscriptionJob'
      { $sel:contentRedaction:StartTranscriptionJob' :: Maybe ContentRedaction
contentRedaction =
          Maybe ContentRedaction
forall a. Maybe a
Prelude.Nothing,
        $sel:subtitles:StartTranscriptionJob' :: Maybe Subtitles
subtitles = Maybe Subtitles
forall a. Maybe a
Prelude.Nothing,
        $sel:languageCode:StartTranscriptionJob' :: Maybe LanguageCode
languageCode = Maybe LanguageCode
forall a. Maybe a
Prelude.Nothing,
        $sel:languageOptions:StartTranscriptionJob' :: Maybe (NonEmpty LanguageCode)
languageOptions = Maybe (NonEmpty LanguageCode)
forall a. Maybe a
Prelude.Nothing,
        $sel:settings:StartTranscriptionJob' :: Maybe Settings
settings = Maybe Settings
forall a. Maybe a
Prelude.Nothing,
        $sel:outputBucketName:StartTranscriptionJob' :: Maybe Text
outputBucketName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
        $sel:mediaFormat:StartTranscriptionJob' :: Maybe MediaFormat
mediaFormat = Maybe MediaFormat
forall a. Maybe a
Prelude.Nothing,
        $sel:outputEncryptionKMSKeyId:StartTranscriptionJob' :: Maybe Text
outputEncryptionKMSKeyId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
        $sel:modelSettings:StartTranscriptionJob' :: Maybe ModelSettings
modelSettings = Maybe ModelSettings
forall a. Maybe a
Prelude.Nothing,
        $sel:kmsEncryptionContext:StartTranscriptionJob' :: Maybe (HashMap Text Text)
kmsEncryptionContext = Maybe (HashMap Text Text)
forall a. Maybe a
Prelude.Nothing,
        $sel:jobExecutionSettings:StartTranscriptionJob' :: Maybe JobExecutionSettings
jobExecutionSettings = Maybe JobExecutionSettings
forall a. Maybe a
Prelude.Nothing,
        $sel:outputKey:StartTranscriptionJob' :: Maybe Text
outputKey = Maybe Text
forall a. Maybe a
Prelude.Nothing,
        $sel:identifyLanguage:StartTranscriptionJob' :: Maybe Bool
identifyLanguage = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
        $sel:tags:StartTranscriptionJob' :: Maybe (NonEmpty Tag)
tags = Maybe (NonEmpty Tag)
forall a. Maybe a
Prelude.Nothing,
        $sel:mediaSampleRateHertz:StartTranscriptionJob' :: Maybe Natural
mediaSampleRateHertz = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:transcriptionJobName:StartTranscriptionJob' :: Text
transcriptionJobName = Text
pTranscriptionJobName_,
        $sel:media:StartTranscriptionJob' :: Media
media = Media
pMedia_
      }

-- | An object that contains the request parameters for content redaction.
startTranscriptionJob_contentRedaction :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe ContentRedaction)
startTranscriptionJob_contentRedaction :: (Maybe ContentRedaction -> f (Maybe ContentRedaction))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_contentRedaction = (StartTranscriptionJob -> Maybe ContentRedaction)
-> (StartTranscriptionJob
    -> Maybe ContentRedaction -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe ContentRedaction)
     (Maybe ContentRedaction)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe ContentRedaction
contentRedaction :: Maybe ContentRedaction
$sel:contentRedaction:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe ContentRedaction
contentRedaction} -> Maybe ContentRedaction
contentRedaction) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe ContentRedaction
a -> StartTranscriptionJob
s {$sel:contentRedaction:StartTranscriptionJob' :: Maybe ContentRedaction
contentRedaction = Maybe ContentRedaction
a} :: StartTranscriptionJob)

-- | Add subtitles to your batch transcription job.
startTranscriptionJob_subtitles :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe Subtitles)
startTranscriptionJob_subtitles :: (Maybe Subtitles -> f (Maybe Subtitles))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_subtitles = (StartTranscriptionJob -> Maybe Subtitles)
-> (StartTranscriptionJob
    -> Maybe Subtitles -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe Subtitles)
     (Maybe Subtitles)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe Subtitles
subtitles :: Maybe Subtitles
$sel:subtitles:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Subtitles
subtitles} -> Maybe Subtitles
subtitles) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe Subtitles
a -> StartTranscriptionJob
s {$sel:subtitles:StartTranscriptionJob' :: Maybe Subtitles
subtitles = Maybe Subtitles
a} :: StartTranscriptionJob)

-- | The language code for the language used in the input media file.
--
-- To transcribe speech in Modern Standard Arabic (ar-SA), your audio or
-- video file must be encoded at a sample rate of 16,000 Hz or higher.
startTranscriptionJob_languageCode :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe LanguageCode)
startTranscriptionJob_languageCode :: (Maybe LanguageCode -> f (Maybe LanguageCode))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_languageCode = (StartTranscriptionJob -> Maybe LanguageCode)
-> (StartTranscriptionJob
    -> Maybe LanguageCode -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe LanguageCode)
     (Maybe LanguageCode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe LanguageCode
languageCode :: Maybe LanguageCode
$sel:languageCode:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe LanguageCode
languageCode} -> Maybe LanguageCode
languageCode) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe LanguageCode
a -> StartTranscriptionJob
s {$sel:languageCode:StartTranscriptionJob' :: Maybe LanguageCode
languageCode = Maybe LanguageCode
a} :: StartTranscriptionJob)

-- | An object containing a list of languages that might be present in your
-- collection of audio files. Automatic language identification chooses a
-- language that best matches the source audio from that list.
--
-- To transcribe speech in Modern Standard Arabic (ar-SA), your audio or
-- video file must be encoded at a sample rate of 16,000 Hz or higher.
startTranscriptionJob_languageOptions :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe (Prelude.NonEmpty LanguageCode))
startTranscriptionJob_languageOptions :: (Maybe (NonEmpty LanguageCode)
 -> f (Maybe (NonEmpty LanguageCode)))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_languageOptions = (StartTranscriptionJob -> Maybe (NonEmpty LanguageCode))
-> (StartTranscriptionJob
    -> Maybe (NonEmpty LanguageCode) -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe (NonEmpty LanguageCode))
     (Maybe (NonEmpty LanguageCode))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe (NonEmpty LanguageCode)
languageOptions :: Maybe (NonEmpty LanguageCode)
$sel:languageOptions:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe (NonEmpty LanguageCode)
languageOptions} -> Maybe (NonEmpty LanguageCode)
languageOptions) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe (NonEmpty LanguageCode)
a -> StartTranscriptionJob
s {$sel:languageOptions:StartTranscriptionJob' :: Maybe (NonEmpty LanguageCode)
languageOptions = Maybe (NonEmpty LanguageCode)
a} :: StartTranscriptionJob) ((Maybe (NonEmpty LanguageCode)
  -> f (Maybe (NonEmpty LanguageCode)))
 -> StartTranscriptionJob -> f StartTranscriptionJob)
-> ((Maybe (NonEmpty LanguageCode)
     -> f (Maybe (NonEmpty LanguageCode)))
    -> Maybe (NonEmpty LanguageCode)
    -> f (Maybe (NonEmpty LanguageCode)))
-> (Maybe (NonEmpty LanguageCode)
    -> f (Maybe (NonEmpty LanguageCode)))
-> StartTranscriptionJob
-> f StartTranscriptionJob
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (NonEmpty LanguageCode)
  (NonEmpty LanguageCode)
  (NonEmpty LanguageCode)
  (NonEmpty LanguageCode)
-> Iso
     (Maybe (NonEmpty LanguageCode))
     (Maybe (NonEmpty LanguageCode))
     (Maybe (NonEmpty LanguageCode))
     (Maybe (NonEmpty LanguageCode))
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  (NonEmpty LanguageCode)
  (NonEmpty LanguageCode)
  (NonEmpty LanguageCode)
  (NonEmpty LanguageCode)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A @Settings@ object that provides optional settings for a transcription
-- job.
startTranscriptionJob_settings :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe Settings)
startTranscriptionJob_settings :: (Maybe Settings -> f (Maybe Settings))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_settings = (StartTranscriptionJob -> Maybe Settings)
-> (StartTranscriptionJob
    -> Maybe Settings -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe Settings)
     (Maybe Settings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe Settings
settings :: Maybe Settings
$sel:settings:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Settings
settings} -> Maybe Settings
settings) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe Settings
a -> StartTranscriptionJob
s {$sel:settings:StartTranscriptionJob' :: Maybe Settings
settings = Maybe Settings
a} :: StartTranscriptionJob)

-- | The location where the transcription is stored.
--
-- If you set the @OutputBucketName@, Amazon Transcribe puts the transcript
-- in the specified S3 bucket. When you call the GetTranscriptionJob
-- operation, the operation returns this location in the
-- @TranscriptFileUri@ field. If you enable content redaction, the redacted
-- transcript appears in @RedactedTranscriptFileUri@. If you enable content
-- redaction and choose to output an unredacted transcript, that
-- transcript\'s location still appears in the @TranscriptFileUri@. The S3
-- bucket must have permissions that allow Amazon Transcribe to put files
-- in the bucket. For more information, see
-- <https://docs.aws.amazon.com/transcribe/latest/dg/security_iam_id-based-policy-examples.html#auth-role-iam-user Permissions Required for IAM User Roles>.
--
-- You can specify an Amazon Web Services Key Management Service (KMS) key
-- to encrypt the output of your transcription using the
-- @OutputEncryptionKMSKeyId@ parameter. If you don\'t specify a KMS key,
-- Amazon Transcribe uses the default Amazon S3 key for server-side
-- encryption of transcripts that are placed in your S3 bucket.
--
-- If you don\'t set the @OutputBucketName@, Amazon Transcribe generates a
-- pre-signed URL, a shareable URL that provides secure access to your
-- transcription, and returns it in the @TranscriptFileUri@ field. Use this
-- URL to download the transcription.
startTranscriptionJob_outputBucketName :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe Prelude.Text)
startTranscriptionJob_outputBucketName :: (Maybe Text -> f (Maybe Text))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_outputBucketName = (StartTranscriptionJob -> Maybe Text)
-> (StartTranscriptionJob -> Maybe Text -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe Text
outputBucketName :: Maybe Text
$sel:outputBucketName:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Text
outputBucketName} -> Maybe Text
outputBucketName) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe Text
a -> StartTranscriptionJob
s {$sel:outputBucketName:StartTranscriptionJob' :: Maybe Text
outputBucketName = Maybe Text
a} :: StartTranscriptionJob)

-- | The format of the input media file.
startTranscriptionJob_mediaFormat :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe MediaFormat)
startTranscriptionJob_mediaFormat :: (Maybe MediaFormat -> f (Maybe MediaFormat))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_mediaFormat = (StartTranscriptionJob -> Maybe MediaFormat)
-> (StartTranscriptionJob
    -> Maybe MediaFormat -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe MediaFormat)
     (Maybe MediaFormat)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe MediaFormat
mediaFormat :: Maybe MediaFormat
$sel:mediaFormat:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe MediaFormat
mediaFormat} -> Maybe MediaFormat
mediaFormat) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe MediaFormat
a -> StartTranscriptionJob
s {$sel:mediaFormat:StartTranscriptionJob' :: Maybe MediaFormat
mediaFormat = Maybe MediaFormat
a} :: StartTranscriptionJob)

-- | The Amazon Resource Name (ARN) of the Amazon Web Services Key Management
-- Service (KMS) key used to encrypt the output of the transcription job.
-- The user calling the @StartTranscriptionJob@ operation must have
-- permission to use the specified KMS key.
--
-- You can use either of the following to identify a KMS key in the current
-- account:
--
-- -   KMS Key ID: \"1234abcd-12ab-34cd-56ef-1234567890ab\"
--
-- -   KMS Key Alias: \"alias\/ExampleAlias\"
--
-- You can use either of the following to identify a KMS key in the current
-- account or another account:
--
-- -   Amazon Resource Name (ARN) of a KMS Key:
--     \"arn:aws:kms:region:account
--     ID:key\/1234abcd-12ab-34cd-56ef-1234567890ab\"
--
-- -   ARN of a KMS Key Alias: \"arn:aws:kms:region:account
--     ID:alias\/ExampleAlias\"
--
-- If you don\'t specify an encryption key, the output of the transcription
-- job is encrypted with the default Amazon S3 key (SSE-S3).
--
-- If you specify a KMS key to encrypt your output, you must also specify
-- an output location in the @OutputBucketName@ parameter.
startTranscriptionJob_outputEncryptionKMSKeyId :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe Prelude.Text)
startTranscriptionJob_outputEncryptionKMSKeyId :: (Maybe Text -> f (Maybe Text))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_outputEncryptionKMSKeyId = (StartTranscriptionJob -> Maybe Text)
-> (StartTranscriptionJob -> Maybe Text -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe Text
outputEncryptionKMSKeyId :: Maybe Text
$sel:outputEncryptionKMSKeyId:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Text
outputEncryptionKMSKeyId} -> Maybe Text
outputEncryptionKMSKeyId) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe Text
a -> StartTranscriptionJob
s {$sel:outputEncryptionKMSKeyId:StartTranscriptionJob' :: Maybe Text
outputEncryptionKMSKeyId = Maybe Text
a} :: StartTranscriptionJob)

-- | Choose the custom language model you use for your transcription job in
-- this parameter.
startTranscriptionJob_modelSettings :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe ModelSettings)
startTranscriptionJob_modelSettings :: (Maybe ModelSettings -> f (Maybe ModelSettings))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_modelSettings = (StartTranscriptionJob -> Maybe ModelSettings)
-> (StartTranscriptionJob
    -> Maybe ModelSettings -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe ModelSettings)
     (Maybe ModelSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe ModelSettings
modelSettings :: Maybe ModelSettings
$sel:modelSettings:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe ModelSettings
modelSettings} -> Maybe ModelSettings
modelSettings) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe ModelSettings
a -> StartTranscriptionJob
s {$sel:modelSettings:StartTranscriptionJob' :: Maybe ModelSettings
modelSettings = Maybe ModelSettings
a} :: StartTranscriptionJob)

-- | A map of plain text, non-secret key:value pairs, known as encryption
-- context pairs, that provide an added layer of security for your data.
startTranscriptionJob_kmsEncryptionContext :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
startTranscriptionJob_kmsEncryptionContext :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_kmsEncryptionContext = (StartTranscriptionJob -> Maybe (HashMap Text Text))
-> (StartTranscriptionJob
    -> Maybe (HashMap Text Text) -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe (HashMap Text Text)
kmsEncryptionContext :: Maybe (HashMap Text Text)
$sel:kmsEncryptionContext:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe (HashMap Text Text)
kmsEncryptionContext} -> Maybe (HashMap Text Text)
kmsEncryptionContext) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe (HashMap Text Text)
a -> StartTranscriptionJob
s {$sel:kmsEncryptionContext:StartTranscriptionJob' :: Maybe (HashMap Text Text)
kmsEncryptionContext = Maybe (HashMap Text Text)
a} :: StartTranscriptionJob) ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
 -> StartTranscriptionJob -> f StartTranscriptionJob)
-> ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
    -> Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> StartTranscriptionJob
-> f StartTranscriptionJob
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
-> Iso
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Provides information about how a transcription job is executed. Use this
-- field to indicate that the job can be queued for deferred execution if
-- the concurrency limit is reached and there are no slots available to
-- immediately run the job.
startTranscriptionJob_jobExecutionSettings :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe JobExecutionSettings)
startTranscriptionJob_jobExecutionSettings :: (Maybe JobExecutionSettings -> f (Maybe JobExecutionSettings))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_jobExecutionSettings = (StartTranscriptionJob -> Maybe JobExecutionSettings)
-> (StartTranscriptionJob
    -> Maybe JobExecutionSettings -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe JobExecutionSettings)
     (Maybe JobExecutionSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe JobExecutionSettings
jobExecutionSettings :: Maybe JobExecutionSettings
$sel:jobExecutionSettings:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe JobExecutionSettings
jobExecutionSettings} -> Maybe JobExecutionSettings
jobExecutionSettings) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe JobExecutionSettings
a -> StartTranscriptionJob
s {$sel:jobExecutionSettings:StartTranscriptionJob' :: Maybe JobExecutionSettings
jobExecutionSettings = Maybe JobExecutionSettings
a} :: StartTranscriptionJob)

-- | You can specify a location in an Amazon S3 bucket to store the output of
-- your transcription job.
--
-- If you don\'t specify an output key, Amazon Transcribe stores the output
-- of your transcription job in the Amazon S3 bucket you specified. By
-- default, the object key is \"your-transcription-job-name.json\".
--
-- You can use output keys to specify the Amazon S3 prefix and file name of
-- the transcription output. For example, specifying the Amazon S3 prefix,
-- \"folder1\/folder2\/\", as an output key would lead to the output being
-- stored as \"folder1\/folder2\/your-transcription-job-name.json\". If you
-- specify \"my-other-job-name.json\" as the output key, the object key is
-- changed to \"my-other-job-name.json\". You can use an output key to
-- change both the prefix and the file name, for example
-- \"folder\/my-other-job-name.json\".
--
-- If you specify an output key, you must also specify an S3 bucket in the
-- @OutputBucketName@ parameter.
startTranscriptionJob_outputKey :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe Prelude.Text)
startTranscriptionJob_outputKey :: (Maybe Text -> f (Maybe Text))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_outputKey = (StartTranscriptionJob -> Maybe Text)
-> (StartTranscriptionJob -> Maybe Text -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe Text
outputKey :: Maybe Text
$sel:outputKey:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Text
outputKey} -> Maybe Text
outputKey) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe Text
a -> StartTranscriptionJob
s {$sel:outputKey:StartTranscriptionJob' :: Maybe Text
outputKey = Maybe Text
a} :: StartTranscriptionJob)

-- | Set this field to @true@ to enable automatic language identification.
-- Automatic language identification is disabled by default. You receive a
-- @BadRequestException@ error if you enter a value for a @LanguageCode@.
startTranscriptionJob_identifyLanguage :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe Prelude.Bool)
startTranscriptionJob_identifyLanguage :: (Maybe Bool -> f (Maybe Bool))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_identifyLanguage = (StartTranscriptionJob -> Maybe Bool)
-> (StartTranscriptionJob -> Maybe Bool -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe Bool)
     (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe Bool
identifyLanguage :: Maybe Bool
$sel:identifyLanguage:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Bool
identifyLanguage} -> Maybe Bool
identifyLanguage) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe Bool
a -> StartTranscriptionJob
s {$sel:identifyLanguage:StartTranscriptionJob' :: Maybe Bool
identifyLanguage = Maybe Bool
a} :: StartTranscriptionJob)

-- | Add tags to an Amazon Transcribe transcription job.
startTranscriptionJob_tags :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe (Prelude.NonEmpty Tag))
startTranscriptionJob_tags :: (Maybe (NonEmpty Tag) -> f (Maybe (NonEmpty Tag)))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_tags = (StartTranscriptionJob -> Maybe (NonEmpty Tag))
-> (StartTranscriptionJob
    -> Maybe (NonEmpty Tag) -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe (NonEmpty Tag))
     (Maybe (NonEmpty Tag))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe (NonEmpty Tag)
tags :: Maybe (NonEmpty Tag)
$sel:tags:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe (NonEmpty Tag)
tags} -> Maybe (NonEmpty Tag)
tags) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe (NonEmpty Tag)
a -> StartTranscriptionJob
s {$sel:tags:StartTranscriptionJob' :: Maybe (NonEmpty Tag)
tags = Maybe (NonEmpty Tag)
a} :: StartTranscriptionJob) ((Maybe (NonEmpty Tag) -> f (Maybe (NonEmpty Tag)))
 -> StartTranscriptionJob -> f StartTranscriptionJob)
-> ((Maybe (NonEmpty Tag) -> f (Maybe (NonEmpty Tag)))
    -> Maybe (NonEmpty Tag) -> f (Maybe (NonEmpty Tag)))
-> (Maybe (NonEmpty Tag) -> f (Maybe (NonEmpty Tag)))
-> StartTranscriptionJob
-> f StartTranscriptionJob
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso (NonEmpty Tag) (NonEmpty Tag) (NonEmpty Tag) (NonEmpty Tag)
-> Iso
     (Maybe (NonEmpty Tag))
     (Maybe (NonEmpty Tag))
     (Maybe (NonEmpty Tag))
     (Maybe (NonEmpty Tag))
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso (NonEmpty Tag) (NonEmpty Tag) (NonEmpty Tag) (NonEmpty Tag)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The sample rate, in Hertz, of the audio track in the input media file.
--
-- If you do not specify the media sample rate, Amazon Transcribe
-- determines the sample rate. If you specify the sample rate, it must
-- match the sample rate detected by Amazon Transcribe. In most cases, you
-- should leave the @MediaSampleRateHertz@ field blank and let Amazon
-- Transcribe determine the sample rate.
startTranscriptionJob_mediaSampleRateHertz :: Lens.Lens' StartTranscriptionJob (Prelude.Maybe Prelude.Natural)
startTranscriptionJob_mediaSampleRateHertz :: (Maybe Natural -> f (Maybe Natural))
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_mediaSampleRateHertz = (StartTranscriptionJob -> Maybe Natural)
-> (StartTranscriptionJob
    -> Maybe Natural -> StartTranscriptionJob)
-> Lens
     StartTranscriptionJob
     StartTranscriptionJob
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Maybe Natural
mediaSampleRateHertz :: Maybe Natural
$sel:mediaSampleRateHertz:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Natural
mediaSampleRateHertz} -> Maybe Natural
mediaSampleRateHertz) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Maybe Natural
a -> StartTranscriptionJob
s {$sel:mediaSampleRateHertz:StartTranscriptionJob' :: Maybe Natural
mediaSampleRateHertz = Maybe Natural
a} :: StartTranscriptionJob)

-- | The name of the job. You can\'t use the strings \"@.@\" or \"@..@\" by
-- themselves as the job name. The name must also be unique within an
-- Amazon Web Services account. If you try to create a transcription job
-- with the same name as a previous transcription job, you get a
-- @ConflictException@ error.
startTranscriptionJob_transcriptionJobName :: Lens.Lens' StartTranscriptionJob Prelude.Text
startTranscriptionJob_transcriptionJobName :: (Text -> f Text)
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_transcriptionJobName = (StartTranscriptionJob -> Text)
-> (StartTranscriptionJob -> Text -> StartTranscriptionJob)
-> Lens StartTranscriptionJob StartTranscriptionJob Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Text
transcriptionJobName :: Text
$sel:transcriptionJobName:StartTranscriptionJob' :: StartTranscriptionJob -> Text
transcriptionJobName} -> Text
transcriptionJobName) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Text
a -> StartTranscriptionJob
s {$sel:transcriptionJobName:StartTranscriptionJob' :: Text
transcriptionJobName = Text
a} :: StartTranscriptionJob)

-- | An object that describes the input media for a transcription job.
startTranscriptionJob_media :: Lens.Lens' StartTranscriptionJob Media
startTranscriptionJob_media :: (Media -> f Media)
-> StartTranscriptionJob -> f StartTranscriptionJob
startTranscriptionJob_media = (StartTranscriptionJob -> Media)
-> (StartTranscriptionJob -> Media -> StartTranscriptionJob)
-> Lens StartTranscriptionJob StartTranscriptionJob Media Media
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJob' {Media
media :: Media
$sel:media:StartTranscriptionJob' :: StartTranscriptionJob -> Media
media} -> Media
media) (\s :: StartTranscriptionJob
s@StartTranscriptionJob' {} Media
a -> StartTranscriptionJob
s {$sel:media:StartTranscriptionJob' :: Media
media = Media
a} :: StartTranscriptionJob)

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

instance Prelude.Hashable StartTranscriptionJob

instance Prelude.NFData StartTranscriptionJob

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

instance Core.ToJSON StartTranscriptionJob where
  toJSON :: StartTranscriptionJob -> Value
toJSON StartTranscriptionJob' {Maybe Bool
Maybe Natural
Maybe (NonEmpty LanguageCode)
Maybe (NonEmpty Tag)
Maybe Text
Maybe (HashMap Text Text)
Maybe JobExecutionSettings
Maybe LanguageCode
Maybe MediaFormat
Maybe ModelSettings
Maybe ContentRedaction
Maybe Subtitles
Maybe Settings
Text
Media
media :: Media
transcriptionJobName :: Text
mediaSampleRateHertz :: Maybe Natural
tags :: Maybe (NonEmpty Tag)
identifyLanguage :: Maybe Bool
outputKey :: Maybe Text
jobExecutionSettings :: Maybe JobExecutionSettings
kmsEncryptionContext :: Maybe (HashMap Text Text)
modelSettings :: Maybe ModelSettings
outputEncryptionKMSKeyId :: Maybe Text
mediaFormat :: Maybe MediaFormat
outputBucketName :: Maybe Text
settings :: Maybe Settings
languageOptions :: Maybe (NonEmpty LanguageCode)
languageCode :: Maybe LanguageCode
subtitles :: Maybe Subtitles
contentRedaction :: Maybe ContentRedaction
$sel:media:StartTranscriptionJob' :: StartTranscriptionJob -> Media
$sel:transcriptionJobName:StartTranscriptionJob' :: StartTranscriptionJob -> Text
$sel:mediaSampleRateHertz:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Natural
$sel:tags:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe (NonEmpty Tag)
$sel:identifyLanguage:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Bool
$sel:outputKey:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Text
$sel:jobExecutionSettings:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe JobExecutionSettings
$sel:kmsEncryptionContext:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe (HashMap Text Text)
$sel:modelSettings:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe ModelSettings
$sel:outputEncryptionKMSKeyId:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Text
$sel:mediaFormat:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe MediaFormat
$sel:outputBucketName:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Text
$sel:settings:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Settings
$sel:languageOptions:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe (NonEmpty LanguageCode)
$sel:languageCode:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe LanguageCode
$sel:subtitles:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe Subtitles
$sel:contentRedaction:StartTranscriptionJob' :: StartTranscriptionJob -> Maybe ContentRedaction
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"ContentRedaction" Text -> ContentRedaction -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ContentRedaction -> Pair) -> Maybe ContentRedaction -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ContentRedaction
contentRedaction,
            (Text
"Subtitles" Text -> Subtitles -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Subtitles -> Pair) -> Maybe Subtitles -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Subtitles
subtitles,
            (Text
"LanguageCode" Text -> LanguageCode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (LanguageCode -> Pair) -> Maybe LanguageCode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe LanguageCode
languageCode,
            (Text
"LanguageOptions" Text -> NonEmpty LanguageCode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (NonEmpty LanguageCode -> Pair)
-> Maybe (NonEmpty LanguageCode) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty LanguageCode)
languageOptions,
            (Text
"Settings" Text -> Settings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Settings -> Pair) -> Maybe Settings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Settings
settings,
            (Text
"OutputBucketName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
outputBucketName,
            (Text
"MediaFormat" Text -> MediaFormat -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (MediaFormat -> Pair) -> Maybe MediaFormat -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe MediaFormat
mediaFormat,
            (Text
"OutputEncryptionKMSKeyId" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
outputEncryptionKMSKeyId,
            (Text
"ModelSettings" Text -> ModelSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (ModelSettings -> Pair) -> Maybe ModelSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ModelSettings
modelSettings,
            (Text
"KMSEncryptionContext" Text -> HashMap Text Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (HashMap Text Text -> Pair)
-> Maybe (HashMap Text Text) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text Text)
kmsEncryptionContext,
            (Text
"JobExecutionSettings" Text -> JobExecutionSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (JobExecutionSettings -> Pair)
-> Maybe JobExecutionSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe JobExecutionSettings
jobExecutionSettings,
            (Text
"OutputKey" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
outputKey,
            (Text
"IdentifyLanguage" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
identifyLanguage,
            (Text
"Tags" Text -> NonEmpty Tag -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (NonEmpty Tag -> Pair) -> Maybe (NonEmpty Tag) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty Tag)
tags,
            (Text
"MediaSampleRateHertz" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
mediaSampleRateHertz,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              ( Text
"TranscriptionJobName"
                  Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
transcriptionJobName
              ),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"Media" Text -> Media -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Media
media)
          ]
      )

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

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

-- | /See:/ 'newStartTranscriptionJobResponse' smart constructor.
data StartTranscriptionJobResponse = StartTranscriptionJobResponse'
  { -- | An object containing details of the asynchronous transcription job.
    StartTranscriptionJobResponse -> Maybe TranscriptionJob
transcriptionJob :: Prelude.Maybe TranscriptionJob,
    -- | The response's http status code.
    StartTranscriptionJobResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (StartTranscriptionJobResponse
-> StartTranscriptionJobResponse -> Bool
(StartTranscriptionJobResponse
 -> StartTranscriptionJobResponse -> Bool)
-> (StartTranscriptionJobResponse
    -> StartTranscriptionJobResponse -> Bool)
-> Eq StartTranscriptionJobResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartTranscriptionJobResponse
-> StartTranscriptionJobResponse -> Bool
$c/= :: StartTranscriptionJobResponse
-> StartTranscriptionJobResponse -> Bool
== :: StartTranscriptionJobResponse
-> StartTranscriptionJobResponse -> Bool
$c== :: StartTranscriptionJobResponse
-> StartTranscriptionJobResponse -> Bool
Prelude.Eq, ReadPrec [StartTranscriptionJobResponse]
ReadPrec StartTranscriptionJobResponse
Int -> ReadS StartTranscriptionJobResponse
ReadS [StartTranscriptionJobResponse]
(Int -> ReadS StartTranscriptionJobResponse)
-> ReadS [StartTranscriptionJobResponse]
-> ReadPrec StartTranscriptionJobResponse
-> ReadPrec [StartTranscriptionJobResponse]
-> Read StartTranscriptionJobResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartTranscriptionJobResponse]
$creadListPrec :: ReadPrec [StartTranscriptionJobResponse]
readPrec :: ReadPrec StartTranscriptionJobResponse
$creadPrec :: ReadPrec StartTranscriptionJobResponse
readList :: ReadS [StartTranscriptionJobResponse]
$creadList :: ReadS [StartTranscriptionJobResponse]
readsPrec :: Int -> ReadS StartTranscriptionJobResponse
$creadsPrec :: Int -> ReadS StartTranscriptionJobResponse
Prelude.Read, Int -> StartTranscriptionJobResponse -> ShowS
[StartTranscriptionJobResponse] -> ShowS
StartTranscriptionJobResponse -> String
(Int -> StartTranscriptionJobResponse -> ShowS)
-> (StartTranscriptionJobResponse -> String)
-> ([StartTranscriptionJobResponse] -> ShowS)
-> Show StartTranscriptionJobResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartTranscriptionJobResponse] -> ShowS
$cshowList :: [StartTranscriptionJobResponse] -> ShowS
show :: StartTranscriptionJobResponse -> String
$cshow :: StartTranscriptionJobResponse -> String
showsPrec :: Int -> StartTranscriptionJobResponse -> ShowS
$cshowsPrec :: Int -> StartTranscriptionJobResponse -> ShowS
Prelude.Show, (forall x.
 StartTranscriptionJobResponse
 -> Rep StartTranscriptionJobResponse x)
-> (forall x.
    Rep StartTranscriptionJobResponse x
    -> StartTranscriptionJobResponse)
-> Generic StartTranscriptionJobResponse
forall x.
Rep StartTranscriptionJobResponse x
-> StartTranscriptionJobResponse
forall x.
StartTranscriptionJobResponse
-> Rep StartTranscriptionJobResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep StartTranscriptionJobResponse x
-> StartTranscriptionJobResponse
$cfrom :: forall x.
StartTranscriptionJobResponse
-> Rep StartTranscriptionJobResponse x
Prelude.Generic)

-- |
-- Create a value of 'StartTranscriptionJobResponse' 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:
--
-- 'transcriptionJob', 'startTranscriptionJobResponse_transcriptionJob' - An object containing details of the asynchronous transcription job.
--
-- 'httpStatus', 'startTranscriptionJobResponse_httpStatus' - The response's http status code.
newStartTranscriptionJobResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  StartTranscriptionJobResponse
newStartTranscriptionJobResponse :: Int -> StartTranscriptionJobResponse
newStartTranscriptionJobResponse Int
pHttpStatus_ =
  StartTranscriptionJobResponse' :: Maybe TranscriptionJob -> Int -> StartTranscriptionJobResponse
StartTranscriptionJobResponse'
    { $sel:transcriptionJob:StartTranscriptionJobResponse' :: Maybe TranscriptionJob
transcriptionJob =
        Maybe TranscriptionJob
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:StartTranscriptionJobResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | An object containing details of the asynchronous transcription job.
startTranscriptionJobResponse_transcriptionJob :: Lens.Lens' StartTranscriptionJobResponse (Prelude.Maybe TranscriptionJob)
startTranscriptionJobResponse_transcriptionJob :: (Maybe TranscriptionJob -> f (Maybe TranscriptionJob))
-> StartTranscriptionJobResponse -> f StartTranscriptionJobResponse
startTranscriptionJobResponse_transcriptionJob = (StartTranscriptionJobResponse -> Maybe TranscriptionJob)
-> (StartTranscriptionJobResponse
    -> Maybe TranscriptionJob -> StartTranscriptionJobResponse)
-> Lens
     StartTranscriptionJobResponse
     StartTranscriptionJobResponse
     (Maybe TranscriptionJob)
     (Maybe TranscriptionJob)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartTranscriptionJobResponse' {Maybe TranscriptionJob
transcriptionJob :: Maybe TranscriptionJob
$sel:transcriptionJob:StartTranscriptionJobResponse' :: StartTranscriptionJobResponse -> Maybe TranscriptionJob
transcriptionJob} -> Maybe TranscriptionJob
transcriptionJob) (\s :: StartTranscriptionJobResponse
s@StartTranscriptionJobResponse' {} Maybe TranscriptionJob
a -> StartTranscriptionJobResponse
s {$sel:transcriptionJob:StartTranscriptionJobResponse' :: Maybe TranscriptionJob
transcriptionJob = Maybe TranscriptionJob
a} :: StartTranscriptionJobResponse)

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

instance Prelude.NFData StartTranscriptionJobResponse