@aws-sdk/client-polly 3.50.0 → 3.53.0

package/dist-types/ts3.4/commands/StartSpeechSynthesisTaskCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { StartSpeechSynthesisTaskInput, StartSpeechSynthesisTaskOutput } from "../models/models_0";
+import { PollyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PollyClient";
+export interface StartSpeechSynthesisTaskCommandInput extends StartSpeechSynthesisTaskInput {
+}
+export interface StartSpeechSynthesisTaskCommandOutput extends StartSpeechSynthesisTaskOutput, __MetadataBearer {
+}
+
+export declare class StartSpeechSynthesisTaskCommand extends $Command<StartSpeechSynthesisTaskCommandInput, StartSpeechSynthesisTaskCommandOutput, PollyClientResolvedConfig> {
+    readonly input: StartSpeechSynthesisTaskCommandInput;
+    constructor(input: StartSpeechSynthesisTaskCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PollyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartSpeechSynthesisTaskCommandInput, StartSpeechSynthesisTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SynthesizeSpeechCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SynthesizeSpeechInput, SynthesizeSpeechOutput } from "../models/models_0";
+import { PollyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PollyClient";
+export interface SynthesizeSpeechCommandInput extends SynthesizeSpeechInput {
+}
+export interface SynthesizeSpeechCommandOutput extends SynthesizeSpeechOutput, __MetadataBearer {
+}
+
+export declare class SynthesizeSpeechCommand extends $Command<SynthesizeSpeechCommandInput, SynthesizeSpeechCommandOutput, PollyClientResolvedConfig> {
+    readonly input: SynthesizeSpeechCommandInput;
+    constructor(input: SynthesizeSpeechCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PollyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SynthesizeSpeechCommandInput, SynthesizeSpeechCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./DeleteLexiconCommand";
+export * from "./DescribeVoicesCommand";
+export * from "./GetLexiconCommand";
+export * from "./GetSpeechSynthesisTaskCommand";
+export * from "./ListLexiconsCommand";
+export * from "./ListSpeechSynthesisTasksCommand";
+export * from "./PutLexiconCommand";
+export * from "./StartSpeechSynthesisTaskCommand";
+export * from "./SynthesizeSpeechCommand";

package/dist-types/ts3.4/endpoints.d.ts

@@ -0,0 +1,2 @@
+import { RegionInfoProvider } from "@aws-sdk/types";
+export declare const defaultRegionInfoProvider: RegionInfoProvider;

package/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Polly";
+export * from "./PollyClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export { PollyServiceException } from "./models/PollyServiceException";

package/dist-types/ts3.4/models/PollyServiceException.d.ts

@@ -0,0 +1,6 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+
+export declare class PollyServiceException extends __ServiceException {
+    
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/ts3.4/models/index.d.ts

@@ -0,0 +1 @@
+export * from "./models_0";

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,481 @@
+
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { Readable } from "stream";
+import { PollyServiceException as __BaseException } from "./PollyServiceException";
+export interface DeleteLexiconInput {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteLexiconInput {
+    
+    const filterSensitiveLog: (obj: DeleteLexiconInput) => any;
+}
+export interface DeleteLexiconOutput {
+}
+export declare namespace DeleteLexiconOutput {
+    
+    const filterSensitiveLog: (obj: DeleteLexiconOutput) => any;
+}
+
+export declare class LexiconNotFoundException extends __BaseException {
+    readonly name: "LexiconNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LexiconNotFoundException, __BaseException>);
+}
+
+export declare class ServiceFailureException extends __BaseException {
+    readonly name: "ServiceFailureException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<ServiceFailureException, __BaseException>);
+}
+export declare enum Engine {
+    NEURAL = "neural",
+    STANDARD = "standard"
+}
+export declare type LanguageCode = "arb" | "cmn-CN" | "cy-GB" | "da-DK" | "de-DE" | "en-AU" | "en-GB" | "en-GB-WLS" | "en-IN" | "en-NZ" | "en-US" | "en-ZA" | "es-ES" | "es-MX" | "es-US" | "fr-CA" | "fr-FR" | "hi-IN" | "is-IS" | "it-IT" | "ja-JP" | "ko-KR" | "nb-NO" | "nl-NL" | "pl-PL" | "pt-BR" | "pt-PT" | "ro-RO" | "ru-RU" | "sv-SE" | "tr-TR";
+export interface DescribeVoicesInput {
+    
+    Engine?: Engine | string;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    IncludeAdditionalLanguageCodes?: boolean;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeVoicesInput {
+    
+    const filterSensitiveLog: (obj: DescribeVoicesInput) => any;
+}
+export declare type Gender = "Female" | "Male";
+export declare type VoiceId = "Aditi" | "Amy" | "Aria" | "Astrid" | "Ayanda" | "Bianca" | "Brian" | "Camila" | "Carla" | "Carmen" | "Celine" | "Chantal" | "Conchita" | "Cristiano" | "Dora" | "Emma" | "Enrique" | "Ewa" | "Filiz" | "Gabrielle" | "Geraint" | "Giorgio" | "Gwyneth" | "Hans" | "Ines" | "Ivy" | "Jacek" | "Jan" | "Joanna" | "Joey" | "Justin" | "Karl" | "Kendra" | "Kevin" | "Kimberly" | "Lea" | "Liv" | "Lotte" | "Lucia" | "Lupe" | "Mads" | "Maja" | "Marlene" | "Mathieu" | "Matthew" | "Maxim" | "Mia" | "Miguel" | "Mizuki" | "Naja" | "Nicole" | "Olivia" | "Penelope" | "Raveena" | "Ricardo" | "Ruben" | "Russell" | "Salli" | "Seoyeon" | "Takumi" | "Tatyana" | "Vicki" | "Vitoria" | "Zeina" | "Zhiyu";
+
+export interface Voice {
+    
+    Gender?: Gender | string;
+    
+    Id?: VoiceId | string;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    LanguageName?: string;
+    
+    Name?: string;
+    
+    AdditionalLanguageCodes?: (LanguageCode | string)[];
+    
+    SupportedEngines?: (Engine | string)[];
+}
+export declare namespace Voice {
+    
+    const filterSensitiveLog: (obj: Voice) => any;
+}
+export interface DescribeVoicesOutput {
+    
+    Voices?: Voice[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeVoicesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeVoicesOutput) => any;
+}
+
+export declare class InvalidNextTokenException extends __BaseException {
+    readonly name: "InvalidNextTokenException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidNextTokenException, __BaseException>);
+}
+
+export declare class EngineNotSupportedException extends __BaseException {
+    readonly name: "EngineNotSupportedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EngineNotSupportedException, __BaseException>);
+}
+export interface GetLexiconInput {
+    
+    Name: string | undefined;
+}
+export declare namespace GetLexiconInput {
+    
+    const filterSensitiveLog: (obj: GetLexiconInput) => any;
+}
+
+export interface Lexicon {
+    
+    Content?: string;
+    
+    Name?: string;
+}
+export declare namespace Lexicon {
+    
+    const filterSensitiveLog: (obj: Lexicon) => any;
+}
+
+export interface LexiconAttributes {
+    
+    Alphabet?: string;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    LastModified?: Date;
+    
+    LexiconArn?: string;
+    
+    LexemesCount?: number;
+    
+    Size?: number;
+}
+export declare namespace LexiconAttributes {
+    
+    const filterSensitiveLog: (obj: LexiconAttributes) => any;
+}
+export interface GetLexiconOutput {
+    
+    Lexicon?: Lexicon;
+    
+    LexiconAttributes?: LexiconAttributes;
+}
+export declare namespace GetLexiconOutput {
+    
+    const filterSensitiveLog: (obj: GetLexiconOutput) => any;
+}
+export interface GetSpeechSynthesisTaskInput {
+    
+    TaskId: string | undefined;
+}
+export declare namespace GetSpeechSynthesisTaskInput {
+    
+    const filterSensitiveLog: (obj: GetSpeechSynthesisTaskInput) => any;
+}
+export declare enum OutputFormat {
+    JSON = "json",
+    MP3 = "mp3",
+    OGG_VORBIS = "ogg_vorbis",
+    PCM = "pcm"
+}
+export declare enum SpeechMarkType {
+    SENTENCE = "sentence",
+    SSML = "ssml",
+    VISEME = "viseme",
+    WORD = "word"
+}
+export declare enum TaskStatus {
+    COMPLETED = "completed",
+    FAILED = "failed",
+    IN_PROGRESS = "inProgress",
+    SCHEDULED = "scheduled"
+}
+export declare enum TextType {
+    SSML = "ssml",
+    TEXT = "text"
+}
+
+export interface SynthesisTask {
+    
+    Engine?: Engine | string;
+    
+    TaskId?: string;
+    
+    TaskStatus?: TaskStatus | string;
+    
+    TaskStatusReason?: string;
+    
+    OutputUri?: string;
+    
+    CreationTime?: Date;
+    
+    RequestCharacters?: number;
+    
+    SnsTopicArn?: string;
+    
+    LexiconNames?: string[];
+    
+    OutputFormat?: OutputFormat | string;
+    
+    SampleRate?: string;
+    
+    SpeechMarkTypes?: (SpeechMarkType | string)[];
+    
+    TextType?: TextType | string;
+    
+    VoiceId?: VoiceId | string;
+    
+    LanguageCode?: LanguageCode | string;
+}
+export declare namespace SynthesisTask {
+    
+    const filterSensitiveLog: (obj: SynthesisTask) => any;
+}
+export interface GetSpeechSynthesisTaskOutput {
+    
+    SynthesisTask?: SynthesisTask;
+}
+export declare namespace GetSpeechSynthesisTaskOutput {
+    
+    const filterSensitiveLog: (obj: GetSpeechSynthesisTaskOutput) => any;
+}
+
+export declare class InvalidTaskIdException extends __BaseException {
+    readonly name: "InvalidTaskIdException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidTaskIdException, __BaseException>);
+}
+
+export declare class SynthesisTaskNotFoundException extends __BaseException {
+    readonly name: "SynthesisTaskNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SynthesisTaskNotFoundException, __BaseException>);
+}
+
+export declare class InvalidLexiconException extends __BaseException {
+    readonly name: "InvalidLexiconException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidLexiconException, __BaseException>);
+}
+
+export declare class InvalidS3BucketException extends __BaseException {
+    readonly name: "InvalidS3BucketException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidS3BucketException, __BaseException>);
+}
+
+export declare class InvalidS3KeyException extends __BaseException {
+    readonly name: "InvalidS3KeyException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidS3KeyException, __BaseException>);
+}
+
+export declare class InvalidSampleRateException extends __BaseException {
+    readonly name: "InvalidSampleRateException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSampleRateException, __BaseException>);
+}
+
+export declare class InvalidSnsTopicArnException extends __BaseException {
+    readonly name: "InvalidSnsTopicArnException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSnsTopicArnException, __BaseException>);
+}
+
+export declare class InvalidSsmlException extends __BaseException {
+    readonly name: "InvalidSsmlException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSsmlException, __BaseException>);
+}
+
+export declare class LanguageNotSupportedException extends __BaseException {
+    readonly name: "LanguageNotSupportedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LanguageNotSupportedException, __BaseException>);
+}
+
+export interface LexiconDescription {
+    
+    Name?: string;
+    
+    Attributes?: LexiconAttributes;
+}
+export declare namespace LexiconDescription {
+    
+    const filterSensitiveLog: (obj: LexiconDescription) => any;
+}
+
+export declare class LexiconSizeExceededException extends __BaseException {
+    readonly name: "LexiconSizeExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LexiconSizeExceededException, __BaseException>);
+}
+export interface ListLexiconsInput {
+    
+    NextToken?: string;
+}
+export declare namespace ListLexiconsInput {
+    
+    const filterSensitiveLog: (obj: ListLexiconsInput) => any;
+}
+export interface ListLexiconsOutput {
+    
+    Lexicons?: LexiconDescription[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLexiconsOutput {
+    
+    const filterSensitiveLog: (obj: ListLexiconsOutput) => any;
+}
+export interface ListSpeechSynthesisTasksInput {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    Status?: TaskStatus | string;
+}
+export declare namespace ListSpeechSynthesisTasksInput {
+    
+    const filterSensitiveLog: (obj: ListSpeechSynthesisTasksInput) => any;
+}
+export interface ListSpeechSynthesisTasksOutput {
+    
+    NextToken?: string;
+    
+    SynthesisTasks?: SynthesisTask[];
+}
+export declare namespace ListSpeechSynthesisTasksOutput {
+    
+    const filterSensitiveLog: (obj: ListSpeechSynthesisTasksOutput) => any;
+}
+
+export declare class MarksNotSupportedForFormatException extends __BaseException {
+    readonly name: "MarksNotSupportedForFormatException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MarksNotSupportedForFormatException, __BaseException>);
+}
+
+export declare class MaxLexemeLengthExceededException extends __BaseException {
+    readonly name: "MaxLexemeLengthExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaxLexemeLengthExceededException, __BaseException>);
+}
+
+export declare class MaxLexiconsNumberExceededException extends __BaseException {
+    readonly name: "MaxLexiconsNumberExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaxLexiconsNumberExceededException, __BaseException>);
+}
+export interface PutLexiconInput {
+    
+    Name: string | undefined;
+    
+    Content: string | undefined;
+}
+export declare namespace PutLexiconInput {
+    
+    const filterSensitiveLog: (obj: PutLexiconInput) => any;
+}
+export interface PutLexiconOutput {
+}
+export declare namespace PutLexiconOutput {
+    
+    const filterSensitiveLog: (obj: PutLexiconOutput) => any;
+}
+
+export declare class UnsupportedPlsAlphabetException extends __BaseException {
+    readonly name: "UnsupportedPlsAlphabetException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedPlsAlphabetException, __BaseException>);
+}
+
+export declare class UnsupportedPlsLanguageException extends __BaseException {
+    readonly name: "UnsupportedPlsLanguageException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedPlsLanguageException, __BaseException>);
+}
+
+export declare class SsmlMarksNotSupportedForTextTypeException extends __BaseException {
+    readonly name: "SsmlMarksNotSupportedForTextTypeException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SsmlMarksNotSupportedForTextTypeException, __BaseException>);
+}
+export interface StartSpeechSynthesisTaskInput {
+    
+    Engine?: Engine | string;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    LexiconNames?: string[];
+    
+    OutputFormat: OutputFormat | string | undefined;
+    
+    OutputS3BucketName: string | undefined;
+    
+    OutputS3KeyPrefix?: string;
+    
+    SampleRate?: string;
+    
+    SnsTopicArn?: string;
+    
+    SpeechMarkTypes?: (SpeechMarkType | string)[];
+    
+    Text: string | undefined;
+    
+    TextType?: TextType | string;
+    
+    VoiceId: VoiceId | string | undefined;
+}
+export declare namespace StartSpeechSynthesisTaskInput {
+    
+    const filterSensitiveLog: (obj: StartSpeechSynthesisTaskInput) => any;
+}
+export interface StartSpeechSynthesisTaskOutput {
+    
+    SynthesisTask?: SynthesisTask;
+}
+export declare namespace StartSpeechSynthesisTaskOutput {
+    
+    const filterSensitiveLog: (obj: StartSpeechSynthesisTaskOutput) => any;
+}
+
+export declare class TextLengthExceededException extends __BaseException {
+    readonly name: "TextLengthExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TextLengthExceededException, __BaseException>);
+}
+export interface SynthesizeSpeechInput {
+    
+    Engine?: Engine | string;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    LexiconNames?: string[];
+    
+    OutputFormat: OutputFormat | string | undefined;
+    
+    SampleRate?: string;
+    
+    SpeechMarkTypes?: (SpeechMarkType | string)[];
+    
+    Text: string | undefined;
+    
+    TextType?: TextType | string;
+    
+    VoiceId: VoiceId | string | undefined;
+}
+export declare namespace SynthesizeSpeechInput {
+    
+    const filterSensitiveLog: (obj: SynthesizeSpeechInput) => any;
+}
+export interface SynthesizeSpeechOutput {
+    
+    AudioStream?: Readable | ReadableStream | Blob;
+    
+    ContentType?: string;
+    
+    RequestCharacters?: number;
+}
+export declare namespace SynthesizeSpeechOutput {
+    
+    const filterSensitiveLog: (obj: SynthesizeSpeechOutput) => any;
+}

package/dist-types/ts3.4/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { Polly } from "../Polly";
+import { PollyClient } from "../PollyClient";
+export interface PollyPaginationConfiguration extends PaginationConfiguration {
+    client: Polly | PollyClient;
+}

package/dist-types/ts3.4/pagination/ListSpeechSynthesisTasksPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListSpeechSynthesisTasksCommandInput, ListSpeechSynthesisTasksCommandOutput } from "../commands/ListSpeechSynthesisTasksCommand";
+import { PollyPaginationConfiguration } from "./Interfaces";
+export declare function paginateListSpeechSynthesisTasks(config: PollyPaginationConfiguration, input: ListSpeechSynthesisTasksCommandInput, ...additionalArguments: any): Paginator<ListSpeechSynthesisTasksCommandOutput>;

package/dist-types/ts3.4/pagination/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Interfaces";
+export * from "./ListSpeechSynthesisTasksPaginator";

package/dist-types/ts3.4/protocols/Aws_restJson1.d.ts

@@ -0,0 +1,29 @@
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
+import { DeleteLexiconCommandInput, DeleteLexiconCommandOutput } from "../commands/DeleteLexiconCommand";
+import { DescribeVoicesCommandInput, DescribeVoicesCommandOutput } from "../commands/DescribeVoicesCommand";
+import { GetLexiconCommandInput, GetLexiconCommandOutput } from "../commands/GetLexiconCommand";
+import { GetSpeechSynthesisTaskCommandInput, GetSpeechSynthesisTaskCommandOutput } from "../commands/GetSpeechSynthesisTaskCommand";
+import { ListLexiconsCommandInput, ListLexiconsCommandOutput } from "../commands/ListLexiconsCommand";
+import { ListSpeechSynthesisTasksCommandInput, ListSpeechSynthesisTasksCommandOutput } from "../commands/ListSpeechSynthesisTasksCommand";
+import { PutLexiconCommandInput, PutLexiconCommandOutput } from "../commands/PutLexiconCommand";
+import { StartSpeechSynthesisTaskCommandInput, StartSpeechSynthesisTaskCommandOutput } from "../commands/StartSpeechSynthesisTaskCommand";
+import { SynthesizeSpeechCommandInput, SynthesizeSpeechCommandOutput } from "../commands/SynthesizeSpeechCommand";
+export declare const serializeAws_restJson1DeleteLexiconCommand: (input: DeleteLexiconCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1DescribeVoicesCommand: (input: DescribeVoicesCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1GetLexiconCommand: (input: GetLexiconCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1GetSpeechSynthesisTaskCommand: (input: GetSpeechSynthesisTaskCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1ListLexiconsCommand: (input: ListLexiconsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1ListSpeechSynthesisTasksCommand: (input: ListSpeechSynthesisTasksCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1PutLexiconCommand: (input: PutLexiconCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1StartSpeechSynthesisTaskCommand: (input: StartSpeechSynthesisTaskCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1SynthesizeSpeechCommand: (input: SynthesizeSpeechCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const deserializeAws_restJson1DeleteLexiconCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DeleteLexiconCommandOutput>;
+export declare const deserializeAws_restJson1DescribeVoicesCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DescribeVoicesCommandOutput>;
+export declare const deserializeAws_restJson1GetLexiconCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetLexiconCommandOutput>;
+export declare const deserializeAws_restJson1GetSpeechSynthesisTaskCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetSpeechSynthesisTaskCommandOutput>;
+export declare const deserializeAws_restJson1ListLexiconsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListLexiconsCommandOutput>;
+export declare const deserializeAws_restJson1ListSpeechSynthesisTasksCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListSpeechSynthesisTasksCommandOutput>;
+export declare const deserializeAws_restJson1PutLexiconCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<PutLexiconCommandOutput>;
+export declare const deserializeAws_restJson1StartSpeechSynthesisTaskCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<StartSpeechSynthesisTaskCommandOutput>;
+export declare const deserializeAws_restJson1SynthesizeSpeechCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SynthesizeSpeechCommandOutput>;

package/dist-types/ts3.4/runtimeConfig.browser.d.ts

@@ -0,0 +1,38 @@
+import { FetchHttpHandler as RequestHandler } from "@aws-sdk/fetch-http-handler";
+import { PollyClientConfig } from "./PollyClient";
+
+export declare const getRuntimeConfig: (config: PollyClientConfig) => {
+    runtime: string;
+    defaultsMode: import("@aws-sdk/types").Provider<import("@aws-sdk/smithy-client").ResolvedDefaultsMode>;
+    base64Decoder: import("@aws-sdk/types").Decoder;
+    base64Encoder: import("@aws-sdk/types").Encoder;
+    bodyLengthChecker: (body: any) => number | undefined;
+    credentialDefaultProvider: (input: any) => import("@aws-sdk/types").Provider<import("@aws-sdk/types").Credentials>;
+    defaultUserAgentProvider: import("@aws-sdk/types").Provider<import("@aws-sdk/types").UserAgent>;
+    maxAttempts: number | import("@aws-sdk/types").Provider<number>;
+    region: string | import("@aws-sdk/types").Provider<any>;
+    requestHandler: (import("@aws-sdk/types").RequestHandler<any, any, import("@aws-sdk/types").HttpHandlerOptions> & import("@aws-sdk/protocol-http").HttpHandler) | RequestHandler;
+    retryMode: string | import("@aws-sdk/types").Provider<string>;
+    sha256: import("@aws-sdk/types").HashConstructor;
+    streamCollector: import("@aws-sdk/types").StreamCollector;
+    useDualstackEndpoint: boolean | import("@aws-sdk/types").Provider<boolean>;
+    useFipsEndpoint: boolean | import("@aws-sdk/types").Provider<boolean>;
+    utf8Decoder: import("@aws-sdk/types").Decoder;
+    utf8Encoder: import("@aws-sdk/types").Encoder;
+    apiVersion: string;
+    urlParser: import("@aws-sdk/types").UrlParser;
+    disableHostPrefix: boolean;
+    logger: import("@aws-sdk/types").Logger;
+    serviceId: string;
+    regionInfoProvider: import("@aws-sdk/types").RegionInfoProvider;
+    endpoint?: string | import("@aws-sdk/types").Endpoint | import("@aws-sdk/types").Provider<import("@aws-sdk/types").Endpoint> | undefined;
+    tls?: boolean | undefined;
+    retryStrategy?: import("@aws-sdk/types").RetryStrategy | undefined;
+    credentials?: import("@aws-sdk/types").Credentials | import("@aws-sdk/types").Provider<import("@aws-sdk/types").Credentials> | undefined;
+    signer?: import("@aws-sdk/types").RequestSigner | import("@aws-sdk/types").Provider<import("@aws-sdk/types").RequestSigner> | undefined;
+    signingEscapePath?: boolean | undefined;
+    systemClockOffset?: number | undefined;
+    signingRegion?: string | undefined;
+    signerConstructor?: (new (options: import("@aws-sdk/signature-v4").SignatureV4Init & import("@aws-sdk/signature-v4").SignatureV4CryptoInit) => import("@aws-sdk/types").RequestSigner) | undefined;
+    customUserAgent?: string | import("@aws-sdk/types").UserAgent | undefined;
+};