@aws-sdk/client-polly 3.50.0 → 3.53.0

package/dist-types/index.d.ts

@@ -3,3 +3,4 @@ export * from "./PollyClient";
 export * from "./commands";
 export * from "./models";
 export * from "./pagination";
+export { PollyServiceException } from "./models/PollyServiceException";

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

@@ -0,0 +1,10 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+/**
+ * Base exception class for all service exceptions from Polly service.
+ */
+export declare class PollyServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

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

@@ -1,6 +1,7 @@
 /// <reference types="node" />
-import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
 import { Readable } from "stream";
+import { PollyServiceException as __BaseException } from "./PollyServiceException";
 export interface DeleteLexiconInput {
     /**
      * <p>The name of the lexicon to delete. Must be an existing lexicon in
@@ -29,18 +30,24 @@ export declare namespace DeleteLexiconOutput {
  *          <p>Verify that the lexicon exists, is in the region (see <a>ListLexicons</a>) and that you spelled its name is spelled
  *       correctly. Then try again.</p>
  */
-export interface LexiconNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "LexiconNotFoundException";
-    $fault: "client";
-    message?: string;
+export declare class LexiconNotFoundException extends __BaseException {
+    readonly name: "LexiconNotFoundException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LexiconNotFoundException, __BaseException>);
 }
 /**
  * <p>An unknown condition has caused a service failure.</p>
  */
-export interface ServiceFailureException extends __SmithyException, $MetadataBearer {
-    name: "ServiceFailureException";
-    $fault: "server";
-    message?: string;
+export declare class ServiceFailureException extends __BaseException {
+    readonly name: "ServiceFailureException";
+    readonly $fault: "server";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceFailureException, __BaseException>);
 }
 export declare enum Engine {
     NEURAL = "neural",
@@ -154,20 +161,26 @@ export declare namespace DescribeVoicesOutput {
  * <p>The NextToken is invalid. Verify that it's spelled correctly, and
  *       then try again.</p>
  */
-export interface InvalidNextTokenException extends __SmithyException, $MetadataBearer {
-    name: "InvalidNextTokenException";
-    $fault: "client";
-    message?: string;
+export declare class InvalidNextTokenException extends __BaseException {
+    readonly name: "InvalidNextTokenException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidNextTokenException, __BaseException>);
 }
 /**
  * <p>This engine is not compatible with the voice that you have designated.
  *       Choose a new voice that is compatible with the engine or change the engine
  *       and restart the operation.</p>
  */
-export interface EngineNotSupportedException extends __SmithyException, $MetadataBearer {
-    name: "EngineNotSupportedException";
-    $fault: "client";
-    message?: string;
+export declare class EngineNotSupportedException extends __BaseException {
+    readonly name: "EngineNotSupportedException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<EngineNotSupportedException, __BaseException>);
 }
 export interface GetLexiconInput {
     /**
@@ -407,81 +420,108 @@ export declare namespace GetSpeechSynthesisTaskOutput {
  * <p>The provided Task ID is not valid. Please provide a valid Task ID and
  *       try again.</p>
  */
-export interface InvalidTaskIdException extends __SmithyException, $MetadataBearer {
-    name: "InvalidTaskIdException";
-    $fault: "client";
-    message?: string;
+export declare class InvalidTaskIdException extends __BaseException {
+    readonly name: "InvalidTaskIdException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidTaskIdException, __BaseException>);
 }
 /**
  * <p>The Speech Synthesis task with requested Task ID cannot be
  *       found.</p>
  */
-export interface SynthesisTaskNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "SynthesisTaskNotFoundException";
-    $fault: "client";
-    message?: string;
+export declare class SynthesisTaskNotFoundException extends __BaseException {
+    readonly name: "SynthesisTaskNotFoundException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SynthesisTaskNotFoundException, __BaseException>);
 }
 /**
  * <p>Amazon Polly can't find the specified lexicon. Verify that the lexicon's
  *       name is spelled correctly, and then try again.</p>
  */
-export interface InvalidLexiconException extends __SmithyException, $MetadataBearer {
-    name: "InvalidLexiconException";
-    $fault: "client";
-    message?: string;
+export declare class InvalidLexiconException extends __BaseException {
+    readonly name: "InvalidLexiconException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidLexiconException, __BaseException>);
 }
 /**
  * <p>The provided Amazon S3 bucket name is invalid. Please check your input
  *       with S3 bucket naming requirements and try again.</p>
  */
-export interface InvalidS3BucketException extends __SmithyException, $MetadataBearer {
-    name: "InvalidS3BucketException";
-    $fault: "client";
-    message?: string;
+export declare class InvalidS3BucketException extends __BaseException {
+    readonly name: "InvalidS3BucketException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidS3BucketException, __BaseException>);
 }
 /**
  * <p>The provided Amazon S3 key prefix is invalid. Please provide a valid
  *       S3 object key name.</p>
  */
-export interface InvalidS3KeyException extends __SmithyException, $MetadataBearer {
-    name: "InvalidS3KeyException";
-    $fault: "client";
-    message?: string;
+export declare class InvalidS3KeyException extends __BaseException {
+    readonly name: "InvalidS3KeyException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidS3KeyException, __BaseException>);
 }
 /**
  * <p>The specified sample rate is not valid.</p>
  */
-export interface InvalidSampleRateException extends __SmithyException, $MetadataBearer {
-    name: "InvalidSampleRateException";
-    $fault: "client";
-    message?: string;
+export declare class InvalidSampleRateException extends __BaseException {
+    readonly name: "InvalidSampleRateException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidSampleRateException, __BaseException>);
 }
 /**
  * <p>The provided SNS topic ARN is invalid. Please provide a valid SNS
  *       topic ARN and try again.</p>
  */
-export interface InvalidSnsTopicArnException extends __SmithyException, $MetadataBearer {
-    name: "InvalidSnsTopicArnException";
-    $fault: "client";
-    message?: string;
+export declare class InvalidSnsTopicArnException extends __BaseException {
+    readonly name: "InvalidSnsTopicArnException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidSnsTopicArnException, __BaseException>);
 }
 /**
  * <p>The SSML you provided is invalid. Verify the SSML syntax, spelling
  *       of tags and values, and then try again.</p>
  */
-export interface InvalidSsmlException extends __SmithyException, $MetadataBearer {
-    name: "InvalidSsmlException";
-    $fault: "client";
-    message?: string;
+export declare class InvalidSsmlException extends __BaseException {
+    readonly name: "InvalidSsmlException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidSsmlException, __BaseException>);
 }
 /**
  * <p>The language specified is not currently supported by Amazon Polly in this
  *       capacity.</p>
  */
-export interface LanguageNotSupportedException extends __SmithyException, $MetadataBearer {
-    name: "LanguageNotSupportedException";
-    $fault: "client";
-    message?: string;
+export declare class LanguageNotSupportedException extends __BaseException {
+    readonly name: "LanguageNotSupportedException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LanguageNotSupportedException, __BaseException>);
 }
 /**
  * <p>Describes the content of the lexicon.</p>
@@ -506,10 +546,13 @@ export declare namespace LexiconDescription {
  * <p>The maximum size of the specified lexicon would be exceeded by this
  *       operation.</p>
  */
-export interface LexiconSizeExceededException extends __SmithyException, $MetadataBearer {
-    name: "LexiconSizeExceededException";
-    $fault: "client";
-    message?: string;
+export declare class LexiconSizeExceededException extends __BaseException {
+    readonly name: "LexiconSizeExceededException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LexiconSizeExceededException, __BaseException>);
 }
 export interface ListLexiconsInput {
     /**
@@ -591,28 +634,37 @@ export declare namespace ListSpeechSynthesisTasksOutput {
  *       selected. Speech marks are only available for content in <code>json</code>
  *       format.</p>
  */
-export interface MarksNotSupportedForFormatException extends __SmithyException, $MetadataBearer {
-    name: "MarksNotSupportedForFormatException";
-    $fault: "client";
-    message?: string;
+export declare class MarksNotSupportedForFormatException extends __BaseException {
+    readonly name: "MarksNotSupportedForFormatException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<MarksNotSupportedForFormatException, __BaseException>);
 }
 /**
  * <p>The maximum size of the lexeme would be exceeded by this
  *       operation.</p>
  */
-export interface MaxLexemeLengthExceededException extends __SmithyException, $MetadataBearer {
-    name: "MaxLexemeLengthExceededException";
-    $fault: "client";
-    message?: string;
+export declare class MaxLexemeLengthExceededException extends __BaseException {
+    readonly name: "MaxLexemeLengthExceededException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<MaxLexemeLengthExceededException, __BaseException>);
 }
 /**
  * <p>The maximum number of lexicons would be exceeded by this
  *       operation.</p>
  */
-export interface MaxLexiconsNumberExceededException extends __SmithyException, $MetadataBearer {
-    name: "MaxLexiconsNumberExceededException";
-    $fault: "client";
-    message?: string;
+export declare class MaxLexiconsNumberExceededException extends __BaseException {
+    readonly name: "MaxLexiconsNumberExceededException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<MaxLexiconsNumberExceededException, __BaseException>);
 }
 export interface PutLexiconInput {
     /**
@@ -644,28 +696,37 @@ export declare namespace PutLexiconOutput {
  * <p>The alphabet specified by the lexicon is not a supported alphabet.
  *       Valid values are <code>x-sampa</code> and <code>ipa</code>.</p>
  */
-export interface UnsupportedPlsAlphabetException extends __SmithyException, $MetadataBearer {
-    name: "UnsupportedPlsAlphabetException";
-    $fault: "client";
-    message?: string;
+export declare class UnsupportedPlsAlphabetException extends __BaseException {
+    readonly name: "UnsupportedPlsAlphabetException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UnsupportedPlsAlphabetException, __BaseException>);
 }
 /**
  * <p>The language specified in the lexicon is unsupported. For a list of
  *       supported languages, see <a href="https://docs.aws.amazon.com/polly/latest/dg/API_LexiconAttributes.html">Lexicon Attributes</a>.</p>
  */
-export interface UnsupportedPlsLanguageException extends __SmithyException, $MetadataBearer {
-    name: "UnsupportedPlsLanguageException";
-    $fault: "client";
-    message?: string;
+export declare class UnsupportedPlsLanguageException extends __BaseException {
+    readonly name: "UnsupportedPlsLanguageException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UnsupportedPlsLanguageException, __BaseException>);
 }
 /**
  * <p>SSML speech marks are not supported for plain text-type
  *       input.</p>
  */
-export interface SsmlMarksNotSupportedForTextTypeException extends __SmithyException, $MetadataBearer {
-    name: "SsmlMarksNotSupportedForTextTypeException";
-    $fault: "client";
-    message?: string;
+export declare class SsmlMarksNotSupportedForTextTypeException extends __BaseException {
+    readonly name: "SsmlMarksNotSupportedForTextTypeException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SsmlMarksNotSupportedForTextTypeException, __BaseException>);
 }
 export interface StartSpeechSynthesisTaskInput {
     /**
@@ -767,10 +828,13 @@ export declare namespace StartSpeechSynthesisTaskOutput {
  *       billed characters. SSML tags are not counted as billed
  *       characters.</p>
  */
-export interface TextLengthExceededException extends __SmithyException, $MetadataBearer {
-    name: "TextLengthExceededException";
-    $fault: "client";
-    message?: string;
+export declare class TextLengthExceededException extends __BaseException {
+    readonly name: "TextLengthExceededException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TextLengthExceededException, __BaseException>);
 }
 export interface SynthesizeSpeechInput {
     /**

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

@@ -0,0 +1,50 @@
+import { HttpHandlerOptions as __HttpHandlerOptions } 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";
+import { PollyClient } from "./PollyClient";
+
+export declare class Polly extends PollyClient {
+    
+    deleteLexicon(args: DeleteLexiconCommandInput, options?: __HttpHandlerOptions): Promise<DeleteLexiconCommandOutput>;
+    deleteLexicon(args: DeleteLexiconCommandInput, cb: (err: any, data?: DeleteLexiconCommandOutput) => void): void;
+    deleteLexicon(args: DeleteLexiconCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteLexiconCommandOutput) => void): void;
+    
+    describeVoices(args: DescribeVoicesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeVoicesCommandOutput>;
+    describeVoices(args: DescribeVoicesCommandInput, cb: (err: any, data?: DescribeVoicesCommandOutput) => void): void;
+    describeVoices(args: DescribeVoicesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeVoicesCommandOutput) => void): void;
+    
+    getLexicon(args: GetLexiconCommandInput, options?: __HttpHandlerOptions): Promise<GetLexiconCommandOutput>;
+    getLexicon(args: GetLexiconCommandInput, cb: (err: any, data?: GetLexiconCommandOutput) => void): void;
+    getLexicon(args: GetLexiconCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetLexiconCommandOutput) => void): void;
+    
+    getSpeechSynthesisTask(args: GetSpeechSynthesisTaskCommandInput, options?: __HttpHandlerOptions): Promise<GetSpeechSynthesisTaskCommandOutput>;
+    getSpeechSynthesisTask(args: GetSpeechSynthesisTaskCommandInput, cb: (err: any, data?: GetSpeechSynthesisTaskCommandOutput) => void): void;
+    getSpeechSynthesisTask(args: GetSpeechSynthesisTaskCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetSpeechSynthesisTaskCommandOutput) => void): void;
+    
+    listLexicons(args: ListLexiconsCommandInput, options?: __HttpHandlerOptions): Promise<ListLexiconsCommandOutput>;
+    listLexicons(args: ListLexiconsCommandInput, cb: (err: any, data?: ListLexiconsCommandOutput) => void): void;
+    listLexicons(args: ListLexiconsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListLexiconsCommandOutput) => void): void;
+    
+    listSpeechSynthesisTasks(args: ListSpeechSynthesisTasksCommandInput, options?: __HttpHandlerOptions): Promise<ListSpeechSynthesisTasksCommandOutput>;
+    listSpeechSynthesisTasks(args: ListSpeechSynthesisTasksCommandInput, cb: (err: any, data?: ListSpeechSynthesisTasksCommandOutput) => void): void;
+    listSpeechSynthesisTasks(args: ListSpeechSynthesisTasksCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListSpeechSynthesisTasksCommandOutput) => void): void;
+    
+    putLexicon(args: PutLexiconCommandInput, options?: __HttpHandlerOptions): Promise<PutLexiconCommandOutput>;
+    putLexicon(args: PutLexiconCommandInput, cb: (err: any, data?: PutLexiconCommandOutput) => void): void;
+    putLexicon(args: PutLexiconCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutLexiconCommandOutput) => void): void;
+    
+    startSpeechSynthesisTask(args: StartSpeechSynthesisTaskCommandInput, options?: __HttpHandlerOptions): Promise<StartSpeechSynthesisTaskCommandOutput>;
+    startSpeechSynthesisTask(args: StartSpeechSynthesisTaskCommandInput, cb: (err: any, data?: StartSpeechSynthesisTaskCommandOutput) => void): void;
+    startSpeechSynthesisTask(args: StartSpeechSynthesisTaskCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartSpeechSynthesisTaskCommandOutput) => void): void;
+    
+    synthesizeSpeech(args: SynthesizeSpeechCommandInput, options?: __HttpHandlerOptions): Promise<SynthesizeSpeechCommandOutput>;
+    synthesizeSpeech(args: SynthesizeSpeechCommandInput, cb: (err: any, data?: SynthesizeSpeechCommandOutput) => void): void;
+    synthesizeSpeech(args: SynthesizeSpeechCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SynthesizeSpeechCommandOutput) => void): void;
+}

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

@@ -0,0 +1,82 @@
+import { EndpointsInputConfig, EndpointsResolvedConfig, RegionInputConfig, RegionResolvedConfig } from "@aws-sdk/config-resolver";
+import { HostHeaderInputConfig, HostHeaderResolvedConfig } from "@aws-sdk/middleware-host-header";
+import { RetryInputConfig, RetryResolvedConfig } from "@aws-sdk/middleware-retry";
+import { AwsAuthInputConfig, AwsAuthResolvedConfig } from "@aws-sdk/middleware-signing";
+import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middleware-user-agent";
+import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
+import { Client as __Client, DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
+import { Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, RegionInfoProvider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } 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 type ServiceInputTypes = DeleteLexiconCommandInput | DescribeVoicesCommandInput | GetLexiconCommandInput | GetSpeechSynthesisTaskCommandInput | ListLexiconsCommandInput | ListSpeechSynthesisTasksCommandInput | PutLexiconCommandInput | StartSpeechSynthesisTaskCommandInput | SynthesizeSpeechCommandInput;
+export declare type ServiceOutputTypes = DeleteLexiconCommandOutput | DescribeVoicesCommandOutput | GetLexiconCommandOutput | GetSpeechSynthesisTaskCommandOutput | ListLexiconsCommandOutput | ListSpeechSynthesisTasksCommandOutput | PutLexiconCommandOutput | StartSpeechSynthesisTaskCommandOutput | SynthesizeSpeechCommandOutput;
+export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
+    
+    requestHandler?: __HttpHandler;
+    
+    sha256?: __HashConstructor;
+    
+    urlParser?: __UrlParser;
+    
+    bodyLengthChecker?: (body: any) => number | undefined;
+    
+    streamCollector?: __StreamCollector;
+    
+    base64Decoder?: __Decoder;
+    
+    base64Encoder?: __Encoder;
+    
+    utf8Decoder?: __Decoder;
+    
+    utf8Encoder?: __Encoder;
+    
+    runtime?: string;
+    
+    disableHostPrefix?: boolean;
+    
+    maxAttempts?: number | __Provider<number>;
+    
+    retryMode?: string | __Provider<string>;
+    
+    logger?: __Logger;
+    
+    useDualstackEndpoint?: boolean | __Provider<boolean>;
+    
+    useFipsEndpoint?: boolean | __Provider<boolean>;
+    
+    serviceId?: string;
+    
+    region?: string | __Provider<string>;
+    
+    credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
+    
+    regionInfoProvider?: RegionInfoProvider;
+    
+    defaultUserAgentProvider?: Provider<__UserAgent>;
+    
+    defaultsMode?: DefaultsMode | Provider<DefaultsMode>;
+}
+declare type PollyClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
+
+export interface PollyClientConfig extends PollyClientConfigType {
+}
+declare type PollyClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
+
+export interface PollyClientResolvedConfig extends PollyClientResolvedConfigType {
+}
+
+export declare class PollyClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, PollyClientResolvedConfig> {
+    
+    readonly config: PollyClientResolvedConfig;
+    constructor(configuration: PollyClientConfig);
+    
+    destroy(): void;
+}
+export {};

package/dist-types/ts3.4/commands/DeleteLexiconCommand.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 { DeleteLexiconInput, DeleteLexiconOutput } from "../models/models_0";
+import { PollyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PollyClient";
+export interface DeleteLexiconCommandInput extends DeleteLexiconInput {
+}
+export interface DeleteLexiconCommandOutput extends DeleteLexiconOutput, __MetadataBearer {
+}
+
+export declare class DeleteLexiconCommand extends $Command<DeleteLexiconCommandInput, DeleteLexiconCommandOutput, PollyClientResolvedConfig> {
+    readonly input: DeleteLexiconCommandInput;
+    constructor(input: DeleteLexiconCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PollyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLexiconCommandInput, DeleteLexiconCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeVoicesCommand.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 { DescribeVoicesInput, DescribeVoicesOutput } from "../models/models_0";
+import { PollyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PollyClient";
+export interface DescribeVoicesCommandInput extends DescribeVoicesInput {
+}
+export interface DescribeVoicesCommandOutput extends DescribeVoicesOutput, __MetadataBearer {
+}
+
+export declare class DescribeVoicesCommand extends $Command<DescribeVoicesCommandInput, DescribeVoicesCommandOutput, PollyClientResolvedConfig> {
+    readonly input: DescribeVoicesCommandInput;
+    constructor(input: DescribeVoicesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PollyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVoicesCommandInput, DescribeVoicesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetLexiconCommand.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 { GetLexiconInput, GetLexiconOutput } from "../models/models_0";
+import { PollyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PollyClient";
+export interface GetLexiconCommandInput extends GetLexiconInput {
+}
+export interface GetLexiconCommandOutput extends GetLexiconOutput, __MetadataBearer {
+}
+
+export declare class GetLexiconCommand extends $Command<GetLexiconCommandInput, GetLexiconCommandOutput, PollyClientResolvedConfig> {
+    readonly input: GetLexiconCommandInput;
+    constructor(input: GetLexiconCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PollyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLexiconCommandInput, GetLexiconCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetSpeechSynthesisTaskCommand.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 { GetSpeechSynthesisTaskInput, GetSpeechSynthesisTaskOutput } from "../models/models_0";
+import { PollyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PollyClient";
+export interface GetSpeechSynthesisTaskCommandInput extends GetSpeechSynthesisTaskInput {
+}
+export interface GetSpeechSynthesisTaskCommandOutput extends GetSpeechSynthesisTaskOutput, __MetadataBearer {
+}
+
+export declare class GetSpeechSynthesisTaskCommand extends $Command<GetSpeechSynthesisTaskCommandInput, GetSpeechSynthesisTaskCommandOutput, PollyClientResolvedConfig> {
+    readonly input: GetSpeechSynthesisTaskCommandInput;
+    constructor(input: GetSpeechSynthesisTaskCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PollyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSpeechSynthesisTaskCommandInput, GetSpeechSynthesisTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListLexiconsCommand.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 { ListLexiconsInput, ListLexiconsOutput } from "../models/models_0";
+import { PollyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PollyClient";
+export interface ListLexiconsCommandInput extends ListLexiconsInput {
+}
+export interface ListLexiconsCommandOutput extends ListLexiconsOutput, __MetadataBearer {
+}
+
+export declare class ListLexiconsCommand extends $Command<ListLexiconsCommandInput, ListLexiconsCommandOutput, PollyClientResolvedConfig> {
+    readonly input: ListLexiconsCommandInput;
+    constructor(input: ListLexiconsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PollyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLexiconsCommandInput, ListLexiconsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListSpeechSynthesisTasksCommand.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 { ListSpeechSynthesisTasksInput, ListSpeechSynthesisTasksOutput } from "../models/models_0";
+import { PollyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PollyClient";
+export interface ListSpeechSynthesisTasksCommandInput extends ListSpeechSynthesisTasksInput {
+}
+export interface ListSpeechSynthesisTasksCommandOutput extends ListSpeechSynthesisTasksOutput, __MetadataBearer {
+}
+
+export declare class ListSpeechSynthesisTasksCommand extends $Command<ListSpeechSynthesisTasksCommandInput, ListSpeechSynthesisTasksCommandOutput, PollyClientResolvedConfig> {
+    readonly input: ListSpeechSynthesisTasksCommandInput;
+    constructor(input: ListSpeechSynthesisTasksCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PollyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSpeechSynthesisTasksCommandInput, ListSpeechSynthesisTasksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutLexiconCommand.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 { PutLexiconInput, PutLexiconOutput } from "../models/models_0";
+import { PollyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PollyClient";
+export interface PutLexiconCommandInput extends PutLexiconInput {
+}
+export interface PutLexiconCommandOutput extends PutLexiconOutput, __MetadataBearer {
+}
+
+export declare class PutLexiconCommand extends $Command<PutLexiconCommandInput, PutLexiconCommandOutput, PollyClientResolvedConfig> {
+    readonly input: PutLexiconCommandInput;
+    constructor(input: PutLexiconCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PollyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutLexiconCommandInput, PutLexiconCommandOutput>;
+    private serialize;
+    private deserialize;
+}