import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import * as T from "../traits.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type LexiconName = string;
export type ErrorMessage = string;
export type IncludeAdditionalLanguageCodes = boolean;
export type NextToken = string;
export type LanguageName = string;
export type VoiceName = string;
export type LexiconContent = string | redacted.Redacted<string>;
export type Alphabet = string;
export type LastModified = Date;
export type LexiconArn = string;
export type LexemesCount = number;
export type Size = number;
export type TaskId = string;
export type TaskStatusReason = string;
export type OutputUri = string;
export type RequestCharacters = number;
export type SnsTopicArn = string;
export type SampleRate = string;
export type MaxResults = number;
export type Text = string;
export type Force = boolean;
export type AudioChunk = Uint8Array;
export type ValidationExceptionFieldName = string;
export type ValidationExceptionFieldMessage = string;
export type AvailabilityErrorMessage = string;
export type CoralAvailabilityThrottlingReason = string;
export type CoralAvailabilityThrottledResource = string;
export type OutputS3BucketName = string;
export type OutputS3KeyPrefix = string;
export type ContentType = string;
export interface DeleteLexiconInput {
    Name: string;
}
export declare const DeleteLexiconInput: S.Schema<DeleteLexiconInput>;
export interface DeleteLexiconOutput {
}
export declare const DeleteLexiconOutput: S.Schema<DeleteLexiconOutput>;
export type Engine = "standard" | "neural" | "long-form" | "generative" | (string & {});
export declare const Engine: S.String;
export type LanguageCode = "arb" | "cmn-CN" | "cy-GB" | "da-DK" | "de-DE" | "en-AU" | "en-GB" | "en-GB-WLS" | "en-IN" | "en-US" | "es-ES" | "es-MX" | "es-US" | "fr-CA" | "fr-FR" | "is-IS" | "it-IT" | "ja-JP" | "hi-IN" | "ko-KR" | "nb-NO" | "nl-NL" | "pl-PL" | "pt-BR" | "pt-PT" | "ro-RO" | "ru-RU" | "sv-SE" | "tr-TR" | "en-NZ" | "en-ZA" | "ca-ES" | "de-AT" | "yue-CN" | "ar-AE" | "fi-FI" | "en-IE" | "nl-BE" | "fr-BE" | "cs-CZ" | "de-CH" | "en-SG" | (string & {});
export declare const LanguageCode: S.String;
export interface DescribeVoicesInput {
    Engine?: Engine;
    LanguageCode?: LanguageCode;
    IncludeAdditionalLanguageCodes?: boolean;
    NextToken?: string;
}
export declare const DescribeVoicesInput: S.Schema<DescribeVoicesInput>;
export type Gender = "Female" | "Male" | (string & {});
export declare const Gender: S.String;
export type VoiceId = "Aditi" | "Amy" | "Astrid" | "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" | "Aria" | "Ayanda" | "Arlet" | "Hannah" | "Arthur" | "Daniel" | "Liam" | "Pedro" | "Kajal" | "Hiujin" | "Laura" | "Elin" | "Ida" | "Suvi" | "Ola" | "Hala" | "Andres" | "Sergio" | "Remi" | "Adriano" | "Thiago" | "Ruth" | "Stephen" | "Kazuha" | "Tomoko" | "Niamh" | "Sofie" | "Lisa" | "Isabelle" | "Zayd" | "Danielle" | "Gregory" | "Burcu" | "Jitka" | "Sabrina" | "Jasmine" | "Jihye" | "Ambre" | "Beatrice" | "Florian" | "Lennart" | "Lorenzo" | "Tiffany" | (string & {});
export declare const VoiceId: S.String;
export type LanguageCodeList = LanguageCode[];
export declare const LanguageCodeList: S.$Array<S.String>;
export type EngineList = Engine[];
export declare const EngineList: S.$Array<S.String>;
export interface Voice {
    Gender?: Gender;
    Id?: VoiceId;
    LanguageCode?: LanguageCode;
    LanguageName?: string;
    Name?: string;
    AdditionalLanguageCodes?: LanguageCode[];
    SupportedEngines?: Engine[];
}
export declare const Voice: S.Schema<Voice>;
export type VoiceList = Voice[];
export declare const VoiceList: S.$Array<S.Schema<Voice>>;
export interface DescribeVoicesOutput {
    Voices?: Voice[];
    NextToken?: string;
}
export declare const DescribeVoicesOutput: S.Schema<DescribeVoicesOutput>;
export interface GetLexiconInput {
    Name: string;
}
export declare const GetLexiconInput: S.Schema<GetLexiconInput>;
export interface Lexicon {
    Content?: string | redacted.Redacted<string>;
    Name?: string;
}
export declare const Lexicon: S.Schema<Lexicon>;
export interface LexiconAttributes {
    Alphabet?: string;
    LanguageCode?: LanguageCode;
    LastModified?: Date;
    LexiconArn?: string;
    LexemesCount?: number;
    Size?: number;
}
export declare const LexiconAttributes: S.Schema<LexiconAttributes>;
export interface GetLexiconOutput {
    Lexicon?: Lexicon;
    LexiconAttributes?: LexiconAttributes;
}
export declare const GetLexiconOutput: S.Schema<GetLexiconOutput>;
export interface GetSpeechSynthesisTaskInput {
    TaskId: string;
}
export declare const GetSpeechSynthesisTaskInput: S.Schema<GetSpeechSynthesisTaskInput>;
export type TaskStatus = "scheduled" | "inProgress" | "completed" | "failed" | (string & {});
export declare const TaskStatus: S.String;
export type LexiconNameList = string[];
export declare const LexiconNameList: S.$Array<S.String>;
export type OutputFormat = "json" | "mp3" | "ogg_opus" | "ogg_vorbis" | "pcm" | "mulaw" | "alaw" | (string & {});
export declare const OutputFormat: S.String;
export type SpeechMarkType = "sentence" | "ssml" | "viseme" | "word" | (string & {});
export declare const SpeechMarkType: S.String;
export type SpeechMarkTypeList = SpeechMarkType[];
export declare const SpeechMarkTypeList: S.$Array<S.String>;
export type TextType = "ssml" | "text" | (string & {});
export declare const TextType: S.String;
export interface SynthesisTask {
    Engine?: Engine;
    TaskId?: string;
    TaskStatus?: TaskStatus;
    TaskStatusReason?: string;
    OutputUri?: string;
    CreationTime?: Date;
    RequestCharacters?: number;
    SnsTopicArn?: string;
    LexiconNames?: string[];
    OutputFormat?: OutputFormat;
    SampleRate?: string;
    SpeechMarkTypes?: SpeechMarkType[];
    TextType?: TextType;
    VoiceId?: VoiceId;
    LanguageCode?: LanguageCode;
}
export declare const SynthesisTask: S.Schema<SynthesisTask>;
export interface GetSpeechSynthesisTaskOutput {
    SynthesisTask?: SynthesisTask;
}
export declare const GetSpeechSynthesisTaskOutput: S.Schema<GetSpeechSynthesisTaskOutput>;
export interface ListLexiconsInput {
    NextToken?: string;
}
export declare const ListLexiconsInput: S.Schema<ListLexiconsInput>;
export interface LexiconDescription {
    Name?: string;
    Attributes?: LexiconAttributes;
}
export declare const LexiconDescription: S.Schema<LexiconDescription>;
export type LexiconDescriptionList = LexiconDescription[];
export declare const LexiconDescriptionList: S.$Array<S.Schema<LexiconDescription>>;
export interface ListLexiconsOutput {
    Lexicons?: LexiconDescription[];
    NextToken?: string;
}
export declare const ListLexiconsOutput: S.Schema<ListLexiconsOutput>;
export interface ListSpeechSynthesisTasksInput {
    MaxResults?: number;
    NextToken?: string;
    Status?: TaskStatus;
}
export declare const ListSpeechSynthesisTasksInput: S.Schema<ListSpeechSynthesisTasksInput>;
export type SynthesisTasks = SynthesisTask[];
export declare const SynthesisTasks: S.$Array<S.Schema<SynthesisTask>>;
export interface ListSpeechSynthesisTasksOutput {
    NextToken?: string;
    SynthesisTasks?: SynthesisTask[];
}
export declare const ListSpeechSynthesisTasksOutput: S.Schema<ListSpeechSynthesisTasksOutput>;
export interface PutLexiconInput {
    Name: string;
    Content: string | redacted.Redacted<string>;
}
export declare const PutLexiconInput: S.Schema<PutLexiconInput>;
export interface PutLexiconOutput {
}
export declare const PutLexiconOutput: S.Schema<PutLexiconOutput>;
export interface FlushStreamConfiguration {
    Force?: boolean;
}
export declare const FlushStreamConfiguration: S.Schema<FlushStreamConfiguration>;
export interface TextEvent {
    Text: string;
    TextType?: TextType;
    FlushStreamConfiguration?: FlushStreamConfiguration;
}
export declare const TextEvent: S.Schema<TextEvent>;
export interface CloseStreamEvent {
}
export declare const CloseStreamEvent: S.Schema<CloseStreamEvent>;
export type StartSpeechSynthesisStreamActionStream = {
    TextEvent: TextEvent;
    CloseStreamEvent?: never;
} | {
    TextEvent?: never;
    CloseStreamEvent: CloseStreamEvent;
};
export declare const StartSpeechSynthesisStreamActionStream: S.Schema<stream.Stream<StartSpeechSynthesisStreamActionStream, Error, never>>;
export interface StartSpeechSynthesisStreamInput {
    Engine: Engine;
    LanguageCode?: LanguageCode;
    LexiconNames?: string[];
    OutputFormat: OutputFormat;
    SampleRate?: string;
    VoiceId: VoiceId;
    ActionStream?: stream.Stream<StartSpeechSynthesisStreamActionStream, Error, never>;
}
export declare const StartSpeechSynthesisStreamInput: S.Schema<StartSpeechSynthesisStreamInput>;
export interface AudioEvent {
    AudioChunk?: Uint8Array;
}
export declare const AudioEvent: S.Schema<AudioEvent>;
export interface StreamClosedEvent {
    RequestCharacters?: number;
}
export declare const StreamClosedEvent: S.Schema<StreamClosedEvent>;
export type ValidationExceptionReason = "unsupportedOperation" | "fieldValidationFailed" | "other" | "invalidInboundEvent" | (string & {});
export declare const ValidationExceptionReason: S.String;
export interface ValidationExceptionField {
    name: string;
    message: string;
}
export declare const ValidationExceptionField: S.Schema<ValidationExceptionField>;
export type ValidationExceptionFieldList = ValidationExceptionField[];
export declare const ValidationExceptionFieldList: S.$Array<S.Schema<ValidationExceptionField>>;
export type QuotaCode = "input-stream-inbound-event-timeout" | "input-stream-timeout" | (string & {});
export declare const QuotaCode: S.String;
export type ServiceCode = "polly" | (string & {});
export declare const ServiceCode: S.String;
export interface ThrottlingReason {
    reason?: string;
    resource?: string;
}
export declare const ThrottlingReason: S.Schema<ThrottlingReason>;
export type ThrottlingReasonList = ThrottlingReason[];
export declare const ThrottlingReasonList: S.$Array<S.Schema<ThrottlingReason>>;
export type StartSpeechSynthesisStreamEventStream = {
    AudioEvent: AudioEvent;
    StreamClosedEvent?: never;
    ValidationException?: never;
    ServiceQuotaExceededException?: never;
    ServiceFailureException?: never;
    ThrottlingException?: never;
} | {
    AudioEvent?: never;
    StreamClosedEvent: StreamClosedEvent;
    ValidationException?: never;
    ServiceQuotaExceededException?: never;
    ServiceFailureException?: never;
    ThrottlingException?: never;
} | {
    AudioEvent?: never;
    StreamClosedEvent?: never;
    ValidationException: ValidationException;
    ServiceQuotaExceededException?: never;
    ServiceFailureException?: never;
    ThrottlingException?: never;
} | {
    AudioEvent?: never;
    StreamClosedEvent?: never;
    ValidationException?: never;
    ServiceQuotaExceededException: ServiceQuotaExceededException;
    ServiceFailureException?: never;
    ThrottlingException?: never;
} | {
    AudioEvent?: never;
    StreamClosedEvent?: never;
    ValidationException?: never;
    ServiceQuotaExceededException?: never;
    ServiceFailureException: ServiceFailureException;
    ThrottlingException?: never;
} | {
    AudioEvent?: never;
    StreamClosedEvent?: never;
    ValidationException?: never;
    ServiceQuotaExceededException?: never;
    ServiceFailureException?: never;
    ThrottlingException: ThrottlingException;
};
export declare const StartSpeechSynthesisStreamEventStream: S.Schema<stream.Stream<StartSpeechSynthesisStreamEventStream, Error, never>>;
export interface StartSpeechSynthesisStreamOutput {
    EventStream?: stream.Stream<StartSpeechSynthesisStreamEventStream, Error, never>;
}
export declare const StartSpeechSynthesisStreamOutput: S.Schema<StartSpeechSynthesisStreamOutput>;
export interface StartSpeechSynthesisTaskInput {
    Engine?: Engine;
    LanguageCode?: LanguageCode;
    LexiconNames?: string[];
    OutputFormat: OutputFormat;
    OutputS3BucketName: string;
    OutputS3KeyPrefix?: string;
    SampleRate?: string;
    SnsTopicArn?: string;
    SpeechMarkTypes?: SpeechMarkType[];
    Text: string;
    TextType?: TextType;
    VoiceId: VoiceId;
}
export declare const StartSpeechSynthesisTaskInput: S.Schema<StartSpeechSynthesisTaskInput>;
export interface StartSpeechSynthesisTaskOutput {
    SynthesisTask?: SynthesisTask;
}
export declare const StartSpeechSynthesisTaskOutput: S.Schema<StartSpeechSynthesisTaskOutput>;
export interface SynthesizeSpeechInput {
    Engine?: Engine;
    LanguageCode?: LanguageCode;
    LexiconNames?: string[];
    OutputFormat: OutputFormat;
    SampleRate?: string;
    SpeechMarkTypes?: SpeechMarkType[];
    Text: string;
    TextType?: TextType;
    VoiceId: VoiceId;
}
export declare const SynthesizeSpeechInput: S.Schema<SynthesizeSpeechInput>;
export interface SynthesizeSpeechOutput {
    AudioStream?: T.StreamingOutputBody;
    ContentType?: string;
    RequestCharacters?: number;
}
export declare const SynthesizeSpeechOutput: S.Schema<SynthesizeSpeechOutput>;
declare const LexiconNotFoundException_base: S.Class<LexiconNotFoundException, S.TaggedStruct<"LexiconNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class LexiconNotFoundException extends LexiconNotFoundException_base {
}
declare const ServiceFailureException_base: S.Class<ServiceFailureException, S.TaggedStruct<"ServiceFailureException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class ServiceFailureException extends ServiceFailureException_base {
}
declare const InvalidNextTokenException_base: S.Class<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidNextTokenException extends InvalidNextTokenException_base {
}
declare const InvalidTaskIdException_base: S.Class<InvalidTaskIdException, S.TaggedStruct<"InvalidTaskIdException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidTaskIdException extends InvalidTaskIdException_base {
}
declare const SynthesisTaskNotFoundException_base: S.Class<SynthesisTaskNotFoundException, S.TaggedStruct<"SynthesisTaskNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class SynthesisTaskNotFoundException extends SynthesisTaskNotFoundException_base {
}
declare const InvalidLexiconException_base: S.Class<InvalidLexiconException, S.TaggedStruct<"InvalidLexiconException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidLexiconException extends InvalidLexiconException_base {
}
declare const LexiconSizeExceededException_base: S.Class<LexiconSizeExceededException, S.TaggedStruct<"LexiconSizeExceededException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class LexiconSizeExceededException extends LexiconSizeExceededException_base {
}
declare const MaxLexemeLengthExceededException_base: S.Class<MaxLexemeLengthExceededException, S.TaggedStruct<"MaxLexemeLengthExceededException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class MaxLexemeLengthExceededException extends MaxLexemeLengthExceededException_base {
}
declare const MaxLexiconsNumberExceededException_base: S.Class<MaxLexiconsNumberExceededException, S.TaggedStruct<"MaxLexiconsNumberExceededException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class MaxLexiconsNumberExceededException extends MaxLexiconsNumberExceededException_base {
}
declare const UnsupportedPlsAlphabetException_base: S.Class<UnsupportedPlsAlphabetException, S.TaggedStruct<"UnsupportedPlsAlphabetException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class UnsupportedPlsAlphabetException extends UnsupportedPlsAlphabetException_base {
}
declare const UnsupportedPlsLanguageException_base: S.Class<UnsupportedPlsLanguageException, S.TaggedStruct<"UnsupportedPlsLanguageException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class UnsupportedPlsLanguageException extends UnsupportedPlsLanguageException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly message: S.String;
    readonly quotaCode: S.String;
    readonly serviceCode: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly message: S.optional<S.String>;
    readonly throttlingReasons: S.optional<S.$Array<S.Schema<ThrottlingReason>>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.String;
    readonly reason: S.String;
    readonly fields: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const EngineNotSupportedException_base: S.Class<EngineNotSupportedException, S.TaggedStruct<"EngineNotSupportedException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class EngineNotSupportedException extends EngineNotSupportedException_base {
}
declare const InvalidS3BucketException_base: S.Class<InvalidS3BucketException, S.TaggedStruct<"InvalidS3BucketException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidS3BucketException extends InvalidS3BucketException_base {
}
declare const InvalidS3KeyException_base: S.Class<InvalidS3KeyException, S.TaggedStruct<"InvalidS3KeyException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidS3KeyException extends InvalidS3KeyException_base {
}
declare const InvalidSampleRateException_base: S.Class<InvalidSampleRateException, S.TaggedStruct<"InvalidSampleRateException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidSampleRateException extends InvalidSampleRateException_base {
}
declare const InvalidSnsTopicArnException_base: S.Class<InvalidSnsTopicArnException, S.TaggedStruct<"InvalidSnsTopicArnException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidSnsTopicArnException extends InvalidSnsTopicArnException_base {
}
declare const InvalidSsmlException_base: S.Class<InvalidSsmlException, S.TaggedStruct<"InvalidSsmlException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidSsmlException extends InvalidSsmlException_base {
}
declare const LanguageNotSupportedException_base: S.Class<LanguageNotSupportedException, S.TaggedStruct<"LanguageNotSupportedException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class LanguageNotSupportedException extends LanguageNotSupportedException_base {
}
declare const MarksNotSupportedForFormatException_base: S.Class<MarksNotSupportedForFormatException, S.TaggedStruct<"MarksNotSupportedForFormatException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class MarksNotSupportedForFormatException extends MarksNotSupportedForFormatException_base {
}
declare const SsmlMarksNotSupportedForTextTypeException_base: S.Class<SsmlMarksNotSupportedForTextTypeException, S.TaggedStruct<"SsmlMarksNotSupportedForTextTypeException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class SsmlMarksNotSupportedForTextTypeException extends SsmlMarksNotSupportedForTextTypeException_base {
}
declare const TextLengthExceededException_base: S.Class<TextLengthExceededException, S.TaggedStruct<"TextLengthExceededException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class TextLengthExceededException extends TextLengthExceededException_base {
}
export type DeleteLexiconError = LexiconNotFoundException | ServiceFailureException | CommonErrors;
/**
 * Deletes the specified pronunciation lexicon stored in an Amazon Web Services 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.
 */
