import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type BotName = string;
export type Description = string;
export type IntentName = string;
export type Version = string;
export type ContentString = string;
export type GroupNumber = number;
export type PromptMaxAttempts = number;
export type ResponseCard = string;
export type SessionTTL = number;
export type SlotName = string;
export type CustomOrBuiltinSlotTypeName = string;
export type Priority = number;
export type Utterance = string;
export type SlotDefaultValueString = string;
export type LambdaARN = string;
export type MessageVersion = string;
export type BuiltinIntentSignature = string;
export type KendraIndexArn = string;
export type QueryFilterString = string;
export type RoleArn = string;
export type InputContextName = string;
export type OutputContextName = string;
export type ContextTimeToLiveInSeconds = number;
export type ContextTurnsToLive = number;
export type SlotTypeName = string;
export type Value = string;
export type RegexPattern = string;
export type Name = string;
export type AliasName = string;
export type BotChannelName = string;
export type NumericalVersion = string;
export type UserId = string;
export type ConfidenceThreshold = number;
export type KmsKeyArn = string;
export type ResourceArn = string;
export type ResourcePrefix = string;
export type IamRoleArn = string;
export type NextToken = string;
export type MaxResults = number;
export type AliasNameOrListAll = string;
export type BuiltinSlotTypeSignature = string;
export type MigrationId = string;
export type V2BotId = string;
export type MigrationAlertMessage = string;
export type MigrationAlertDetail = string;
export type MigrationAlertReferenceURL = string;
export type UtteranceString = string;
export type Count = number;
export type AmazonResourceName = string;
export type TagKey = string;
export type TagValue = string;
export type V2BotName = string;
export interface CreateBotVersionRequest {
    name: string;
    checksum?: string;
}
export declare const CreateBotVersionRequest: S.Schema<CreateBotVersionRequest>;
export interface Intent {
    intentName: string;
    intentVersion: string;
}
export declare const Intent: S.Schema<Intent>;
export type IntentList = Intent[];
export declare const IntentList: S.$Array<S.Schema<Intent>>;
export type ContentType = "PlainText" | "SSML" | "CustomPayload" | (string & {});
export declare const ContentType: S.String;
export interface Message {
    contentType: ContentType;
    content: string;
    groupNumber?: number;
}
export declare const Message: S.Schema<Message>;
export type MessageList = Message[];
export declare const MessageList: S.$Array<S.Schema<Message>>;
export interface Prompt {
    messages: Message[];
    maxAttempts: number;
    responseCard?: string;
}
export declare const Prompt: S.Schema<Prompt>;
export interface Statement {
    messages: Message[];
    responseCard?: string;
}
export declare const Statement: S.Schema<Statement>;
export type Status = "BUILDING" | "READY" | "READY_BASIC_TESTING" | "FAILED" | "NOT_BUILT" | (string & {});
export declare const Status: S.String;
export type Locale = "de-DE" | "en-AU" | "en-GB" | "en-IN" | "en-US" | "es-419" | "es-ES" | "es-US" | "fr-FR" | "fr-CA" | "it-IT" | "ja-JP" | "ko-KR" | (string & {});
export declare const Locale: S.String;
export interface CreateBotVersionResponse {
    name?: string;
    description?: string;
    intents?: Intent[];
    clarificationPrompt?: Prompt;
    abortStatement?: Statement;
    status?: Status;
    failureReason?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    idleSessionTTLInSeconds?: number;
    voiceId?: string;
    checksum?: string;
    version?: string;
    locale?: Locale;
    childDirected?: boolean;
    enableModelImprovements?: boolean;
    detectSentiment?: boolean;
}
export declare const CreateBotVersionResponse: S.Schema<CreateBotVersionResponse>;
export interface CreateIntentVersionRequest {
    name: string;
    checksum?: string;
}
export declare const CreateIntentVersionRequest: S.Schema<CreateIntentVersionRequest>;
export type SlotConstraint = "Required" | "Optional" | (string & {});
export declare const SlotConstraint: S.String;
export type SlotUtteranceList = string[];
export declare const SlotUtteranceList: S.$Array<S.String>;
export type ObfuscationSetting = "NONE" | "DEFAULT_OBFUSCATION" | (string & {});
export declare const ObfuscationSetting: S.String;
export interface SlotDefaultValue {
    defaultValue: string;
}
export declare const SlotDefaultValue: S.Schema<SlotDefaultValue>;
export type SlotDefaultValueList = SlotDefaultValue[];
export declare const SlotDefaultValueList: S.$Array<S.Schema<SlotDefaultValue>>;
export interface SlotDefaultValueSpec {
    defaultValueList: SlotDefaultValue[];
}
export declare const SlotDefaultValueSpec: S.Schema<SlotDefaultValueSpec>;
export interface Slot {
    name: string;
    description?: string;
    slotConstraint: SlotConstraint;
    slotType?: string;
    slotTypeVersion?: string;
    valueElicitationPrompt?: Prompt;
    priority?: number;
    sampleUtterances?: string[];
    responseCard?: string;
    obfuscationSetting?: ObfuscationSetting;
    defaultValueSpec?: SlotDefaultValueSpec;
}
export declare const Slot: S.Schema<Slot>;
export type SlotList = Slot[];
export declare const SlotList: S.$Array<S.Schema<Slot>>;
export type IntentUtteranceList = string[];
export declare const IntentUtteranceList: S.$Array<S.String>;
export interface FollowUpPrompt {
    prompt: Prompt;
    rejectionStatement: Statement;
}
export declare const FollowUpPrompt: S.Schema<FollowUpPrompt>;
export interface CodeHook {
    uri: string;
    messageVersion: string;
}
export declare const CodeHook: S.Schema<CodeHook>;
export type FulfillmentActivityType = "ReturnIntent" | "CodeHook" | (string & {});
export declare const FulfillmentActivityType: S.String;
export interface FulfillmentActivity {
    type: FulfillmentActivityType;
    codeHook?: CodeHook;
}
export declare const FulfillmentActivity: S.Schema<FulfillmentActivity>;
export interface KendraConfiguration {
    kendraIndex: string;
    queryFilterString?: string;
    role: string;
}
export declare const KendraConfiguration: S.Schema<KendraConfiguration>;
export interface InputContext {
    name: string;
}
export declare const InputContext: S.Schema<InputContext>;
export type InputContextList = InputContext[];
export declare const InputContextList: S.$Array<S.Schema<InputContext>>;
export interface OutputContext {
    name: string;
    timeToLiveInSeconds: number;
    turnsToLive: number;
}
export declare const OutputContext: S.Schema<OutputContext>;
export type OutputContextList = OutputContext[];
export declare const OutputContextList: S.$Array<S.Schema<OutputContext>>;
export interface CreateIntentVersionResponse {
    name?: string;
    description?: string;
    slots?: Slot[];
    sampleUtterances?: string[];
    confirmationPrompt?: Prompt;
    rejectionStatement?: Statement;
    followUpPrompt?: FollowUpPrompt;
    conclusionStatement?: Statement;
    dialogCodeHook?: CodeHook;
    fulfillmentActivity?: FulfillmentActivity;
    parentIntentSignature?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    version?: string;
    checksum?: string;
    kendraConfiguration?: KendraConfiguration;
    inputContexts?: InputContext[];
    outputContexts?: OutputContext[];
}
export declare const CreateIntentVersionResponse: S.Schema<CreateIntentVersionResponse>;
export interface CreateSlotTypeVersionRequest {
    name: string;
    checksum?: string;
}
export declare const CreateSlotTypeVersionRequest: S.Schema<CreateSlotTypeVersionRequest>;
export type SynonymList = string[];
export declare const SynonymList: S.$Array<S.String>;
export interface EnumerationValue {
    value: string;
    synonyms?: string[];
}
export declare const EnumerationValue: S.Schema<EnumerationValue>;
export type EnumerationValues = EnumerationValue[];
export declare const EnumerationValues: S.$Array<S.Schema<EnumerationValue>>;
export type SlotValueSelectionStrategy = "ORIGINAL_VALUE" | "TOP_RESOLUTION" | (string & {});
export declare const SlotValueSelectionStrategy: S.String;
export interface SlotTypeRegexConfiguration {
    pattern: string;
}
export declare const SlotTypeRegexConfiguration: S.Schema<SlotTypeRegexConfiguration>;
export interface SlotTypeConfiguration {
    regexConfiguration?: SlotTypeRegexConfiguration;
}
export declare const SlotTypeConfiguration: S.Schema<SlotTypeConfiguration>;
export type SlotTypeConfigurations = SlotTypeConfiguration[];
export declare const SlotTypeConfigurations: S.$Array<S.Schema<SlotTypeConfiguration>>;
export interface CreateSlotTypeVersionResponse {
    name?: string;
    description?: string;
    enumerationValues?: EnumerationValue[];
    lastUpdatedDate?: Date;
    createdDate?: Date;
    version?: string;
    checksum?: string;
    valueSelectionStrategy?: SlotValueSelectionStrategy;
    parentSlotTypeSignature?: string;
    slotTypeConfigurations?: SlotTypeConfiguration[];
}
export declare const CreateSlotTypeVersionResponse: S.Schema<CreateSlotTypeVersionResponse>;
export interface DeleteBotRequest {
    name: string;
}
export declare const DeleteBotRequest: S.Schema<DeleteBotRequest>;
export interface DeleteBotResponse {
}
export declare const DeleteBotResponse: S.Schema<DeleteBotResponse>;
export type ReferenceType = "Intent" | "Bot" | "BotAlias" | "BotChannel" | (string & {});
export declare const ReferenceType: S.String;
export interface ResourceReference {
    name?: string;
    version?: string;
}
export declare const ResourceReference: S.Schema<ResourceReference>;
export interface DeleteBotAliasRequest {
    name: string;
    botName: string;
}
export declare const DeleteBotAliasRequest: S.Schema<DeleteBotAliasRequest>;
export interface DeleteBotAliasResponse {
}
export declare const DeleteBotAliasResponse: S.Schema<DeleteBotAliasResponse>;
export interface DeleteBotChannelAssociationRequest {
    name: string;
    botName: string;
    botAlias: string;
}
export declare const DeleteBotChannelAssociationRequest: S.Schema<DeleteBotChannelAssociationRequest>;
export interface DeleteBotChannelAssociationResponse {
}
export declare const DeleteBotChannelAssociationResponse: S.Schema<DeleteBotChannelAssociationResponse>;
export interface DeleteBotVersionRequest {
    name: string;
    version: string;
}
export declare const DeleteBotVersionRequest: S.Schema<DeleteBotVersionRequest>;
export interface DeleteBotVersionResponse {
}
export declare const DeleteBotVersionResponse: S.Schema<DeleteBotVersionResponse>;
export interface DeleteIntentRequest {
    name: string;
}
export declare const DeleteIntentRequest: S.Schema<DeleteIntentRequest>;
export interface DeleteIntentResponse {
}
export declare const DeleteIntentResponse: S.Schema<DeleteIntentResponse>;
export interface DeleteIntentVersionRequest {
    name: string;
    version: string;
}
export declare const DeleteIntentVersionRequest: S.Schema<DeleteIntentVersionRequest>;
export interface DeleteIntentVersionResponse {
}
export declare const DeleteIntentVersionResponse: S.Schema<DeleteIntentVersionResponse>;
export interface DeleteSlotTypeRequest {
    name: string;
}
export declare const DeleteSlotTypeRequest: S.Schema<DeleteSlotTypeRequest>;
export interface DeleteSlotTypeResponse {
}
export declare const DeleteSlotTypeResponse: S.Schema<DeleteSlotTypeResponse>;
export interface DeleteSlotTypeVersionRequest {
    name: string;
    version: string;
}
export declare const DeleteSlotTypeVersionRequest: S.Schema<DeleteSlotTypeVersionRequest>;
export interface DeleteSlotTypeVersionResponse {
}
export declare const DeleteSlotTypeVersionResponse: S.Schema<DeleteSlotTypeVersionResponse>;
export interface DeleteUtterancesRequest {
    botName: string;
    userId: string;
}
export declare const DeleteUtterancesRequest: S.Schema<DeleteUtterancesRequest>;
export interface DeleteUtterancesResponse {
}
export declare const DeleteUtterancesResponse: S.Schema<DeleteUtterancesResponse>;
export interface GetBotRequest {
    name: string;
    versionOrAlias: string;
}
export declare const GetBotRequest: S.Schema<GetBotRequest>;
export interface GetBotResponse {
    name?: string;
    description?: string;
    intents?: Intent[];
    enableModelImprovements?: boolean;
    nluIntentConfidenceThreshold?: number;
    clarificationPrompt?: Prompt;
    abortStatement?: Statement;
    status?: Status;
    failureReason?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    idleSessionTTLInSeconds?: number;
    voiceId?: string;
    checksum?: string;
    version?: string;
    locale?: Locale;
    childDirected?: boolean;
    detectSentiment?: boolean;
}
export declare const GetBotResponse: S.Schema<GetBotResponse>;
export interface GetBotAliasRequest {
    name: string;
    botName: string;
}
export declare const GetBotAliasRequest: S.Schema<GetBotAliasRequest>;
export type LogType = "AUDIO" | "TEXT" | (string & {});
export declare const LogType: S.String;
export type Destination = "CLOUDWATCH_LOGS" | "S3" | (string & {});
export declare const Destination: S.String;
export interface LogSettingsResponse {
    logType?: LogType;
    destination?: Destination;
    kmsKeyArn?: string;
    resourceArn?: string;
    resourcePrefix?: string;
}
export declare const LogSettingsResponse: S.Schema<LogSettingsResponse>;
export type LogSettingsResponseList = LogSettingsResponse[];
export declare const LogSettingsResponseList: S.$Array<S.Schema<LogSettingsResponse>>;
export interface ConversationLogsResponse {
    logSettings?: LogSettingsResponse[];
    iamRoleArn?: string;
}
export declare const ConversationLogsResponse: S.Schema<ConversationLogsResponse>;
export interface GetBotAliasResponse {
    name?: string;
    description?: string;
    botVersion?: string;
    botName?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    checksum?: string;
    conversationLogs?: ConversationLogsResponse;
}
export declare const GetBotAliasResponse: S.Schema<GetBotAliasResponse>;
export interface GetBotAliasesRequest {
    botName: string;
    nextToken?: string;
    maxResults?: number;
    nameContains?: string;
}
export declare const GetBotAliasesRequest: S.Schema<GetBotAliasesRequest>;
export interface BotAliasMetadata {
    name?: string;
    description?: string;
    botVersion?: string;
    botName?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    checksum?: string;
    conversationLogs?: ConversationLogsResponse;
}
export declare const BotAliasMetadata: S.Schema<BotAliasMetadata>;
export type BotAliasMetadataList = BotAliasMetadata[];
export declare const BotAliasMetadataList: S.$Array<S.Schema<BotAliasMetadata>>;
export interface GetBotAliasesResponse {
    BotAliases?: BotAliasMetadata[];
    nextToken?: string;
}
export declare const GetBotAliasesResponse: S.Schema<GetBotAliasesResponse>;
export interface GetBotChannelAssociationRequest {
    name: string;
    botName: string;
    botAlias: string;
}
export declare const GetBotChannelAssociationRequest: S.Schema<GetBotChannelAssociationRequest>;
export type ChannelType = "Facebook" | "Slack" | "Twilio-Sms" | "Kik" | (string & {});
export declare const ChannelType: S.String;
export type ChannelConfigurationMap = {
    [key: string]: string | undefined;
};
export declare const ChannelConfigurationMap: S.$Record<S.String, S.optional<S.String>>;
export type ChannelStatus = "IN_PROGRESS" | "CREATED" | "FAILED" | (string & {});
export declare const ChannelStatus: S.String;
export interface GetBotChannelAssociationResponse {
    name?: string;
    description?: string;
    botAlias?: string;
    botName?: string;
    createdDate?: Date;
    type?: ChannelType;
    botConfiguration?: {
        [key: string]: string | undefined;
    };
    status?: ChannelStatus;
    failureReason?: string;
}
export declare const GetBotChannelAssociationResponse: S.Schema<GetBotChannelAssociationResponse>;
export interface GetBotChannelAssociationsRequest {
    botName: string;
    botAlias: string;
    nextToken?: string;
    maxResults?: number;
    nameContains?: string;
}
export declare const GetBotChannelAssociationsRequest: S.Schema<GetBotChannelAssociationsRequest>;
export interface BotChannelAssociation {
    name?: string;
    description?: string;
    botAlias?: string;
    botName?: string;
    createdDate?: Date;
    type?: ChannelType;
    botConfiguration?: {
        [key: string]: string | undefined;
    };
    status?: ChannelStatus;
    failureReason?: string;
}
export declare const BotChannelAssociation: S.Schema<BotChannelAssociation>;
export type BotChannelAssociationList = BotChannelAssociation[];
export declare const BotChannelAssociationList: S.$Array<S.Schema<BotChannelAssociation>>;
export interface GetBotChannelAssociationsResponse {
    botChannelAssociations?: BotChannelAssociation[];
    nextToken?: string;
}
export declare const GetBotChannelAssociationsResponse: S.Schema<GetBotChannelAssociationsResponse>;
export interface GetBotsRequest {
    nextToken?: string;
    maxResults?: number;
    nameContains?: string;
}
export declare const GetBotsRequest: S.Schema<GetBotsRequest>;
export interface BotMetadata {
    name?: string;
    description?: string;
    status?: Status;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    version?: string;
}
export declare const BotMetadata: S.Schema<BotMetadata>;
export type BotMetadataList = BotMetadata[];
export declare const BotMetadataList: S.$Array<S.Schema<BotMetadata>>;
export interface GetBotsResponse {
    bots?: BotMetadata[];
    nextToken?: string;
}
export declare const GetBotsResponse: S.Schema<GetBotsResponse>;
export interface GetBotVersionsRequest {
    name: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const GetBotVersionsRequest: S.Schema<GetBotVersionsRequest>;
export interface GetBotVersionsResponse {
    bots?: BotMetadata[];
    nextToken?: string;
}
export declare const GetBotVersionsResponse: S.Schema<GetBotVersionsResponse>;
export interface GetBuiltinIntentRequest {
    signature: string;
}
export declare const GetBuiltinIntentRequest: S.Schema<GetBuiltinIntentRequest>;
export type LocaleList = Locale[];
export declare const LocaleList: S.$Array<S.String>;
export interface BuiltinIntentSlot {
    name?: string;
}
export declare const BuiltinIntentSlot: S.Schema<BuiltinIntentSlot>;
export type BuiltinIntentSlotList = BuiltinIntentSlot[];
export declare const BuiltinIntentSlotList: S.$Array<S.Schema<BuiltinIntentSlot>>;
export interface GetBuiltinIntentResponse {
    signature?: string;
    supportedLocales?: Locale[];
    slots?: BuiltinIntentSlot[];
}
export declare const GetBuiltinIntentResponse: S.Schema<GetBuiltinIntentResponse>;
export interface GetBuiltinIntentsRequest {
    locale?: Locale;
    signatureContains?: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const GetBuiltinIntentsRequest: S.Schema<GetBuiltinIntentsRequest>;
export interface BuiltinIntentMetadata {
    signature?: string;
    supportedLocales?: Locale[];
}
export declare const BuiltinIntentMetadata: S.Schema<BuiltinIntentMetadata>;
export type BuiltinIntentMetadataList = BuiltinIntentMetadata[];
export declare const BuiltinIntentMetadataList: S.$Array<S.Schema<BuiltinIntentMetadata>>;
export interface GetBuiltinIntentsResponse {
    intents?: BuiltinIntentMetadata[];
    nextToken?: string;
}
export declare const GetBuiltinIntentsResponse: S.Schema<GetBuiltinIntentsResponse>;
export interface GetBuiltinSlotTypesRequest {
    locale?: Locale;
    signatureContains?: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const GetBuiltinSlotTypesRequest: S.Schema<GetBuiltinSlotTypesRequest>;
export interface BuiltinSlotTypeMetadata {
    signature?: string;
    supportedLocales?: Locale[];
}
export declare const BuiltinSlotTypeMetadata: S.Schema<BuiltinSlotTypeMetadata>;
export type BuiltinSlotTypeMetadataList = BuiltinSlotTypeMetadata[];
export declare const BuiltinSlotTypeMetadataList: S.$Array<S.Schema<BuiltinSlotTypeMetadata>>;
export interface GetBuiltinSlotTypesResponse {
    slotTypes?: BuiltinSlotTypeMetadata[];
    nextToken?: string;
}
export declare const GetBuiltinSlotTypesResponse: S.Schema<GetBuiltinSlotTypesResponse>;
export type ResourceType = "BOT" | "INTENT" | "SLOT_TYPE" | (string & {});
export declare const ResourceType: S.String;
export type ExportType = "ALEXA_SKILLS_KIT" | "LEX" | (string & {});
export declare const ExportType: S.String;
export interface GetExportRequest {
    name: string;
    version: string;
    resourceType: ResourceType;
    exportType: ExportType;
}
export declare const GetExportRequest: S.Schema<GetExportRequest>;
export type ExportStatus = "IN_PROGRESS" | "READY" | "FAILED" | (string & {});
export declare const ExportStatus: S.String;
export interface GetExportResponse {
    name?: string;
    version?: string;
    resourceType?: ResourceType;
    exportType?: ExportType;
    exportStatus?: ExportStatus;
    failureReason?: string;
    url?: string;
}
export declare const GetExportResponse: S.Schema<GetExportResponse>;
export interface GetImportRequest {
    importId: string;
}
export declare const GetImportRequest: S.Schema<GetImportRequest>;
export type MergeStrategy = "OVERWRITE_LATEST" | "FAIL_ON_CONFLICT" | (string & {});
export declare const MergeStrategy: S.String;
export type ImportStatus = "IN_PROGRESS" | "COMPLETE" | "FAILED" | (string & {});
export declare const ImportStatus: S.String;
export type StringList = string[];
export declare const StringList: S.$Array<S.String>;
export interface GetImportResponse {
    name?: string;
    resourceType?: ResourceType;
    mergeStrategy?: MergeStrategy;
    importId?: string;
    importStatus?: ImportStatus;
    failureReason?: string[];
    createdDate?: Date;
}
export declare const GetImportResponse: S.Schema<GetImportResponse>;
export interface GetIntentRequest {
    name: string;
    version: string;
}
export declare const GetIntentRequest: S.Schema<GetIntentRequest>;
export interface GetIntentResponse {
    name?: string;
    description?: string;
    slots?: Slot[];
    sampleUtterances?: string[];
    confirmationPrompt?: Prompt;
    rejectionStatement?: Statement;
    followUpPrompt?: FollowUpPrompt;
    conclusionStatement?: Statement;
    dialogCodeHook?: CodeHook;
    fulfillmentActivity?: FulfillmentActivity;
    parentIntentSignature?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    version?: string;
    checksum?: string;
    kendraConfiguration?: KendraConfiguration;
    inputContexts?: InputContext[];
    outputContexts?: OutputContext[];
}
export declare const GetIntentResponse: S.Schema<GetIntentResponse>;
export interface GetIntentsRequest {
    nextToken?: string;
    maxResults?: number;
    nameContains?: string;
}
export declare const GetIntentsRequest: S.Schema<GetIntentsRequest>;
export interface IntentMetadata {
    name?: string;
    description?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    version?: string;
}
export declare const IntentMetadata: S.Schema<IntentMetadata>;
export type IntentMetadataList = IntentMetadata[];
export declare const IntentMetadataList: S.$Array<S.Schema<IntentMetadata>>;
export interface GetIntentsResponse {
    intents?: IntentMetadata[];
    nextToken?: string;
}
export declare const GetIntentsResponse: S.Schema<GetIntentsResponse>;
export interface GetIntentVersionsRequest {
    name: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const GetIntentVersionsRequest: S.Schema<GetIntentVersionsRequest>;
export interface GetIntentVersionsResponse {
    intents?: IntentMetadata[];
    nextToken?: string;
}
export declare const GetIntentVersionsResponse: S.Schema<GetIntentVersionsResponse>;
export interface GetMigrationRequest {
    migrationId: string;
}
export declare const GetMigrationRequest: S.Schema<GetMigrationRequest>;
export type MigrationStatus = "IN_PROGRESS" | "COMPLETED" | "FAILED" | (string & {});
export declare const MigrationStatus: S.String;
export type MigrationStrategy = "CREATE_NEW" | "UPDATE_EXISTING" | (string & {});
export declare const MigrationStrategy: S.String;
export type MigrationAlertType = "ERROR" | "WARN" | (string & {});
export declare const MigrationAlertType: S.String;
export type MigrationAlertDetails = string[];
export declare const MigrationAlertDetails: S.$Array<S.String>;
export type MigrationAlertReferenceURLs = string[];
export declare const MigrationAlertReferenceURLs: S.$Array<S.String>;
export interface MigrationAlert {
    type?: MigrationAlertType;
    message?: string;
    details?: string[];
    referenceURLs?: string[];
}
export declare const MigrationAlert: S.Schema<MigrationAlert>;
export type MigrationAlerts = MigrationAlert[];
export declare const MigrationAlerts: S.$Array<S.Schema<MigrationAlert>>;
export interface GetMigrationResponse {
    migrationId?: string;
    v1BotName?: string;
    v1BotVersion?: string;
    v1BotLocale?: Locale;
    v2BotId?: string;
    v2BotRole?: string;
    migrationStatus?: MigrationStatus;
    migrationStrategy?: MigrationStrategy;
    migrationTimestamp?: Date;
    alerts?: MigrationAlert[];
}
export declare const GetMigrationResponse: S.Schema<GetMigrationResponse>;
export type MigrationSortAttribute = "V1_BOT_NAME" | "MIGRATION_DATE_TIME" | (string & {});
export declare const MigrationSortAttribute: S.String;
export type SortOrder = "ASCENDING" | "DESCENDING" | (string & {});
export declare const SortOrder: S.String;
export interface GetMigrationsRequest {
    sortByAttribute?: MigrationSortAttribute;
    sortByOrder?: SortOrder;
    v1BotNameContains?: string;
    migrationStatusEquals?: MigrationStatus;
    maxResults?: number;
    nextToken?: string;
}
export declare const GetMigrationsRequest: S.Schema<GetMigrationsRequest>;
export interface MigrationSummary {
    migrationId?: string;
    v1BotName?: string;
    v1BotVersion?: string;
    v1BotLocale?: Locale;
    v2BotId?: string;
    v2BotRole?: string;
    migrationStatus?: MigrationStatus;
    migrationStrategy?: MigrationStrategy;
    migrationTimestamp?: Date;
}
export declare const MigrationSummary: S.Schema<MigrationSummary>;
export type MigrationSummaryList = MigrationSummary[];
export declare const MigrationSummaryList: S.$Array<S.Schema<MigrationSummary>>;
export interface GetMigrationsResponse {
    migrationSummaries?: MigrationSummary[];
    nextToken?: string;
}
export declare const GetMigrationsResponse: S.Schema<GetMigrationsResponse>;
export interface GetSlotTypeRequest {
    name: string;
    version: string;
}
export declare const GetSlotTypeRequest: S.Schema<GetSlotTypeRequest>;
export interface GetSlotTypeResponse {
    name?: string;
    description?: string;
    enumerationValues?: EnumerationValue[];
    lastUpdatedDate?: Date;
    createdDate?: Date;
    version?: string;
    checksum?: string;
    valueSelectionStrategy?: SlotValueSelectionStrategy;
    parentSlotTypeSignature?: string;
    slotTypeConfigurations?: SlotTypeConfiguration[];
}
export declare const GetSlotTypeResponse: S.Schema<GetSlotTypeResponse>;
export interface GetSlotTypesRequest {
    nextToken?: string;
    maxResults?: number;
    nameContains?: string;
}
export declare const GetSlotTypesRequest: S.Schema<GetSlotTypesRequest>;
export interface SlotTypeMetadata {
    name?: string;
    description?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    version?: string;
}
export declare const SlotTypeMetadata: S.Schema<SlotTypeMetadata>;
export type SlotTypeMetadataList = SlotTypeMetadata[];
export declare const SlotTypeMetadataList: S.$Array<S.Schema<SlotTypeMetadata>>;
export interface GetSlotTypesResponse {
    slotTypes?: SlotTypeMetadata[];
    nextToken?: string;
}
export declare const GetSlotTypesResponse: S.Schema<GetSlotTypesResponse>;
export interface GetSlotTypeVersionsRequest {
    name: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const GetSlotTypeVersionsRequest: S.Schema<GetSlotTypeVersionsRequest>;
export interface GetSlotTypeVersionsResponse {
    slotTypes?: SlotTypeMetadata[];
    nextToken?: string;
}
export declare const GetSlotTypeVersionsResponse: S.Schema<GetSlotTypeVersionsResponse>;
export type BotVersions = string[];
export declare const BotVersions: S.$Array<S.String>;
export type StatusType = "Detected" | "Missed" | (string & {});
export declare const StatusType: S.String;
export interface GetUtterancesViewRequest {
    botName: string;
    botVersions: string[];
    statusType: StatusType;
}
export declare const GetUtterancesViewRequest: S.Schema<GetUtterancesViewRequest>;
export interface UtteranceData {
    utteranceString?: string;
    count?: number;
    distinctUsers?: number;
    firstUtteredDate?: Date;
    lastUtteredDate?: Date;
}
export declare const UtteranceData: S.Schema<UtteranceData>;
export type ListOfUtterance = UtteranceData[];
export declare const ListOfUtterance: S.$Array<S.Schema<UtteranceData>>;
export interface UtteranceList {
    botVersion?: string;
    utterances?: UtteranceData[];
}
export declare const UtteranceList: S.Schema<UtteranceList>;
export type ListsOfUtterances = UtteranceList[];
export declare const ListsOfUtterances: S.$Array<S.Schema<UtteranceList>>;
export interface GetUtterancesViewResponse {
    botName?: string;
    utterances?: UtteranceList[];
}
export declare const GetUtterancesViewResponse: S.Schema<GetUtterancesViewResponse>;
export interface ListTagsForResourceRequest {
    resourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface Tag {
    key: string;
    value: string;
}
export declare const Tag: S.Schema<Tag>;
export type TagList = Tag[];
export declare const TagList: S.$Array<S.Schema<Tag>>;
export interface ListTagsForResourceResponse {
    tags?: Tag[];
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export type ProcessBehavior = "SAVE" | "BUILD" | (string & {});
export declare const ProcessBehavior: S.String;
export interface PutBotRequest {
    name: string;
    description?: string;
    intents?: Intent[];
    enableModelImprovements?: boolean;
    nluIntentConfidenceThreshold?: number;
    clarificationPrompt?: Prompt;
    abortStatement?: Statement;
    idleSessionTTLInSeconds?: number;
    voiceId?: string;
    checksum?: string;
    processBehavior?: ProcessBehavior;
    locale: Locale;
    childDirected: boolean;
    detectSentiment?: boolean;
    createVersion?: boolean;
    tags?: Tag[];
}
export declare const PutBotRequest: S.Schema<PutBotRequest>;
export interface PutBotResponse {
    name?: string;
    description?: string;
    intents?: Intent[];
    enableModelImprovements?: boolean;
    nluIntentConfidenceThreshold?: number;
    clarificationPrompt?: Prompt;
    abortStatement?: Statement;
    status?: Status;
    failureReason?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    idleSessionTTLInSeconds?: number;
    voiceId?: string;
    checksum?: string;
    version?: string;
    locale?: Locale;
    childDirected?: boolean;
    createVersion?: boolean;
    detectSentiment?: boolean;
    tags?: Tag[];
}
export declare const PutBotResponse: S.Schema<PutBotResponse>;
export interface LogSettingsRequest {
    logType: LogType;
    destination: Destination;
    kmsKeyArn?: string;
    resourceArn: string;
}
export declare const LogSettingsRequest: S.Schema<LogSettingsRequest>;
export type LogSettingsRequestList = LogSettingsRequest[];
export declare const LogSettingsRequestList: S.$Array<S.Schema<LogSettingsRequest>>;
export interface ConversationLogsRequest {
    logSettings: LogSettingsRequest[];
    iamRoleArn: string;
}
export declare const ConversationLogsRequest: S.Schema<ConversationLogsRequest>;
export interface PutBotAliasRequest {
    name: string;
    description?: string;
    botVersion: string;
    botName: string;
    checksum?: string;
    conversationLogs?: ConversationLogsRequest;
    tags?: Tag[];
}
export declare const PutBotAliasRequest: S.Schema<PutBotAliasRequest>;
export interface PutBotAliasResponse {
    name?: string;
    description?: string;
    botVersion?: string;
    botName?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    checksum?: string;
    conversationLogs?: ConversationLogsResponse;
    tags?: Tag[];
}
export declare const PutBotAliasResponse: S.Schema<PutBotAliasResponse>;
export interface PutIntentRequest {
    name: string;
    description?: string;
    slots?: Slot[];
    sampleUtterances?: string[];
    confirmationPrompt?: Prompt;
    rejectionStatement?: Statement;
    followUpPrompt?: FollowUpPrompt;
    conclusionStatement?: Statement;
    dialogCodeHook?: CodeHook;
    fulfillmentActivity?: FulfillmentActivity;
    parentIntentSignature?: string;
    checksum?: string;
    createVersion?: boolean;
    kendraConfiguration?: KendraConfiguration;
    inputContexts?: InputContext[];
    outputContexts?: OutputContext[];
}
export declare const PutIntentRequest: S.Schema<PutIntentRequest>;
export interface PutIntentResponse {
    name?: string;
    description?: string;
    slots?: Slot[];
    sampleUtterances?: string[];
    confirmationPrompt?: Prompt;
    rejectionStatement?: Statement;
    followUpPrompt?: FollowUpPrompt;
    conclusionStatement?: Statement;
    dialogCodeHook?: CodeHook;
    fulfillmentActivity?: FulfillmentActivity;
    parentIntentSignature?: string;
    lastUpdatedDate?: Date;
    createdDate?: Date;
    version?: string;
    checksum?: string;
    createVersion?: boolean;
    kendraConfiguration?: KendraConfiguration;
    inputContexts?: InputContext[];
    outputContexts?: OutputContext[];
}
export declare const PutIntentResponse: S.Schema<PutIntentResponse>;
export interface PutSlotTypeRequest {
    name: string;
    description?: string;
    enumerationValues?: EnumerationValue[];
    checksum?: string;
    valueSelectionStrategy?: SlotValueSelectionStrategy;
    createVersion?: boolean;
    parentSlotTypeSignature?: string;
    slotTypeConfigurations?: SlotTypeConfiguration[];
}
export declare const PutSlotTypeRequest: S.Schema<PutSlotTypeRequest>;
export interface PutSlotTypeResponse {
    name?: string;
    description?: string;
    enumerationValues?: EnumerationValue[];
    lastUpdatedDate?: Date;
    createdDate?: Date;
    version?: string;
    checksum?: string;
    valueSelectionStrategy?: SlotValueSelectionStrategy;
    createVersion?: boolean;
    parentSlotTypeSignature?: string;
    slotTypeConfigurations?: SlotTypeConfiguration[];
}
export declare const PutSlotTypeResponse: S.Schema<PutSlotTypeResponse>;
export interface StartImportRequest {
    payload: Uint8Array;
    resourceType: ResourceType;
    mergeStrategy: MergeStrategy;
    tags?: Tag[];
}
export declare const StartImportRequest: S.Schema<StartImportRequest>;
export interface StartImportResponse {
    name?: string;
    resourceType?: ResourceType;
    mergeStrategy?: MergeStrategy;
    importId?: string;
    importStatus?: ImportStatus;
    tags?: Tag[];
    createdDate?: Date;
}
export declare const StartImportResponse: S.Schema<StartImportResponse>;
export interface StartMigrationRequest {
    v1BotName: string;
    v1BotVersion: string;
    v2BotName: string;
    v2BotRole: string;
    migrationStrategy: MigrationStrategy;
}
export declare const StartMigrationRequest: S.Schema<StartMigrationRequest>;
export interface StartMigrationResponse {
    v1BotName?: string;
    v1BotVersion?: string;
    v1BotLocale?: Locale;
    v2BotId?: string;
    v2BotRole?: string;
    migrationId?: string;
    migrationStrategy?: MigrationStrategy;
    migrationTimestamp?: Date;
}
export declare const StartMigrationResponse: S.Schema<StartMigrationResponse>;
export interface TagResourceRequest {
    resourceArn: string;
    tags: Tag[];
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    resourceArn: string;
    tagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
declare const BadRequestException_base: S.Class<BadRequestException, S.TaggedStruct<"BadRequestException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class BadRequestException extends BadRequestException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const InternalFailureException_base: S.Class<InternalFailureException, S.TaggedStruct<"InternalFailureException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalFailureException extends InternalFailureException_base {
}
declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
    readonly retryAfterSeconds: S.optional<S.String>;
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class LimitExceededException extends LimitExceededException_base {
}
declare const NotFoundException_base: S.Class<NotFoundException, S.TaggedStruct<"NotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class NotFoundException extends NotFoundException_base {
}
declare const PreconditionFailedException_base: S.Class<PreconditionFailedException, S.TaggedStruct<"PreconditionFailedException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class PreconditionFailedException extends PreconditionFailedException_base {
}
declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
    readonly referenceType: S.optional<S.String>;
    readonly exampleReference: S.optional<S.Schema<ResourceReference>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceInUseException extends ResourceInUseException_base {
}
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
export type CreateBotVersionError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | PreconditionFailedException | CommonErrors;
/**
 * Creates a new version of the bot based on the `$LATEST`
 * version. If the `$LATEST` version of this resource hasn't
 * changed since you created the last version, Amazon Lex doesn't create a new
 * version. It returns the last created version.
 *
 * You can update only the `$LATEST` version of the bot.
 * You can't update the numbered versions that you create with the
 * `CreateBotVersion` operation.
 *
 * When you create the first version of a bot, Amazon Lex sets the version
 * to 1. Subsequent versions increment by 1. For more information, see versioning-intro.
 *
 * This operation requires permission for the
 * `lex:CreateBotVersion` action.
 */
export declare const createBotVersion: API.OperationMethod<CreateBotVersionRequest, CreateBotVersionResponse, CreateBotVersionError, Credentials | Region | HttpClient.HttpClient>;
export type CreateIntentVersionError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | PreconditionFailedException | CommonErrors;
/**
 * Creates a new version of an intent based on the
 * `$LATEST` version of the intent. If the `$LATEST`
 * version of this intent hasn't changed since you last updated it, Amazon Lex
 * doesn't create a new version. It returns the last version you
 * created.
 *
 * You can update only the `$LATEST` version of the
 * intent. You can't update the numbered versions that you create with the
 * `CreateIntentVersion` operation.
 *
 * When you create a version of an intent, Amazon Lex sets the version to
 * 1. Subsequent versions increment by 1. For more information, see versioning-intro.
 *
 * This operation requires permissions to perform the
 * `lex:CreateIntentVersion` action.
 */
export declare const createIntentVersion: API.OperationMethod<CreateIntentVersionRequest, CreateIntentVersionResponse, CreateIntentVersionError, Credentials | Region | HttpClient.HttpClient>;
export type CreateSlotTypeVersionError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | PreconditionFailedException | CommonErrors;
/**
 * Creates a new version of a slot type based on the
 * `$LATEST` version of the specified slot type. If the
 * `$LATEST` version of this resource has not changed since the
 * last version that you created, Amazon Lex doesn't create a new version. It
 * returns the last version that you created.
 *
 * You can update only the `$LATEST` version of a slot
 * type. You can't update the numbered versions that you create with the
 * `CreateSlotTypeVersion` operation.
 *
 * When you create a version of a slot type, Amazon Lex sets the version to
 * 1. Subsequent versions increment by 1. For more information, see versioning-intro.
 *
 * This operation requires permissions for the
 * `lex:CreateSlotTypeVersion` action.
 */
export declare const createSlotTypeVersion: API.OperationMethod<CreateSlotTypeVersionRequest, CreateSlotTypeVersionResponse, CreateSlotTypeVersionError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteBotError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | ResourceInUseException | CommonErrors;
/**
 * Deletes all versions of the bot, including the `$LATEST`
 * version. To delete a specific version of the bot, use the DeleteBotVersion operation. The `DeleteBot`
 * operation doesn't immediately remove the bot schema. Instead, it is marked
 * for deletion and removed later.
 *
 * Amazon Lex stores utterances indefinitely for improving the ability of
 * your bot to respond to user inputs. These utterances are not removed when
 * the bot is deleted. To remove the utterances, use the DeleteUtterances operation.
 *
 * If a bot has an alias, you can't delete it. Instead, the
 * `DeleteBot` operation returns a
 * `ResourceInUseException` exception that includes a reference
 * to the alias that refers to the bot. To remove the reference to the bot,
 * delete the alias. If you get the same exception again, delete the
 * referring alias until the `DeleteBot` operation is
 * successful.
 *
 * This operation requires permissions for the
 * `lex:DeleteBot` action.
 */
export declare const deleteBot: API.OperationMethod<DeleteBotRequest, DeleteBotResponse, DeleteBotError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteBotAliasError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | ResourceInUseException | CommonErrors;
/**
 * Deletes an alias for the specified bot.
 *
 * You can't delete an alias that is used in the association between a
 * bot and a messaging channel. If an alias is used in a channel association,
 * the `DeleteBot` operation returns a
 * `ResourceInUseException` exception that includes a reference
 * to the channel association that refers to the bot. You can remove the
 * reference to the alias by deleting the channel association. If you get the
 * same exception again, delete the referring association until the
 * `DeleteBotAlias` operation is successful.
 */
export declare const deleteBotAlias: API.OperationMethod<DeleteBotAliasRequest, DeleteBotAliasResponse, DeleteBotAliasError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteBotChannelAssociationError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Deletes the association between an Amazon Lex bot and a messaging
 * platform.
 *
 * This operation requires permission for the
 * `lex:DeleteBotChannelAssociation` action.
 */
export declare const deleteBotChannelAssociation: API.OperationMethod<DeleteBotChannelAssociationRequest, DeleteBotChannelAssociationResponse, DeleteBotChannelAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteBotVersionError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | ResourceInUseException | CommonErrors;
/**
 * Deletes a specific version of a bot. To delete all versions of a
 * bot, use the DeleteBot operation.
 *
 * This operation requires permissions for the
 * `lex:DeleteBotVersion` action.
 */
export declare const deleteBotVersion: API.OperationMethod<DeleteBotVersionRequest, DeleteBotVersionResponse, DeleteBotVersionError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteIntentError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | ResourceInUseException | CommonErrors;
/**
 * Deletes all versions of the intent, including the
 * `$LATEST` version. To delete a specific version of the
 * intent, use the DeleteIntentVersion operation.
 *
 * You can delete a version of an intent only if it is not
 * referenced. To delete an intent that is referred to in one or more bots
 * (see how-it-works), you must remove those references
 * first.
 *
 * If you get the `ResourceInUseException` exception, it
 * provides an example reference that shows where the intent is referenced.
 * To remove the reference to the intent, either update the bot or delete
 * it. If you get the same exception when you attempt to delete the intent
 * again, repeat until the intent has no references and the call to
 * `DeleteIntent` is successful.
 *
 * This operation requires permission for the
 * `lex:DeleteIntent` action.
 */
export declare const deleteIntent: API.OperationMethod<DeleteIntentRequest, DeleteIntentResponse, DeleteIntentError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteIntentVersionError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | ResourceInUseException | CommonErrors;
/**
 * Deletes a specific version of an intent. To delete all versions of
 * a intent, use the DeleteIntent operation.
 *
 * This operation requires permissions for the
 * `lex:DeleteIntentVersion` action.
 */
export declare const deleteIntentVersion: API.OperationMethod<DeleteIntentVersionRequest, DeleteIntentVersionResponse, DeleteIntentVersionError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSlotTypeError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | ResourceInUseException | CommonErrors;
/**
 * Deletes all versions of the slot type, including the
 * `$LATEST` version. To delete a specific version of the slot
 * type, use the DeleteSlotTypeVersion operation.
 *
 * You can delete a version of a slot type only if it is not
 * referenced. To delete a slot type that is referred to in one or more
 * intents, you must remove those references first.
 *
 * If you get the `ResourceInUseException` exception,
 * the exception provides an example reference that shows the intent where
 * the slot type is referenced. To remove the reference to the slot type,
 * either update the intent or delete it. If you get the same exception
 * when you attempt to delete the slot type again, repeat until the slot
 * type has no references and the `DeleteSlotType` call is
 * successful.
 *
 * This operation requires permission for the
 * `lex:DeleteSlotType` action.
 */
export declare const deleteSlotType: API.OperationMethod<DeleteSlotTypeRequest, DeleteSlotTypeResponse, DeleteSlotTypeError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSlotTypeVersionError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | ResourceInUseException | CommonErrors;
/**
 * Deletes a specific version of a slot type. To delete all versions
 * of a slot type, use the DeleteSlotType operation.
 *
 * This operation requires permissions for the
 * `lex:DeleteSlotTypeVersion` action.
 */
export declare const deleteSlotTypeVersion: API.OperationMethod<DeleteSlotTypeVersionRequest, DeleteSlotTypeVersionResponse, DeleteSlotTypeVersionError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteUtterancesError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Deletes stored utterances.
 *
 * Amazon Lex stores the utterances that users send to your bot. Utterances
 * are stored for 15 days for use with the GetUtterancesView operation, and then stored indefinitely for use in improving the
 * ability of your bot to respond to user input.
 *
 * Use the `DeleteUtterances` operation to manually delete
 * stored utterances for a specific user. When you use the
 * `DeleteUtterances` operation, utterances stored for improving
 * your bot's ability to respond to user input are deleted immediately.
 * Utterances stored for use with the `GetUtterancesView`
 * operation are deleted after 15 days.
 *
 * This operation requires permissions for the
 * `lex:DeleteUtterances` action.
 */
export declare const deleteUtterances: API.OperationMethod<DeleteUtterancesRequest, DeleteUtterancesResponse, DeleteUtterancesError, Credentials | Region | HttpClient.HttpClient>;
export type GetBotError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Returns metadata information for a specific bot. You must provide
 * the bot name and the bot version or alias.
 *
 * This operation requires permissions for the
 * `lex:GetBot` action.
 */
export declare const getBot: API.OperationMethod<GetBotRequest, GetBotResponse, GetBotError, Credentials | Region | HttpClient.HttpClient>;
export type GetBotAliasError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Returns information about an Amazon Lex bot alias. For more information
 * about aliases, see versioning-aliases.
 *
 * This operation requires permissions for the
 * `lex:GetBotAlias` action.
 */
export declare const getBotAlias: API.OperationMethod<GetBotAliasRequest, GetBotAliasResponse, GetBotAliasError, Credentials | Region | HttpClient.HttpClient>;
export type GetBotAliasesError = BadRequestException | InternalFailureException | LimitExceededException | CommonErrors;
/**
 * Returns a list of aliases for a specified Amazon Lex bot.
 *
 * This operation requires permissions for the
 * `lex:GetBotAliases` action.
 */
export declare const getBotAliases: API.OperationMethod<GetBotAliasesRequest, GetBotAliasesResponse, GetBotAliasesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetBotAliasesRequest) => stream.Stream<GetBotAliasesResponse, GetBotAliasesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetBotAliasesRequest) => stream.Stream<unknown, GetBotAliasesError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetBotChannelAssociationError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Returns information about the association between an Amazon Lex bot and
 * a messaging platform.
 *
 * This operation requires permissions for the
 * `lex:GetBotChannelAssociation` action.
 */
export declare const getBotChannelAssociation: API.OperationMethod<GetBotChannelAssociationRequest, GetBotChannelAssociationResponse, GetBotChannelAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type GetBotChannelAssociationsError = BadRequestException | InternalFailureException | LimitExceededException | CommonErrors;
/**
 * Returns a list of all of the channels associated with the
 * specified bot.
 *
 * The `GetBotChannelAssociations` operation requires
 * permissions for the `lex:GetBotChannelAssociations`
 * action.
 */
export declare const getBotChannelAssociations: API.OperationMethod<GetBotChannelAssociationsRequest, GetBotChannelAssociationsResponse, GetBotChannelAssociationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetBotChannelAssociationsRequest) => stream.Stream<GetBotChannelAssociationsResponse, GetBotChannelAssociationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetBotChannelAssociationsRequest) => stream.Stream<unknown, GetBotChannelAssociationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetBotsError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Returns bot information as follows:
 *
 * - If you provide the `nameContains` field, the
 * response includes information for the `$LATEST` version of
 * all bots whose name contains the specified string.
 *
 * - If you don't specify the `nameContains` field, the
 * operation returns information about the `$LATEST` version
 * of all of your bots.
 *
 * This operation requires permission for the `lex:GetBots`
 * action.
 */
export declare const getBots: API.OperationMethod<GetBotsRequest, GetBotsResponse, GetBotsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetBotsRequest) => stream.Stream<GetBotsResponse, GetBotsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetBotsRequest) => stream.Stream<unknown, GetBotsError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetBotVersionsError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Gets information about all of the versions of a bot.
 *
 * The `GetBotVersions` operation returns a
 * `BotMetadata` object for each version of a bot. For example,
 * if a bot has three numbered versions, the `GetBotVersions`
 * operation returns four `BotMetadata` objects in the response,
 * one for each numbered version and one for the `$LATEST`
 * version.
 *
 * The `GetBotVersions` operation always returns at least
 * one version, the `$LATEST` version.
 *
 * This operation requires permissions for the
 * `lex:GetBotVersions` action.
 */
