amazonka-polly-1.6.0: Amazon Polly SDK.

Copyright(c) 2013-2018 Brendan Hay
LicenseMozilla Public License, v. 2.0.
MaintainerBrendan Hay <brendan.g.hay+amazonka@gmail.com>
Stabilityauto-generated
Portabilitynon-portable (GHC extensions)
Safe HaskellNone
LanguageHaskell2010

Network.AWS.Polly

Contents

Description

Amazon Polly is a web service that makes it easy to synthesize speech from text.

The Amazon Polly service provides API operations for synthesizing high-quality speech from plain text and Speech Synthesis Markup Language (SSML), along with managing pronunciations lexicons that enable you to get the best results for your application domain.

Synopsis

Service Configuration

polly :: Service #

API version 2016-06-10 of the Amazon Polly SDK configuration.

Errors

Error matchers are designed for use with the functions provided by Control.Exception.Lens. This allows catching (and rethrowing) service specific errors returned by Polly.

UnsupportedPlsLanguageException

_UnsupportedPlsLanguageException :: AsError a => Getting (First ServiceError) a ServiceError #

The language specified in the lexicon is unsupported. For a list of supported languages, see Lexicon Attributes .

InvalidSsmlException

_InvalidSsmlException :: AsError a => Getting (First ServiceError) a ServiceError #

The SSML you provided is invalid. Verify the SSML syntax, spelling of tags and values, and then try again.

InvalidSampleRateException

_InvalidSampleRateException :: AsError a => Getting (First ServiceError) a ServiceError #

The specified sample rate is not valid.

MaxLexiconsNumberExceededException

_MaxLexiconsNumberExceededException :: AsError a => Getting (First ServiceError) a ServiceError #

The maximum number of lexicons would be exceeded by this operation.

TextLengthExceededException

_TextLengthExceededException :: AsError a => Getting (First ServiceError) a ServiceError #

The value of the Text parameter is longer than the accepted limits. The limit for input text is a maximum of 3000 characters total, of which no more than 1500 can be billed characters. SSML tags are not counted as billed characters.

MaxLexemeLengthExceededException

_MaxLexemeLengthExceededException :: AsError a => Getting (First ServiceError) a ServiceError #

The maximum size of the lexeme would be exceeded by this operation.

InvalidLexiconException

_InvalidLexiconException :: AsError a => Getting (First ServiceError) a ServiceError #

Amazon Polly can't find the specified lexicon. Verify that the lexicon's name is spelled correctly, and then try again.

ServiceFailureException

_ServiceFailureException :: AsError a => Getting (First ServiceError) a ServiceError #

An unknown condition has caused a service failure.

UnsupportedPlsAlphabetException

_UnsupportedPlsAlphabetException :: AsError a => Getting (First ServiceError) a ServiceError #

The alphabet specified by the lexicon is not a supported alphabet. Valid values are x-sampa and ipa .

InvalidNextTokenException

_InvalidNextTokenException :: AsError a => Getting (First ServiceError) a ServiceError #

The NextToken is invalid. Verify that it's spelled correctly, and then try again.

MarksNotSupportedForFormatException

_MarksNotSupportedForFormatException :: AsError a => Getting (First ServiceError) a ServiceError #

Speech marks are not supported for the OutputFormat selected. Speech marks are only available for content in json format.

SsmlMarksNotSupportedForTextTypeException

_SsmlMarksNotSupportedForTextTypeException :: AsError a => Getting (First ServiceError) a ServiceError #

SSML speech marks are not supported for plain text-type input.

LexiconSizeExceededException

_LexiconSizeExceededException :: AsError a => Getting (First ServiceError) a ServiceError #

The maximum size of the specified lexicon would be exceeded by this operation.

LexiconNotFoundException

_LexiconNotFoundException :: AsError a => Getting (First ServiceError) a ServiceError #

Amazon Polly can't find the specified lexicon. This could be caused by a lexicon that is missing, its name is misspelled or specifying a lexicon that is in a different region.

Verify that the lexicon exists, is in the region (see ListLexicons ) and that you spelled its name is spelled correctly. Then try again.

Waiters

Waiters poll by repeatedly sending a request until some remote success condition configured by the Wait specification is fulfilled. The Wait specification determines how many attempts should be made, in addition to delay and retry strategies.