export declare const deleteLexicon: API.OperationMethod<DeleteLexiconInput, DeleteLexiconOutput, DeleteLexiconError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeVoicesError = InvalidNextTokenException | ServiceFailureException | CommonErrors;
/**
 * 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.
 */
export declare const describeVoices: API.OperationMethod<DescribeVoicesInput, DescribeVoicesOutput, DescribeVoicesError, Credentials | Region | HttpClient.HttpClient>;
export type GetLexiconError = LexiconNotFoundException | ServiceFailureException | CommonErrors;
/**
 * Returns the content of the specified pronunciation lexicon stored
 * in an Amazon Web Services Region. For more information, see Managing Lexicons.
 */
export declare const getLexicon: API.OperationMethod<GetLexiconInput, GetLexiconOutput, GetLexiconError, Credentials | Region | HttpClient.HttpClient>;
export type GetSpeechSynthesisTaskError = InvalidTaskIdException | ServiceFailureException | SynthesisTaskNotFoundException | CommonErrors;
/**
 * Retrieves a specific SpeechSynthesisTask object based on its TaskID.
 * This object contains information about the given speech synthesis task,
 * including the status of the task, and a link to the S3 bucket containing
 * the output of the task.
 */
export declare const getSpeechSynthesisTask: API.OperationMethod<GetSpeechSynthesisTaskInput, GetSpeechSynthesisTaskOutput, GetSpeechSynthesisTaskError, Credentials | Region | HttpClient.HttpClient>;
export type ListLexiconsError = InvalidNextTokenException | ServiceFailureException | CommonErrors;
/**
 * Returns a list of pronunciation lexicons stored in an Amazon Web Services Region. For more information, see Managing Lexicons.
 */