export declare const getBotVersions: API.OperationMethod<GetBotVersionsRequest, GetBotVersionsResponse, GetBotVersionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetBotVersionsRequest) => stream.Stream<GetBotVersionsResponse, GetBotVersionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetBotVersionsRequest) => stream.Stream<unknown, GetBotVersionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetBuiltinIntentError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Returns information about a built-in intent.
 *
 * This operation requires permission for the
 * `lex:GetBuiltinIntent` action.
 */
export declare const getBuiltinIntent: API.OperationMethod<GetBuiltinIntentRequest, GetBuiltinIntentResponse, GetBuiltinIntentError, Credentials | Region | HttpClient.HttpClient>;
export type GetBuiltinIntentsError = BadRequestException | InternalFailureException | LimitExceededException | CommonErrors;
/**
 * Gets a list of built-in intents that meet the specified
 * criteria.
 *
 * This operation requires permission for the
 * `lex:GetBuiltinIntents` action.
 */
export declare const getBuiltinIntents: API.OperationMethod<GetBuiltinIntentsRequest, GetBuiltinIntentsResponse, GetBuiltinIntentsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetBuiltinIntentsRequest) => stream.Stream<GetBuiltinIntentsResponse, GetBuiltinIntentsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetBuiltinIntentsRequest) => stream.Stream<unknown, GetBuiltinIntentsError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetBuiltinSlotTypesError = BadRequestException | InternalFailureException | LimitExceededException | CommonErrors;
/**
 * Gets a list of built-in slot types that meet the specified
 * criteria.
 *
 * For a list of built-in slot types, see Slot Type Reference in the Alexa Skills
 * Kit.
 *
 * This operation requires permission for the
 * `lex:GetBuiltInSlotTypes` action.
 */