Operations

Some AWS operations return results that are incomplete and require subsequent requests in order to obtain the entire result set. The process of sending subsequent requests to continue where a previous request left off is called pagination. For example, the ListObjects operation of Amazon S3 returns up to 1000 objects at a time, and you must send subsequent requests with the appropriate Marker in order to retrieve the next page of results.

Operations that have an AWSPager instance can transparently perform subsequent requests, correctly setting Markers and other request facets to iterate through the entire result set of a truncated API operation. Operations which support this have an additional note in the documentation.

Many operations have the ability to filter results on the server side. See the individual operation parameters for details.

GetLexicon

DescribeVoices (Paginated)

ListLexicons

SynthesizeSpeech

PutLexicon

DeleteLexicon

Types

Gender

data Gender #

Constructors

Female 
Male 

Instances

Bounded Gender # 
Enum Gender # 
Eq Gender # 

Methods

(==) :: Gender -> Gender -> Bool #

(/=) :: Gender -> Gender -> Bool #

Data Gender # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Gender -> c Gender #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Gender #

toConstr :: Gender -> Constr #

dataTypeOf :: Gender -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Gender) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Gender) #

gmapT :: (forall b. Data b => b -> b) -> Gender -> Gender #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r #

gmapQ :: (forall d. Data d => d -> u) -> Gender -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Gender -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Gender -> m Gender #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Gender -> m Gender #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Gender -> m Gender #

Ord Gender # 
Read Gender # 
Show Gender # 
Generic Gender # 

Associated Types

type Rep Gender :: * -> * #

Methods

from :: Gender -> Rep Gender x #

to :: Rep Gender x -> Gender #

Hashable Gender # 

Methods

hashWithSalt :: Int -> Gender -> Int #

hash :: Gender -> Int #

FromJSON Gender # 
NFData Gender # 

Methods

rnf :: Gender -> () #

ToHeader Gender # 

Methods

toHeader :: HeaderName -> Gender -> [Header] #

ToQuery Gender # 
ToByteString Gender # 

Methods

toBS :: Gender -> ByteString #

FromText Gender # 

Methods

parser :: Parser Gender #

ToText Gender # 

Methods

toText :: Gender -> Text #

type Rep Gender # 
type Rep Gender = D1 * (MetaData "Gender" "Network.AWS.Polly.Types.Sum" "amazonka-polly-1.6.0-ApBZzACP19U912sdDsQ2zs" False) ((:+:) * (C1 * (MetaCons "Female" PrefixI False) (U1 *)) (C1 * (MetaCons "Male" PrefixI False) (U1 *)))

LanguageCode

data LanguageCode #

Instances

Bounded LanguageCode # 
Enum LanguageCode # 
Eq LanguageCode # 
Data LanguageCode # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LanguageCode -> c LanguageCode #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LanguageCode #

toConstr :: LanguageCode -> Constr #

dataTypeOf :: LanguageCode -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LanguageCode) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LanguageCode) #

gmapT :: (forall b. Data b => b -> b) -> LanguageCode -> LanguageCode #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LanguageCode -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LanguageCode -> r #

gmapQ :: (forall d. Data d => d -> u) -> LanguageCode -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LanguageCode -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LanguageCode -> m LanguageCode #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LanguageCode -> m LanguageCode #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LanguageCode -> m LanguageCode #

Ord LanguageCode # 
Read LanguageCode # 
Show LanguageCode # 
Generic LanguageCode # 

Associated Types

type Rep LanguageCode :: * -> * #

Hashable LanguageCode # 
ToJSON LanguageCode # 
FromJSON LanguageCode # 
NFData LanguageCode # 

Methods

rnf :: LanguageCode -> () #

ToHeader LanguageCode # 
ToQuery LanguageCode # 
ToByteString LanguageCode # 
FromText LanguageCode # 
ToText LanguageCode # 

Methods

toText :: LanguageCode -> Text #

