@aws-sdk/client-lex-model-building-service 3.31.0 → 3.35.0

package/dist-types/ts3.4/commands/DeleteSlotTypeCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { DeleteSlotTypeRequest } from "../models/models_0";
+export interface DeleteSlotTypeCommandInput extends DeleteSlotTypeRequest {
+}
+export interface DeleteSlotTypeCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes all versions of the slot type, including the
+ *         <code>$LATEST</code> version. To delete a specific version of the slot
+ *       type, use the <a>DeleteSlotTypeVersion</a> operation.</p>
+ *          <p> 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. </p>
+ *          <note>
+ *             <p> If you get the <code>ResourceInUseException</code> 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 <code>DeleteSlotType</code> call is
+ *         successful. </p>
+ *          </note>
+ *          <p>This operation requires permission for the
+ *         <code>lex:DeleteSlotType</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, DeleteSlotTypeCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, DeleteSlotTypeCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new DeleteSlotTypeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSlotTypeCommandInput} for command's `input` shape.
+ * @see {@link DeleteSlotTypeCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteSlotTypeCommand extends $Command<DeleteSlotTypeCommandInput, DeleteSlotTypeCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: DeleteSlotTypeCommandInput;
+    constructor(input: DeleteSlotTypeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSlotTypeCommandInput, DeleteSlotTypeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteSlotTypeVersionCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { DeleteSlotTypeVersionRequest } from "../models/models_0";
+export interface DeleteSlotTypeVersionCommandInput extends DeleteSlotTypeVersionRequest {
+}
+export interface DeleteSlotTypeVersionCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes a specific version of a slot type. To delete all versions
+ *       of a slot type, use the <a>DeleteSlotType</a> operation. </p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:DeleteSlotTypeVersion</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, DeleteSlotTypeVersionCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, DeleteSlotTypeVersionCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new DeleteSlotTypeVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSlotTypeVersionCommandInput} for command's `input` shape.
+ * @see {@link DeleteSlotTypeVersionCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteSlotTypeVersionCommand extends $Command<DeleteSlotTypeVersionCommandInput, DeleteSlotTypeVersionCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: DeleteSlotTypeVersionCommandInput;
+    constructor(input: DeleteSlotTypeVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSlotTypeVersionCommandInput, DeleteSlotTypeVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteUtterancesCommand.d.ts

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { DeleteUtterancesRequest } from "../models/models_0";
+export interface DeleteUtterancesCommandInput extends DeleteUtterancesRequest {
+}
+export interface DeleteUtterancesCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes stored utterances.</p>
+ *          <p>Amazon Lex stores the utterances that users send to your bot. Utterances
+ *       are stored for 15 days for use with the <a>GetUtterancesView</a> operation, and then stored indefinitely for use in improving the
+ *       ability of your bot to respond to user input.</p>
+ *          <p>Use the <code>DeleteUtterances</code> operation to manually delete
+ *       stored utterances for a specific user. When you use the
+ *         <code>DeleteUtterances</code> operation, utterances stored for improving
+ *       your bot's ability to respond to user input are deleted immediately.
+ *       Utterances stored for use with the <code>GetUtterancesView</code>
+ *       operation are deleted after 15 days.</p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:DeleteUtterances</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, DeleteUtterancesCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, DeleteUtterancesCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new DeleteUtterancesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteUtterancesCommandInput} for command's `input` shape.
+ * @see {@link DeleteUtterancesCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteUtterancesCommand extends $Command<DeleteUtterancesCommandInput, DeleteUtterancesCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: DeleteUtterancesCommandInput;
+    constructor(input: DeleteUtterancesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteUtterancesCommandInput, DeleteUtterancesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetBotAliasCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetBotAliasRequest, GetBotAliasResponse } from "../models/models_0";
+export interface GetBotAliasCommandInput extends GetBotAliasRequest {
+}
+export interface GetBotAliasCommandOutput extends GetBotAliasResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about an Amazon Lex bot alias. For more information
+ *       about aliases, see <a>versioning-aliases</a>.</p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:GetBotAlias</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotAliasCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotAliasCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotAliasCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotAliasCommandInput} for command's `input` shape.
+ * @see {@link GetBotAliasCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBotAliasCommand extends $Command<GetBotAliasCommandInput, GetBotAliasCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetBotAliasCommandInput;
+    constructor(input: GetBotAliasCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBotAliasCommandInput, GetBotAliasCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetBotAliasesCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetBotAliasesRequest, GetBotAliasesResponse } from "../models/models_0";
+export interface GetBotAliasesCommandInput extends GetBotAliasesRequest {
+}
+export interface GetBotAliasesCommandOutput extends GetBotAliasesResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of aliases for a specified Amazon Lex bot.</p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:GetBotAliases</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotAliasesCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotAliasesCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotAliasesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotAliasesCommandInput} for command's `input` shape.
+ * @see {@link GetBotAliasesCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBotAliasesCommand extends $Command<GetBotAliasesCommandInput, GetBotAliasesCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetBotAliasesCommandInput;
+    constructor(input: GetBotAliasesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBotAliasesCommandInput, GetBotAliasesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetBotChannelAssociationCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetBotChannelAssociationRequest, GetBotChannelAssociationResponse } from "../models/models_0";
+export interface GetBotChannelAssociationCommandInput extends GetBotChannelAssociationRequest {
+}
+export interface GetBotChannelAssociationCommandOutput extends GetBotChannelAssociationResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about the association between an Amazon Lex bot and
+ *       a messaging platform.</p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:GetBotChannelAssociation</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotChannelAssociationCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotChannelAssociationCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotChannelAssociationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotChannelAssociationCommandInput} for command's `input` shape.
+ * @see {@link GetBotChannelAssociationCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBotChannelAssociationCommand extends $Command<GetBotChannelAssociationCommandInput, GetBotChannelAssociationCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetBotChannelAssociationCommandInput;
+    constructor(input: GetBotChannelAssociationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBotChannelAssociationCommandInput, GetBotChannelAssociationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetBotChannelAssociationsCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetBotChannelAssociationsRequest, GetBotChannelAssociationsResponse } from "../models/models_0";
+export interface GetBotChannelAssociationsCommandInput extends GetBotChannelAssociationsRequest {
+}
+export interface GetBotChannelAssociationsCommandOutput extends GetBotChannelAssociationsResponse, __MetadataBearer {
+}
+/**
+ * <p> Returns a list of all of the channels associated with the
+ *       specified bot. </p>
+ *          <p>The <code>GetBotChannelAssociations</code> operation requires
+ *       permissions for the <code>lex:GetBotChannelAssociations</code>
+ *       action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotChannelAssociationsCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotChannelAssociationsCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotChannelAssociationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotChannelAssociationsCommandInput} for command's `input` shape.
+ * @see {@link GetBotChannelAssociationsCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBotChannelAssociationsCommand extends $Command<GetBotChannelAssociationsCommandInput, GetBotChannelAssociationsCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetBotChannelAssociationsCommandInput;
+    constructor(input: GetBotChannelAssociationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBotChannelAssociationsCommandInput, GetBotChannelAssociationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetBotCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetBotRequest, GetBotResponse } from "../models/models_0";
+export interface GetBotCommandInput extends GetBotRequest {
+}
+export interface GetBotCommandOutput extends GetBotResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns metadata information for a specific bot. You must provide
+ *       the bot name and the bot version or alias. </p>
+ *          <p> This operation requires permissions for the
+ *         <code>lex:GetBot</code> action. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotCommandInput} for command's `input` shape.
+ * @see {@link GetBotCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBotCommand extends $Command<GetBotCommandInput, GetBotCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetBotCommandInput;
+    constructor(input: GetBotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBotCommandInput, GetBotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetBotVersionsCommand.d.ts

@@ -0,0 +1,45 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetBotVersionsRequest, GetBotVersionsResponse } from "../models/models_0";
+export interface GetBotVersionsCommandInput extends GetBotVersionsRequest {
+}
+export interface GetBotVersionsCommandOutput extends GetBotVersionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets information about all of the versions of a bot.</p>
+ *          <p>The <code>GetBotVersions</code> operation returns a
+ *         <code>BotMetadata</code> object for each version of a bot. For example,
+ *       if a bot has three numbered versions, the <code>GetBotVersions</code>
+ *       operation returns four <code>BotMetadata</code> objects in the response,
+ *       one for each numbered version and one for the <code>$LATEST</code>
+ *       version. </p>
+ *          <p>The <code>GetBotVersions</code> operation always returns at least
+ *       one version, the <code>$LATEST</code> version.</p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:GetBotVersions</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotVersionsCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotVersionsCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotVersionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotVersionsCommandInput} for command's `input` shape.
+ * @see {@link GetBotVersionsCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBotVersionsCommand extends $Command<GetBotVersionsCommandInput, GetBotVersionsCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetBotVersionsCommandInput;
+    constructor(input: GetBotVersionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBotVersionsCommandInput, GetBotVersionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetBotsCommand.d.ts

@@ -0,0 +1,49 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetBotsRequest, GetBotsResponse } from "../models/models_0";
+export interface GetBotsCommandInput extends GetBotsRequest {
+}
+export interface GetBotsCommandOutput extends GetBotsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns bot information as follows: </p>
+ *          <ul>
+ *             <li>
+ *                <p>If you provide the <code>nameContains</code> field, the
+ *           response includes information for the <code>$LATEST</code> version of
+ *           all bots whose name contains the specified string.</p>
+ *             </li>
+ *             <li>
+ *                <p>If you don't specify the <code>nameContains</code> field, the
+ *           operation returns information about the <code>$LATEST</code> version
+ *           of all of your bots.</p>
+ *             </li>
+ *          </ul>
+ *          <p>This operation requires permission for the <code>lex:GetBots</code>
+ *       action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotsCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotsCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotsCommandInput} for command's `input` shape.
+ * @see {@link GetBotsCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBotsCommand extends $Command<GetBotsCommandInput, GetBotsCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetBotsCommandInput;
+    constructor(input: GetBotsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBotsCommandInput, GetBotsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetBuiltinIntentCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetBuiltinIntentRequest, GetBuiltinIntentResponse } from "../models/models_0";
+export interface GetBuiltinIntentCommandInput extends GetBuiltinIntentRequest {
+}
+export interface GetBuiltinIntentCommandOutput extends GetBuiltinIntentResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a built-in intent.</p>
+ *          <p>This operation requires permission for the
+ *         <code>lex:GetBuiltinIntent</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBuiltinIntentCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBuiltinIntentCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBuiltinIntentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBuiltinIntentCommandInput} for command's `input` shape.
+ * @see {@link GetBuiltinIntentCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBuiltinIntentCommand extends $Command<GetBuiltinIntentCommandInput, GetBuiltinIntentCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetBuiltinIntentCommandInput;
+    constructor(input: GetBuiltinIntentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBuiltinIntentCommandInput, GetBuiltinIntentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetBuiltinIntentsCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetBuiltinIntentsRequest, GetBuiltinIntentsResponse } from "../models/models_0";
+export interface GetBuiltinIntentsCommandInput extends GetBuiltinIntentsRequest {
+}
+export interface GetBuiltinIntentsCommandOutput extends GetBuiltinIntentsResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a list of built-in intents that meet the specified
+ *       criteria.</p>
+ *          <p>This operation requires permission for the
+ *         <code>lex:GetBuiltinIntents</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBuiltinIntentsCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBuiltinIntentsCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBuiltinIntentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBuiltinIntentsCommandInput} for command's `input` shape.
+ * @see {@link GetBuiltinIntentsCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBuiltinIntentsCommand extends $Command<GetBuiltinIntentsCommandInput, GetBuiltinIntentsCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetBuiltinIntentsCommandInput;
+    constructor(input: GetBuiltinIntentsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBuiltinIntentsCommandInput, GetBuiltinIntentsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetBuiltinSlotTypesCommand.d.ts

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetBuiltinSlotTypesRequest, GetBuiltinSlotTypesResponse } from "../models/models_0";
+export interface GetBuiltinSlotTypesCommandInput extends GetBuiltinSlotTypesRequest {
+}
+export interface GetBuiltinSlotTypesCommandOutput extends GetBuiltinSlotTypesResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a list of built-in slot types that meet the specified
+ *       criteria.</p>
+ *          <p>For a list of built-in slot types, see <a href="https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/built-in-intent-ref/slot-type-reference">Slot Type Reference</a> in the <i>Alexa Skills
+ *         Kit</i>.</p>
+ *
+ *          <p>This operation requires permission for the
+ *         <code>lex:GetBuiltInSlotTypes</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBuiltinSlotTypesCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBuiltinSlotTypesCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBuiltinSlotTypesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBuiltinSlotTypesCommandInput} for command's `input` shape.
+ * @see {@link GetBuiltinSlotTypesCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBuiltinSlotTypesCommand extends $Command<GetBuiltinSlotTypesCommandInput, GetBuiltinSlotTypesCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetBuiltinSlotTypesCommandInput;
+    constructor(input: GetBuiltinSlotTypesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBuiltinSlotTypesCommandInput, GetBuiltinSlotTypesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetExportCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetExportRequest, GetExportResponse } from "../models/models_0";
+export interface GetExportCommandInput extends GetExportRequest {
+}
+export interface GetExportCommandOutput extends GetExportResponse, __MetadataBearer {
+}
+/**
+ * <p>Exports the contents of a Amazon Lex resource in a specified format.
+ *     </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetExportCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetExportCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetExportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetExportCommandInput} for command's `input` shape.
+ * @see {@link GetExportCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetExportCommand extends $Command<GetExportCommandInput, GetExportCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetExportCommandInput;
+    constructor(input: GetExportCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetExportCommandInput, GetExportCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetImportCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
+import { GetImportRequest, GetImportResponse } from "../models/models_0";
+export interface GetImportCommandInput extends GetImportRequest {
+}
+export interface GetImportCommandOutput extends GetImportResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets information about an import job started with the
+ *         <code>StartImport</code> operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetImportCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetImportCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetImportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetImportCommandInput} for command's `input` shape.
+ * @see {@link GetImportCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetImportCommand extends $Command<GetImportCommandInput, GetImportCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
+    readonly input: GetImportCommandInput;
+    constructor(input: GetImportCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetImportCommandInput, GetImportCommandOutput>;
+    private serialize;
+    private deserialize;
+}