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

package/src/commands/GetBotChannelAssociationCommand.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 { GetBotChannelAssociationRequest, GetBotChannelAssociationResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetBotChannelAssociationCommand,
+  serializeAws_restJson1GetBotChannelAssociationCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface GetBotChannelAssociationCommandInput extends GetBotChannelAssociationRequest {}
+export interface GetBotChannelAssociationCommandOutput extends GetBotChannelAssociationResponse, __MetadataBearer {}
+
+/**
+ * <p>Returns information about the association between an Amazon Lex bot and
+ *       a messaging platform.</p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:GetBotChannelAssociation</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotChannelAssociationCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotChannelAssociationCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotChannelAssociationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotChannelAssociationCommandInput} for command's `input` shape.
+ * @see {@link GetBotChannelAssociationCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetBotChannelAssociationCommand extends $Command<
+  GetBotChannelAssociationCommandInput,
+  GetBotChannelAssociationCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetBotChannelAssociationCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetBotChannelAssociationCommandInput, GetBotChannelAssociationCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetBotChannelAssociationCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetBotChannelAssociationRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetBotChannelAssociationResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetBotChannelAssociationCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetBotChannelAssociationCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetBotChannelAssociationCommandOutput> {
+    return deserializeAws_restJson1GetBotChannelAssociationCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetBotChannelAssociationsCommand.ts

@@ -0,0 +1,106 @@
+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 { GetBotChannelAssociationsRequest, GetBotChannelAssociationsResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetBotChannelAssociationsCommand,
+  serializeAws_restJson1GetBotChannelAssociationsCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface GetBotChannelAssociationsCommandInput extends GetBotChannelAssociationsRequest {}
+export interface GetBotChannelAssociationsCommandOutput extends GetBotChannelAssociationsResponse, __MetadataBearer {}
+
+/**
+ * <p> Returns a list of all of the channels associated with the
+ *       specified bot. </p>
+ *          <p>The <code>GetBotChannelAssociations</code> operation requires
+ *       permissions for the <code>lex:GetBotChannelAssociations</code>
+ *       action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotChannelAssociationsCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotChannelAssociationsCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotChannelAssociationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotChannelAssociationsCommandInput} for command's `input` shape.
+ * @see {@link GetBotChannelAssociationsCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetBotChannelAssociationsCommand extends $Command<
+  GetBotChannelAssociationsCommandInput,
+  GetBotChannelAssociationsCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetBotChannelAssociationsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetBotChannelAssociationsCommandInput, GetBotChannelAssociationsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetBotChannelAssociationsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetBotChannelAssociationsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetBotChannelAssociationsResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetBotChannelAssociationsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetBotChannelAssociationsCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<GetBotChannelAssociationsCommandOutput> {
+    return deserializeAws_restJson1GetBotChannelAssociationsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetBotCommand.ts

@@ -0,0 +1,99 @@
+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 { GetBotRequest, GetBotResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetBotCommand, serializeAws_restJson1GetBotCommand } from "../protocols/Aws_restJson1";
+
+export interface GetBotCommandInput extends GetBotRequest {}
+export interface GetBotCommandOutput extends GetBotResponse, __MetadataBearer {}
+
+/**
+ * <p>Returns metadata information for a specific bot. You must provide
+ *       the bot name and the bot version or alias. </p>
+ *          <p> This operation requires permissions for the
+ *         <code>lex:GetBot</code> action. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotCommandInput} for command's `input` shape.
+ * @see {@link GetBotCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetBotCommand extends $Command<
+  GetBotCommandInput,
+  GetBotCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetBotCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetBotCommandInput, GetBotCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetBotCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetBotRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetBotResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetBotCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetBotCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetBotCommandOutput> {
+    return deserializeAws_restJson1GetBotCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetBotVersionsCommand.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 { GetBotVersionsRequest, GetBotVersionsResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetBotVersionsCommand,
+  serializeAws_restJson1GetBotVersionsCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface GetBotVersionsCommandInput extends GetBotVersionsRequest {}
+export interface GetBotVersionsCommandOutput extends GetBotVersionsResponse, __MetadataBearer {}
+
+/**
+ * <p>Gets information about all of the versions of a bot.</p>
+ *          <p>The <code>GetBotVersions</code> operation returns a
+ *         <code>BotMetadata</code> object for each version of a bot. For example,
+ *       if a bot has three numbered versions, the <code>GetBotVersions</code>
+ *       operation returns four <code>BotMetadata</code> objects in the response,
+ *       one for each numbered version and one for the <code>$LATEST</code>
+ *       version. </p>
+ *          <p>The <code>GetBotVersions</code> operation always returns at least
+ *       one version, the <code>$LATEST</code> version.</p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:GetBotVersions</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotVersionsCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotVersionsCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotVersionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotVersionsCommandInput} for command's `input` shape.
+ * @see {@link GetBotVersionsCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetBotVersionsCommand extends $Command<
+  GetBotVersionsCommandInput,
+  GetBotVersionsCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetBotVersionsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetBotVersionsCommandInput, GetBotVersionsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetBotVersionsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetBotVersionsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetBotVersionsResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetBotVersionsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetBotVersionsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetBotVersionsCommandOutput> {
+    return deserializeAws_restJson1GetBotVersionsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetBotsCommand.ts

@@ -0,0 +1,113 @@
+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 { GetBotsRequest, GetBotsResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetBotsCommand,
+  serializeAws_restJson1GetBotsCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface GetBotsCommandInput extends GetBotsRequest {}
+export interface GetBotsCommandOutput extends GetBotsResponse, __MetadataBearer {}
+
+/**
+ * <p>Returns bot information as follows: </p>
+ *          <ul>
+ *             <li>
+ *                <p>If you provide the <code>nameContains</code> field, the
+ *           response includes information for the <code>$LATEST</code> version of
+ *           all bots whose name contains the specified string.</p>
+ *             </li>
+ *             <li>
+ *                <p>If you don't specify the <code>nameContains</code> field, the
+ *           operation returns information about the <code>$LATEST</code> version
+ *           of all of your bots.</p>
+ *             </li>
+ *          </ul>
+ *          <p>This operation requires permission for the <code>lex:GetBots</code>
+ *       action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetBotsCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetBotsCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetBotsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBotsCommandInput} for command's `input` shape.
+ * @see {@link GetBotsCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetBotsCommand extends $Command<
+  GetBotsCommandInput,
+  GetBotsCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetBotsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetBotsCommandInput, GetBotsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetBotsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetBotsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetBotsResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetBotsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetBotsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetBotsCommandOutput> {
+    return deserializeAws_restJson1GetBotsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

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