export declare const getBuiltinSlotTypes: API.OperationMethod<GetBuiltinSlotTypesRequest, GetBuiltinSlotTypesResponse, GetBuiltinSlotTypesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetBuiltinSlotTypesRequest) => stream.Stream<GetBuiltinSlotTypesResponse, GetBuiltinSlotTypesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetBuiltinSlotTypesRequest) => stream.Stream<unknown, GetBuiltinSlotTypesError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetExportError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Exports the contents of a Amazon Lex resource in a specified format.
 */
export declare const getExport: API.OperationMethod<GetExportRequest, GetExportResponse, GetExportError, Credentials | Region | HttpClient.HttpClient>;
export type GetImportError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Gets information about an import job started with the
 * `StartImport` operation.
 */
export declare const getImport: API.OperationMethod<GetImportRequest, GetImportResponse, GetImportError, Credentials | Region | HttpClient.HttpClient>;
export type GetIntentError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Returns information about an intent. In addition to the intent
 * name, you must specify the intent version.
 *
 * This operation requires permissions to perform the
 * `lex:GetIntent` action.
 */
export declare const getIntent: API.OperationMethod<GetIntentRequest, GetIntentResponse, GetIntentError, Credentials | Region | HttpClient.HttpClient>;
export type GetIntentsError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Returns intent information as follows:
 *
 * - If you specify the `nameContains` field, returns the
 * `$LATEST` version of all intents that contain the
 * specified string.
 *
 * - If you don't specify the `nameContains` field,
 * returns information about the `$LATEST` version of all
 * intents.
 *
 * The operation requires permission for the
 * `lex:GetIntents` action.
 */
