@aws-sdk/client-polly 3.1012.0 → 3.1013.0

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

@@ -1,4 +1,6 @@
 import type { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { QuotaCode, ServiceCode, ValidationExceptionReason } from "./enums";
+import { ThrottlingReason, ValidationExceptionField } from "./models_0";
 import { PollyServiceException as __BaseException } from "./PollyServiceException";
 /**
  * <p>Amazon Polly can't find the specified lexicon. This could be caused by a
@@ -250,6 +252,67 @@ export declare class UnsupportedPlsLanguageException extends __BaseException {
      */
     constructor(opts: __ExceptionOptionType<UnsupportedPlsLanguageException, __BaseException>);
 }
+/**
+ * <p>The request would cause a service quota to be exceeded.</p>
+ * @public
+ */
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    /**
+     * <p>The quota code identifying the specific quota.</p>
+     * @public
+     */
+    quotaCode: QuotaCode | undefined;
+    /**
+     * <p>The service code identifying the originating service.</p>
+     * @public
+     */
+    serviceCode: ServiceCode | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+/**
+ * <p>The request was denied because of request throttling.</p>
+ * @public
+ */
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    /**
+     * <p>A list of reasons explaining why the request was throttled.</p>
+     * @public
+     */
+    throttlingReasons?: ThrottlingReason[] | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+/**
+ * <p>The input fails to satisfy the constraints specified by the service.</p>
+ * @public
+ */
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    /**
+     * <p>The reason the request failed validation.</p>
+     * @public
+     */
+    reason: ValidationExceptionReason | undefined;
+    /**
+     * <p>The fields that caused the validation error.</p>
+     * @public
+     */
+    fields?: ValidationExceptionField[] | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
 /**
  * <p>SSML speech marks are not supported for plain text-type
  *       input.</p>

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

@@ -1,5 +1,25 @@
 import { StreamingBlobTypes } from "@smithy/types";
 import { Engine, Gender, LanguageCode, OutputFormat, SpeechMarkType, TaskStatus, TextType, VoiceId } from "./enums";
+import { ServiceFailureException, ServiceQuotaExceededException, ThrottlingException, ValidationException } from "./errors";
+/**
+ * <p>Contains a chunk of synthesized audio data.</p>
+ * @public
+ */
+export interface AudioEvent {
+    /**
+     * <p>A chunk of synthesized audio data encoded in the format specified by the
+     *       <code>OutputFormat</code> parameter.</p>
+     * @public
+     */
+    AudioChunk?: Uint8Array | undefined;
+}
+/**
+ * <p>Indicates the end of the input stream. After sending this event, the input stream
+ *      will be closed and all audio will be returned.</p>
+ * @public
+ */
+export interface CloseStreamEvent {
+}
 /**
  * @public
  */
@@ -120,6 +140,18 @@ export interface DescribeVoicesOutput {
      */
     NextToken?: string | undefined;
 }
+/**
+ * <p>Configuration that controls when synthesized audio data is sent on the output stream.</p>
+ * @public
+ */
+export interface FlushStreamConfiguration {
+    /**
+     * <p>Specifies whether to force the synthesis engine to immediately
+     *       write buffered audio data to the output stream.</p>
+     * @public
+     */
+    Force?: boolean | undefined;
+}
 /**
  * @public
  */
