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

package/src/commands/DeleteIntentVersionCommand.ts

@@ -0,0 +1,102 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import {
+  LexModelBuildingServiceClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LexModelBuildingServiceClient";
+import { DeleteIntentVersionRequest } from "../models/models_0";
+import {
+  deserializeAws_restJson1DeleteIntentVersionCommand,
+  serializeAws_restJson1DeleteIntentVersionCommand,
+} from "../protocols/Aws_restJson1";
+
+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/src/commands/DeleteSlotTypeCommand.ts

@@ -0,0 +1,115 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import {
+  LexModelBuildingServiceClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LexModelBuildingServiceClient";
+import { DeleteSlotTypeRequest } from "../models/models_0";
+import {
+  deserializeAws_restJson1DeleteSlotTypeCommand,
+  serializeAws_restJson1DeleteSlotTypeCommand,
+} from "../protocols/Aws_restJson1";
+
+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/src/commands/DeleteSlotTypeVersionCommand.ts

@@ -0,0 +1,102 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import {
+  LexModelBuildingServiceClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LexModelBuildingServiceClient";
+import { DeleteSlotTypeVersionRequest } from "../models/models_0";
+import {
+  deserializeAws_restJson1DeleteSlotTypeVersionCommand,
+  serializeAws_restJson1DeleteSlotTypeVersionCommand,
+} from "../protocols/Aws_restJson1";
+
+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/src/commands/DeleteUtterancesCommand.ts

@@ -0,0 +1,110 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import {
+  LexModelBuildingServiceClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LexModelBuildingServiceClient";
+import { DeleteUtterancesRequest } from "../models/models_0";
+import {
+  deserializeAws_restJson1DeleteUtterancesCommand,
+  serializeAws_restJson1DeleteUtterancesCommand,
+} from "../protocols/Aws_restJson1";
+
+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/src/commands/GetBotAliasCommand.ts

@@ -0,0 +1,102 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import {
+  LexModelBuildingServiceClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LexModelBuildingServiceClient";
+import { GetBotAliasRequest, GetBotAliasResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetBotAliasCommand,
+  serializeAws_restJson1GetBotAliasCommand,
+} from "../protocols/Aws_restJson1";
+
+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/src/commands/GetBotAliasesCommand.ts

@@ -0,0 +1,101 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import {
+  LexModelBuildingServiceClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../LexModelBuildingServiceClient";
+import { GetBotAliasesRequest, GetBotAliasesResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetBotAliasesCommand,
+  serializeAws_restJson1GetBotAliasesCommand,
+} from "../protocols/Aws_restJson1";
+
+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
+}