polly

package
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 15, 2018 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Overview

Package polly provides the client and types for making API requests to Amazon Polly.

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.

See https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10 for more information on this service.

See polly package documentation for more information. https://docs.aws.amazon.com/sdk-for-go/api/service/polly/

Using the Client

To Amazon Polly with the SDK use the New function to create a new service client. With that client you can make API requests to the service. These clients are safe to use concurrently.

See the SDK's documentation for more information on how to use the SDK. https://docs.aws.amazon.com/sdk-for-go/api/

See aws.Config documentation for more information on configuring SDK clients. https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config

See the Amazon Polly client Polly for more information on creating client for this service. https://docs.aws.amazon.com/sdk-for-go/api/service/polly/#New

Index

Examples

Constants

View Source 
const (

	// ErrCodeInvalidLexiconException for service response error code
	// "InvalidLexiconException".
	//
	// Amazon Polly can't find the specified lexicon. Verify that the lexicon's
	// name is spelled correctly, and then try again.
	ErrCodeInvalidLexiconException = "InvalidLexiconException"

	// ErrCodeInvalidNextTokenException for service response error code
	// "InvalidNextTokenException".
	//
	// The NextToken is invalid. Verify that it's spelled correctly, and then try
	// again.
	ErrCodeInvalidNextTokenException = "InvalidNextTokenException"

	// ErrCodeInvalidSampleRateException for service response error code
	// "InvalidSampleRateException".
	//
	// The specified sample rate is not valid.
	ErrCodeInvalidSampleRateException = "InvalidSampleRateException"

	// ErrCodeInvalidSsmlException for service response error code
	// "InvalidSsmlException".
	//
	// The SSML you provided is invalid. Verify the SSML syntax, spelling of tags
	// and values, and then try again.
	ErrCodeInvalidSsmlException = "InvalidSsmlException"

	// ErrCodeLexiconNotFoundException for service response error code
	// "LexiconNotFoundException".
	//
	// 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.
	ErrCodeLexiconNotFoundException = "LexiconNotFoundException"

	// ErrCodeLexiconSizeExceededException for service response error code
	// "LexiconSizeExceededException".
	//
	// The maximum size of the specified lexicon would be exceeded by this operation.
	ErrCodeLexiconSizeExceededException = "LexiconSizeExceededException"

	// ErrCodeMarksNotSupportedForFormatException for service response error code
	// "MarksNotSupportedForFormatException".
	//
	// Speech marks are not supported for the OutputFormat selected. Speech marks
	// are only available for content in json format.
	ErrCodeMarksNotSupportedForFormatException = "MarksNotSupportedForFormatException"

	// ErrCodeMaxLexemeLengthExceededException for service response error code
	// "MaxLexemeLengthExceededException".
	//
	// The maximum size of the lexeme would be exceeded by this operation.
	ErrCodeMaxLexemeLengthExceededException = "MaxLexemeLengthExceededException"

	// ErrCodeMaxLexiconsNumberExceededException for service response error code
	// "MaxLexiconsNumberExceededException".
	//
	// The maximum number of lexicons would be exceeded by this operation.
	ErrCodeMaxLexiconsNumberExceededException = "MaxLexiconsNumberExceededException"

	// ErrCodeServiceFailureException for service response error code
	// "ServiceFailureException".
	//
	// An unknown condition has caused a service failure.
	ErrCodeServiceFailureException = "ServiceFailureException"

	// ErrCodeSsmlMarksNotSupportedForTextTypeException for service response error code
	// "SsmlMarksNotSupportedForTextTypeException".
	//
	// SSML speech marks are not supported for plain text-type input.
	ErrCodeSsmlMarksNotSupportedForTextTypeException = "SsmlMarksNotSupportedForTextTypeException"

	// ErrCodeTextLengthExceededException for service response error code
	// "TextLengthExceededException".
	//
	// 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.
	ErrCodeTextLengthExceededException = "TextLengthExceededException"

	// ErrCodeUnsupportedPlsAlphabetException for service response error code
	// "UnsupportedPlsAlphabetException".
	//
	// The alphabet specified by the lexicon is not a supported alphabet. Valid
	// values are x-sampa and ipa.
	ErrCodeUnsupportedPlsAlphabetException = "UnsupportedPlsAlphabetException"

	// ErrCodeUnsupportedPlsLanguageException for service response error code
	// "UnsupportedPlsLanguageException".
	//
	// The language specified in the lexicon is unsupported. For a list of supported
	// languages, see Lexicon Attributes (http://docs.aws.amazon.com/polly/latest/dg/API_LexiconAttributes.html).
	ErrCodeUnsupportedPlsLanguageException = "UnsupportedPlsLanguageException"
)
View Source 
const (
	ServiceName = "polly"     // Service endpoint prefix API calls made to.
	EndpointsID = ServiceName // Service ID for Regions and Endpoints metadata.
)

Service information constants

Variables

This section is empty.

Functions

This section is empty.

Types

type DeleteLexiconInput 