export declare const listLexicons: API.OperationMethod<ListLexiconsInput, ListLexiconsOutput, ListLexiconsError, Credentials | Region | HttpClient.HttpClient>;
export type ListSpeechSynthesisTasksError = InvalidNextTokenException | ServiceFailureException | CommonErrors;
/**
 * Returns a list of SpeechSynthesisTask objects ordered by their
 * creation date. This operation can filter the tasks by their status, for
 * example, allowing users to list only tasks that are completed.
 */
export declare const listSpeechSynthesisTasks: API.OperationMethod<ListSpeechSynthesisTasksInput, ListSpeechSynthesisTasksOutput, ListSpeechSynthesisTasksError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSpeechSynthesisTasksInput) => stream.Stream<ListSpeechSynthesisTasksOutput, ListSpeechSynthesisTasksError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSpeechSynthesisTasksInput) => stream.Stream<unknown, ListSpeechSynthesisTasksError, Credentials | Region | HttpClient.HttpClient>;
};
export type PutLexiconError = InvalidLexiconException | LexiconSizeExceededException | MaxLexemeLengthExceededException | MaxLexiconsNumberExceededException | ServiceFailureException | UnsupportedPlsAlphabetException | UnsupportedPlsLanguageException | CommonErrors;
/**
 * Stores a pronunciation lexicon in an Amazon Web Services 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.
 */
