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

package/commands/CreateSlotTypeVersionCommand.ts

@@ -1,113 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { CreateSlotTypeVersionRequest, CreateSlotTypeVersionResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateSlotTypeVersionCommand,
-  serializeAws_restJson1CreateSlotTypeVersionCommand,
-} from "../protocols/Aws_restJson1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateSlotTypeVersionCommandInput extends CreateSlotTypeVersionRequest {}
-export interface CreateSlotTypeVersionCommandOutput extends CreateSlotTypeVersionResponse, __MetadataBearer {}
-
-/**
- * <p>Creates a new version of a slot type based on the
- *         <code>$LATEST</code> version of the specified slot type. If the
- *         <code>$LATEST</code> version of this resource has not changed since the
- *       last version that you created, Amazon Lex doesn't create a new version. It
- *       returns the last version that you created. </p>
- *          <note>
- *             <p>You can update only the <code>$LATEST</code> version of a slot
- *         type. You can't update the numbered versions that you create with the
- *           <code>CreateSlotTypeVersion</code> operation.</p>
- *          </note>
- *
- *          <p>When you create a version of a slot type, Amazon Lex sets the version to
- *       1. Subsequent versions increment by 1. For more information, see <a>versioning-intro</a>. </p>
- *
- *          <p>This operation requires permissions for the
- *         <code>lex:CreateSlotTypeVersion</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, CreateSlotTypeVersionCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, CreateSlotTypeVersionCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new CreateSlotTypeVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSlotTypeVersionCommandInput} for command's `input` shape.
- * @see {@link CreateSlotTypeVersionCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateSlotTypeVersionCommand extends $Command<
-  CreateSlotTypeVersionCommandInput,
-  CreateSlotTypeVersionCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateSlotTypeVersionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateSlotTypeVersionCommandInput, CreateSlotTypeVersionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "CreateSlotTypeVersionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateSlotTypeVersionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateSlotTypeVersionResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateSlotTypeVersionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateSlotTypeVersionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateSlotTypeVersionCommandOutput> {
-    return deserializeAws_restJson1CreateSlotTypeVersionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteBotAliasCommand.ts

@@ -1,106 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { DeleteBotAliasRequest } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteBotAliasCommand,
-  serializeAws_restJson1DeleteBotAliasCommand,
-} from "../protocols/Aws_restJson1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface DeleteBotAliasCommandInput extends DeleteBotAliasRequest {}
-export interface DeleteBotAliasCommandOutput extends __MetadataBearer {}
-
-/**
- * <p>Deletes an alias for the specified bot. </p>
- *          <p>You can't delete an alias that is used in the association between a
- *       bot and a messaging channel. If an alias is used in a channel association,
- *       the <code>DeleteBot</code> operation returns a
- *         <code>ResourceInUseException</code> exception that includes a reference
- *       to the channel association that refers to the bot. You can remove the
- *       reference to the alias by deleting the channel association. If you get the
- *       same exception again, delete the referring association until the
- *         <code>DeleteBotAlias</code> operation is successful.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, DeleteBotAliasCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, DeleteBotAliasCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new DeleteBotAliasCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBotAliasCommandInput} for command's `input` shape.
- * @see {@link DeleteBotAliasCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteBotAliasCommand extends $Command<
-  DeleteBotAliasCommandInput,
-  DeleteBotAliasCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteBotAliasCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteBotAliasCommandInput, DeleteBotAliasCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "DeleteBotAliasCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteBotAliasRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteBotAliasCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteBotAliasCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteBotAliasCommandOutput> {
-    return deserializeAws_restJson1DeleteBotAliasCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteBotChannelAssociationCommand.ts

@@ -1,104 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { DeleteBotChannelAssociationRequest } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteBotChannelAssociationCommand,
-  serializeAws_restJson1DeleteBotChannelAssociationCommand,
-} from "../protocols/Aws_restJson1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface DeleteBotChannelAssociationCommandInput extends DeleteBotChannelAssociationRequest {}
-export interface DeleteBotChannelAssociationCommandOutput extends __MetadataBearer {}
-
-/**
- * <p>Deletes the association between an Amazon Lex bot and a messaging
- *       platform.</p>
- *          <p>This operation requires permission for the
- *         <code>lex:DeleteBotChannelAssociation</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, DeleteBotChannelAssociationCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, DeleteBotChannelAssociationCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new DeleteBotChannelAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBotChannelAssociationCommandInput} for command's `input` shape.
- * @see {@link DeleteBotChannelAssociationCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteBotChannelAssociationCommand extends $Command<
-  DeleteBotChannelAssociationCommandInput,
-  DeleteBotChannelAssociationCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteBotChannelAssociationCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteBotChannelAssociationCommandInput, DeleteBotChannelAssociationCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "DeleteBotChannelAssociationCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteBotChannelAssociationRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteBotChannelAssociationCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteBotChannelAssociationCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<DeleteBotChannelAssociationCommandOutput> {
-    return deserializeAws_restJson1DeleteBotChannelAssociationCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteBotCommand.ts

@@ -1,114 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { DeleteBotRequest } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteBotCommand,
-  serializeAws_restJson1DeleteBotCommand,
-} from "../protocols/Aws_restJson1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface DeleteBotCommandInput extends DeleteBotRequest {}
-export interface DeleteBotCommandOutput extends __MetadataBearer {}
-
-/**
- * <p>Deletes all versions of the bot, including the <code>$LATEST</code>
- *       version. To delete a specific version of the bot, use the <a>DeleteBotVersion</a> operation. The <code>DeleteBot</code>
- *       operation doesn't immediately remove the bot schema. Instead, it is marked
- *       for deletion and removed later.</p>
- *          <p>Amazon Lex stores utterances indefinitely for improving the ability of
- *       your bot to respond to user inputs. These utterances are not removed when
- *       the bot is deleted. To remove the utterances, use the <a>DeleteUtterances</a> operation.</p>
- *          <p>If a bot has an alias, you can't delete it. Instead, the
- *         <code>DeleteBot</code> operation returns a
- *         <code>ResourceInUseException</code> exception that includes a reference
- *       to the alias that refers to the bot. To remove the reference to the bot,
- *       delete the alias. If you get the same exception again, delete the
- *       referring alias until the <code>DeleteBot</code> operation is
- *       successful.</p>
- *
- *          <p>This operation requires permissions for the
- *         <code>lex:DeleteBot</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, DeleteBotCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, DeleteBotCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new DeleteBotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBotCommandInput} for command's `input` shape.
- * @see {@link DeleteBotCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteBotCommand extends $Command<
-  DeleteBotCommandInput,
-  DeleteBotCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteBotCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteBotCommandInput, DeleteBotCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "DeleteBotCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteBotRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteBotCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteBotCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteBotCommandOutput> {
-    return deserializeAws_restJson1DeleteBotCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteBotVersionCommand.ts

@@ -1,101 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { DeleteBotVersionRequest } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteBotVersionCommand,
-  serializeAws_restJson1DeleteBotVersionCommand,
-} from "../protocols/Aws_restJson1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface DeleteBotVersionCommandInput extends DeleteBotVersionRequest {}
-export interface DeleteBotVersionCommandOutput extends __MetadataBearer {}
-
-/**
- * <p>Deletes a specific version of a bot. To delete all versions of a
- *       bot, use the <a>DeleteBot</a> operation. </p>
- *          <p>This operation requires permissions for the
- *         <code>lex:DeleteBotVersion</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, DeleteBotVersionCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, DeleteBotVersionCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new DeleteBotVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBotVersionCommandInput} for command's `input` shape.
- * @see {@link DeleteBotVersionCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteBotVersionCommand extends $Command<
-  DeleteBotVersionCommandInput,
-  DeleteBotVersionCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteBotVersionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteBotVersionCommandInput, DeleteBotVersionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "DeleteBotVersionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteBotVersionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteBotVersionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteBotVersionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteBotVersionCommandOutput> {
-    return deserializeAws_restJson1DeleteBotVersionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteIntentCommand.ts

@@ -1,115 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { DeleteIntentRequest } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteIntentCommand,
-  serializeAws_restJson1DeleteIntentCommand,
-} from "../protocols/Aws_restJson1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface DeleteIntentCommandInput extends DeleteIntentRequest {}
-export interface DeleteIntentCommandOutput extends __MetadataBearer {}
-
-/**
- * <p>Deletes all versions of the intent, including the
- *         <code>$LATEST</code> version. To delete a specific version of the
- *       intent, use the <a>DeleteIntentVersion</a> operation.</p>
- *          <p> You can delete a version of an intent only if it is not
- *       referenced. To delete an intent that is referred to in one or more bots
- *       (see <a>how-it-works</a>), you must remove those references
- *       first. </p>
- *          <note>
- *             <p> If you get the <code>ResourceInUseException</code> exception, it
- *         provides an example reference that shows where the intent is referenced.
- *         To remove the reference to the intent, either update the bot or delete
- *         it. If you get the same exception when you attempt to delete the intent
- *         again, repeat until the intent has no references and the call to
- *           <code>DeleteIntent</code> is successful. </p>
- *          </note>
- *
- *          <p> This operation requires permission for the
- *         <code>lex:DeleteIntent</code> action. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, DeleteIntentCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, DeleteIntentCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new DeleteIntentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteIntentCommandInput} for command's `input` shape.
- * @see {@link DeleteIntentCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteIntentCommand extends $Command<
-  DeleteIntentCommandInput,
-  DeleteIntentCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteIntentCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteIntentCommandInput, DeleteIntentCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "DeleteIntentCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteIntentRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteIntentCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteIntentCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteIntentCommandOutput> {
-    return deserializeAws_restJson1DeleteIntentCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}