{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.Polly.Types.Voice
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Polly.Types.Voice where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Polly.Types.Engine
import Amazonka.Polly.Types.Gender
import Amazonka.Polly.Types.LanguageCode
import Amazonka.Polly.Types.VoiceId
import qualified Amazonka.Prelude as Prelude

-- | Description of the voice.
--
-- /See:/ 'newVoice' smart constructor.
data Voice = Voice'
  { -- | Additional codes for languages available for the specified voice in
    -- addition to its default language.
    --
    -- For example, the default language for Aditi is Indian English (en-IN)
    -- because it was first used for that language. Since Aditi is bilingual
    -- and fluent in both Indian English and Hindi, this parameter would show
    -- the code @hi-IN@.
    Voice -> Maybe [LanguageCode]
additionalLanguageCodes :: Prelude.Maybe [LanguageCode],
    -- | Gender of the voice.
    Voice -> Maybe Gender
gender :: Prelude.Maybe Gender,
    -- | Amazon Polly assigned voice ID. This is the ID that you specify when
    -- calling the @SynthesizeSpeech@ operation.
    Voice -> Maybe VoiceId
id :: Prelude.Maybe VoiceId,
    -- | Language code of the voice.
    Voice -> Maybe LanguageCode
languageCode :: Prelude.Maybe LanguageCode,
    -- | Human readable name of the language in English.
    Voice -> Maybe Text
languageName :: Prelude.Maybe Prelude.Text,
    -- | Name of the voice (for example, Salli, Kendra, etc.). This provides a
    -- human readable voice name that you might display in your application.
    Voice -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | Specifies which engines (@standard@ or @neural@) that are supported by a
    -- given voice.
    Voice -> Maybe [Engine]
supportedEngines :: Prelude.Maybe [Engine]
  }
  deriving (Voice -> Voice -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Voice -> Voice -> Bool
$c/= :: Voice -> Voice -> Bool
== :: Voice -> Voice -> Bool
$c== :: Voice -> Voice -> Bool
Prelude.Eq, ReadPrec [Voice]
ReadPrec Voice
Int -> ReadS Voice
ReadS [Voice]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Voice]
$creadListPrec :: ReadPrec [Voice]
readPrec :: ReadPrec Voice
$creadPrec :: ReadPrec Voice
readList :: ReadS [Voice]
$creadList :: ReadS [Voice]
readsPrec :: Int -> ReadS Voice
$creadsPrec :: Int -> ReadS Voice
Prelude.Read, Int -> Voice -> ShowS
[Voice] -> ShowS
Voice -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Voice] -> ShowS
$cshowList :: [Voice] -> ShowS
show :: Voice -> String
$cshow :: Voice -> String
showsPrec :: Int -> Voice -> ShowS
$cshowsPrec :: Int -> Voice -> ShowS
Prelude.Show, forall x. Rep Voice x -> Voice
forall x. Voice -> Rep Voice x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Voice x -> Voice
$cfrom :: forall x. Voice -> Rep Voice x
Prelude.Generic)

-- |
-- Create a value of 'Voice' 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:
--
-- 'additionalLanguageCodes', 'voice_additionalLanguageCodes' - Additional codes for languages available for the specified voice in
-- addition to its default language.
--
-- For example, the default language for Aditi is Indian English (en-IN)
-- because it was first used for that language. Since Aditi is bilingual
-- and fluent in both Indian English and Hindi, this parameter would show
-- the code @hi-IN@.
--
-- 'gender', 'voice_gender' - Gender of the voice.
--
-- 'id', 'voice_id' - Amazon Polly assigned voice ID. This is the ID that you specify when
-- calling the @SynthesizeSpeech@ operation.
--
-- 'languageCode', 'voice_languageCode' - Language code of the voice.
--
-- 'languageName', 'voice_languageName' - Human readable name of the language in English.
--
-- 'name', 'voice_name' - Name of the voice (for example, Salli, Kendra, etc.). This provides a
-- human readable voice name that you might display in your application.
--
-- 'supportedEngines', 'voice_supportedEngines' - Specifies which engines (@standard@ or @neural@) that are supported by a
-- given voice.
newVoice ::
  Voice