export declare const getIntents: API.OperationMethod<GetIntentsRequest, GetIntentsResponse, GetIntentsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetIntentsRequest) => stream.Stream<GetIntentsResponse, GetIntentsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetIntentsRequest) => stream.Stream<unknown, GetIntentsError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetIntentVersionsError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Gets information about all of the versions of an intent.
 *
 * The `GetIntentVersions` operation returns an
 * `IntentMetadata` object for each version of an intent. For
 * example, if an intent has three numbered versions, the
 * `GetIntentVersions` operation returns four
 * `IntentMetadata` objects in the response, one for each
 * numbered version and one for the `$LATEST` version.
 *
 * The `GetIntentVersions` operation always returns at
 * least one version, the `$LATEST` version.
 *
 * This operation requires permissions for the
 * `lex:GetIntentVersions` action.
 */
export declare const getIntentVersions: API.OperationMethod<GetIntentVersionsRequest, GetIntentVersionsResponse, GetIntentVersionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetIntentVersionsRequest) => stream.Stream<GetIntentVersionsResponse, GetIntentVersionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetIntentVersionsRequest) => stream.Stream<unknown, GetIntentVersionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetMigrationError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Provides details about an ongoing or complete migration from an
 * Amazon Lex V1 bot to an Amazon Lex V2 bot. Use this operation to view the migration
 * alerts and warnings related to the migration.
 */
