export interface Intent {
    /** The name of the intent. */
    intentName: string;
    /** The version of the intent. */
    intentVersion: string;
}
export interface Prompt {
    /** An array of objects, each of which provides a message string and its type. You can specify the message string in plain text or in Speech Synthesis Markup Language (SSML). */
    messages: any[];
    /** The number of times to prompt the user for information. */
    maxAttempts: number;
    /** A response card. Amazon Lex uses this prompt at runtime, in the PostText API response. It substitutes session attributes and slot values for placeholders in the response card. For more information, se */
    responseCard?: string;
}
export interface Statement {
    /** A collection of message objects. */
    messages: any[];
    /** At runtime, if the client is using the PostText API, Amazon Lex includes the response card in the response. It substitutes all of the session attributes and slot values for placeholders in the respons */
    responseCard?: string;
}
export interface Tag {
    /** The key for the tag. Keys are not case-sensitive and must be unique. */
    key: string;
    /** The value associated with a key. The value may be an empty string but it can't be null. */
    value: string;
}
export interface ConversationLogsRequest {
    /** The settings for your conversation logs. You can log the conversation text, conversation audio, or both. */
    logSettings: any[];
    /** The Amazon Resource Name (ARN) of an IAM role with permission to write to your CloudWatch Logs for text logs and your S3 bucket for audio logs. If audio encryption is enabled, this role also provides  */
    iamRoleArn: string;
}
export interface Slot {
    /** The name of the slot. */
    name: string;
    /** A description of the slot. */
    description?: string;
    /** Specifies whether the slot is required or optional. */
    slotConstraint: 'Required' | 'Optional';
    /** The type of the slot, either a custom slot type that you defined or one of the built-in slot types. */
    slotType?: string;
    /** The version of the slot type. */
    slotTypeVersion?: string;
    /** The prompt that Amazon Lex uses to elicit the slot value from the user. */
    valueElicitationPrompt?: any;
    /** Directs Amazon Lex the order in which to elicit this slot value from the user. For example, if the intent has two slots with priorities 1 and 2, AWS Amazon Lex first elicits a value for the slot with  */
    priority?: number;
    /** If you know a specific pattern with which users might respond to an Amazon Lex request for a slot value, you can provide those utterances to improve accuracy. This is optional. In most cases, Amazon L */
    sampleUtterances?: any[];
    /** A set of possible responses for the slot type used by text-based clients. A user chooses an option from the response card, instead of using text to reply. */
    responseCard?: string;
    /** Determines whether a slot is obfuscated in conversation logs and stored utterances. When you obfuscate a slot, the value is replaced by the slot name in curly braces ({}). For example, if the slot nam */
    obfuscationSetting?: 'NONE' | 'DEFAULT_OBFUSCATION';
    /** A list of default values for the slot. Default values are used when Amazon Lex hasn't determined a value for a slot. You can specify default values from context variables, session attributes, and defi */
    defaultValueSpec?: any;
}
export interface FollowUpPrompt {
    /** Prompts for information from the user. */
    prompt: Prompt;
    /** If the user answers "no" to the question defined in the prompt field, Amazon Lex responds with this statement to acknowledge that the intent was canceled. */
    rejectionStatement: Statement;
}
export interface CodeHook {
    /** The Amazon Resource Name (ARN) of the Lambda function. */
    uri: string;
    /** The version of the request-response that you want Amazon Lex to use to invoke your Lambda function. For more information, see using-lambda. */
    messageVersion: string;
}
export interface FulfillmentActivity {
    /** How the intent should be fulfilled, either by running a Lambda function or by returning the slot data to the client application. */
    type: 'ReturnIntent' | 'CodeHook';
    /** A description of the Lambda function that is run to fulfill the intent. */
    codeHook?: CodeHook;
}
export interface KendraConfiguration {
    /** The Amazon Resource Name (ARN) of the Amazon Kendra index that you want the AMAZON.KendraSearchIntent intent to search. The index must be in the same account and Region as the Amazon Lex bot. If the A */
    kendraIndex: string;
    /** A query filter that Amazon Lex sends to Amazon Kendra to filter the response from the query. The filter is in the format defined by Amazon Kendra. For more information, see Filtering queries. You can  */
    queryFilterString?: string;
    /** The Amazon Resource Name (ARN) of an IAM role that has permission to search the Amazon Kendra index. The role must be in the same account and Region as the Amazon Lex bot. If the role does not exist,  */
    role: string;
}
export interface InputContext {
    /** The name of the context. */
    name: string;
}
export interface OutputContext {
    /** The name of the context. */
    name: string;
    /** The number of seconds that the context should be active after it is first sent in a PostContent or PostText response. You can set the value between 5 and 86,400 seconds (24 hours). */
    timeToLiveInSeconds: number;
    /** The number of conversation turns that the context should be active. A conversation turn is one PostContent or PostText request and the corresponding response from Amazon Lex. */
    turnsToLive: number;
}
export interface EnumerationValue {
    /** The value of the slot type. */
    value: string;
    /** Additional values related to the slot type value. */
    synonyms?: any[];
}
export interface SlotTypeConfiguration {
    /** A regular expression used to validate the value of a slot. */
    regexConfiguration?: any;
}
export interface CreateBotVersionInput {
    /** The name of the bot that you want to create a new version of. The name is case sensitive. */
    name: string;
    /** Identifies a specific revision of the $LATEST version of the bot. If you specify a checksum and the $LATEST version of the bot has a different checksum, a PreconditionFailedException exception is retu */
    checksum?: string;
}
export interface CreateIntentVersionInput {
    /** The name of the intent that you want to create a new version of. The name is case sensitive. */
    name: string;
    /** Checksum of the $LATEST version of the intent that should be used to create the new version. If you specify a checksum and the $LATEST version of the intent has a different checksum, Amazon Lex return */
    checksum?: string;
}
export interface CreateSlotTypeVersionInput {
    /** The name of the slot type that you want to create a new version for. The name is case sensitive. */
    name: string;
    /** Checksum for the $LATEST version of the slot type that you want to publish. If you specify a checksum and the $LATEST version of the slot type has a different checksum, Amazon Lex returns a Preconditi */
    checksum?: string;
}
export interface DeleteBotInput {
    /** The name of the bot. The name is case sensitive. */
    name: string;
}
export interface DeleteBotAliasInput {
    /** The name of the bot that the alias points to. */
    botName: string;
    /** The name of the alias to delete. The name is case sensitive. */
    name: string;
}
export interface DeleteBotChannelAssociationInput {
    /** An alias that points to the specific version of the Amazon Lex bot to which this association is being made. */
    botAlias: string;
    /** The name of the Amazon Lex bot. */
    botName: string;
    /** The name of the association. The name is case sensitive. */
    name: string;
}
export interface DeleteBotVersionInput {
    /** The name of the bot. */
    name: string;
    /** The version of the bot to delete. You cannot delete the $LATEST version of the bot. To delete the $LATEST version, use the DeleteBot operation. */
    version: string;
}
export interface DeleteIntentInput {
    /** The name of the intent. The name is case sensitive. */
    name: string;
}
export interface DeleteIntentVersionInput {
    /** The name of the intent. */
    name: string;
    /** The version of the intent to delete. You cannot delete the $LATEST version of the intent. To delete the $LATEST version, use the DeleteIntent operation. */
    version: string;
}
export interface DeleteSlotTypeInput {
    /** The name of the slot type. The name is case sensitive. */
    name: string;
}
export interface DeleteSlotTypeVersionInput {
    /** The name of the slot type. */
    name: string;
    /** The version of the slot type to delete. You cannot delete the $LATEST version of the slot type. To delete the $LATEST version, use the DeleteSlotType operation. */
    version: string;
}
export interface DeleteUtterancesInput {
    /** The name of the bot that stored the utterances. */
    botName: string;
    /** The unique identifier for the user that made the utterances. This is the user ID that was sent in the PostContent or PostText operation request that contained the utterance. */
    userId: string;
}
export interface GetBotInput {
    /** The name of the bot. The name is case sensitive. */
    name: string;
    /** The version or alias of the bot. */
    versionOrAlias: string;
}
export interface GetBotAliasInput {
    /** The name of the bot. */
    botName: string;
    /** The name of the bot alias. The name is case sensitive. */
    name: string;
}
export interface GetBotAliasesInput {
    /** The name of the bot. */
    botName: string;
    /** The maximum number of aliases to return in the response. The default is 50. . */
    maxResults?: number;
    /** Substring to match in bot alias names. An alias will be returned if any part of its name matches the substring. For example, "xyz" matches both "xyzabc" and "abcxyz." */
    nameContains?: string;
    /** A pagination token for fetching the next page of aliases. If the response to this call is truncated, Amazon Lex returns a pagination token in the response. To fetch the next page of aliases, specify t */
    nextToken?: string;
}
export interface GetBotChannelAssociationInput {
    /** An alias pointing to the specific version of the Amazon Lex bot to which this association is being made. */
    botAlias: string;
    /** The name of the Amazon Lex bot. */
    botName: string;
    /** The name of the association between the bot and the channel. The name is case sensitive. */
    name: string;
}
export interface GetBotChannelAssociationsInput {
    /** An alias pointing to the specific version of the Amazon Lex bot to which this association is being made. */
    botAlias: string;
    /** The name of the Amazon Lex bot in the association. */
    botName: string;
    /** The maximum number of associations to return in the response. The default is 50. */
    maxResults?: number;
    /** Substring to match in channel association names. An association will be returned if any part of its name matches the substring. For example, "xyz" matches both "xyzabc" and "abcxyz." To return all bot */
    nameContains?: string;
    /** A pagination token for fetching the next page of associations. If the response to this call is truncated, Amazon Lex returns a pagination token in the response. To fetch the next page of associations, */
    nextToken?: string;
}
export interface GetBotsInput {
    /** The maximum number of bots to return in the response that the request will return. The default is 10. */
    maxResults?: number;
    /** Substring to match in bot names. A bot will be returned if any part of its name matches the substring. For example, "xyz" matches both "xyzabc" and "abcxyz." */
    nameContains?: string;
    /** A pagination token that fetches the next page of bots. If the response to this call is truncated, Amazon Lex returns a pagination token in the response. To fetch the next page of bots, specify the pag */
    nextToken?: string;
}
export interface GetBotVersionsInput {
    /** The name of the bot for which versions should be returned. */
    name: string;
    /** The maximum number of bot versions to return in the response. The default is 10. */
    maxResults?: number;
    /** A pagination token for fetching the next page of bot versions. If the response to this call is truncated, Amazon Lex returns a pagination token in the response. To fetch the next page of versions, spe */
    nextToken?: string;
}
export interface GetBuiltinIntentInput {
    /** The unique identifier for a built-in intent. To find the signature for an intent, see Standard Built-in Intents in the Alexa Skills Kit. */
    signature: string;
}
export interface GetBuiltinIntentsInput {
    /** A list of locales that the intent supports. */
    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';
    /** The maximum number of intents to return in the response. The default is 10. */
    maxResults?: number;
    /** A pagination token that fetches the next page of intents. If this API call is truncated, Amazon Lex returns a pagination token in the response. To fetch the next page of intents, use the pagination to */
    nextToken?: string;
    /** Substring to match in built-in intent signatures. An intent will be returned if any part of its signature matches the substring. For example, "xyz" matches both "xyzabc" and "abcxyz." To find the sign */
    signatureContains?: string;
}
export interface GetBuiltinSlotTypesInput {
    /** A list of locales that the slot type supports. */
    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';
    /** The maximum number of slot types to return in the response. The default is 10. */
    maxResults?: number;
    /** A pagination token that fetches the next page of slot types. If the response to this API call is truncated, Amazon Lex returns a pagination token in the response. To fetch the next page of slot types, */
    nextToken?: string;
    /** Substring to match in built-in slot type signatures. A slot type will be returned if any part of its signature matches the substring. For example, "xyz" matches both "xyzabc" and "abcxyz." */
    signatureContains?: string;
}
export interface GetExportInput {
    /** The format of the exported data. */
    exportType: 'ALEXA_SKILLS_KIT' | 'LEX';
    /** The name of the bot to export. */
    name: string;
    /** The type of resource to export. */
    resourceType: 'BOT' | 'INTENT' | 'SLOT_TYPE';
    /** The version of the bot to export. */
    version: string;
}
export interface GetImportInput {
    /** The identifier of the import job information to return. */
    importId: string;
}
export interface GetIntentInput {
    /** The name of the intent. The name is case sensitive. */
    name: string;
    /** The version of the intent. */
    version: string;
}
export interface GetIntentsInput {
    /** The maximum number of intents to return in the response. The default is 10. */
    maxResults?: number;
    /** Substring to match in intent names. An intent will be returned if any part of its name matches the substring. For example, "xyz" matches both "xyzabc" and "abcxyz." */
    nameContains?: string;
    /** A pagination token that fetches the next page of intents. If the response to this API call is truncated, Amazon Lex returns a pagination token in the response. To fetch the next page of intents, speci */
    nextToken?: string;
}
export interface GetIntentVersionsInput {
    /** The name of the intent for which versions should be returned. */
    name: string;
    /** The maximum number of intent versions to return in the response. The default is 10. */
    maxResults?: number;
    /** A pagination token for fetching the next page of intent versions. If the response to this call is truncated, Amazon Lex returns a pagination token in the response. To fetch the next page of versions,  */
    nextToken?: string;
}
export interface GetMigrationInput {
    /** The unique identifier of the migration to view. The migrationID is returned by the operation. */
    migrationId: string;
}
export interface GetMigrationsInput {
    /** The maximum number of migrations to return in the response. The default is 10. */
    maxResults?: number;
    /** Filters the list to contain only migrations in the specified state. */
    migrationStatusEquals?: 'IN_PROGRESS' | 'COMPLETED' | 'FAILED';
    /** A pagination token that fetches the next page of migrations. If the response to this operation is truncated, Amazon Lex returns a pagination token in the response. To fetch the next page of migrations */
    nextToken?: string;
    /** The field to sort the list of migrations by. You can sort by the Amazon Lex V1 bot name or the date and time that the migration was started. */
    sortByAttribute?: 'V1_BOT_NAME' | 'MIGRATION_DATE_TIME';
    /** The order so sort the list. */
    sortByOrder?: 'ASCENDING' | 'DESCENDING';
    /** Filters the list to contain only bots whose name contains the specified string. The string is matched anywhere in bot name. */
    v1BotNameContains?: string;
}
export interface GetSlotTypeInput {
    /** The name of the slot type. The name is case sensitive. */
    name: string;
    /** The version of the slot type. */
    version: string;
}
export interface GetSlotTypesInput {
    /** The maximum number of slot types to return in the response. The default is 10. */
    maxResults?: number;
    /** Substring to match in slot type names. A slot type will be returned if any part of its name matches the substring. For example, "xyz" matches both "xyzabc" and "abcxyz." */
    nameContains?: string;
    /** A pagination token that fetches the next page of slot types. If the response to this API call is truncated, Amazon Lex returns a pagination token in the response. To fetch next page of slot types, spe */
    nextToken?: string;
}
export interface GetSlotTypeVersionsInput {
    /** The name of the slot type for which versions should be returned. */
    name: string;
    /** The maximum number of slot type versions to return in the response. The default is 10. */
    maxResults?: number;
    /** A pagination token for fetching the next page of slot type versions. If the response to this call is truncated, Amazon Lex returns a pagination token in the response. To fetch the next page of version */
    nextToken?: string;
}
export interface GetUtterancesViewInput {
    /** The name of the bot for which utterance information should be returned. */
    botName: string;
    /** An array of bot versions for which utterance information should be returned. The limit is 5 versions per request. */
    botVersions: string[];
    /** To return utterances that were recognized and handled, use Detected. To return utterances that were not recognized, use Missed. */
    statusType: 'Detected' | 'Missed';
}
export interface ListTagsForResourceInput {
    /** The Amazon Resource Name (ARN) of the resource to get a list of tags for. */
    resourceArn: string;
}
export interface PutBotInput {
    /** For each Amazon Lex bot created with the Amazon Lex Model Building Service, you must specify whether your use of Amazon Lex is related to a website, program, or other application that is directed or t */
    childDirected: boolean;
    /** Specifies the target locale for the bot. Any intent used in the bot must be compatible with the locale of the bot. The default is en-US. */
    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';
    /** The name of the bot. The name is not case sensitive. */
    name: string;
    /** When Amazon Lex can't understand the user's input in context, it tries to elicit the information a few times. After that, Amazon Lex sends the message defined in abortStatement to the user, and then c */
    abortStatement?: Statement;
    /** Identifies a specific revision of the $LATEST version. When you create a new bot, leave the checksum field blank. If you specify a checksum you get a BadRequestException exception. When you want to up */
    checksum?: string;
    /** When Amazon Lex doesn't understand the user's intent, it uses this message to get clarification. To specify how many times Amazon Lex should repeat the clarification prompt, use the maxAttempts field. */
    clarificationPrompt?: Prompt;
    /** When set to true a new numbered version of the bot is created. This is the same as calling the CreateBotVersion operation. If you don't specify createVersion, the default is false. */
    createVersion?: boolean;
    /** A description of the bot. */
    description?: string;
    /** When set to true user utterances are sent to Amazon Comprehend for sentiment analysis. If you don't specify detectSentiment, the default is false. */
    detectSentiment?: boolean;
    /** Set to true to enable access to natural language understanding improvements. When you set the enableModelImprovements parameter to true you can use the nluIntentConfidenceThreshold parameter to config */
    enableModelImprovements?: boolean;
    /** The maximum time in seconds that Amazon Lex retains the data gathered in a conversation. A user interaction session remains active for the amount of time specified. If no conversation occurs during th */
    idleSessionTTLInSeconds?: number;
    /** An array of Intent objects. Each intent represents a command that a user can express. For example, a pizza ordering bot might support an OrderPizza intent. For more information, see how-it-works. */
    intents?: Intent[];
    /** Determines the threshold where Amazon Lex will insert the AMAZON.FallbackIntent, AMAZON.KendraSearchIntent, or both when returning alternative intents in a PostContent or PostText response. AMAZON.Fal */
    nluIntentConfidenceThreshold?: number;
    /** If you set the processBehavior element to BUILD, Amazon Lex builds the bot so that it can be run. If you set the element to SAVE Amazon Lex saves the bot, but doesn't build it. If you don't specify th */
    processBehavior?: 'SAVE' | 'BUILD';
    /** A list of tags to add to the bot. You can only add tags when you create a bot, you can't use the PutBot operation to update the tags on a bot. To update tags, use the TagResource operation. */
    tags?: Tag[];
    /** The Amazon Polly voice ID that you want Amazon Lex to use for voice interactions with the user. The locale configured for the voice must match the locale of the bot. For more information, see Voices i */
    voiceId?: string;
}
export interface PutBotAliasInput {
    /** The name of the bot. */
    botName: string;
    /** The version of the bot. */
    botVersion: string;
    /** The name of the alias. The name is not case sensitive. */
    name: string;
    /** Identifies a specific revision of the $LATEST version. When you create a new bot alias, leave the checksum field blank. If you specify a checksum you get a BadRequestException exception. When you want */
    checksum?: string;
    /** Settings for conversation logs for the alias. */
    conversationLogs?: ConversationLogsRequest;
    /** A description of the alias. */
    description?: string;
    /** A list of tags to add to the bot alias. You can only add tags when you create an alias, you can't use the PutBotAlias operation to update the tags on a bot alias. To update tags, use the TagResource o */
    tags?: Tag[];
}
export interface PutIntentInput {
    /** The name of the intent. The name is not case sensitive. The name can't match a built-in intent name, or a built-in intent name with "AMAZON." removed. For example, because there is a built-in intent c */
    name: string;
    /** Identifies a specific revision of the $LATEST version. When you create a new intent, leave the checksum field blank. If you specify a checksum you get a BadRequestException exception. When you want to */
    checksum?: string;
    /** The statement that you want Amazon Lex to convey to the user after the intent is successfully fulfilled by the Lambda function. This element is relevant only if you provide a Lambda function in the fu */
    conclusionStatement?: Statement;
    /** Prompts the user to confirm the intent. This question should have a yes or no answer. Amazon Lex uses this prompt to ensure that the user acknowledges that the intent is ready for fulfillment. For exa */
    confirmationPrompt?: Prompt;
    /** When set to true a new numbered version of the intent is created. This is the same as calling the CreateIntentVersion operation. If you do not specify createVersion, the default is false. */
    createVersion?: boolean;
    /** A description of the intent. */
    description?: string;
    /** Specifies a Lambda function to invoke for each user input. You can invoke this Lambda function to personalize user interaction. For example, suppose your bot determines that the user is John. Your Lam */
    dialogCodeHook?: CodeHook;
    /** Amazon Lex uses this prompt to solicit additional activity after fulfilling an intent. For example, after the OrderPizza intent is fulfilled, you might prompt the user to order a drink. The action tha */
    followUpPrompt?: FollowUpPrompt;
    /** Required. Describes how the intent is fulfilled. For example, after a user provides all of the information for a pizza order, fulfillmentActivity defines how the bot places an order with a local pizza */
    fulfillmentActivity?: FulfillmentActivity;
    /** An array of InputContext objects that lists the contexts that must be active for Amazon Lex to choose the intent in a conversation with the user. */
    inputContexts?: InputContext[];
    /** Configuration information required to use the AMAZON.KendraSearchIntent intent to connect to an Amazon Kendra index. For more information, see AMAZON.KendraSearchIntent. */
    kendraConfiguration?: KendraConfiguration;
    /** An array of OutputContext objects that lists the contexts that the intent activates when the intent is fulfilled. */
    outputContexts?: OutputContext[];
    /** A unique identifier for the built-in intent to base this intent on. To find the signature for an intent, see Standard Built-in Intents in the Alexa Skills Kit. */
    parentIntentSignature?: string;
    /** When the user answers "no" to the question defined in confirmationPrompt, Amazon Lex responds with this statement to acknowledge that the intent was canceled. You must provide both the rejectionStatem */
    rejectionStatement?: Statement;
    /** An array of utterances (strings) that a user might say to signal the intent. For example, "I want {PizzaSize} pizza", "Order {Quantity} {PizzaSize} pizzas". In each utterance, a slot name is enclosed  */
    sampleUtterances?: string[];
    /** An array of intent slots. At runtime, Amazon Lex elicits required slot values from the user using prompts defined in the slots. For more information, see how-it-works. */
    slots?: Slot[];
}
export interface PutSlotTypeInput {
    /** The name of the slot type. The name is not case sensitive. The name can't match a built-in slot type name, or a built-in slot type name with "AMAZON." removed. For example, because there is a built-in */
    name: string;
    /** Identifies a specific revision of the $LATEST version. When you create a new slot type, leave the checksum field blank. If you specify a checksum you get a BadRequestException exception. When you want */
    checksum?: string;
    /** When set to true a new numbered version of the slot type is created. This is the same as calling the CreateSlotTypeVersion operation. If you do not specify createVersion, the default is false. */
    createVersion?: boolean;
    /** A description of the slot type. */
    description?: string;
    /** A list of EnumerationValue objects that defines the values that the slot type can take. Each value can have a list of synonyms, which are additional values that help train the machine learning model a */
    enumerationValues?: EnumerationValue[];
    /** The built-in slot type used as the parent of the slot type. When you define a parent slot type, the new slot type has all of the same configuration as the parent. Only AMAZON.AlphaNumeric is supported */
    parentSlotTypeSignature?: string;
    /** Configuration information that extends the parent built-in slot type. The configuration is added to the settings for the parent slot type. */
    slotTypeConfigurations?: SlotTypeConfiguration[];
    /** Determines the slot resolution strategy that Amazon Lex uses to return slot type values. The field can be set to one of the following values: ORIGINAL_VALUE - Returns the value entered by the user, if */
    valueSelectionStrategy?: 'ORIGINAL_VALUE' | 'TOP_RESOLUTION';
}
export interface StartImportInput {
    /** Specifies the action that the StartImport operation should take when there is an existing resource with the same name. FAIL_ON_CONFLICT - The import operation is stopped on the first conflict between  */
    mergeStrategy: 'OVERWRITE_LATEST' | 'FAIL_ON_CONFLICT';
    /** A zip archive in binary format. The archive should contain one file, a JSON file containing the resource to import. The resource should match the type specified in the resourceType field. */
    payload: string;
    /** Specifies the type of resource to export. Each resource also exports any resources that it depends on. A bot exports dependent intents. An intent exports dependent slot types. */
    resourceType: 'BOT' | 'INTENT' | 'SLOT_TYPE';
    /** A list of tags to add to the imported bot. You can only add tags when you import a bot, you can't add tags to an intent or slot type. */
    tags?: Tag[];
}
export interface StartMigrationInput {
    /** The strategy used to conduct the migration. CREATE_NEW - Creates a new Amazon Lex V2 bot and migrates the Amazon Lex V1 bot to the new bot. UPDATE_EXISTING - Overwrites the existing Amazon Lex V2 bot  */
    migrationStrategy: 'CREATE_NEW' | 'UPDATE_EXISTING';
    /** The name of the Amazon Lex V1 bot that you are migrating to Amazon Lex V2. */
    v1BotName: string;
    /** The version of the bot to migrate to Amazon Lex V2. You can migrate the $LATEST version as well as any numbered version. */
    v1BotVersion: string;
    /** The name of the Amazon Lex V2 bot that you are migrating the Amazon Lex V1 bot to. If the Amazon Lex V2 bot doesn't exist, you must use the CREATE_NEW migration strategy. If the Amazon Lex V2 bot exis */
    v2BotName: string;
    /** The IAM role that Amazon Lex uses to run the Amazon Lex V2 bot. */
    v2BotRole: string;
}
export interface TagResourceInput {
    /** The Amazon Resource Name (ARN) of the bot, bot alias, or bot channel to tag. */
    resourceArn: string;
    /** A list of tag keys to add to the resource. If a tag key already exists, the existing value is replaced with the new value. */
    tags: Tag[];
}
export interface UntagResourceInput {
    /** The Amazon Resource Name (ARN) of the resource to remove the tags from. */
    resourceArn: string;
    /** A list of tag keys to remove from the resource. If a tag key does not exist on the resource, it is ignored. */
    tagKeys: string[];
}
/** Lex Model Building Service service binding for Step Functions SDK integrations. */
export declare class LexModelBuildingService {
    constructor();
    createBotVersion<T>(params: CreateBotVersionInput): Promise<T>;
    createIntentVersion<T>(params: CreateIntentVersionInput): Promise<T>;
    createSlotTypeVersion<T>(params: CreateSlotTypeVersionInput): Promise<T>;
    deleteBot<T>(params: DeleteBotInput): Promise<T>;
    deleteBotAlias<T>(params: DeleteBotAliasInput): Promise<T>;
    deleteBotChannelAssociation<T>(params: DeleteBotChannelAssociationInput): Promise<T>;
    deleteBotVersion<T>(params: DeleteBotVersionInput): Promise<T>;
    deleteIntent<T>(params: DeleteIntentInput): Promise<T>;
    deleteIntentVersion<T>(params: DeleteIntentVersionInput): Promise<T>;
    deleteSlotType<T>(params: DeleteSlotTypeInput): Promise<T>;
    deleteSlotTypeVersion<T>(params: DeleteSlotTypeVersionInput): Promise<T>;
    deleteUtterances<T>(params: DeleteUtterancesInput): Promise<T>;
    getBot<T>(params: GetBotInput): Promise<T>;
    getBotAlias<T>(params: GetBotAliasInput): Promise<T>;
    getBotAliases<T>(params: GetBotAliasesInput): Promise<T>;
    getBotChannelAssociation<T>(params: GetBotChannelAssociationInput): Promise<T>;
    getBotChannelAssociations<T>(params: GetBotChannelAssociationsInput): Promise<T>;
    getBots<T>(params: GetBotsInput): Promise<T>;
    getBotVersions<T>(params: GetBotVersionsInput): Promise<T>;
    getBuiltinIntent<T>(params: GetBuiltinIntentInput): Promise<T>;
    getBuiltinIntents<T>(params: GetBuiltinIntentsInput): Promise<T>;
    getBuiltinSlotTypes<T>(params: GetBuiltinSlotTypesInput): Promise<T>;
    getExport<T>(params: GetExportInput): Promise<T>;
    getImport<T>(params: GetImportInput): Promise<T>;
    getIntent<T>(params: GetIntentInput): Promise<T>;
    getIntents<T>(params: GetIntentsInput): Promise<T>;
    getIntentVersions<T>(params: GetIntentVersionsInput): Promise<T>;
    getMigration<T>(params: GetMigrationInput): Promise<T>;
    getMigrations<T>(params: GetMigrationsInput): Promise<T>;
    getSlotType<T>(params: GetSlotTypeInput): Promise<T>;
    getSlotTypes<T>(params: GetSlotTypesInput): Promise<T>;
    getSlotTypeVersions<T>(params: GetSlotTypeVersionsInput): Promise<T>;
    getUtterancesView<T>(params: GetUtterancesViewInput): Promise<T>;
    listTagsForResource<T>(params: ListTagsForResourceInput): Promise<T>;
    putBot<T>(params: PutBotInput): Promise<T>;
    putBotAlias<T>(params: PutBotAliasInput): Promise<T>;
    putIntent<T>(params: PutIntentInput): Promise<T>;
    putSlotType<T>(params: PutSlotTypeInput): Promise<T>;
    startImport<T>(params: StartImportInput): Promise<T>;
    startMigration<T>(params: StartMigrationInput): Promise<T>;
    tagResource<T>(params: TagResourceInput): Promise<T>;
    untagResource<T>(params: UntagResourceInput): Promise<T>;
}
//# sourceMappingURL=LexModelBuildingService.d.ts.map