type Rep LanguageCode # 
type Rep LanguageCode = D1 * (MetaData "LanguageCode" "Network.AWS.Polly.Types.Sum" "amazonka-polly-1.6.0-ApBZzACP19U912sdDsQ2zs" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "CyGb" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "DaDk" PrefixI False) (U1 *)) (C1 * (MetaCons "DeDe" PrefixI False) (U1 *)))) ((:+:) * (C1 * (MetaCons "EnAu" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "EnGb" PrefixI False) (U1 *)) (C1 * (MetaCons "EnGbWls" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * (C1 * (MetaCons "EnIn" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "EnUs" PrefixI False) (U1 *)) (C1 * (MetaCons "EsEs" PrefixI False) (U1 *)))) ((:+:) * (C1 * (MetaCons "EsUs" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "FrCa" PrefixI False) (U1 *)) (C1 * (MetaCons "FrFr" PrefixI False) (U1 *)))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "IsIs" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "ItIt" PrefixI False) (U1 *)) (C1 * (MetaCons "JaJp" PrefixI False) (U1 *)))) ((:+:) * (C1 * (MetaCons "KoKr" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "NbNo" PrefixI False) (U1 *)) (C1 * (MetaCons "NlNl" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * (C1 * (MetaCons "PlPl" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "PtBr" PrefixI False) (U1 *)) (C1 * (MetaCons "PtPt" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "RoRo" PrefixI False) (U1 *)) (C1 * (MetaCons "RuRu" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "SvSe" PrefixI False) (U1 *)) (C1 * (MetaCons "TrTr" PrefixI False) (U1 *)))))))

OutputFormat

data OutputFormat #

Constructors

JSON 
MP3 
OggVorbis 
Pcm 

Instances

Bounded OutputFormat # 
Enum OutputFormat # 
Eq OutputFormat # 
Data OutputFormat # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OutputFormat -> c OutputFormat #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OutputFormat #

toConstr :: OutputFormat -> Constr #

dataTypeOf :: OutputFormat -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c OutputFormat) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OutputFormat) #

gmapT :: (forall b. Data b => b -> b) -> OutputFormat -> OutputFormat #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OutputFormat -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OutputFormat -> r #

gmapQ :: (forall d. Data d => d -> u) -> OutputFormat -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OutputFormat -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OutputFormat -> m OutputFormat #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputFormat -> m OutputFormat #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputFormat -> m OutputFormat #

Ord OutputFormat # 
Read OutputFormat # 
Show OutputFormat # 
Generic OutputFormat # 

Associated Types

type Rep OutputFormat :: * -> * #

Hashable OutputFormat # 
ToJSON OutputFormat # 
NFData OutputFormat # 

Methods

rnf :: OutputFormat -> () #

ToHeader OutputFormat # 
ToQuery OutputFormat # 
ToByteString OutputFormat # 
FromText OutputFormat # 
ToText OutputFormat # 

Methods

toText :: OutputFormat -> Text #

type Rep OutputFormat # 
type Rep OutputFormat = D1 * (MetaData "OutputFormat" "Network.AWS.Polly.Types.Sum" "amazonka-polly-1.6.0-ApBZzACP19U912sdDsQ2zs" False) ((:+:) * ((:+:) * (C1 * (MetaCons "JSON" PrefixI False) (U1 *)) (C1 * (MetaCons "MP3" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "OggVorbis" PrefixI False) (U1 *)) (C1 * (MetaCons "Pcm" PrefixI False) (U1 *))))

SpeechMarkType

data SpeechMarkType #

Constructors

Sentence 
Ssml 
Viseme 
Word 

Instances

Bounded SpeechMarkType # 
Enum SpeechMarkType # 
Eq SpeechMarkType # 
Data SpeechMarkType # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpeechMarkType -> c SpeechMarkType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpeechMarkType #

toConstr :: SpeechMarkType -> Constr #

dataTypeOf :: SpeechMarkType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SpeechMarkType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpeechMarkType) #

gmapT :: (forall b. Data b => b -> b) -> SpeechMarkType -> SpeechMarkType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpeechMarkType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpeechMarkType -> r #

gmapQ :: (forall d. Data d => d -> u) -> SpeechMarkType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpeechMarkType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpeechMarkType -> m SpeechMarkType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpeechMarkType -> m SpeechMarkType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpeechMarkType -> m SpeechMarkType #

Ord SpeechMarkType # 
Read SpeechMarkType # 
Show SpeechMarkType # 
Generic SpeechMarkType # 

Associated Types

type Rep SpeechMarkType :: * -> * #