newVoice :: Voice
newVoice =
  Voice'
    { $sel:additionalLanguageCodes:Voice' :: Maybe [LanguageCode]
additionalLanguageCodes = forall a. Maybe a
Prelude.Nothing,
      $sel:gender:Voice' :: Maybe Gender
gender = forall a. Maybe a
Prelude.Nothing,
      $sel:id:Voice' :: Maybe VoiceId
id = forall a. Maybe a
Prelude.Nothing,
      $sel:languageCode:Voice' :: Maybe LanguageCode
languageCode = forall a. Maybe a
Prelude.Nothing,
      $sel:languageName:Voice' :: Maybe Text
languageName = forall a. Maybe a
Prelude.Nothing,
      $sel:name:Voice' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:supportedEngines:Voice' :: Maybe [Engine]
supportedEngines = forall a. Maybe a
Prelude.Nothing
    }

-- | Additional codes for languages available for the specified voice in
-- addition to its default language.
--
-- For example, the default language for Aditi is Indian English (en-IN)
-- because it was first used for that language. Since Aditi is bilingual
-- and fluent in both Indian English and Hindi, this parameter would show
-- the code @hi-IN@.
voice_additionalLanguageCodes :: Lens.Lens' Voice (Prelude.Maybe [LanguageCode])
voice_additionalLanguageCodes :: Lens' Voice (Maybe [LanguageCode])
voice_additionalLanguageCodes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Voice' {Maybe [LanguageCode]
additionalLanguageCodes :: Maybe [LanguageCode]
$sel:additionalLanguageCodes:Voice' :: Voice -> Maybe [LanguageCode]
additionalLanguageCodes} -> Maybe [LanguageCode]
additionalLanguageCodes) (\s :: Voice
s@Voice' {} Maybe [LanguageCode]
a -> Voice
s {$sel:additionalLanguageCodes:Voice' :: Maybe [LanguageCode]
additionalLanguageCodes = Maybe [LanguageCode]
a} :: Voice) 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

-- | Gender of the voice.
voice_gender :: Lens.Lens' Voice (Prelude.Maybe Gender)
voice_gender :: Lens' Voice (Maybe Gender)
voice_gender = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Voice' {Maybe Gender
gender :: Maybe Gender
$sel:gender:Voice' :: Voice -> Maybe Gender
gender} -> Maybe Gender
gender) (\s :: Voice
s@Voice' {} Maybe Gender
a -> Voice
s {$sel:gender:Voice' :: Maybe Gender
gender = Maybe Gender
a} :: Voice)

-- | Amazon Polly assigned voice ID. This is the ID that you specify when
-- calling the @SynthesizeSpeech@ operation.
voice_id :: Lens.Lens' Voice (Prelude.Maybe VoiceId)
voice_id :: Lens' Voice (Maybe VoiceId)
voice_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Voice' {Maybe VoiceId
id :: Maybe VoiceId
$sel:id:Voice' :: Voice -> Maybe VoiceId
id} -> Maybe VoiceId
id) (\s :: Voice
s@Voice' {} Maybe VoiceId
a -> Voice
s {$sel:id:Voice' :: Maybe VoiceId
id = Maybe VoiceId
a} :: Voice)

-- | Language code of the voice.
voice_languageCode :: Lens.Lens' Voice (Prelude.Maybe LanguageCode)
voice_languageCode :: Lens' Voice (Maybe LanguageCode)
voice_languageCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Voice' {Maybe LanguageCode
languageCode :: Maybe LanguageCode
$sel:languageCode:Voice' :: Voice -> Maybe LanguageCode
languageCode} -> Maybe LanguageCode
languageCode) (\s :: Voice
s@Voice' {} Maybe LanguageCode
a -> Voice
s {$sel:languageCode:Voice' :: Maybe LanguageCode
languageCode = Maybe LanguageCode
a} :: Voice)

-- | Human readable name of the language in English.
voice_languageName :: Lens.Lens' Voice (Prelude.Maybe Prelude.Text)
voice_languageName :: Lens' Voice (Maybe Text)
voice_languageName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Voice' {Maybe Text
languageName :: Maybe Text
$sel:languageName:Voice' :: Voice -> Maybe Text
languageName} -> Maybe Text
languageName) (\s :: Voice
s@Voice' {} Maybe Text
a -> Voice
s {$sel:languageName:Voice' :: Maybe Text
languageName = Maybe Text
a} :: Voice)