export declare const getMigration: API.OperationMethod<GetMigrationRequest, GetMigrationResponse, GetMigrationError, Credentials | Region | HttpClient.HttpClient>;
export type GetMigrationsError = BadRequestException | InternalFailureException | LimitExceededException | CommonErrors;
/**
 * Gets a list of migrations between Amazon Lex V1 and Amazon Lex V2.
 */
export declare const getMigrations: API.OperationMethod<GetMigrationsRequest, GetMigrationsResponse, GetMigrationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetMigrationsRequest) => stream.Stream<GetMigrationsResponse, GetMigrationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetMigrationsRequest) => stream.Stream<unknown, GetMigrationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetSlotTypeError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Returns information about a specific version of a slot type. In
 * addition to specifying the slot type name, you must specify the slot type
 * version.
 *
 * This operation requires permissions for the
 * `lex:GetSlotType` action.
 */
export declare const getSlotType: API.OperationMethod<GetSlotTypeRequest, GetSlotTypeResponse, GetSlotTypeError, Credentials | Region | HttpClient.HttpClient>;
export type GetSlotTypesError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Returns slot type information as follows:
 *
 * - If you specify the `nameContains` field, returns the
 * `$LATEST` version of all slot types that contain the
 * specified string.
 *
 * - If you don't specify the `nameContains` field,
 * returns information about the `$LATEST` version of all slot
 * types.
 *
 * The operation requires permission for the
 * `lex:GetSlotTypes` action.
 */