Hashable SpeechMarkType # 
ToJSON SpeechMarkType # 
NFData SpeechMarkType # 

Methods

rnf :: SpeechMarkType -> () #

ToHeader SpeechMarkType # 
ToQuery SpeechMarkType # 
ToByteString SpeechMarkType # 
FromText SpeechMarkType # 
ToText SpeechMarkType # 
type Rep SpeechMarkType # 
type Rep SpeechMarkType = D1 * (MetaData "SpeechMarkType" "Network.AWS.Polly.Types.Sum" "amazonka-polly-1.6.0-ApBZzACP19U912sdDsQ2zs" False) ((:+:) * ((:+:) * (C1 * (MetaCons "Sentence" PrefixI False) (U1 *)) (C1 * (MetaCons "Ssml" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "Viseme" PrefixI False) (U1 *)) (C1 * (MetaCons "Word" PrefixI False) (U1 *))))

TextType

data TextType #

Constructors

TTSsml 
TTText 

Instances

Bounded TextType # 
Enum TextType # 
Eq TextType # 
Data TextType # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TextType -> c TextType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TextType #

toConstr :: TextType -> Constr #

dataTypeOf :: TextType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TextType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TextType) #

gmapT :: (forall b. Data b => b -> b) -> TextType -> TextType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TextType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TextType -> r #

gmapQ :: (forall d. Data d => d -> u) -> TextType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TextType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TextType -> m TextType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TextType -> m TextType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TextType -> m TextType #

Ord TextType # 
Read TextType # 
Show TextType # 
Generic TextType # 

Associated Types

type Rep TextType :: * -> * #

Methods

from :: TextType -> Rep TextType x #

to :: Rep TextType x -> TextType #

Hashable TextType # 

Methods

hashWithSalt :: Int -> TextType -> Int #

hash :: TextType -> Int #

ToJSON TextType # 
NFData TextType # 

Methods

rnf :: TextType -> () #

ToHeader TextType # 

Methods

toHeader :: HeaderName -> TextType -> [Header] #

ToQuery TextType # 
ToByteString TextType # 

Methods

toBS :: TextType -> ByteString #

FromText TextType # 
ToText TextType # 

Methods

toText :: TextType -> Text #

type Rep TextType # 
type Rep TextType = D1 * (MetaData "TextType" "Network.AWS.Polly.Types.Sum" "amazonka-polly-1.6.0-ApBZzACP19U912sdDsQ2zs" False) ((:+:) * (C1 * (MetaCons "TTSsml" PrefixI False) (U1 *)) (C1 * (MetaCons "TTText" PrefixI False) (U1 *)))

VoiceId

data VoiceId #

Instances

Bounded VoiceId # 
Enum VoiceId # 
Eq VoiceId # 

Methods

(==) :: VoiceId -> VoiceId -> Bool #

(/=) :: VoiceId -> VoiceId -> Bool #

Data VoiceId # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VoiceId -> c VoiceId #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VoiceId #

toConstr :: VoiceId -> Constr #

dataTypeOf :: VoiceId -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c VoiceId) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VoiceId) #

gmapT :: (forall b. Data b => b -> b) -> VoiceId -> VoiceId #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VoiceId -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VoiceId -> r #

gmapQ :: (forall d. Data d => d -> u) -> VoiceId -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> VoiceId -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VoiceId -> m VoiceId #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VoiceId -> m VoiceId #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VoiceId -> m VoiceId #

Ord VoiceId # 
Read VoiceId # 
Show VoiceId # 
Generic VoiceId # 

Associated Types

type Rep VoiceId :: * -> * #

Methods

from :: VoiceId -> Rep VoiceId x #

to :: Rep VoiceId x -> VoiceId #

Hashable VoiceId # 

Methods

hashWithSalt :: Int -> VoiceId -> Int #

hash :: VoiceId -> Int #

ToJSON VoiceId # 
FromJSON VoiceId # 
NFData VoiceId # 

Methods

rnf :: VoiceId -> () #

ToHeader VoiceId # 

Methods

toHeader :: HeaderName -> VoiceId -> [Header] #

ToQuery VoiceId # 
ToByteString VoiceId # 

Methods

toBS :: VoiceId -> ByteString #

FromText VoiceId # 
ToText VoiceId # 

Methods

toText :: VoiceId -> Text #