-- | Name of the voice (for example, Salli, Kendra, etc.). This provides a
-- human readable voice name that you might display in your application.
voice_name :: Lens.Lens' Voice (Prelude.Maybe Prelude.Text)
voice_name :: Lens' Voice (Maybe Text)
voice_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Voice' {Maybe Text
name :: Maybe Text
$sel:name:Voice' :: Voice -> Maybe Text
name} -> Maybe Text
name) (\s :: Voice
s@Voice' {} Maybe Text
a -> Voice
s {$sel:name:Voice' :: Maybe Text
name = Maybe Text
a} :: Voice)

-- | Specifies which engines (@standard@ or @neural@) that are supported by a
-- given voice.
voice_supportedEngines :: Lens.Lens' Voice (Prelude.Maybe [Engine])
voice_supportedEngines :: Lens' Voice (Maybe [Engine])
voice_supportedEngines = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Voice' {Maybe [Engine]
supportedEngines :: Maybe [Engine]
$sel:supportedEngines:Voice' :: Voice -> Maybe [Engine]
supportedEngines} -> Maybe [Engine]
supportedEngines) (\s :: Voice
s@Voice' {} Maybe [Engine]
a -> Voice
s {$sel:supportedEngines:Voice' :: Maybe [Engine]
supportedEngines = Maybe [Engine]
a} :: Voice) 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

instance Data.FromJSON Voice where
  parseJSON :: Value -> Parser Voice
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Voice"
      ( \Object
x ->
          Maybe [LanguageCode]
-> Maybe Gender
-> Maybe VoiceId
-> Maybe LanguageCode
-> Maybe Text
-> Maybe Text
-> Maybe [Engine]
-> Voice
Voice'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"AdditionalLanguageCodes"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Gender")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Id")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (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 -> Parser (Maybe a)
Data..:? Key
"LanguageName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Name")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"SupportedEngines"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
      )

instance Prelude.Hashable Voice where
  hashWithSalt :: Int -> Voice -> Int
hashWithSalt Int
_salt Voice' {Maybe [Engine]
Maybe [LanguageCode]
Maybe Text
Maybe Gender
Maybe LanguageCode
Maybe VoiceId
supportedEngines :: Maybe [Engine]
name :: Maybe Text
languageName :: Maybe Text
languageCode :: Maybe LanguageCode
id :: Maybe VoiceId
gender :: Maybe Gender
additionalLanguageCodes :: Maybe [LanguageCode]
$sel:supportedEngines:Voice' :: Voice -> Maybe [Engine]
$sel:name:Voice' :: Voice -> Maybe Text
$sel:languageName:Voice' :: Voice -> Maybe Text
$sel:languageCode:Voice' :: Voice -> Maybe LanguageCode
$sel:id:Voice' :: Voice -> Maybe VoiceId
$sel:gender:Voice' :: Voice -> Maybe Gender
$sel:additionalLanguageCodes:Voice' :: Voice -> Maybe [LanguageCode]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [LanguageCode]
additionalLanguageCodes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Gender
gender
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe VoiceId
id
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe LanguageCode
languageCode
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
languageName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Engine]
supportedEngines

instance Prelude.NFData Voice where
  rnf :: Voice -> ()
rnf Voice' {Maybe [Engine]
Maybe [LanguageCode]
Maybe Text
Maybe Gender
Maybe LanguageCode
Maybe VoiceId
supportedEngines :: Maybe [Engine]
name :: Maybe Text
languageName :: Maybe Text
languageCode :: Maybe LanguageCode
id :: Maybe VoiceId
gender :: Maybe Gender
additionalLanguageCodes :: Maybe [LanguageCode]
$sel:supportedEngines:Voice' :: Voice -> Maybe [Engine]
$sel:name:Voice' :: Voice -> Maybe Text
$sel:languageName:Voice' :: Voice -> Maybe Text
$sel:languageCode:Voice' :: Voice -> Maybe LanguageCode
$sel:id:Voice' :: Voice -> Maybe VoiceId
$sel:gender:Voice' :: Voice -> Maybe Gender
$sel:additionalLanguageCodes:Voice' :: Voice -> Maybe [LanguageCode]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [LanguageCode]
additionalLanguageCodes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Gender
gender
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe VoiceId
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LanguageCode
languageCode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
languageName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Engine]
supportedEngines