export declare const getSlotTypes: API.OperationMethod<GetSlotTypesRequest, GetSlotTypesResponse, GetSlotTypesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetSlotTypesRequest) => stream.Stream<GetSlotTypesResponse, GetSlotTypesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetSlotTypesRequest) => stream.Stream<unknown, GetSlotTypesError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetSlotTypeVersionsError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Gets information about all versions of a slot type.
 *
 * The `GetSlotTypeVersions` operation returns a
 * `SlotTypeMetadata` object for each version of a slot type.
 * For example, if a slot type has three numbered versions, the
 * `GetSlotTypeVersions` operation returns four
 * `SlotTypeMetadata` objects in the response, one for each
 * numbered version and one for the `$LATEST` version.
 *
 * The `GetSlotTypeVersions` operation always returns at
 * least one version, the `$LATEST` version.
 *
 * This operation requires permissions for the
 * `lex:GetSlotTypeVersions` action.
 */
export declare const getSlotTypeVersions: API.OperationMethod<GetSlotTypeVersionsRequest, GetSlotTypeVersionsResponse, GetSlotTypeVersionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetSlotTypeVersionsRequest) => stream.Stream<GetSlotTypeVersionsResponse, GetSlotTypeVersionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetSlotTypeVersionsRequest) => stream.Stream<unknown, GetSlotTypeVersionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetUtterancesViewError = BadRequestException | InternalFailureException | LimitExceededException | CommonErrors;
/**
 * Use the `GetUtterancesView` operation to get information
 * about the utterances that your users have made to your bot. You can use
 * this list to tune the utterances that your bot responds to.
 *
 * For example, say that you have created a bot to order flowers.
 * After your users have used your bot for a while, use the
 * `GetUtterancesView` operation to see the requests that they
 * have made and whether they have been successful. You might find that the
 * utterance "I want flowers" is not being recognized. You could add this
 * utterance to the `OrderFlowers` intent so that your bot
 * recognizes that utterance.
 *
 * After you publish a new version of a bot, you can get information
 * about the old version and the new so that you can compare the performance
 * across the two versions.
 *
 * Utterance statistics are generated once a day. Data is available
 * for the last 15 days. You can request information for up to 5 versions of
 * your bot in each request. Amazon Lex returns the most frequent utterances
 * received by the bot in the last 15 days. The response contains information
 * about a maximum of 100 utterances for each version.
 *
 * If you set `childDirected` field to true when you
 * created your bot, if you are using slot obfuscation with one or more
 * slots, or if you opted out of participating in improving Amazon Lex, utterances
 * are not available.
 *
 * This operation requires permissions for the
 * `lex:GetUtterancesView` action.
 */