export declare const putLexicon: API.OperationMethod<PutLexiconInput, PutLexiconOutput, PutLexiconError, Credentials | Region | HttpClient.HttpClient>;
export type StartSpeechSynthesisStreamError = ServiceFailureException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Synthesizes UTF-8 input, plain text, or SSML over a bidirectional streaming connection.
 * Specify synthesis parameters in HTTP/2 headers, send text incrementally as events on the input stream,
 * and receive synthesized audio as it becomes available.
 *
 * This operation serves as a bidirectional counterpart to `SynthesizeSpeech`:
 *
 * - SynthesizeSpeech
 */
export declare const startSpeechSynthesisStream: API.OperationMethod<StartSpeechSynthesisStreamInput, StartSpeechSynthesisStreamOutput, StartSpeechSynthesisStreamError, Credentials | Region | HttpClient.HttpClient>;
export type StartSpeechSynthesisTaskError = EngineNotSupportedException | InvalidS3BucketException | InvalidS3KeyException | InvalidSampleRateException | InvalidSnsTopicArnException | InvalidSsmlException | LanguageNotSupportedException | LexiconNotFoundException | MarksNotSupportedForFormatException | ServiceFailureException | SsmlMarksNotSupportedForTextTypeException | TextLengthExceededException | CommonErrors;
/**
 * Allows the creation of an asynchronous synthesis task, by starting a
 * new `SpeechSynthesisTask`. This operation requires all the
 * standard information needed for speech synthesis, plus the name of an
 * Amazon S3 bucket for the service to store the output of the synthesis task
 * and two optional parameters (`OutputS3KeyPrefix` and
 * `SnsTopicArn`). Once the synthesis task is created, this
 * operation will return a `SpeechSynthesisTask` object, which
 * will include an identifier of this task as well as the current status. The
 * `SpeechSynthesisTask` object is available for 72 hours after
 * starting the asynchronous synthesis task.
 */
export declare const startSpeechSynthesisTask: API.OperationMethod<StartSpeechSynthesisTaskInput, StartSpeechSynthesisTaskOutput, StartSpeechSynthesisTaskError, Credentials | Region | HttpClient.HttpClient>;
export type SynthesizeSpeechError = EngineNotSupportedException | InvalidSampleRateException | InvalidSsmlException | LanguageNotSupportedException | LexiconNotFoundException | MarksNotSupportedForFormatException | ServiceFailureException | SsmlMarksNotSupportedForTextTypeException | TextLengthExceededException | CommonErrors;
/**
 * 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.
 */
export declare const synthesizeSpeech: API.OperationMethod<SynthesizeSpeechInput, SynthesizeSpeechOutput, SynthesizeSpeechError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=polly.d.ts.map