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

package/src/commands/GetBuiltinIntentsCommand.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 { GetBuiltinIntentsRequest, GetBuiltinIntentsResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetBuiltinIntentsCommand,
+  serializeAws_restJson1GetBuiltinIntentsCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface GetBuiltinIntentsCommandInput extends GetBuiltinIntentsRequest {}
+export interface GetBuiltinIntentsCommandOutput extends GetBuiltinIntentsResponse, __MetadataBearer {}
+
+/**
+ * <p>Gets a list of built-in intents that meet the specified
+ *       criteria.</p>
+ *          <p>This operation requires permission for the
+ *         <code>lex:GetBuiltinIntents</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBuiltinIntentsCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBuiltinIntentsCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBuiltinIntentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBuiltinIntentsCommandInput} for command's `input` shape.
+ * @see {@link GetBuiltinIntentsCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetBuiltinIntentsCommand extends $Command<
+  GetBuiltinIntentsCommandInput,
+  GetBuiltinIntentsCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetBuiltinIntentsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetBuiltinIntentsCommandInput, GetBuiltinIntentsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetBuiltinIntentsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetBuiltinIntentsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetBuiltinIntentsResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetBuiltinIntentsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetBuiltinIntentsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetBuiltinIntentsCommandOutput> {
+    return deserializeAws_restJson1GetBuiltinIntentsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetBuiltinSlotTypesCommand.ts

@@ -0,0 +1,105 @@
+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 { GetBuiltinSlotTypesRequest, GetBuiltinSlotTypesResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetBuiltinSlotTypesCommand,
+  serializeAws_restJson1GetBuiltinSlotTypesCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface GetBuiltinSlotTypesCommandInput extends GetBuiltinSlotTypesRequest {}
+export interface GetBuiltinSlotTypesCommandOutput extends GetBuiltinSlotTypesResponse, __MetadataBearer {}
+
+/**
+ * <p>Gets a list of built-in slot types that meet the specified
+ *       criteria.</p>
+ *          <p>For a list of built-in slot types, see <a href="https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/built-in-intent-ref/slot-type-reference">Slot Type Reference</a> in the <i>Alexa Skills
+ *         Kit</i>.</p>
+ *
+ *          <p>This operation requires permission for the
+ *         <code>lex:GetBuiltInSlotTypes</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBuiltinSlotTypesCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBuiltinSlotTypesCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBuiltinSlotTypesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBuiltinSlotTypesCommandInput} for command's `input` shape.
+ * @see {@link GetBuiltinSlotTypesCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetBuiltinSlotTypesCommand extends $Command<
+  GetBuiltinSlotTypesCommandInput,
+  GetBuiltinSlotTypesCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetBuiltinSlotTypesCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetBuiltinSlotTypesCommandInput, GetBuiltinSlotTypesCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetBuiltinSlotTypesCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetBuiltinSlotTypesRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetBuiltinSlotTypesResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetBuiltinSlotTypesCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetBuiltinSlotTypesCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetBuiltinSlotTypesCommandOutput> {
+    return deserializeAws_restJson1GetBuiltinSlotTypesCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetExportCommand.ts

@@ -0,0 +1,100 @@
+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 { GetExportRequest, GetExportResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetExportCommand,
+  serializeAws_restJson1GetExportCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface GetExportCommandInput extends GetExportRequest {}
+export interface GetExportCommandOutput extends GetExportResponse, __MetadataBearer {}
+
+/**
+ * <p>Exports the contents of a Amazon Lex resource in a specified format.
+ *     </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetExportCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetExportCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetExportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetExportCommandInput} for command's `input` shape.
+ * @see {@link GetExportCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetExportCommand extends $Command<
+  GetExportCommandInput,
+  GetExportCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetExportCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetExportCommandInput, GetExportCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetExportCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetExportRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetExportResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetExportCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetExportCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetExportCommandOutput> {
+    return deserializeAws_restJson1GetExportCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetImportCommand.ts

@@ -0,0 +1,100 @@
+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 { GetImportRequest, GetImportResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetImportCommand,
+  serializeAws_restJson1GetImportCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface GetImportCommandInput extends GetImportRequest {}
+export interface GetImportCommandOutput extends GetImportResponse, __MetadataBearer {}
+
+/**
+ * <p>Gets information about an import job started with the
+ *         <code>StartImport</code> operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetImportCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetImportCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetImportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetImportCommandInput} for command's `input` shape.
+ * @see {@link GetImportCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetImportCommand extends $Command<
+  GetImportCommandInput,
+  GetImportCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetImportCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetImportCommandInput, GetImportCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetImportCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetImportRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetImportResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetImportCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetImportCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetImportCommandOutput> {
+    return deserializeAws_restJson1GetImportCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetIntentCommand.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 { GetIntentRequest, GetIntentResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetIntentCommand,
+  serializeAws_restJson1GetIntentCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class GetIntentCommand extends $Command<
+  GetIntentCommandInput,
+  GetIntentCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetIntentCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetIntentCommandInput, GetIntentCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetIntentCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetIntentRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetIntentResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetIntentCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetIntentCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetIntentCommandOutput> {
+    return deserializeAws_restJson1GetIntentCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetIntentVersionsCommand.ts

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