export declare const getUtterancesView: API.OperationMethod<GetUtterancesViewRequest, GetUtterancesViewResponse, GetUtterancesViewError, Credentials | Region | HttpClient.HttpClient>;
export type ListTagsForResourceError = BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Gets a list of tags associated with the specified resource. Only bots,
 * bot aliases, and bot channels can have tags associated with them.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type PutBotError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | PreconditionFailedException | CommonErrors;
/**
 * Creates an Amazon Lex conversational bot or replaces an existing bot.
 * When you create or update a bot you are only required to specify a name, a
 * locale, and whether the bot is directed toward children under age 13. You
 * can use this to add intents later, or to remove intents from an existing
 * bot. When you create a bot with the minimum information, the bot is
 * created or updated but Amazon Lex returns the `` response
 * `FAILED`. You can build the bot after you add one or more
 * intents. For more information about Amazon Lex bots, see how-it-works.
 *
 * If you specify the name of an existing bot, the fields in the
 * request replace the existing values in the `$LATEST` version of
 * the bot. Amazon Lex removes any fields that you don't provide values for in the
 * request, except for the `idleTTLInSeconds` and
 * `privacySettings` fields, which are set to their default
 * values. If you don't specify values for required fields, Amazon Lex throws an
 * exception.
 *
 * This operation requires permissions for the `lex:PutBot`
 * action. For more information, see security-iam.
 */
