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

package/src/commands/GetUtterancesViewCommand.ts

@@ -0,0 +1,122 @@
+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 { GetUtterancesViewRequest, GetUtterancesViewResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetUtterancesViewCommand,
+  serializeAws_restJson1GetUtterancesViewCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface GetUtterancesViewCommandInput extends GetUtterancesViewRequest {}
+export interface GetUtterancesViewCommandOutput extends GetUtterancesViewResponse, __MetadataBearer {}
+
+/**
+ * <p>Use the <code>GetUtterancesView</code> operation to get information
+ *       about the utterances that your users have made to your bot. You can use
+ *       this list to tune the utterances that your bot responds to.</p>
+ *          <p>For example, say that you have created a bot to order flowers.
+ *       After your users have used your bot for a while, use the
+ *         <code>GetUtterancesView</code> operation to see the requests that they
+ *       have made and whether they have been successful. You might find that the
+ *       utterance "I want flowers" is not being recognized. You could add this
+ *       utterance to the <code>OrderFlowers</code> intent so that your bot
+ *       recognizes that utterance.</p>
+ *          <p>After you publish a new version of a bot, you can get information
+ *       about the old version and the new so that you can compare the performance
+ *       across the two versions. </p>
+ *          <p>Utterance statistics are generated once a day. Data is available
+ *       for the last 15 days. You can request information for up to 5 versions of
+ *       your bot in each request. Amazon Lex returns the most frequent utterances
+ *       received by the bot in the last 15 days. The response contains information
+ *       about a maximum of 100 utterances for each version.</p>
+ *          <p>If you set <code>childDirected</code> field to true when you
+ *       created your bot, if you are using slot obfuscation with one or more
+ *       slots, or if you opted out of participating in improving Amazon Lex, utterances
+ *       are not available.</p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:GetUtterancesView</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, GetUtterancesViewCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, GetUtterancesViewCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new GetUtterancesViewCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUtterancesViewCommandInput} for command's `input` shape.
+ * @see {@link GetUtterancesViewCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetUtterancesViewCommand extends $Command<
+  GetUtterancesViewCommandInput,
+  GetUtterancesViewCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetUtterancesViewCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetUtterancesViewCommandInput, GetUtterancesViewCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "GetUtterancesViewCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetUtterancesViewRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetUtterancesViewResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetUtterancesViewCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetUtterancesViewCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetUtterancesViewCommandOutput> {
+    return deserializeAws_restJson1GetUtterancesViewCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListTagsForResourceCommand.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 { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1ListTagsForResourceCommand,
+  serializeAws_restJson1ListTagsForResourceCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {}
+
+/**
+ * <p>Gets a list of tags associated with the specified resource. Only bots,
+ *       bot aliases, and bot channels can have tags associated with them.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, ListTagsForResourceCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, ListTagsForResourceCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ListTagsForResourceCommand extends $Command<
+  ListTagsForResourceCommandInput,
+  ListTagsForResourceCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListTagsForResourceCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "ListTagsForResourceCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListTagsForResourceRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListTagsForResourceResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListTagsForResourceCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1ListTagsForResourceCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListTagsForResourceCommandOutput> {
+    return deserializeAws_restJson1ListTagsForResourceCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/PutBotAliasCommand.ts

@@ -0,0 +1,104 @@
+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 { PutBotAliasRequest, PutBotAliasResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1PutBotAliasCommand,
+  serializeAws_restJson1PutBotAliasCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface PutBotAliasCommandInput extends PutBotAliasRequest {}
+export interface PutBotAliasCommandOutput extends PutBotAliasResponse, __MetadataBearer {}
+
+/**
+ * <p>Creates an alias for the specified version of the bot or replaces
+ *       an alias for the specified bot. To change the version of the bot that the
+ *       alias points to, replace the alias. For more information about aliases,
+ *       see <a>versioning-aliases</a>.</p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:PutBotAlias</code> action. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, PutBotAliasCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, PutBotAliasCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new PutBotAliasCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutBotAliasCommandInput} for command's `input` shape.
+ * @see {@link PutBotAliasCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PutBotAliasCommand extends $Command<
+  PutBotAliasCommandInput,
+  PutBotAliasCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PutBotAliasCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PutBotAliasCommandInput, PutBotAliasCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "PutBotAliasCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PutBotAliasRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: PutBotAliasResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: PutBotAliasCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1PutBotAliasCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutBotAliasCommandOutput> {
+    return deserializeAws_restJson1PutBotAliasCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/PutBotCommand.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 { PutBotRequest, PutBotResponse } from "../models/models_0";
+import { deserializeAws_restJson1PutBotCommand, serializeAws_restJson1PutBotCommand } from "../protocols/Aws_restJson1";
+
+export interface PutBotCommandInput extends PutBotRequest {}
+export interface PutBotCommandOutput extends PutBotResponse, __MetadataBearer {}
+
+/**
+ * <p>Creates an Amazon Lex conversational bot or replaces an existing bot.
+ *       When you create or update a bot you are only required to specify a name, a
+ *       locale, and whether the bot is directed toward children under age 13. You
+ *       can use this to add intents later, or to remove intents from an existing
+ *       bot. When you create a bot with the minimum information, the bot is
+ *       created or updated but Amazon Lex returns the <code></code> response
+ *         <code>FAILED</code>. You can build the bot after you add one or more
+ *       intents. For more information about Amazon Lex bots, see <a>how-it-works</a>. </p>
+ *          <p>If you specify the name of an existing bot, the fields in the
+ *       request replace the existing values in the <code>$LATEST</code> version of
+ *       the bot. Amazon Lex removes any fields that you don't provide values for in the
+ *       request, except for the <code>idleTTLInSeconds</code> and
+ *         <code>privacySettings</code> fields, which are set to their default
+ *       values. If you don't specify values for required fields, Amazon Lex throws an
+ *       exception.</p>
+ *
+ *          <p>This operation requires permissions for the <code>lex:PutBot</code>
+ *       action. For more information, see <a>security-iam</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, PutBotCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, PutBotCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new PutBotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutBotCommandInput} for command's `input` shape.
+ * @see {@link PutBotCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PutBotCommand extends $Command<
+  PutBotCommandInput,
+  PutBotCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PutBotCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PutBotCommandInput, PutBotCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "PutBotCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PutBotRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: PutBotResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: PutBotCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1PutBotCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutBotCommandOutput> {
+    return deserializeAws_restJson1PutBotCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/PutIntentCommand.ts

@@ -0,0 +1,156 @@
+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 { PutIntentRequest, PutIntentResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1PutIntentCommand,
+  serializeAws_restJson1PutIntentCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface PutIntentCommandInput extends PutIntentRequest {}
+export interface PutIntentCommandOutput extends PutIntentResponse, __MetadataBearer {}
+
+/**
+ * <p>Creates an intent or replaces an existing intent.</p>
+ *          <p>To define the interaction between the user and your bot, you use
+ *       one or more intents. For a pizza ordering bot, for example, you would
+ *       create an <code>OrderPizza</code> intent. </p>
+ *          <p>To create an intent or replace an existing intent, you must provide
+ *       the following:</p>
+ *          <ul>
+ *             <li>
+ *                <p>Intent name. For example, <code>OrderPizza</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>Sample utterances. For example, "Can I order a pizza, please."
+ *           and "I want to order a pizza."</p>
+ *             </li>
+ *             <li>
+ *                <p>Information to be gathered. You specify slot types for the
+ *           information that your bot will request from the user. You can specify
+ *           standard slot types, such as a date or a time, or custom slot types
+ *           such as the size and crust of a pizza.</p>
+ *             </li>
+ *             <li>
+ *                <p>How the intent will be fulfilled. You can provide a Lambda
+ *           function or configure the intent to return the intent information to
+ *           the client application. If you use a Lambda function, when all of the
+ *           intent information is available, Amazon Lex invokes your Lambda function.
+ *           If you configure your intent to return the intent information to the
+ *           client application. </p>
+ *             </li>
+ *          </ul>
+ *          <p>You can specify other optional information in the request, such
+ *       as:</p>
+ *
+ *          <ul>
+ *             <li>
+ *                <p>A confirmation prompt to ask the user to confirm an intent. For
+ *           example, "Shall I order your pizza?"</p>
+ *             </li>
+ *             <li>
+ *                <p>A conclusion statement to send to the user after the intent has
+ *           been fulfilled. For example, "I placed your pizza order."</p>
+ *             </li>
+ *             <li>
+ *                <p>A follow-up prompt that asks the user for additional activity.
+ *           For example, asking "Do you want to order a drink with your
+ *           pizza?"</p>
+ *             </li>
+ *          </ul>
+ *          <p>If you specify an existing intent name to update the intent, Amazon Lex
+ *       replaces the values in the <code>$LATEST</code> version of the intent with
+ *       the values in the request. Amazon Lex removes fields that you don't provide in
+ *       the request. If you don't specify the required fields, Amazon Lex throws an
+ *       exception. When you update the <code>$LATEST</code> version of an intent,
+ *       the <code>status</code> field of any bot that uses the
+ *         <code>$LATEST</code> version of the intent is set to
+ *         <code>NOT_BUILT</code>.</p>
+ *          <p>For more information, see <a>how-it-works</a>.</p>
+ *          <p>This operation requires permissions for the
+ *         <code>lex:PutIntent</code> action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexModelBuildingServiceClient, PutIntentCommand } from "@aws-sdk/client-lex-model-building-service"; // ES Modules import
+ * // const { LexModelBuildingServiceClient, PutIntentCommand } = require("@aws-sdk/client-lex-model-building-service"); // CommonJS import
+ * const client = new LexModelBuildingServiceClient(config);
+ * const command = new PutIntentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutIntentCommandInput} for command's `input` shape.
+ * @see {@link PutIntentCommandOutput} for command's `response` shape.
+ * @see {@link LexModelBuildingServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PutIntentCommand extends $Command<
+  PutIntentCommandInput,
+  PutIntentCommandOutput,
+  LexModelBuildingServiceClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PutIntentCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LexModelBuildingServiceClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PutIntentCommandInput, PutIntentCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LexModelBuildingServiceClient";
+    const commandName = "PutIntentCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PutIntentRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: PutIntentResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: PutIntentCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1PutIntentCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutIntentCommandOutput> {
+    return deserializeAws_restJson1PutIntentCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}