type Rep VoiceId # 
type Rep VoiceId = D1 * (MetaData "VoiceId" "Network.AWS.Polly.Types.Sum" "amazonka-polly-1.6.0-ApBZzACP19U912sdDsQ2zs" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "Aditi" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Amy" PrefixI False) (U1 *)) (C1 * (MetaCons "Astrid" PrefixI False) (U1 *)))) ((:+:) * (C1 * (MetaCons "Brian" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Carla" PrefixI False) (U1 *)) (C1 * (MetaCons "Carmen" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * (C1 * (MetaCons "Celine" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Chantal" PrefixI False) (U1 *)) (C1 * (MetaCons "Conchita" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "Cristiano" PrefixI False) (U1 *)) (C1 * (MetaCons "Dora" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "Emma" PrefixI False) (U1 *)) (C1 * (MetaCons "Enrique" PrefixI False) (U1 *)))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "Ewa" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Filiz" PrefixI False) (U1 *)) (C1 * (MetaCons "Geraint" PrefixI False) (U1 *)))) ((:+:) * (C1 * (MetaCons "Giorgio" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Gwyneth" PrefixI False) (U1 *)) (C1 * (MetaCons "Hans" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * (C1 * (MetaCons "Ines" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Ivy" PrefixI False) (U1 *)) (C1 * (MetaCons "Jacek" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "Jan" PrefixI False) (U1 *)) (C1 * (MetaCons "Joanna" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "Joey" PrefixI False) (U1 *)) (C1 * (MetaCons "Justin" PrefixI False) (U1 *))))))) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "Karl" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Kendra" PrefixI False) (U1 *)) (C1 * (MetaCons "Kimberly" PrefixI False) (U1 *)))) ((:+:) * (C1 * (MetaCons "Liv" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Lotte" PrefixI False) (U1 *)) (C1 * (MetaCons "Mads" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * (C1 * (MetaCons "Maja" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Marlene" PrefixI False) (U1 *)) (C1 * (MetaCons "Mathieu" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "Matthew" PrefixI False) (U1 *)) (C1 * (MetaCons "Maxim" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "Miguel" PrefixI False) (U1 *)) (C1 * (MetaCons "Mizuki" PrefixI False) (U1 *)))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "Naja" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Nicole" PrefixI False) (U1 *)) (C1 * (MetaCons "Penelope" PrefixI False) (U1 *)))) ((:+:) * (C1 * (MetaCons "Raveena" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Ricardo" PrefixI False) (U1 *)) (C1 * (MetaCons "Ruben" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * (C1 * (MetaCons "Russell" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Salli" PrefixI False) (U1 *)) (C1 * (MetaCons "Seoyeon" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "Takumi" PrefixI False) (U1 *)) (C1 * (MetaCons "Tatyana" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "Vicki" PrefixI False) (U1 *)) (C1 * (MetaCons "Vitoria" PrefixI False) (U1 *))))))))

Lexicon

data Lexicon #

Provides lexicon name and lexicon content in string format. For more information, see Pronunciation Lexicon Specification (PLS) Version 1.0 .

See: lexicon smart constructor.

Instances

Eq Lexicon # 

Methods

(==) :: Lexicon -> Lexicon -> Bool #

(/=) :: Lexicon -> Lexicon -> Bool #

Data Lexicon # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lexicon -> c Lexicon #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lexicon #

toConstr :: Lexicon -> Constr #

dataTypeOf :: Lexicon -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Lexicon) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lexicon) #

gmapT :: (forall b. Data b => b -> b) -> Lexicon -> Lexicon #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lexicon -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lexicon -> r #

gmapQ :: (forall d. Data d => d -> u) -> Lexicon -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Lexicon -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lexicon -> m Lexicon #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lexicon -> m Lexicon #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lexicon -> m Lexicon #

Show Lexicon # 
Generic Lexicon # 

Associated Types

type Rep Lexicon :: * -> * #

Methods

from :: Lexicon -> Rep Lexicon x #

to :: Rep Lexicon x -> Lexicon #

Hashable Lexicon # 

Methods

hashWithSalt :: Int -> Lexicon -> Int #

hash :: Lexicon -> Int #

FromJSON Lexicon # 
NFData Lexicon # 

Methods