export declare const putBot: API.OperationMethod<PutBotRequest, PutBotResponse, PutBotError, Credentials | Region | HttpClient.HttpClient>;
export type PutBotAliasError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | PreconditionFailedException | CommonErrors;
/**
 * Creates an alias for the specified version of the bot or replaces
 * an alias for the specified bot. To change the version of the bot that the
 * alias points to, replace the alias. For more information about aliases,
 * see versioning-aliases.
 *
 * This operation requires permissions for the
 * `lex:PutBotAlias` action.
 */
export declare const putBotAlias: API.OperationMethod<PutBotAliasRequest, PutBotAliasResponse, PutBotAliasError, Credentials | Region | HttpClient.HttpClient>;
export type PutIntentError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | PreconditionFailedException | CommonErrors;
/**
 * Creates an intent or replaces an existing intent.
 *
 * To define the interaction between the user and your bot, you use
 * one or more intents. For a pizza ordering bot, for example, you would
 * create an `OrderPizza` intent.
 *
 * To create an intent or replace an existing intent, you must provide
 * the following:
 *
 * - Intent name. For example, `OrderPizza`.
 *
 * - Sample utterances. For example, "Can I order a pizza, please."
 * and "I want to order a pizza."
 *
 * - Information to be gathered. You specify slot types for the
 * information that your bot will request from the user. You can specify
 * standard slot types, such as a date or a time, or custom slot types
 * such as the size and crust of a pizza.
 *
 * - How the intent will be fulfilled. You can provide a Lambda
 * function or configure the intent to return the intent information to
 * the client application. If you use a Lambda function, when all of the
 * intent information is available, Amazon Lex invokes your Lambda function.
 * If you configure your intent to return the intent information to the
 * client application.
 *
 * You can specify other optional information in the request, such
 * as:
 *
 * - A confirmation prompt to ask the user to confirm an intent. For
 * example, "Shall I order your pizza?"
 *
 * - A conclusion statement to send to the user after the intent has
 * been fulfilled. For example, "I placed your pizza order."
 *
 * - A follow-up prompt that asks the user for additional activity.
 * For example, asking "Do you want to order a drink with your
 * pizza?"
 *
 * If you specify an existing intent name to update the intent, Amazon Lex
 * replaces the values in the `$LATEST` version of the intent with
 * the values in the request. Amazon Lex removes fields that you don't provide in
 * the request. If you don't specify the required fields, Amazon Lex throws an
 * exception. When you update the `$LATEST` version of an intent,
 * the `status` field of any bot that uses the
 * `$LATEST` version of the intent is set to
 * `NOT_BUILT`.
 *
 * For more information, see how-it-works.
 *
 * This operation requires permissions for the
 * `lex:PutIntent` action.
 */
export declare const putIntent: API.OperationMethod<PutIntentRequest, PutIntentResponse, PutIntentError, Credentials | Region | HttpClient.HttpClient>;
export type PutSlotTypeError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | PreconditionFailedException | CommonErrors;
/**
 * Creates a custom slot type or replaces an existing custom slot
 * type.
 *
 * To create a custom slot type, specify a name for the slot type and
 * a set of enumeration values, which are the values that a slot of this type
 * can assume. For more information, see how-it-works.
 *
 * If you specify the name of an existing slot type, the fields in the
 * request replace the existing values in the `$LATEST` version of
 * the slot type. Amazon Lex removes the fields that you don't provide in the
 * request. If you don't specify required fields, Amazon Lex throws an exception.
 * When you update the `$LATEST` version of a slot type, if a bot
 * uses the `$LATEST` version of an intent that contains the slot
 * type, the bot's `status` field is set to
 * `NOT_BUILT`.
 *
 * This operation requires permissions for the
 * `lex:PutSlotType` action.
 */
export declare const putSlotType: API.OperationMethod<PutSlotTypeRequest, PutSlotTypeResponse, PutSlotTypeError, Credentials | Region | HttpClient.HttpClient>;
export type StartImportError = BadRequestException | InternalFailureException | LimitExceededException | CommonErrors;
/**
 * Starts a job to import a resource to Amazon Lex.
 */
export declare const startImport: API.OperationMethod<StartImportRequest, StartImportResponse, StartImportError, Credentials | Region | HttpClient.HttpClient>;
export type StartMigrationError = AccessDeniedException | BadRequestException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Starts migrating a bot from Amazon Lex V1 to Amazon Lex V2. Migrate your bot when
 * you want to take advantage of the new features of Amazon Lex V2.
 *
 * For more information, see Migrating a bot in the Amazon Lex
 * developer guide.
 */
export declare const startMigration: API.OperationMethod<StartMigrationRequest, StartMigrationResponse, StartMigrationError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Adds the specified tags to the specified resource. If a tag key
 * already exists, the existing value is replaced with the new value.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = BadRequestException | ConflictException | InternalFailureException | LimitExceededException | NotFoundException | CommonErrors;
/**
 * Removes tags from a bot, bot alias or bot channel.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=lex-model-building-service.d.ts.map