type DeleteLexiconInput struct {

	// The name of the lexicon to delete. Must be an existing lexicon in the region.
	//
	// Name is a required field
	Name *string `location:"uri" locationName:"LexiconName" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/DeleteLexiconInput

func (DeleteLexiconInput) GoString 

func (s DeleteLexiconInput) GoString() string

GoString returns the string representation

func (*DeleteLexiconInput) SetName 

func (s *DeleteLexiconInput) SetName(v string) *DeleteLexiconInput

SetName sets the Name field's value.

func (DeleteLexiconInput) String 

func (s DeleteLexiconInput) String() string

String returns the string representation

func (*DeleteLexiconInput) Validate 

func (s *DeleteLexiconInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteLexiconOutput 

type DeleteLexiconOutput struct {
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/DeleteLexiconOutput

func (DeleteLexiconOutput) GoString 

func (s DeleteLexiconOutput) GoString() string

GoString returns the string representation

func (DeleteLexiconOutput) SDKResponseMetadata 

func (s DeleteLexiconOutput) SDKResponseMetadata() aws.Response

SDKResponseMetdata return sthe response metadata for the API.

func (DeleteLexiconOutput) String 

func (s DeleteLexiconOutput) String() string

String returns the string representation

type DeleteLexiconRequest 

type DeleteLexiconRequest struct {
	*aws.Request
	Input *DeleteLexiconInput
}

DeleteLexiconRequest is a API request type for the DeleteLexicon API operation.

func (DeleteLexiconRequest) Send 

func (r DeleteLexiconRequest) Send() (*DeleteLexiconOutput, error)

Send marshals and sends the DeleteLexicon API request.

type DescribeVoicesInput 

type DescribeVoicesInput struct {

	// The language identification tag (ISO 639 code for the language name-ISO 3166
	// country code) for filtering the list of voices returned. If you don't specify
	// this optional parameter, all available voices are returned.
	LanguageCode LanguageCode `location:"querystring" locationName:"LanguageCode" type:"string" enum:"true"`

	// An opaque pagination token returned from the previous DescribeVoices operation.
	// If present, this indicates where to continue the listing.
	NextToken *string `location:"querystring" locationName:"NextToken" type:"string"`
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/DescribeVoicesInput

func (DescribeVoicesInput) GoString 

func (s DescribeVoicesInput) GoString() string

GoString returns the string representation

func (*DescribeVoicesInput) SetLanguageCode 

func (s *DescribeVoicesInput) SetLanguageCode(v LanguageCode) *DescribeVoicesInput

SetLanguageCode sets the LanguageCode field's value.

func (*DescribeVoicesInput) SetNextToken 

func (s *DescribeVoicesInput) SetNextToken(v string) *DescribeVoicesInput

SetNextToken sets the NextToken field's value.

func (DescribeVoicesInput) String 

func (s DescribeVoicesInput) String() string

String returns the string representation

type DescribeVoicesOutput 

type DescribeVoicesOutput struct {

	// The pagination token to use in the next request to continue the listing of
	// voices. NextToken is returned only if the response is truncated.
	NextToken *string `type:"string"`

	// A list of voices with their properties.
	Voices []Voice `type:"list"`
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/DescribeVoicesOutput

func (DescribeVoicesOutput) GoString 

func (s DescribeVoicesOutput) GoString() string

GoString returns the string representation

func (DescribeVoicesOutput) SDKResponseMetadata 

func (s DescribeVoicesOutput) SDKResponseMetadata() aws.Response

SDKResponseMetdata return sthe response metadata for the API.

func (*DescribeVoicesOutput) SetNextToken 

func (s *DescribeVoicesOutput) SetNextToken(v string) *DescribeVoicesOutput

SetNextToken sets the NextToken field's value.

func (*DescribeVoicesOutput) SetVoices 

func (s *DescribeVoicesOutput) SetVoices(v []Voice) *DescribeVoicesOutput

SetVoices sets the Voices field's value.

func (DescribeVoicesOutput) String 

func (s DescribeVoicesOutput) String() string

String returns the string representation

type DescribeVoicesRequest 

type DescribeVoicesRequest struct {
	*aws.Request
	Input *DescribeVoicesInput
}

DescribeVoicesRequest is a API request type for the DescribeVoices API operation.

func (DescribeVoicesRequest) Send 

func (r DescribeVoicesRequest) Send() (*DescribeVoicesOutput, error)

Send marshals and sends the DescribeVoices API request.

type Gender 

type Gender string
const (
	GenderFemale Gender = "Female"
	GenderMale   Gender = "Male"
)

Enum values for Gender

type GetLexiconInput 

type GetLexiconInput struct {

	// Name of the lexicon.
	//
	// Name is a required field
	Name *string `location:"uri" locationName:"LexiconName" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/GetLexiconInput

func (GetLexiconInput) GoString 

func (s GetLexiconInput) GoString() string

GoString returns the string representation

func (*GetLexiconInput) SetName 

func (s *GetLexiconInput) SetName(v string) *GetLexiconInput

SetName sets the Name field's value.

func (GetLexiconInput) String 

func (s GetLexiconInput) String() string

String returns the string representation

func (*GetLexiconInput) Validate 

func (s *GetLexiconInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type GetLexiconOutput 

type GetLexiconOutput struct {

	// Lexicon object that provides name and the string content of the lexicon.
	Lexicon *Lexicon `type:"structure"`

	// Metadata of the lexicon, including phonetic alphabetic used, language code,
	// lexicon ARN, number of lexemes defined in the lexicon, and size of lexicon
	// in bytes.
	LexiconAttributes *LexiconAttributes `type:"structure"`
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/GetLexiconOutput

func (GetLexiconOutput) GoString 

func (s GetLexiconOutput) GoString() string

GoString returns the string representation

func (GetLexiconOutput) SDKResponseMetadata 

func (s GetLexiconOutput) SDKResponseMetadata() aws.Response

SDKResponseMetdata return sthe response metadata for the API.

func (*GetLexiconOutput) SetLexicon 

func (s *GetLexiconOutput) SetLexicon(v *Lexicon) *GetLexiconOutput

SetLexicon sets the Lexicon field's value.

func (*GetLexiconOutput) SetLexiconAttributes 

func (s *GetLexiconOutput) SetLexiconAttributes(v *LexiconAttributes) *GetLexiconOutput

SetLexiconAttributes sets the LexiconAttributes field's value.

func (GetLexiconOutput) String 

func (s GetLexiconOutput) String() string

String returns the string representation

type GetLexiconRequest 

type GetLexiconRequest struct {
	*aws.Request
	Input *GetLexiconInput
}

GetLexiconRequest is a API request type for the GetLexicon API operation.

func (GetLexiconRequest) Send 

func (r GetLexiconRequest) Send() (*GetLexiconOutput, error)

Send marshals and sends the GetLexicon API request.

type LanguageCode 

type LanguageCode string
const (
	LanguageCodeCyGb    LanguageCode = "cy-GB"
	LanguageCodeDaDk    LanguageCode = "da-DK"
	LanguageCodeDeDe    LanguageCode = "de-DE"
	LanguageCodeEnAu    LanguageCode = "en-AU"
	LanguageCodeEnGb    LanguageCode = "en-GB"
	LanguageCodeEnGbWls LanguageCode = "en-GB-WLS"
	LanguageCodeEnIn    LanguageCode = "en-IN"
	LanguageCodeEnUs    LanguageCode = "en-US"
	LanguageCodeEsEs    LanguageCode = "es-ES"
	LanguageCodeEsUs    LanguageCode = "es-US"
	LanguageCodeFrCa    LanguageCode = "fr-CA"
	LanguageCodeFrFr    LanguageCode = "fr-FR"
	LanguageCodeIsIs    LanguageCode = "is-IS"
	LanguageCodeItIt    LanguageCode = "it-IT"
	LanguageCodeKoKr    LanguageCode = "ko-KR"
	LanguageCodeJaJp    LanguageCode = "ja-JP"
	LanguageCodeNbNo    LanguageCode = "nb-NO"
	LanguageCodeNlNl    LanguageCode = "nl-NL"
	LanguageCodePlPl    LanguageCode = "pl-PL"
	LanguageCodePtBr    LanguageCode = "pt-BR"
	LanguageCodePtPt    LanguageCode = "pt-PT"
	LanguageCodeRoRo    LanguageCode = "ro-RO"
	LanguageCodeRuRu    LanguageCode = "ru-RU"
	LanguageCodeSvSe    LanguageCode = "sv-SE"
	LanguageCodeTrTr    LanguageCode = "tr-TR"
)

Enum values for LanguageCode

type Lexicon 

type Lexicon struct {

	// Lexicon content in string format. The content of a lexicon must be in PLS
	// format.
	Content *string `type:"string"`

	// Name of the lexicon.
	Name *string `type:"string"`
	// contains filtered or unexported fields
}

Provides lexicon name and lexicon content in string format. For more information, see Pronunciation Lexicon Specification (PLS) Version 1.0 (https://www.w3.org/TR/pronunciation-lexicon/). Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/Lexicon

func (Lexicon) GoString 

func (s Lexicon) GoString() string

GoString returns the string representation

func (*Lexicon) SetContent 

func (s *Lexicon) SetContent(v string) *Lexicon

SetContent sets the Content field's value.

func (*Lexicon) SetName 

func (s *Lexicon) SetName(v string) *Lexicon

SetName sets the Name field's value.

func (Lexicon) String 

func (s Lexicon) String() string

String returns the string representation

type LexiconAttributes 

type LexiconAttributes struct {

	// Phonetic alphabet used in the lexicon. Valid values are ipa and x-sampa.
	Alphabet *string `type:"string"`

	// 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.
	LanguageCode LanguageCode `type:"string" enum:"true"`

	// Date lexicon was last modified (a timestamp value).
	LastModified *time.Time `type:"timestamp" timestampFormat:"unix"`

	// Number of lexemes in the lexicon.
	LexemesCount *int64 `type:"integer"`

	// Amazon Resource Name (ARN) of the lexicon.
	LexiconArn *string `type:"string"`

	// Total size of the lexicon, in characters.
	Size *int64 `type:"integer"`
	// contains filtered or unexported fields
}

Contains metadata describing the lexicon such as the number of lexemes, language code, and so on. For more information, see Managing Lexicons (http://docs.aws.amazon.com/polly/latest/dg/managing-lexicons.html). Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/LexiconAttributes

func (LexiconAttributes) GoString 

func (s LexiconAttributes) GoString() string

GoString returns the string representation

func (*LexiconAttributes) SetAlphabet 

func (s *LexiconAttributes) SetAlphabet(v string) *LexiconAttributes

SetAlphabet sets the Alphabet field's value.

func (*LexiconAttributes) SetLanguageCode 

func (s *LexiconAttributes) SetLanguageCode(v LanguageCode) *LexiconAttributes

SetLanguageCode sets the LanguageCode field's value.

func (*LexiconAttributes) SetLastModified 

func (s *LexiconAttributes) SetLastModified(v time.Time) *LexiconAttributes

SetLastModified sets the LastModified field's value.

func (*LexiconAttributes) SetLexemesCount 

func (s *LexiconAttributes) SetLexemesCount(v int64) *LexiconAttributes

SetLexemesCount sets the LexemesCount field's value.

func (*LexiconAttributes) SetLexiconArn 

func (s *LexiconAttributes) SetLexiconArn(v string) *LexiconAttributes

SetLexiconArn sets the LexiconArn field's value.

func (*LexiconAttributes) SetSize 

func (s *LexiconAttributes) SetSize(v int64) *LexiconAttributes

SetSize sets the Size field's value.

func (LexiconAttributes) String 

func (s LexiconAttributes) String() string

String returns the string representation

type LexiconDescription 

type LexiconDescription struct {

	// Provides lexicon metadata.
	Attributes *LexiconAttributes `type:"structure"`

	// Name of the lexicon.
	Name *string `type:"string"`
	// contains filtered or unexported fields
}

Describes the content of the lexicon. Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/LexiconDescription

func (LexiconDescription) GoString 

func (s LexiconDescription) GoString() string

GoString returns the string representation

func (*LexiconDescription) SetAttributes 

func (s *LexiconDescription) SetAttributes(v *LexiconAttributes) *LexiconDescription

SetAttributes sets the Attributes field's value.

func (*LexiconDescription) SetName 

func (s *LexiconDescription) SetName(v string) *LexiconDescription

SetName sets the Name field's value.

func (LexiconDescription) String 

func (s LexiconDescription) String() string

String returns the string representation

type ListLexiconsInput 

type ListLexiconsInput struct {

	// An opaque pagination token returned from previous ListLexicons operation.
	// If present, indicates where to continue the list of lexicons.
	NextToken *string `location:"querystring" locationName:"NextToken" type:"string"`
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/ListLexiconsInput

func (ListLexiconsInput) GoString 

func (s ListLexiconsInput) GoString() string

GoString returns the string representation

func (*ListLexiconsInput) SetNextToken 

func (s *ListLexiconsInput) SetNextToken(v string) *ListLexiconsInput

SetNextToken sets the NextToken field's value.

func (ListLexiconsInput) String 

func (s ListLexiconsInput) String() string

String returns the string representation

type ListLexiconsOutput 

type ListLexiconsOutput struct {

	// A list of lexicon names and attributes.
	Lexicons []LexiconDescription `type:"list"`

	// The pagination token to use in the next request to continue the listing of
	// lexicons. NextToken is returned only if the response is truncated.
	NextToken *string `type:"string"`
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/ListLexiconsOutput

func (ListLexiconsOutput) GoString 

func (s ListLexiconsOutput) GoString() string

GoString returns the string representation

func (ListLexiconsOutput) SDKResponseMetadata 

func (s ListLexiconsOutput) SDKResponseMetadata() aws.Response

SDKResponseMetdata return sthe response metadata for the API.

func (*ListLexiconsOutput) SetLexicons 

func (s *ListLexiconsOutput) SetLexicons(v []LexiconDescription) *ListLexiconsOutput

SetLexicons sets the Lexicons field's value.

func (*ListLexiconsOutput) SetNextToken 

func (s *ListLexiconsOutput) SetNextToken(v string) *ListLexiconsOutput

SetNextToken sets the NextToken field's value.

func (ListLexiconsOutput) String 

func (s ListLexiconsOutput) String() string

String returns the string representation

type ListLexiconsRequest 

type ListLexiconsRequest struct {
	*aws.Request
	Input *ListLexiconsInput
}

ListLexiconsRequest is a API request type for the ListLexicons API operation.

func (ListLexiconsRequest) Send 

func (r ListLexiconsRequest) Send() (*ListLexiconsOutput, error)

Send marshals and sends the ListLexicons API request.

type OutputFormat 

type OutputFormat string
const (
	OutputFormatJson      OutputFormat = "json"
	OutputFormatMp3       OutputFormat = "mp3"
	OutputFormatOggVorbis OutputFormat = "ogg_vorbis"
	OutputFormatPcm       OutputFormat = "pcm"
)

Enum values for OutputFormat

type Polly 

type Polly struct {
	*aws.Client
}

Polly provides the API operation methods for making requests to Amazon Polly. See this package's package overview docs for details on the service.

Polly methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func New 

func New(config aws.Config) *Polly

New creates a new instance of the Polly client with a config. If additional configuration is needed for the client instance use the optional aws.Config parameter to add your extra config.

Example: 

// Create a Polly client from just a config.
svc := polly.New(myConfig)

// Create a Polly client with additional configuration
svc := polly.New(myConfig, aws.NewConfig().WithRegion("us-west-2"))

func (*Polly) DeleteLexiconRequest 

func (c *Polly) DeleteLexiconRequest(input *DeleteLexiconInput) DeleteLexiconRequest

DeleteLexiconRequest returns a request value for making API operation for Amazon Polly.

Deletes the specified pronunciation lexicon stored in an AWS Region. A lexicon which has been deleted is not available for speech synthesis, nor is it possible to retrieve it using either the GetLexicon or ListLexicon APIs.

For more information, see Managing Lexicons (http://docs.aws.amazon.com/polly/latest/dg/managing-lexicons.html). 

// Example sending a request using the DeleteLexiconRequest method.
req := client.DeleteLexiconRequest(params)
resp, err := req.Send()
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/DeleteLexicon

Example (Shared00)

To delete a lexicon

Deletes a specified pronunciation lexicon stored in an AWS Region. 

package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/aws/awserr"
	"github.com/aws/aws-sdk-go-v2/aws/external"
	"github.com/aws/aws-sdk-go-v2/service/polly"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := polly.New(cfg)
	input := &polly.DeleteLexiconInput{
		Name: aws.String("example"),
	}

	req := svc.DeleteLexiconRequest(input)
	result, err := req.Send()
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case polly.ErrCodeLexiconNotFoundException:
				fmt.Println(polly.ErrCodeLexiconNotFoundException, aerr.Error())
			case polly.ErrCodeServiceFailureException:
				fmt.Println(polly.ErrCodeServiceFailureException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Polly) DescribeVoicesRequest 

func (c *Polly) DescribeVoicesRequest(input *DescribeVoicesInput) DescribeVoicesRequest

DescribeVoicesRequest returns a request value for making API operation for Amazon Polly.

Returns the list of voices that are available for use when requesting speech synthesis. Each voice speaks a specified language, is either male or female, and is identified by an ID, which is the ASCII version of the voice name.

When synthesizing speech ( SynthesizeSpeech ), you provide the voice ID for the voice you want from the list of voices returned by DescribeVoices.

For example, you want your news reader application to read news in a specific language, but giving a user the option to choose the voice. Using the DescribeVoices operation you can provide the user with a list of available voices to select from.

You can optionally specify a language code to filter the available voices. For example, if you specify en-US, the operation returns a list of all available US English voices.

This operation requires permissions to perform the polly:DescribeVoices action. 

// Example sending a request using the DescribeVoicesRequest method.
req := client.DescribeVoicesRequest(params)
resp, err := req.Send()
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/DescribeVoices

Example (Shared00)

To describe available voices

Returns the list of voices that are available for use when requesting speech synthesis. Displayed languages are those within the specified language code. If no language code is specified, voices for all available languages are displayed. 

package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go-v2/aws/awserr"
	"github.com/aws/aws-sdk-go-v2/aws/external"
	"github.com/aws/aws-sdk-go-v2/service/polly"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := polly.New(cfg)
	input := &polly.DescribeVoicesInput{
		LanguageCode: polly.LanguageCodeEnGb,
	}

	req := svc.DescribeVoicesRequest(input)
	result, err := req.Send()
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case polly.ErrCodeInvalidNextTokenException:
				fmt.Println(polly.ErrCodeInvalidNextTokenException, aerr.Error())
			case polly.ErrCodeServiceFailureException:
				fmt.Println(polly.ErrCodeServiceFailureException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Polly) GetLexiconRequest 

func (c *Polly) GetLexiconRequest(input *GetLexiconInput) GetLexiconRequest

GetLexiconRequest returns a request value for making API operation for Amazon Polly.

Returns the content of the specified pronunciation lexicon stored in an AWS Region. For more information, see Managing Lexicons (http://docs.aws.amazon.com/polly/latest/dg/managing-lexicons.html). 

// Example sending a request using the GetLexiconRequest method.
req := client.GetLexiconRequest(params)
resp, err := req.Send()
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/GetLexicon

Example (Shared00)

To retrieve a lexicon

Returns the content of the specified pronunciation lexicon stored in an AWS Region. 

package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/aws/awserr"
	"github.com/aws/aws-sdk-go-v2/aws/external"
	"github.com/aws/aws-sdk-go-v2/service/polly"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := polly.New(cfg)
	input := &polly.GetLexiconInput{
		Name: aws.String(""),
	}

	req := svc.GetLexiconRequest(input)
	result, err := req.Send()
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case polly.ErrCodeLexiconNotFoundException:
				fmt.Println(polly.ErrCodeLexiconNotFoundException, aerr.Error())
			case polly.ErrCodeServiceFailureException:
				fmt.Println(polly.ErrCodeServiceFailureException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Polly) ListLexiconsRequest 

func (c *Polly) ListLexiconsRequest(input *ListLexiconsInput) ListLexiconsRequest

ListLexiconsRequest returns a request value for making API operation for Amazon Polly.

Returns a list of pronunciation lexicons stored in an AWS Region. For more information, see Managing Lexicons (http://docs.aws.amazon.com/polly/latest/dg/managing-lexicons.html). 

// Example sending a request using the ListLexiconsRequest method.
req := client.ListLexiconsRequest(params)
resp, err := req.Send()
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/ListLexicons

Example (Shared00)

To list all lexicons in a region

Returns a list of pronunciation lexicons stored in an AWS Region. 

package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go-v2/aws/awserr"
	"github.com/aws/aws-sdk-go-v2/aws/external"
	"github.com/aws/aws-sdk-go-v2/service/polly"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := polly.New(cfg)
	input := &polly.ListLexiconsInput{}

	req := svc.ListLexiconsRequest(input)
	result, err := req.Send()
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case polly.ErrCodeInvalidNextTokenException:
				fmt.Println(polly.ErrCodeInvalidNextTokenException, aerr.Error())
			case polly.ErrCodeServiceFailureException:
				fmt.Println(polly.ErrCodeServiceFailureException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Polly) PutLexiconRequest 

func (c *Polly) PutLexiconRequest(input *PutLexiconInput) PutLexiconRequest

PutLexiconRequest returns a request value for making API operation for Amazon Polly.

Stores a pronunciation lexicon in an AWS Region. If a lexicon with the same name already exists in the region, it is overwritten by the new lexicon. Lexicon operations have eventual consistency, therefore, it might take some time before the lexicon is available to the SynthesizeSpeech operation.

For more information, see Managing Lexicons (http://docs.aws.amazon.com/polly/latest/dg/managing-lexicons.html). 

// Example sending a request using the PutLexiconRequest method.
req := client.PutLexiconRequest(params)
resp, err := req.Send()
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/PutLexicon

Example (Shared00)

To save a lexicon

Stores a pronunciation lexicon in an AWS Region. 

package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/aws/awserr"
	"github.com/aws/aws-sdk-go-v2/aws/external"
	"github.com/aws/aws-sdk-go-v2/service/polly"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := polly.New(cfg)
	input := &polly.PutLexiconInput{
		Content: aws.String("file://example.pls"),
		Name:    aws.String("W3C"),
	}

	req := svc.PutLexiconRequest(input)
	result, err := req.Send()
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case polly.ErrCodeInvalidLexiconException:
				fmt.Println(polly.ErrCodeInvalidLexiconException, aerr.Error())
			case polly.ErrCodeUnsupportedPlsAlphabetException:
				fmt.Println(polly.ErrCodeUnsupportedPlsAlphabetException, aerr.Error())
			case polly.ErrCodeUnsupportedPlsLanguageException:
				fmt.Println(polly.ErrCodeUnsupportedPlsLanguageException, aerr.Error())
			case polly.ErrCodeLexiconSizeExceededException:
				fmt.Println(polly.ErrCodeLexiconSizeExceededException, aerr.Error())
			case polly.ErrCodeMaxLexemeLengthExceededException:
				fmt.Println(polly.ErrCodeMaxLexemeLengthExceededException, aerr.Error())
			case polly.ErrCodeMaxLexiconsNumberExceededException:
				fmt.Println(polly.ErrCodeMaxLexiconsNumberExceededException, aerr.Error())
			case polly.ErrCodeServiceFailureException:
				fmt.Println(polly.ErrCodeServiceFailureException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Polly) SynthesizeSpeechRequest 

func (c *Polly) SynthesizeSpeechRequest(input *SynthesizeSpeechInput) SynthesizeSpeechRequest

SynthesizeSpeechRequest returns a request value for making API operation for Amazon Polly.

Synthesizes UTF-8 input, plain text or SSML, to a stream of bytes. SSML input must be valid, well-formed SSML. Some alphabets might not be available with all the voices (for example, Cyrillic might not be read at all by English voices) unless phoneme mapping is used. For more information, see How it Works (http://docs.aws.amazon.com/polly/latest/dg/how-text-to-speech-works.html). 

// Example sending a request using the SynthesizeSpeechRequest method.
req := client.SynthesizeSpeechRequest(params)
resp, err := req.Send()
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/SynthesizeSpeech

Example (Shared00)

To synthesize speech

Synthesizes plain text or SSML into a file of human-like speech. 

package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/aws/awserr"
	"github.com/aws/aws-sdk-go-v2/aws/external"
	"github.com/aws/aws-sdk-go-v2/service/polly"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := polly.New(cfg)
	input := &polly.SynthesizeSpeechInput{
		LexiconNames: []string{
			"example",
		},
		OutputFormat: polly.OutputFormatMp3,
		SampleRate:   aws.String("8000"),
		Text:         aws.String("All Gaul is divided into three parts"),
		TextType:     polly.TextTypeText,
		VoiceId:      polly.VoiceIdJoanna,
	}

	req := svc.SynthesizeSpeechRequest(input)
	result, err := req.Send()
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case polly.ErrCodeTextLengthExceededException:
				fmt.Println(polly.ErrCodeTextLengthExceededException, aerr.Error())
			case polly.ErrCodeInvalidSampleRateException:
				fmt.Println(polly.ErrCodeInvalidSampleRateException, aerr.Error())
			case polly.ErrCodeInvalidSsmlException:
				fmt.Println(polly.ErrCodeInvalidSsmlException, aerr.Error())
			case polly.ErrCodeLexiconNotFoundException:
				fmt.Println(polly.ErrCodeLexiconNotFoundException, aerr.Error())
			case polly.ErrCodeServiceFailureException:
				fmt.Println(polly.ErrCodeServiceFailureException, aerr.Error())
			case polly.ErrCodeMarksNotSupportedForFormatException:
				fmt.Println(polly.ErrCodeMarksNotSupportedForFormatException, aerr.Error())
			case polly.ErrCodeSsmlMarksNotSupportedForTextTypeException:
				fmt.Println(polly.ErrCodeSsmlMarksNotSupportedForTextTypeException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

type PutLexiconInput 

type PutLexiconInput struct {

	// Content of the PLS lexicon as string data.
	//
	// Content is a required field
	Content *string `type:"string" required:"true"`

	// Name of the lexicon. The name must follow the regular express format [0-9A-Za-z]{1,20}.
	// That is, the name is a case-sensitive alphanumeric string up to 20 characters
	// long.
	//
	// Name is a required field
	Name *string `location:"uri" locationName:"LexiconName" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/PutLexiconInput

func (PutLexiconInput) GoString 

func (s PutLexiconInput) GoString() string

GoString returns the string representation

func (*PutLexiconInput) SetContent 

func (s *PutLexiconInput) SetContent(v string) *PutLexiconInput

SetContent sets the Content field's value.

func (*PutLexiconInput) SetName 

func (s *PutLexiconInput) SetName(v string) *PutLexiconInput

SetName sets the Name field's value.

func (PutLexiconInput) String 

func (s PutLexiconInput) String() string

String returns the string representation

func (*PutLexiconInput) Validate 

func (s *PutLexiconInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type PutLexiconOutput 

type PutLexiconOutput struct {
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/PutLexiconOutput

func (PutLexiconOutput) GoString 

func (s PutLexiconOutput) GoString() string

GoString returns the string representation

func (PutLexiconOutput) SDKResponseMetadata 

func (s PutLexiconOutput) SDKResponseMetadata() aws.Response

SDKResponseMetdata return sthe response metadata for the API.

func (PutLexiconOutput) String 

func (s PutLexiconOutput) String() string

String returns the string representation

type PutLexiconRequest 

type PutLexiconRequest struct {
	*aws.Request
	Input *PutLexiconInput
}

PutLexiconRequest is a API request type for the PutLexicon API operation.

func (PutLexiconRequest) Send 

func (r PutLexiconRequest) Send() (*PutLexiconOutput, error)

Send marshals and sends the PutLexicon API request.

type SpeechMarkType 

type SpeechMarkType string
const (
	SpeechMarkTypeSentence SpeechMarkType = "sentence"
	SpeechMarkTypeSsml     SpeechMarkType = "ssml"
	SpeechMarkTypeViseme   SpeechMarkType = "viseme"
	SpeechMarkTypeWord     SpeechMarkType = "word"
)

Enum values for SpeechMarkType

type SynthesizeSpeechInput 

type SynthesizeSpeechInput struct {

	// List of one or more pronunciation lexicon names you want the service to apply
	// during synthesis. Lexicons are applied only if the language of the lexicon
	// is the same as the language of the voice. For information about storing lexicons,
	// see PutLexicon (http://docs.aws.amazon.com/polly/latest/dg/API_PutLexicon.html).
	LexiconNames []string `type:"list"`

	// The format in which the returned output will be encoded. For audio stream,
	// this will be mp3, ogg_vorbis, or pcm. For speech marks, this will be json.
	//
	// OutputFormat is a required field
	OutputFormat OutputFormat `type:"string" required:"true" enum:"true"`

	// The audio frequency specified in Hz.
	//
	// The valid values for mp3 and ogg_vorbis are "8000", "16000", and "22050".
	// The default value is "22050".
	//
	// Valid values for pcm are "8000" and "16000" The default value is "16000".
	SampleRate *string `type:"string"`

	// The type of speech marks returned for the input text.
	SpeechMarkTypes []SpeechMarkType `type:"list"`

	// Input text to synthesize. If you specify ssml as the TextType, follow the
	// SSML format for the input text.
	//
	// Text is a required field
	Text *string `type:"string" required:"true"`

	// Specifies whether the input text is plain text or SSML. The default value
	// is plain text. For more information, see Using SSML (http://docs.aws.amazon.com/polly/latest/dg/ssml.html).
	TextType TextType `type:"string" enum:"true"`

	// Voice ID to use for the synthesis. You can get a list of available voice
	// IDs by calling the DescribeVoices (http://docs.aws.amazon.com/polly/latest/dg/API_DescribeVoices.html)
	// operation.
	//
	// VoiceId is a required field
	VoiceId VoiceId `type:"string" required:"true" enum:"true"`
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/SynthesizeSpeechInput

func (SynthesizeSpeechInput) GoString 

func (s SynthesizeSpeechInput) GoString() string

GoString returns the string representation

func (*SynthesizeSpeechInput) SetLexiconNames 

func (s *SynthesizeSpeechInput) SetLexiconNames(v []string) *SynthesizeSpeechInput

SetLexiconNames sets the LexiconNames field's value.

func (*SynthesizeSpeechInput) SetOutputFormat 

func (s *SynthesizeSpeechInput) SetOutputFormat(v OutputFormat) *SynthesizeSpeechInput

SetOutputFormat sets the OutputFormat field's value.

func (*SynthesizeSpeechInput) SetSampleRate 

func (s *SynthesizeSpeechInput) SetSampleRate(v string) *SynthesizeSpeechInput

SetSampleRate sets the SampleRate field's value.

func (*SynthesizeSpeechInput) SetSpeechMarkTypes 

func (s *SynthesizeSpeechInput) SetSpeechMarkTypes(v []SpeechMarkType) *SynthesizeSpeechInput

SetSpeechMarkTypes sets the SpeechMarkTypes field's value.

func (*SynthesizeSpeechInput) SetText 

func (s *SynthesizeSpeechInput) SetText(v string) *SynthesizeSpeechInput

SetText sets the Text field's value.

func (*SynthesizeSpeechInput) SetTextType 

func (s *SynthesizeSpeechInput) SetTextType(v TextType) *SynthesizeSpeechInput

SetTextType sets the TextType field's value.

func (*SynthesizeSpeechInput) SetVoiceId 

func (s *SynthesizeSpeechInput) SetVoiceId(v VoiceId) *SynthesizeSpeechInput

SetVoiceId sets the VoiceId field's value.

func (SynthesizeSpeechInput) String 

func (s SynthesizeSpeechInput) String() string

String returns the string representation

func (*SynthesizeSpeechInput) Validate 

func (s *SynthesizeSpeechInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type SynthesizeSpeechOutput 

type SynthesizeSpeechOutput struct {

	// Stream containing the synthesized speech.
	AudioStream io.ReadCloser `type:"blob"`

	// Specifies the type audio stream. This should reflect the OutputFormat parameter
	// in your request.
	//
	//    *  If you request mp3 as the OutputFormat, the ContentType returned is
	//    audio/mpeg.
	//
	//    *  If you request ogg_vorbis as the OutputFormat, the ContentType returned
	//    is audio/ogg.
	//
	//    *  If you request pcm as the OutputFormat, the ContentType returned is
	//    audio/pcm in a signed 16-bit, 1 channel (mono), little-endian format.
	//
	//
	//    * If you request json as the OutputFormat, the ContentType returned is
	//    audio/json.
	ContentType *string `location:"header" locationName:"Content-Type" type:"string"`

	// Number of characters synthesized.
	RequestCharacters *int64 `location:"header" locationName:"x-amzn-RequestCharacters" type:"integer"`
	// contains filtered or unexported fields
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/SynthesizeSpeechOutput

func (SynthesizeSpeechOutput) GoString 

func (s SynthesizeSpeechOutput) GoString() string

GoString returns the string representation

func (SynthesizeSpeechOutput) SDKResponseMetadata 

func (s SynthesizeSpeechOutput) SDKResponseMetadata() aws.Response

SDKResponseMetdata return sthe response metadata for the API.

func (*SynthesizeSpeechOutput) SetAudioStream 

func (s *SynthesizeSpeechOutput) SetAudioStream(v io.ReadCloser) *SynthesizeSpeechOutput

SetAudioStream sets the AudioStream field's value.

func (*SynthesizeSpeechOutput) SetContentType 

func (s *SynthesizeSpeechOutput) SetContentType(v string) *SynthesizeSpeechOutput

SetContentType sets the ContentType field's value.

func (*SynthesizeSpeechOutput) SetRequestCharacters 

func (s *SynthesizeSpeechOutput) SetRequestCharacters(v int64) *SynthesizeSpeechOutput

SetRequestCharacters sets the RequestCharacters field's value.

func (SynthesizeSpeechOutput) String 

func (s SynthesizeSpeechOutput) String() string

String returns the string representation

type SynthesizeSpeechRequest 

type SynthesizeSpeechRequest struct {
	*aws.Request
	Input *SynthesizeSpeechInput
}

SynthesizeSpeechRequest is a API request type for the SynthesizeSpeech API operation.

func (SynthesizeSpeechRequest) Send 

func (r SynthesizeSpeechRequest) Send() (*SynthesizeSpeechOutput, error)

Send marshals and sends the SynthesizeSpeech API request.

type TextType 

type TextType string
const (
	TextTypeSsml TextType = "ssml"
	TextTypeText TextType = "text"
)

Enum values for TextType

type Voice 

type Voice struct {

	// Gender of the voice.
	Gender Gender `type:"string" enum:"true"`

	// Amazon Polly assigned voice ID. This is the ID that you specify when calling
	// the SynthesizeSpeech operation.
	Id VoiceId `type:"string" enum:"true"`

	// Language code of the voice.
	LanguageCode LanguageCode `type:"string" enum:"true"`

	// Human readable name of the language in English.
	LanguageName *string `type:"string"`

	// Name of the voice (for example, Salli, Kendra, etc.). This provides a human
	// readable voice name that you might display in your application.
	Name *string `type:"string"`
	// contains filtered or unexported fields
}

Description of the voice. Please also see https://docs.aws.amazon.com/goto/WebAPI/polly-2016-06-10/Voice

func (Voice) GoString 

func (s Voice) GoString() string

GoString returns the string representation

func (*Voice) SetGender 

func (s *Voice) SetGender(v Gender) *Voice

SetGender sets the Gender field's value.

func (*Voice) SetId 

func (s *Voice) SetId(v VoiceId) *Voice

SetId sets the Id field's value.

func (*Voice) SetLanguageCode 

func (s *Voice) SetLanguageCode(v LanguageCode) *Voice

SetLanguageCode sets the LanguageCode field's value.

func (*Voice) SetLanguageName 

func (s *Voice) SetLanguageName(v string) *Voice

SetLanguageName sets the LanguageName field's value.

func (*Voice) SetName 

func (s *Voice) SetName(v string) *Voice

SetName sets the Name field's value.

func (Voice) String 

func (s Voice) String() string

String returns the string representation

type VoiceId 

type VoiceId string
const (
	VoiceIdGeraint   VoiceId = "Geraint"
	VoiceIdGwyneth   VoiceId = "Gwyneth"
	VoiceIdMads      VoiceId = "Mads"
	VoiceIdNaja      VoiceId = "Naja"
	VoiceIdHans      VoiceId = "Hans"
	VoiceIdMarlene   VoiceId = "Marlene"
	VoiceIdNicole    VoiceId = "Nicole"
	VoiceIdRussell   VoiceId = "Russell"
	VoiceIdAmy       VoiceId = "Amy"
	VoiceIdBrian     VoiceId = "Brian"
	VoiceIdEmma      VoiceId = "Emma"
	VoiceIdRaveena   VoiceId = "Raveena"
	VoiceIdIvy       VoiceId = "Ivy"
	VoiceIdJoanna    VoiceId = "Joanna"
	VoiceIdJoey      VoiceId = "Joey"
	VoiceIdJustin    VoiceId = "Justin"
	VoiceIdKendra    VoiceId = "Kendra"
	VoiceIdKimberly  VoiceId = "Kimberly"
	VoiceIdMatthew   VoiceId = "Matthew"
	VoiceIdSalli     VoiceId = "Salli"
	VoiceIdConchita  VoiceId = "Conchita"
	VoiceIdEnrique   VoiceId = "Enrique"
	VoiceIdMiguel    VoiceId = "Miguel"
	VoiceIdPenelope  VoiceId = "Penelope"
	VoiceIdChantal   VoiceId = "Chantal"
	VoiceIdCeline    VoiceId = "Celine"
	VoiceIdMathieu   VoiceId = "Mathieu"
	VoiceIdDora      VoiceId = "Dora"
	VoiceIdKarl      VoiceId = "Karl"
	VoiceIdCarla     VoiceId = "Carla"
	VoiceIdGiorgio   VoiceId = "Giorgio"
	VoiceIdMizuki    VoiceId = "Mizuki"
	VoiceIdLiv       VoiceId = "Liv"
	VoiceIdLotte     VoiceId = "Lotte"
	VoiceIdRuben     VoiceId = "Ruben"
	VoiceIdEwa       VoiceId = "Ewa"
	VoiceIdJacek     VoiceId = "Jacek"
	VoiceIdJan       VoiceId = "Jan"
	VoiceIdMaja      VoiceId = "Maja"
	VoiceIdRicardo   VoiceId = "Ricardo"
	VoiceIdVitoria   VoiceId = "Vitoria"
	VoiceIdCristiano VoiceId = "Cristiano"
	VoiceIdInes      VoiceId = "Ines"
	VoiceIdCarmen    VoiceId = "Carmen"
	VoiceIdMaxim     VoiceId = "Maxim"
	VoiceIdTatyana   VoiceId = "Tatyana"
	VoiceIdAstrid    VoiceId = "Astrid"
	VoiceIdFiliz     VoiceId = "Filiz"
	VoiceIdVicki     VoiceId = "Vicki"
	VoiceIdTakumi    VoiceId = "Takumi"
	VoiceIdSeoyeon   VoiceId = "Seoyeon"
	VoiceIdAditi     VoiceId = "Aditi"
)

Enum values for VoiceId

Source Files

View all Source files

Directories

Path Synopsis
Package pollyiface provides an interface to enable mocking the Amazon Polly service client for testing your code.
 Package pollyiface provides an interface to enable mocking the Amazon Polly service client for testing your code.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.