@@ -277,7 +309,7 @@ export interface SynthesisTask {
     LexiconNames?: string[] | undefined;
     /**
      * <p>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
+     *       stream, this will be mp3, ogg_vorbis, ogg_opus, mu-law, a-law, or pcm. For speech marks, this will
      *       be json. </p>
      * @public
      */
@@ -290,6 +322,8 @@ export interface SynthesisTask {
      *       is "24000". The default value for generative voices is "24000".</p>
      *          <p>Valid values for pcm are "8000" and "16000" The default value is
      *       "16000". </p>
+     *          <p>Valid value for ogg_opus is "48000". </p>
+     *          <p>Valid value for mu-law and a-law is "8000". </p>
      * @public
      */
     SampleRate?: string | undefined;
@@ -443,6 +477,284 @@ export interface PutLexiconInput {
  */
 export interface PutLexiconOutput {
 }
+/**
+ * <p>Contains text content to be synthesized into speech.</p>
+ * @public
+ */
+export interface TextEvent {
+    /**
+     * <p>The text content to synthesize. If you specify <code>ssml</code> as the
+     *       <code>TextType</code>, follow the SSML format for the input text.</p>
+     * @public
+     */
+    Text: string | undefined;
+    /**
+     * <p>Specifies whether the input text is plain text or SSML. Default: plain text.</p>
+     * @public
+     */
+    TextType?: TextType | undefined;
+    /**
+     * <p>Configuration for controlling when synthesized audio flushes to the output stream.</p>
+     * @public
+     */
+    FlushStreamConfiguration?: FlushStreamConfiguration | undefined;
+}
+/**
+ * <p>Inbound event stream for sending input and control events to manage bidirectional speech synthesis.</p>
+ * @public
+ */
+export type StartSpeechSynthesisStreamActionStream = StartSpeechSynthesisStreamActionStream.CloseStreamEventMember | StartSpeechSynthesisStreamActionStream.TextEventMember | StartSpeechSynthesisStreamActionStream.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace StartSpeechSynthesisStreamActionStream {
+    /**
+     * <p>A text event containing content to be synthesized.</p>
+     * @public
+     */
+    interface TextEventMember {
+        TextEvent: TextEvent;
+        CloseStreamEvent?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>An event indicating the end of the input stream.</p>
+     * @public
+     */
+    interface CloseStreamEventMember {
+        TextEvent?: never;
+        CloseStreamEvent: CloseStreamEvent;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        TextEvent?: never;
+        CloseStreamEvent?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        TextEvent: (value: TextEvent) => T;
+        CloseStreamEvent: (value: CloseStreamEvent) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * @public
+ */
+export interface StartSpeechSynthesisStreamInput {
+    /**
+     * <p>Specifies the engine for Amazon Polly to use when processing input text for speech synthesis.
+     *       Currently, only the <code>generative</code> engine is supported.
+     *       If you specify a voice that the selected engine doesn't support, Amazon Polly returns an error.</p>
+     * @public
+     */
+    Engine: Engine | undefined;
+    /**
+     * <p>An optional parameter that sets the language code for the speech synthesis request. Specify this parameter only
+     *       when using a bilingual voice. If a bilingual voice is used and no language code is specified, Amazon Polly
+     *       uses the default language of the bilingual voice.</p>
+     * @public
+     */
+    LanguageCode?: LanguageCode | undefined;
+    /**
+     * <p>The names of one or more pronunciation lexicons for the service to apply
+     *       during synthesis. Amazon Polly applies lexicons only when the lexicon language matches the voice language.</p>
+     * @public
+     */
+    LexiconNames?: string[] | undefined;
+    /**
+     * <p>The audio format for the synthesized speech. Currently, Amazon Polly does not support JSON speech marks.</p>
+     * @public
+     */
+    OutputFormat: OutputFormat | undefined;
+    /**
+     * <p>The audio frequency, specified in Hz.</p>
+     * @public
+     */
+    SampleRate?: string | undefined;
+    /**
+     * <p>The voice to use in synthesis. To get a list of available voice IDs, use the <a href="https://docs.aws.amazon.com/polly/latest/API/API_DescribeVoices.html">DescribeVoices</a> operation.</p>
+     * @public
+     */
+    VoiceId: VoiceId | undefined;
+    /**
+     * <p>The input event stream that contains text events and stream control events.</p>
+     * @public
+     */
+    ActionStream?: AsyncIterable<StartSpeechSynthesisStreamActionStream> | undefined;
+}
+/**
+ * <p>Indicates that the synthesis stream is closed and provides summary information.</p>
+ * @public
+ */
+export interface StreamClosedEvent {
+    /**
+     * <p>The total number of characters synthesized during the streaming session.</p>
+     * @public
+     */
+    RequestCharacters?: number | undefined;
+}
+/**
+ * <p>Provides information about a specific throttling reason.</p>
+ * @public
+ */
+export interface ThrottlingReason {
+    /**
+     * <p>The reason code explaining why the request was throttled.</p>
+     * @public
+     */
+    reason?: string | undefined;
+    /**
+     * <p>The resource that caused the throttling.</p>
+     * @public
+     */
+    resource?: string | undefined;
+}
+/**
+ * <p>Information about a field that failed validation.</p>
+ * @public
+ */
+export interface ValidationExceptionField {
+    /**
+     * <p>The name of the field that failed validation.</p>
+     * @public
+     */
+    name: string | undefined;
+    /**
+     * <p>A message describing why the field failed validation.</p>
+     * @public
+     */
+    message: string | undefined;
+}
+/**
+ * <p>Outbound event stream that contains synthesized audio data and stream status events.</p>
+ * @public
+ */
+export type StartSpeechSynthesisStreamEventStream = StartSpeechSynthesisStreamEventStream.AudioEventMember | StartSpeechSynthesisStreamEventStream.ServiceFailureExceptionMember | StartSpeechSynthesisStreamEventStream.ServiceQuotaExceededExceptionMember | StartSpeechSynthesisStreamEventStream.StreamClosedEventMember | StartSpeechSynthesisStreamEventStream.ThrottlingExceptionMember | StartSpeechSynthesisStreamEventStream.ValidationExceptionMember | StartSpeechSynthesisStreamEventStream.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace StartSpeechSynthesisStreamEventStream {
+    /**
+     * <p>An audio event containing synthesized speech.</p>
+     * @public
+     */
+    interface AudioEventMember {
+        AudioEvent: AudioEvent;
+        StreamClosedEvent?: never;
+        ValidationException?: never;
+        ServiceQuotaExceededException?: never;
+        ServiceFailureException?: never;
+        ThrottlingException?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>An event, with summary information, indicating the stream has closed.</p>
+     * @public
+     */
+    interface StreamClosedEventMember {
+        AudioEvent?: never;
+        StreamClosedEvent: StreamClosedEvent;
+        ValidationException?: never;
+        ServiceQuotaExceededException?: never;
+        ServiceFailureException?: never;
+        ThrottlingException?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>An exception indicating the input failed validation.</p>
+     * @public
+     */
+    interface ValidationExceptionMember {
+        AudioEvent?: never;
+        StreamClosedEvent?: never;
+        ValidationException: ValidationException;
+        ServiceQuotaExceededException?: never;
+        ServiceFailureException?: never;
+        ThrottlingException?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>An exception indicating a service quota would be exceeded.</p>
+     * @public
+     */
+    interface ServiceQuotaExceededExceptionMember {
+        AudioEvent?: never;
+        StreamClosedEvent?: never;
+        ValidationException?: never;
+        ServiceQuotaExceededException: ServiceQuotaExceededException;
+        ServiceFailureException?: never;
+        ThrottlingException?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>An unknown condition has caused a service failure.</p>
+     * @public
+     */
+    interface ServiceFailureExceptionMember {
+        AudioEvent?: never;
+        StreamClosedEvent?: never;
+        ValidationException?: never;
+        ServiceQuotaExceededException?: never;
+        ServiceFailureException: ServiceFailureException;
+        ThrottlingException?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>An exception indicating the request was throttled.</p>
+     * @public
+     */
+    interface ThrottlingExceptionMember {
+        AudioEvent?: never;
+        StreamClosedEvent?: never;
+        ValidationException?: never;
+        ServiceQuotaExceededException?: never;
+        ServiceFailureException?: never;
+        ThrottlingException: ThrottlingException;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        AudioEvent?: never;
+        StreamClosedEvent?: never;
+        ValidationException?: never;
+        ServiceQuotaExceededException?: never;
+        ServiceFailureException?: never;
+        ThrottlingException?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        AudioEvent: (value: AudioEvent) => T;
+        StreamClosedEvent: (value: StreamClosedEvent) => T;
+        ValidationException: (value: ValidationException) => T;
+        ServiceQuotaExceededException: (value: ServiceQuotaExceededException) => T;
+        ServiceFailureException: (value: ServiceFailureException) => T;
+        ThrottlingException: (value: ThrottlingException) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * @public
+ */
+export interface StartSpeechSynthesisStreamOutput {
+    /**
+     * <p>The output event stream that contains synthesized audio events and stream status events.</p>
+     * @public
+     */
+    EventStream?: AsyncIterable<StartSpeechSynthesisStreamEventStream> | undefined;
+}
 /**
  * @public
  */
@@ -476,7 +788,7 @@ export interface StartSpeechSynthesisTaskInput {
     LexiconNames?: string[] | undefined;
     /**
      * <p>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
+     *       stream, this will be mp3, ogg_vorbis, ogg_opus, mu-law, a-law, or pcm. For speech marks, this will
      *       be json. </p>
      * @public
      */
@@ -499,6 +811,8 @@ export interface StartSpeechSynthesisTaskInput {
      *       is "24000". The default value for generative voices is "24000".</p>
      *          <p>Valid values for pcm are "8000" and "16000" The default value is
      *       "16000". </p>
+     *          <p>Valid value for ogg_opus is "48000". </p>
+     *          <p>Valid value for mu-law and a-law is "8000". </p>
      * @public
      */
     SampleRate?: string | undefined;
@@ -579,7 +893,7 @@ export interface SynthesizeSpeechInput {
     LexiconNames?: string[] | undefined;
     /**
      * <p> 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
+     *       stream, this will be mp3, ogg_vorbis, ogg_opus, mu-law, a-law or pcm. For speech marks, this will
      *       be json. </p>
      *          <p>When pcm is used, the content returned is audio/pcm in a signed
      *       16-bit, 1 channel (mono), little-endian format. </p>
@@ -593,6 +907,8 @@ export interface SynthesizeSpeechInput {
      *       is "24000". The default value for generative voices is "24000".</p>
      *          <p>Valid values for pcm are "8000" and "16000" The default value is
      *       "16000". </p>
+     *          <p>Valid value for ogg_opus is "48000". </p>
+     *          <p>Valid value for mu-law and a-law is "8000". </p>
      * @public
      */
     SampleRate?: string | undefined;
@@ -646,12 +962,29 @@ export interface SynthesizeSpeechOutput {
      *           audio/ogg. </p>
      *             </li>
      *             <li>
+     *                <p> If you request <code>ogg_opus</code> as the
+     *             <code>OutputFormat</code>, the <code>ContentType</code> returned is
+     *           audio/ogg. </p>
+     *             </li>
+     *             <li>
      *                <p> If you request <code>pcm</code> as the
      *             <code>OutputFormat</code>, the <code>ContentType</code> returned is
      *           audio/pcm in a signed 16-bit, 1 channel (mono), little-endian format.
      *         </p>
      *             </li>
      *             <li>
+     *                <p> If you request <code>mu-law</code> as the
+     *             <code>OutputFormat</code>, the <code>ContentType</code> returned is
+     *           audio/mulaw.
+     *         </p>
+     *             </li>
+     *             <li>
+     *                <p> If you request <code>a-law</code> as the
+     *             <code>OutputFormat</code>, the <code>ContentType</code> returned is
+     *           audio/alaw.
+     *         </p>
+     *             </li>
+     *             <li>
      *                <p>If you request <code>json</code> as the
      *             <code>OutputFormat</code>, the <code>ContentType</code> returned is
      *           application/x-json-stream.</p>

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

@@ -9,6 +9,8 @@ export declare const getRuntimeConfig: (config: PollyClientConfig) => {
     bodyLengthChecker: import("@smithy/types").BodyLengthCalculator;
     credentialDefaultProvider: ((input: any) => import("@smithy/types").AwsCredentialIdentityProvider) | ((_: unknown) => () => Promise<import("@smithy/types").AwsCredentialIdentity>);
     defaultUserAgentProvider: (config?: import("@aws-sdk/util-user-agent-browser").PreviouslyResolved) => Promise<import("@smithy/types").UserAgent>;
+    eventStreamPayloadHandlerProvider: import("@smithy/types").EventStreamPayloadHandlerProvider;
+    eventStreamSerdeProvider: import("@smithy/types").EventStreamSerdeProvider;
     maxAttempts: number | import("@smithy/types").Provider<number>;
     region: string | import("@smithy/types").Provider<any>;
     requestHandler: import("@smithy/protocol-http").HttpHandler<any> | RequestHandler;

package/dist-types/runtimeConfig.d.ts

@@ -1,4 +1,4 @@
-import { NodeHttpHandler as RequestHandler } from "@smithy/node-http-handler";
+import { NodeHttp2Handler as RequestHandler } from "@smithy/node-http-handler";
 import type { PollyClientConfig } from "./PollyClient";
 /**
  * @internal
@@ -10,6 +10,8 @@ export declare const getRuntimeConfig: (config: PollyClientConfig) => {
     bodyLengthChecker: import("@smithy/types").BodyLengthCalculator;
     credentialDefaultProvider: ((input: any) => import("@smithy/types").AwsCredentialIdentityProvider) | ((init?: import("@aws-sdk/credential-provider-node").DefaultProviderInit) => import("@aws-sdk/credential-provider-node/dist-types/runtime/memoize-chain").MemoizedRuntimeConfigAwsCredentialIdentityProvider);
     defaultUserAgentProvider: (config?: import("@aws-sdk/util-user-agent-node").PreviouslyResolved) => Promise<import("@smithy/types").UserAgent>;
+    eventStreamPayloadHandlerProvider: import("@smithy/types").EventStreamPayloadHandlerProvider;
+    eventStreamSerdeProvider: import("@smithy/types").EventStreamSerdeProvider;
     maxAttempts: number | import("@smithy/types").Provider<number>;
     region: string | import("@smithy/types").Provider<string>;
     requestHandler: RequestHandler | import("@smithy/protocol-http").HttpHandler<any>;

package/dist-types/runtimeConfig.native.d.ts

@@ -4,6 +4,7 @@ import type { PollyClientConfig } from "./PollyClient";
  */
 export declare const getRuntimeConfig: (config: PollyClientConfig) => {
     runtime: string;
+    eventStreamPayloadHandlerProvider: import("@smithy/types").EventStreamPayloadHandlerProvider;
     sha256: import("@smithy/types").HashConstructor;
     requestHandler: import("@smithy/types").NodeHttpHandlerOptions | import("@smithy/types").FetchHttpHandlerOptions | Record<string, unknown> | import("@smithy/protocol-http").HttpHandler<any> | import("@smithy/fetch-http-handler").FetchHttpHandler;
     cacheMiddleware?: boolean;
@@ -32,6 +33,7 @@ export declare const getRuntimeConfig: (config: PollyClientConfig) => {
     retryMode: string | import("@smithy/types").Provider<string>;
     logger: import("@smithy/types").Logger;
     extensions: import("./runtimeExtensions").RuntimeExtension[];
+    eventStreamSerdeProvider: import("@smithy/types").EventStreamSerdeProvider;
     defaultsMode: import("@smithy/smithy-client").DefaultsMode | import("@smithy/types").Provider<import("@smithy/smithy-client").DefaultsMode>;
     sdkStreamMixin: import("@smithy/types").SdkStreamMixinInjector;
     customUserAgent?: string | import("@smithy/types").UserAgent;

package/dist-types/schemas/schemas_0.d.ts

@@ -1,5 +1,5 @@
 import { TypeRegistry } from "@smithy/core/schema";
-import type { StaticErrorSchema, StaticOperationSchema, StaticStructureSchema } from "@smithy/types";
+import type { StaticErrorSchema, StaticOperationSchema, StaticStructureSchema, StaticUnionSchema } from "@smithy/types";
 export declare var PollyServiceException$: StaticErrorSchema;
 export declare var EngineNotSupportedException$: StaticErrorSchema;
 export declare var InvalidLexiconException$: StaticErrorSchema;
@@ -17,21 +17,27 @@ export declare var MarksNotSupportedForFormatException$: StaticErrorSchema;
 export declare var MaxLexemeLengthExceededException$: StaticErrorSchema;
 export declare var MaxLexiconsNumberExceededException$: StaticErrorSchema;
 export declare var ServiceFailureException$: StaticErrorSchema;
+export declare var ServiceQuotaExceededException$: StaticErrorSchema;
 export declare var SsmlMarksNotSupportedForTextTypeException$: StaticErrorSchema;
 export declare var SynthesisTaskNotFoundException$: StaticErrorSchema;
 export declare var TextLengthExceededException$: StaticErrorSchema;
+export declare var ThrottlingException$: StaticErrorSchema;
 export declare var UnsupportedPlsAlphabetException$: StaticErrorSchema;
 export declare var UnsupportedPlsLanguageException$: StaticErrorSchema;
+export declare var ValidationException$: StaticErrorSchema;
 /**
  * TypeRegistry instances containing modeled errors.
  * @internal
  *
  */
 export declare const errorTypeRegistries: TypeRegistry[];
+export declare var AudioEvent$: StaticStructureSchema;
+export declare var CloseStreamEvent$: StaticStructureSchema;
 export declare var DeleteLexiconInput$: StaticStructureSchema;
 export declare var DeleteLexiconOutput$: StaticStructureSchema;
 export declare var DescribeVoicesInput$: StaticStructureSchema;
 export declare var DescribeVoicesOutput$: StaticStructureSchema;
+export declare var FlushStreamConfiguration$: StaticStructureSchema;
 export declare var GetLexiconInput$: StaticStructureSchema;
 export declare var GetLexiconOutput$: StaticStructureSchema;
 export declare var GetSpeechSynthesisTaskInput$: StaticStructureSchema;
@@ -45,12 +51,20 @@ export declare var ListSpeechSynthesisTasksInput$: StaticStructureSchema;
 export declare var ListSpeechSynthesisTasksOutput$: StaticStructureSchema;
 export declare var PutLexiconInput$: StaticStructureSchema;
 export declare var PutLexiconOutput$: StaticStructureSchema;
+export declare var StartSpeechSynthesisStreamInput$: StaticStructureSchema;
+export declare var StartSpeechSynthesisStreamOutput$: StaticStructureSchema;
 export declare var StartSpeechSynthesisTaskInput$: StaticStructureSchema;
 export declare var StartSpeechSynthesisTaskOutput$: StaticStructureSchema;
+export declare var StreamClosedEvent$: StaticStructureSchema;
 export declare var SynthesisTask$: StaticStructureSchema;
 export declare var SynthesizeSpeechInput$: StaticStructureSchema;
 export declare var SynthesizeSpeechOutput$: StaticStructureSchema;
+export declare var TextEvent$: StaticStructureSchema;
+export declare var ThrottlingReason$: StaticStructureSchema;
+export declare var ValidationExceptionField$: StaticStructureSchema;
 export declare var Voice$: StaticStructureSchema;
+export declare var StartSpeechSynthesisStreamActionStream$: StaticUnionSchema;
+export declare var StartSpeechSynthesisStreamEventStream$: StaticUnionSchema;
 export declare var DeleteLexicon$: StaticOperationSchema;
 export declare var DescribeVoices$: StaticOperationSchema;
 export declare var GetLexicon$: StaticOperationSchema;
@@ -58,5 +72,6 @@ export declare var GetSpeechSynthesisTask$: StaticOperationSchema;
 export declare var ListLexicons$: StaticOperationSchema;
 export declare var ListSpeechSynthesisTasks$: StaticOperationSchema;
 export declare var PutLexicon$: StaticOperationSchema;
+export declare var StartSpeechSynthesisStream$: StaticOperationSchema;
 export declare var StartSpeechSynthesisTask$: StaticOperationSchema;
 export declare var SynthesizeSpeech$: StaticOperationSchema;

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

@@ -31,6 +31,10 @@ import {
   PutLexiconCommandInput,
   PutLexiconCommandOutput,
 } from "./commands/PutLexiconCommand";
+import {
+  StartSpeechSynthesisStreamCommandInput,
+  StartSpeechSynthesisStreamCommandOutput,
+} from "./commands/StartSpeechSynthesisStreamCommand";
 import {
   StartSpeechSynthesisTaskCommandInput,
   StartSpeechSynthesisTaskCommandOutput,
@@ -135,6 +139,19 @@ export interface Polly {
     options: __HttpHandlerOptions,
     cb: (err: any, data?: PutLexiconCommandOutput) => void
   ): void;
+  startSpeechSynthesisStream(
+    args: StartSpeechSynthesisStreamCommandInput,
+    options?: __HttpHandlerOptions
+  ): Promise<StartSpeechSynthesisStreamCommandOutput>;
+  startSpeechSynthesisStream(
+    args: StartSpeechSynthesisStreamCommandInput,
+    cb: (err: any, data?: StartSpeechSynthesisStreamCommandOutput) => void
+  ): void;
+  startSpeechSynthesisStream(
+    args: StartSpeechSynthesisStreamCommandInput,
+    options: __HttpHandlerOptions,
+    cb: (err: any, data?: StartSpeechSynthesisStreamCommandOutput) => void
+  ): void;
   startSpeechSynthesisTask(
     args: StartSpeechSynthesisTaskCommandInput,
     options?: __HttpHandlerOptions