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

package/dist/types/commands/GetIntentCommand.d.ts

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

package/dist/types/commands/GetIntentVersionsCommand.d.ts

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

package/dist/types/commands/GetIntentsCommand.d.ts

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

package/dist/types/commands/GetMigrationCommand.d.ts

@@ -1,37 +0,0 @@
-import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
-import { GetMigrationRequest, GetMigrationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetMigrationCommandInput extends GetMigrationRequest {
-}
-export interface GetMigrationCommandOutput extends GetMigrationResponse, __MetadataBearer {
-}
-/**
- * <p>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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, GetMigrationCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, GetMigrationCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new GetMigrationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetMigrationCommandInput} for command's `input` shape.
- * @see {@link GetMigrationCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetMigrationCommand extends $Command<GetMigrationCommandInput, GetMigrationCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
-    readonly input: GetMigrationCommandInput;
-    constructor(input: GetMigrationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMigrationCommandInput, GetMigrationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/GetMigrationsCommand.d.ts

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

package/dist/types/commands/GetSlotTypeCommand.d.ts

@@ -1,39 +0,0 @@
-import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
-import { GetSlotTypeRequest, GetSlotTypeResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetSlotTypeCommandInput extends GetSlotTypeRequest {
-}
-export interface GetSlotTypeCommandOutput extends GetSlotTypeResponse, __MetadataBearer {
-}
-/**
- * <p>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.</p>
- *          <p>This operation requires permissions for the
- *         <code>lex:GetSlotType</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, GetSlotTypeCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, GetSlotTypeCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new GetSlotTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSlotTypeCommandInput} for command's `input` shape.
- * @see {@link GetSlotTypeCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetSlotTypeCommand extends $Command<GetSlotTypeCommandInput, GetSlotTypeCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
-    readonly input: GetSlotTypeCommandInput;
-    constructor(input: GetSlotTypeCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSlotTypeCommandInput, GetSlotTypeCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/GetSlotTypeVersionsCommand.d.ts

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

package/dist/types/commands/GetSlotTypesCommand.d.ts

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

package/dist/types/commands/GetUtterancesViewCommand.d.ts

@@ -1,58 +0,0 @@
-import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
-import { GetUtterancesViewRequest, GetUtterancesViewResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetUtterancesViewCommandInput extends GetUtterancesViewRequest {
-}
-export interface GetUtterancesViewCommandOutput extends GetUtterancesViewResponse, __MetadataBearer {
-}
-/**
- * <p>Use the <code>GetUtterancesView</code> 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.</p>
- *          <p>For example, say that you have created a bot to order flowers.
- *       After your users have used your bot for a while, use the
- *         <code>GetUtterancesView</code> 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 <code>OrderFlowers</code> intent so that your bot
- *       recognizes that utterance.</p>
- *          <p>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. </p>
- *          <p>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.</p>
- *          <p>If you set <code>childDirected</code> 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.</p>
- *          <p>This operation requires permissions for the
- *         <code>lex:GetUtterancesView</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, GetUtterancesViewCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, GetUtterancesViewCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new GetUtterancesViewCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetUtterancesViewCommandInput} for command's `input` shape.
- * @see {@link GetUtterancesViewCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetUtterancesViewCommand extends $Command<GetUtterancesViewCommandInput, GetUtterancesViewCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
-    readonly input: GetUtterancesViewCommandInput;
-    constructor(input: GetUtterancesViewCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUtterancesViewCommandInput, GetUtterancesViewCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/ListTagsForResourceCommand.d.ts

@@ -1,36 +0,0 @@
-import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
-import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
-}
-export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
-}
-/**
- * <p>Gets a list of tags associated with the specified resource. Only bots,
- *       bot aliases, and bot channels can have tags associated with them.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, ListTagsForResourceCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, ListTagsForResourceCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
-    readonly input: ListTagsForResourceCommandInput;
-    constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/PutBotAliasCommand.d.ts

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

package/dist/types/commands/PutBotCommand.d.ts

@@ -1,52 +0,0 @@
-import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
-import { PutBotRequest, PutBotResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutBotCommandInput extends PutBotRequest {
-}
-export interface PutBotCommandOutput extends PutBotResponse, __MetadataBearer {
-}
-/**
- * <p>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 <code></code> response
- *         <code>FAILED</code>. You can build the bot after you add one or more
- *       intents. For more information about Amazon Lex bots, see <a>how-it-works</a>. </p>
- *          <p>If you specify the name of an existing bot, the fields in the
- *       request replace the existing values in the <code>$LATEST</code> version of
- *       the bot. Amazon Lex removes any fields that you don't provide values for in the
- *       request, except for the <code>idleTTLInSeconds</code> and
- *         <code>privacySettings</code> fields, which are set to their default
- *       values. If you don't specify values for required fields, Amazon Lex throws an
- *       exception.</p>
- *
- *          <p>This operation requires permissions for the <code>lex:PutBot</code>
- *       action. For more information, see <a>security-iam</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, PutBotCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, PutBotCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new PutBotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutBotCommandInput} for command's `input` shape.
- * @see {@link PutBotCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutBotCommand extends $Command<PutBotCommandInput, PutBotCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
-    readonly input: PutBotCommandInput;
-    constructor(input: PutBotCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutBotCommandInput, PutBotCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/PutIntentCommand.d.ts

@@ -1,92 +0,0 @@
-import { LexModelBuildingServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexModelBuildingServiceClient";
-import { PutIntentRequest, PutIntentResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutIntentCommandInput extends PutIntentRequest {
-}
-export interface PutIntentCommandOutput extends PutIntentResponse, __MetadataBearer {
-}
-/**
- * <p>Creates an intent or replaces an existing intent.</p>
- *          <p>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 <code>OrderPizza</code> intent. </p>
- *          <p>To create an intent or replace an existing intent, you must provide
- *       the following:</p>
- *          <ul>
- *             <li>
- *                <p>Intent name. For example, <code>OrderPizza</code>.</p>
- *             </li>
- *             <li>
- *                <p>Sample utterances. For example, "Can I order a pizza, please."
- *           and "I want to order a pizza."</p>
- *             </li>
- *             <li>
- *                <p>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.</p>
- *             </li>
- *             <li>
- *                <p>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. </p>
- *             </li>
- *          </ul>
- *          <p>You can specify other optional information in the request, such
- *       as:</p>
- *
- *          <ul>
- *             <li>
- *                <p>A confirmation prompt to ask the user to confirm an intent. For
- *           example, "Shall I order your pizza?"</p>
- *             </li>
- *             <li>
- *                <p>A conclusion statement to send to the user after the intent has
- *           been fulfilled. For example, "I placed your pizza order."</p>
- *             </li>
- *             <li>
- *                <p>A follow-up prompt that asks the user for additional activity.
- *           For example, asking "Do you want to order a drink with your
- *           pizza?"</p>
- *             </li>
- *          </ul>
- *          <p>If you specify an existing intent name to update the intent, Amazon Lex
- *       replaces the values in the <code>$LATEST</code> 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 <code>$LATEST</code> version of an intent,
- *       the <code>status</code> field of any bot that uses the
- *         <code>$LATEST</code> version of the intent is set to
- *         <code>NOT_BUILT</code>.</p>
- *          <p>For more information, see <a>how-it-works</a>.</p>
- *          <p>This operation requires permissions for the
- *         <code>lex:PutIntent</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, PutIntentCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, PutIntentCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new PutIntentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutIntentCommandInput} for command's `input` shape.
- * @see {@link PutIntentCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutIntentCommand extends $Command<PutIntentCommandInput, PutIntentCommandOutput, LexModelBuildingServiceClientResolvedConfig> {
-    readonly input: PutIntentCommandInput;
-    constructor(input: PutIntentCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexModelBuildingServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutIntentCommandInput, PutIntentCommandOutput>;
-    private serialize;
-    private deserialize;
-}