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

package/commands/DeleteIntentVersionCommand.ts

@@ -1,101 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { DeleteIntentVersionRequest } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteIntentVersionCommand,
-  serializeAws_restJson1DeleteIntentVersionCommand,
-} 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 DeleteIntentVersionCommandInput extends DeleteIntentVersionRequest {}
-export interface DeleteIntentVersionCommandOutput extends __MetadataBearer {}
-
-/**
- * <p>Deletes a specific version of an intent. To delete all versions of
- *       a intent, use the <a>DeleteIntent</a> operation. </p>
- *          <p>This operation requires permissions for the
- *         <code>lex:DeleteIntentVersion</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexModelBuildingServiceClient, DeleteIntentVersionCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
- * // const { LexModelBuildingServiceClient, DeleteIntentVersionCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
- * const client = new LexModelBuildingServiceClient(config);
- * const command = new DeleteIntentVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteIntentVersionCommandInput} for command's `input` shape.
- * @see {@link DeleteIntentVersionCommandOutput} for command's `response` shape.
- * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteIntentVersionCommand extends $Command<
-  DeleteIntentVersionCommandInput,
-  DeleteIntentVersionCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteIntentVersionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteIntentVersionCommandInput, DeleteIntentVersionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "DeleteIntentVersionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteIntentVersionRequest.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: DeleteIntentVersionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteIntentVersionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteIntentVersionCommandOutput> {
-    return deserializeAws_restJson1DeleteIntentVersionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteSlotTypeCommand.ts

@@ -1,114 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { DeleteSlotTypeRequest } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteSlotTypeCommand,
-  serializeAws_restJson1DeleteSlotTypeCommand,
-} 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 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 class DeleteSlotTypeCommand extends $Command<
-  DeleteSlotTypeCommandInput,
-  DeleteSlotTypeCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteSlotTypeCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteSlotTypeCommandInput, DeleteSlotTypeCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "DeleteSlotTypeCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteSlotTypeRequest.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: DeleteSlotTypeCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteSlotTypeCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteSlotTypeCommandOutput> {
-    return deserializeAws_restJson1DeleteSlotTypeCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteSlotTypeVersionCommand.ts

@@ -1,101 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { DeleteSlotTypeVersionRequest } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteSlotTypeVersionCommand,
-  serializeAws_restJson1DeleteSlotTypeVersionCommand,
-} 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 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 class DeleteSlotTypeVersionCommand extends $Command<
-  DeleteSlotTypeVersionCommandInput,
-  DeleteSlotTypeVersionCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteSlotTypeVersionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteSlotTypeVersionCommandInput, DeleteSlotTypeVersionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "DeleteSlotTypeVersionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteSlotTypeVersionRequest.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: DeleteSlotTypeVersionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteSlotTypeVersionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteSlotTypeVersionCommandOutput> {
-    return deserializeAws_restJson1DeleteSlotTypeVersionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteUtterancesCommand.ts

@@ -1,109 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { DeleteUtterancesRequest } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteUtterancesCommand,
-  serializeAws_restJson1DeleteUtterancesCommand,
-} 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 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 class DeleteUtterancesCommand extends $Command<
-  DeleteUtterancesCommandInput,
-  DeleteUtterancesCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteUtterancesCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteUtterancesCommandInput, DeleteUtterancesCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "DeleteUtterancesCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteUtterancesRequest.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: DeleteUtterancesCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteUtterancesCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteUtterancesCommandOutput> {
-    return deserializeAws_restJson1DeleteUtterancesCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/GetBotAliasCommand.ts

@@ -1,101 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { GetBotAliasRequest, GetBotAliasResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1GetBotAliasCommand,
-  serializeAws_restJson1GetBotAliasCommand,
-} 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 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 class GetBotAliasCommand extends $Command<
-  GetBotAliasCommandInput,
-  GetBotAliasCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: GetBotAliasCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<GetBotAliasCommandInput, GetBotAliasCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "GetBotAliasCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: GetBotAliasRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: GetBotAliasResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: GetBotAliasCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1GetBotAliasCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetBotAliasCommandOutput> {
-    return deserializeAws_restJson1GetBotAliasCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/GetBotAliasesCommand.ts

@@ -1,100 +0,0 @@
-import {
-  LexModelBuildingServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexModelBuildingServiceClient";
-import { GetBotAliasesRequest, GetBotAliasesResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1GetBotAliasesCommand,
-  serializeAws_restJson1GetBotAliasesCommand,
-} 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 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 class GetBotAliasesCommand extends $Command<
-  GetBotAliasesCommandInput,
-  GetBotAliasesCommandOutput,
-  LexModelBuildingServiceClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: GetBotAliasesCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexModelBuildingServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<GetBotAliasesCommandInput, GetBotAliasesCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexModelBuildingServiceClient";
-    const commandName = "GetBotAliasesCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: GetBotAliasesRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: GetBotAliasesResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: GetBotAliasesCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1GetBotAliasesCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetBotAliasesCommandOutput> {
-    return deserializeAws_restJson1GetBotAliasesCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}