rnf :: Lexicon -> () #

type Rep Lexicon # 
type Rep Lexicon = D1 * (MetaData "Lexicon" "Network.AWS.Polly.Types.Product" "amazonka-polly-1.6.0-ApBZzACP19U912sdDsQ2zs" False) (C1 * (MetaCons "Lexicon'" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "_lContent") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Maybe Text))) (S1 * (MetaSel (Just Symbol "_lName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Maybe (Sensitive Text))))))

lexicon :: Lexicon #

Creates a value of Lexicon with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

  • lContent - Lexicon content in string format. The content of a lexicon must be in PLS format.
  • lName - Name of the lexicon.

lContent :: Lens' Lexicon (Maybe Text) #

Lexicon content in string format. The content of a lexicon must be in PLS format.

lName :: Lens' Lexicon (Maybe Text) #

Name of the lexicon.

LexiconAttributes

data LexiconAttributes #

Contains metadata describing the lexicon such as the number of lexemes, language code, and so on. For more information, see Managing Lexicons .

See: lexiconAttributes smart constructor.

Instances

Eq LexiconAttributes # 
Data LexiconAttributes # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LexiconAttributes -> c LexiconAttributes #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LexiconAttributes #

toConstr :: LexiconAttributes -> Constr #

dataTypeOf :: LexiconAttributes -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LexiconAttributes) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LexiconAttributes) #

gmapT :: (forall b. Data b => b -> b) -> LexiconAttributes -> LexiconAttributes #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LexiconAttributes -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LexiconAttributes -> r #

gmapQ :: (forall d. Data d => d -> u) -> LexiconAttributes -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LexiconAttributes -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LexiconAttributes -> m LexiconAttributes #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LexiconAttributes -> m LexiconAttributes #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LexiconAttributes -> m LexiconAttributes #

Read LexiconAttributes # 
Show LexiconAttributes # 
Generic LexiconAttributes # 
Hashable LexiconAttributes # 
FromJSON LexiconAttributes # 
NFData LexiconAttributes # 

Methods

rnf :: LexiconAttributes -> () #

type Rep LexiconAttributes # 
type Rep LexiconAttributes = D1 * (MetaData "LexiconAttributes" "Network.AWS.Polly.Types.Product" "amazonka-polly-1.6.0-ApBZzACP19U912sdDsQ2zs" False) (C1 * (MetaCons "LexiconAttributes'" PrefixI True) ((:*:) * ((:*:) * (S1 * (MetaSel (Just Symbol "_laLanguageCode") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Maybe LanguageCode))) ((:*:) * (S1 * (MetaSel (Just Symbol "_laSize") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Maybe Int))) (S1 * (MetaSel (Just Symbol "_laLexemesCount") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Maybe Int))))) ((:*:) * (S1 * (MetaSel (Just Symbol "_laLexiconARN") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Maybe Text))) ((:*:) * (S1 * (MetaSel (Just Symbol "_laAlphabet") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Maybe Text))) (S1 * (MetaSel (Just Symbol "_laLastModified") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Maybe POSIX)))))))

lexiconAttributes :: LexiconAttributes #

Creates a value of LexiconAttributes with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

  • laLanguageCode - Language code that the lexicon applies to. A lexicon with a language code such as "en" would be applied to all English languages (en-GB, en-US, en-AUS, en-WLS, and so on.
  • laSize - Total size of the lexicon, in characters.
  • laLexemesCount - Number of lexemes in the lexicon.
  • laLexiconARN - Amazon Resource Name (ARN) of the lexicon.
  • laAlphabet - Phonetic alphabet used in the lexicon. Valid values are ipa and x-sampa .
  • laLastModified - Date lexicon was last modified (a timestamp value).

laLanguageCode :: Lens' LexiconAttributes (Maybe LanguageCode) #

Language code that the lexicon applies to. A lexicon with a language code such as "en" would be applied to all English languages (en-GB, en-US, en-AUS, en-WLS, and so on.

laSize :: Lens' LexiconAttributes (Maybe Int) #

Total size of the lexicon, in characters.

laLexemesCount :: Lens' LexiconAttributes (Maybe Int) #

Number of lexemes in the lexicon.

laLexiconARN :: Lens' LexiconAttributes (Maybe Text) #

Amazon Resource Name (ARN) of the lexicon.

laAlphabet :: Lens' LexiconAttributes (Maybe Text) #

Phonetic alphabet used in the lexicon. Valid values are ipa and x-sampa .

laLastModified :: Lens' LexiconAttributes (Maybe UTCTime) #

Date lexicon was last modified (a timestamp value).

LexiconDescription

data LexiconDescription #

Describes the content of the lexicon.

See: lexiconDescription smart constructor.

Instances

Eq LexiconDescription # 
Data LexiconDescription # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LexiconDescription -> c LexiconDescription #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LexiconDescription #

toConstr :: LexiconDescription -> Constr #

dataTypeOf :: LexiconDescription -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LexiconDescription) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LexiconDescription) #

gmapT :: (forall b. Data b => b -> b) -> LexiconDescription -> LexiconDescription #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LexiconDescription -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LexiconDescription -> r #

gmapQ :: (forall d. Data d => d -> u) -> LexiconDescription -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LexiconDescription -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LexiconDescription -> m LexiconDescription #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LexiconDescription -> m LexiconDescription #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LexiconDescription -> m LexiconDescription #

Show LexiconDescription # 
Generic LexiconDescription # 
Hashable LexiconDescription # 
FromJSON LexiconDescription # 
NFData LexiconDescription # 

Methods

rnf :: LexiconDescription -> () #

type Rep LexiconDescription # 
type Rep LexiconDescription = D1 * (MetaData "LexiconDescription" "Network.AWS.Polly.Types.Product" "amazonka-polly-1.6.0-ApBZzACP19U912sdDsQ2zs" False) (C1 * (MetaCons "LexiconDescription'" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "_ldAttributes") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Maybe LexiconAttributes))) (S1 * (MetaSel (Just Symbol "_ldName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * (Maybe (Sensitive Text))))))

lexiconDescription :: LexiconDescription #

Creates a value of LexiconDescription with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

ldName :: Lens' LexiconDescription (Maybe Text) #

Name of the lexicon.

Voice

data Voice #

Description of the voice.

See: voice smart constructor.

Instances

Eq Voice # 

Methods

(==) :: Voice -> Voice -> Bool #

(/=) :: Voice -> Voice -> Bool #

Data Voice # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Voice -> c Voice #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Voice #

toConstr :: Voice -> Constr #

dataTypeOf :: Voice -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Voice) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Voice) #

gmapT :: (forall b. Data b => b -> b) -> Voice -> Voice #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Voice -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Voice -> r #

gmapQ :: (forall d. Data d => d -> u) -> Voice -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Voice -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Voice -> m Voice #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Voice -> m Voice #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Voice -> m Voice #

Read Voice # 
Show Voice # 

Methods

showsPrec :: Int -> Voice -> ShowS #

show :: Voice -> String #

showList :: [Voice] -> ShowS #

Generic Voice # 

Associated Types

type Rep Voice :: * -> * #

Methods

from :: Voice -> Rep Voice x #

to :: Rep Voice x -> Voice #

Hashable Voice # 

Methods

hashWithSalt :: Int -> Voice -> Int #

hash :: Voice -> Int #

FromJSON Voice # 
NFData Voice # 

Methods

rnf :: Voice -> () #

type Rep Voice # 

voice :: Voice #

Creates a value of Voice with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

  • vLanguageCode - Language code of the voice.
  • vLanguageName - Human readable name of the language in English.
  • vGender - Gender of the voice.
  • vName - Name of the voice (for example, Salli, Kendra, etc.). This provides a human readable voice name that you might display in your application.
  • vId - Amazon Polly assigned voice ID. This is the ID that you specify when calling the SynthesizeSpeech operation.

vLanguageCode :: Lens' Voice (Maybe LanguageCode) #

Language code of the voice.

vLanguageName :: Lens' Voice (Maybe Text) #

Human readable name of the language in English.

vGender :: Lens' Voice (Maybe Gender) #

Gender of the voice.

vName :: Lens' Voice (Maybe Text) #

Name of the voice (for example, Salli, Kendra, etc.). This provides a human readable voice name that you might display in your application.

vId :: Lens' Voice (Maybe VoiceId) #

Amazon Polly assigned voice ID. This is the ID that you specify when calling the SynthesizeSpeech operation.