@aws-sdk/client-lex-runtime-v2 3.34.0 → 3.37.0

package/LexRuntimeV2.ts

@@ -1,299 +0,0 @@
-import { LexRuntimeV2Client } from "./LexRuntimeV2Client";
-import {
-  DeleteSessionCommand,
-  DeleteSessionCommandInput,
-  DeleteSessionCommandOutput,
-} from "./commands/DeleteSessionCommand";
-import { GetSessionCommand, GetSessionCommandInput, GetSessionCommandOutput } from "./commands/GetSessionCommand";
-import { PutSessionCommand, PutSessionCommandInput, PutSessionCommandOutput } from "./commands/PutSessionCommand";
-import {
-  RecognizeTextCommand,
-  RecognizeTextCommandInput,
-  RecognizeTextCommandOutput,
-} from "./commands/RecognizeTextCommand";
-import {
-  RecognizeUtteranceCommand,
-  RecognizeUtteranceCommandInput,
-  RecognizeUtteranceCommandOutput,
-} from "./commands/RecognizeUtteranceCommand";
-import {
-  StartConversationCommand,
-  StartConversationCommandInput,
-  StartConversationCommandOutput,
-} from "./commands/StartConversationCommand";
-import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
-
-/**
- * <p></p>
- */
-export class LexRuntimeV2 extends LexRuntimeV2Client {
-  /**
-   * <p>Removes session information for a specified bot, alias, and user ID. </p>
-   *          <p>You can use this operation to restart a conversation with a bot.
-   *          When you remove a session, the entire history of the session is removed
-   *          so that you can start again.</p>
-   *          <p>You don't need to delete a session. Sessions have a time limit and
-   *          will expire. Set the session time limit when you create the bot. The
-   *          default is 5 minutes, but you can specify anything between 1 minute and
-   *          24 hours.</p>
-   *          <p>If you specify a bot or alias ID that doesn't exist, you receive a
-   *             <code>BadRequestException.</code>
-   *          </p>
-   *          <p>If the locale doesn't exist in the bot, or if the locale hasn't been
-   *          enables for the alias, you receive a
-   *          <code>BadRequestException</code>.</p>
-   */
-  public deleteSession(
-    args: DeleteSessionCommandInput,
-    options?: __HttpHandlerOptions
-  ): Promise<DeleteSessionCommandOutput>;
-  public deleteSession(
-    args: DeleteSessionCommandInput,
-    cb: (err: any, data?: DeleteSessionCommandOutput) => void
-  ): void;
-  public deleteSession(
-    args: DeleteSessionCommandInput,
-    options: __HttpHandlerOptions,
-    cb: (err: any, data?: DeleteSessionCommandOutput) => void
-  ): void;
-  public deleteSession(
-    args: DeleteSessionCommandInput,
-    optionsOrCb?: __HttpHandlerOptions | ((err: any, data?: DeleteSessionCommandOutput) => void),
-    cb?: (err: any, data?: DeleteSessionCommandOutput) => void
-  ): Promise<DeleteSessionCommandOutput> | void {
-    const command = new DeleteSessionCommand(args);
-    if (typeof optionsOrCb === "function") {
-      this.send(command, optionsOrCb);
-    } else if (typeof cb === "function") {
-      if (typeof optionsOrCb !== "object") throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-      this.send(command, optionsOrCb || {}, cb);
-    } else {
-      return this.send(command, optionsOrCb);
-    }
-  }
-
-  /**
-   * <p>Returns session information for a specified bot, alias, and
-   *          user.</p>
-   *          <p>For example, you can use this operation to retrieve session
-   *          information for a user that has left a long-running session in
-   *          use.</p>
-   *          <p>If the bot, alias, or session identifier doesn't exist, Amazon Lex V2
-   *          returns a <code>BadRequestException</code>. If the locale doesn't exist
-   *          or is not enabled for the alias, you receive a
-   *             <code>BadRequestException</code>.</p>
-   */
-  public getSession(args: GetSessionCommandInput, options?: __HttpHandlerOptions): Promise<GetSessionCommandOutput>;
-  public getSession(args: GetSessionCommandInput, cb: (err: any, data?: GetSessionCommandOutput) => void): void;
-  public getSession(
-    args: GetSessionCommandInput,
-    options: __HttpHandlerOptions,
-    cb: (err: any, data?: GetSessionCommandOutput) => void
-  ): void;
-  public getSession(
-    args: GetSessionCommandInput,
-    optionsOrCb?: __HttpHandlerOptions | ((err: any, data?: GetSessionCommandOutput) => void),
-    cb?: (err: any, data?: GetSessionCommandOutput) => void
-  ): Promise<GetSessionCommandOutput> | void {
-    const command = new GetSessionCommand(args);
-    if (typeof optionsOrCb === "function") {
-      this.send(command, optionsOrCb);
-    } else if (typeof cb === "function") {
-      if (typeof optionsOrCb !== "object") throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-      this.send(command, optionsOrCb || {}, cb);
-    } else {
-      return this.send(command, optionsOrCb);
-    }
-  }
-
-  /**
-   * <p>Creates a new session or modifies an existing session with an Amazon Lex V2
-   *          bot. Use this operation to enable your application to set the state of
-   *          the bot.</p>
-   */
-  public putSession(args: PutSessionCommandInput, options?: __HttpHandlerOptions): Promise<PutSessionCommandOutput>;
-  public putSession(args: PutSessionCommandInput, cb: (err: any, data?: PutSessionCommandOutput) => void): void;
-  public putSession(
-    args: PutSessionCommandInput,
-    options: __HttpHandlerOptions,
-    cb: (err: any, data?: PutSessionCommandOutput) => void
-  ): void;
-  public putSession(
-    args: PutSessionCommandInput,
-    optionsOrCb?: __HttpHandlerOptions | ((err: any, data?: PutSessionCommandOutput) => void),
-    cb?: (err: any, data?: PutSessionCommandOutput) => void
-  ): Promise<PutSessionCommandOutput> | void {
-    const command = new PutSessionCommand(args);
-    if (typeof optionsOrCb === "function") {
-      this.send(command, optionsOrCb);
-    } else if (typeof cb === "function") {
-      if (typeof optionsOrCb !== "object") throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-      this.send(command, optionsOrCb || {}, cb);
-    } else {
-      return this.send(command, optionsOrCb);
-    }
-  }
-
-  /**
-   * <p>Sends user input to Amazon Lex V2. Client applications use this API to send
-   *          requests to Amazon Lex V2 at runtime. Amazon Lex V2 then interprets the user input
-   *          using the machine learning model that it build for the bot.</p>
-   *          <p>In response, Amazon Lex V2 returns the next message to convey to the user
-   *          and an optional response card to display.</p>
-   */
-  public recognizeText(
-    args: RecognizeTextCommandInput,
-    options?: __HttpHandlerOptions
-  ): Promise<RecognizeTextCommandOutput>;
-  public recognizeText(
-    args: RecognizeTextCommandInput,
-    cb: (err: any, data?: RecognizeTextCommandOutput) => void
-  ): void;
-  public recognizeText(
-    args: RecognizeTextCommandInput,
-    options: __HttpHandlerOptions,
-    cb: (err: any, data?: RecognizeTextCommandOutput) => void
-  ): void;
-  public recognizeText(
-    args: RecognizeTextCommandInput,
-    optionsOrCb?: __HttpHandlerOptions | ((err: any, data?: RecognizeTextCommandOutput) => void),
-    cb?: (err: any, data?: RecognizeTextCommandOutput) => void
-  ): Promise<RecognizeTextCommandOutput> | void {
-    const command = new RecognizeTextCommand(args);
-    if (typeof optionsOrCb === "function") {
-      this.send(command, optionsOrCb);
-    } else if (typeof cb === "function") {
-      if (typeof optionsOrCb !== "object") throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-      this.send(command, optionsOrCb || {}, cb);
-    } else {
-      return this.send(command, optionsOrCb);
-    }
-  }
-
-  /**
-   * <p>Sends user input to Amazon Lex V2. You can send text or speech. Clients use
-   *          this API to send text and audio requests to Amazon Lex V2 at runtime. Amazon Lex V2
-   *          interprets the user input using the machine learning model built for
-   *          the bot.</p>
-   *          <p>The following request fields must be compressed with gzip and then
-   *          base64 encoded before you send them to Amazon Lex V2. </p>
-   *          <ul>
-   *             <li>
-   *                <p>requestAttributes</p>
-   *             </li>
-   *             <li>
-   *                <p>sessionState</p>
-   *             </li>
-   *          </ul>
-   *          <p>The following response fields are compressed using gzip and then
-   *          base64 encoded by Amazon Lex V2. Before you can use these fields, you must
-   *          decode and decompress them. </p>
-   *          <ul>
-   *             <li>
-   *                <p>inputTranscript</p>
-   *             </li>
-   *             <li>
-   *                <p>interpretations</p>
-   *             </li>
-   *             <li>
-   *                <p>messages</p>
-   *             </li>
-   *             <li>
-   *                <p>requestAttributes</p>
-   *             </li>
-   *             <li>
-   *                <p>sessionState</p>
-   *             </li>
-   *          </ul>
-   *          <p>The example contains a Java application that compresses and encodes
-   *          a Java object to send to Amazon Lex V2, and a second that decodes and
-   *          decompresses a response from Amazon Lex V2.</p>
-   */
-  public recognizeUtterance(
-    args: RecognizeUtteranceCommandInput,
-    options?: __HttpHandlerOptions
-  ): Promise<RecognizeUtteranceCommandOutput>;
-  public recognizeUtterance(
-    args: RecognizeUtteranceCommandInput,
-    cb: (err: any, data?: RecognizeUtteranceCommandOutput) => void
-  ): void;
-  public recognizeUtterance(
-    args: RecognizeUtteranceCommandInput,
-    options: __HttpHandlerOptions,
-    cb: (err: any, data?: RecognizeUtteranceCommandOutput) => void
-  ): void;
-  public recognizeUtterance(
-    args: RecognizeUtteranceCommandInput,
-    optionsOrCb?: __HttpHandlerOptions | ((err: any, data?: RecognizeUtteranceCommandOutput) => void),
-    cb?: (err: any, data?: RecognizeUtteranceCommandOutput) => void
-  ): Promise<RecognizeUtteranceCommandOutput> | void {
-    const command = new RecognizeUtteranceCommand(args);
-    if (typeof optionsOrCb === "function") {
-      this.send(command, optionsOrCb);
-    } else if (typeof cb === "function") {
-      if (typeof optionsOrCb !== "object") throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-      this.send(command, optionsOrCb || {}, cb);
-    } else {
-      return this.send(command, optionsOrCb);
-    }
-  }
-
-  /**
-   * <p>Starts an HTTP/2 bidirectional event stream that enables you to send
-   *          audio, text, or DTMF input in real time. After your application starts
-   *          a conversation, users send input to Amazon Lex V2 as a stream of events. Amazon Lex V2
-   *          processes the incoming events and responds with streaming text or audio
-   *          events.
-   *       </p>
-   *          <p>Audio input must be in the following format: <code>audio/lpcm
-   *             sample-rate=8000 sample-size-bits=16 channel-count=1;
-   *             is-big-endian=false</code>.</p>
-   *          <p>The <code>StartConversation</code> operation is supported only in
-   *          the following SDKs: </p>
-   *          <ul>
-   *             <li>
-   *                <p>
-   *                   <a href="https://docs.aws.amazon.com/goto/SdkForCpp/runtime.lex.v2-2020-08-07/StartConversation">AWS SDK for C++</a>
-   *                </p>
-   *             </li>
-   *             <li>
-   *                <p>
-   *                   <a href="https://docs.aws.amazon.com/goto/SdkForJavaV2/runtime.lex.v2-2020-08-07/StartConversation">AWS SDK for Java V2</a>
-   *                </p>
-   *             </li>
-   *             <li>
-   *                <p>
-   *                   <a href="https://docs.aws.amazon.com/goto/SdkForRubyV3/runtime.lex.v2-2020-08-07/StartConversation">AWS SDK for Ruby V3</a>
-   *                </p>
-   *             </li>
-   *          </ul>
-   */
-  public startConversation(
-    args: StartConversationCommandInput,
-    options?: __HttpHandlerOptions
-  ): Promise<StartConversationCommandOutput>;
-  public startConversation(
-    args: StartConversationCommandInput,
-    cb: (err: any, data?: StartConversationCommandOutput) => void
-  ): void;
-  public startConversation(
-    args: StartConversationCommandInput,
-    options: __HttpHandlerOptions,
-    cb: (err: any, data?: StartConversationCommandOutput) => void
-  ): void;
-  public startConversation(
-    args: StartConversationCommandInput,
-    optionsOrCb?: __HttpHandlerOptions | ((err: any, data?: StartConversationCommandOutput) => void),
-    cb?: (err: any, data?: StartConversationCommandOutput) => void
-  ): Promise<StartConversationCommandOutput> | void {
-    const command = new StartConversationCommand(args);
-    if (typeof optionsOrCb === "function") {
-      this.send(command, optionsOrCb);
-    } else if (typeof cb === "function") {
-      if (typeof optionsOrCb !== "object") throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-      this.send(command, optionsOrCb || {}, cb);
-    } else {
-      return this.send(command, optionsOrCb);
-    }
-  }
-}

package/LexRuntimeV2Client.ts

@@ -1,282 +0,0 @@
-import { DeleteSessionCommandInput, DeleteSessionCommandOutput } from "./commands/DeleteSessionCommand";
-import { GetSessionCommandInput, GetSessionCommandOutput } from "./commands/GetSessionCommand";
-import { PutSessionCommandInput, PutSessionCommandOutput } from "./commands/PutSessionCommand";
-import { RecognizeTextCommandInput, RecognizeTextCommandOutput } from "./commands/RecognizeTextCommand";
-import { RecognizeUtteranceCommandInput, RecognizeUtteranceCommandOutput } from "./commands/RecognizeUtteranceCommand";
-import { StartConversationCommandInput, StartConversationCommandOutput } from "./commands/StartConversationCommand";
-import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
-import {
-  EndpointsInputConfig,
-  EndpointsResolvedConfig,
-  RegionInputConfig,
-  RegionResolvedConfig,
-  resolveEndpointsConfig,
-  resolveRegionConfig,
-} from "@aws-sdk/config-resolver";
-import {
-  EventStreamSerdeInputConfig,
-  EventStreamSerdeResolvedConfig,
-  resolveEventStreamSerdeConfig,
-} from "@aws-sdk/eventstream-serde-config-resolver";
-import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
-import {
-  EventStreamInputConfig,
-  EventStreamResolvedConfig,
-  resolveEventStreamConfig,
-} from "@aws-sdk/middleware-eventstream";
-import {
-  HostHeaderInputConfig,
-  HostHeaderResolvedConfig,
-  getHostHeaderPlugin,
-  resolveHostHeaderConfig,
-} from "@aws-sdk/middleware-host-header";
-import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
-import { RetryInputConfig, RetryResolvedConfig, getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
-import {
-  AwsAuthInputConfig,
-  AwsAuthResolvedConfig,
-  getAwsAuthPlugin,
-  resolveAwsAuthConfig,
-} from "@aws-sdk/middleware-signing";
-import {
-  UserAgentInputConfig,
-  UserAgentResolvedConfig,
-  getUserAgentPlugin,
-  resolveUserAgentConfig,
-} from "@aws-sdk/middleware-user-agent";
-import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
-import {
-  Client as __Client,
-  SmithyConfiguration as __SmithyConfiguration,
-  SmithyResolvedConfiguration as __SmithyResolvedConfiguration,
-} from "@aws-sdk/smithy-client";
-import {
-  Provider,
-  RegionInfoProvider,
-  Credentials as __Credentials,
-  Decoder as __Decoder,
-  Encoder as __Encoder,
-  EventStreamPayloadHandlerProvider as __EventStreamPayloadHandlerProvider,
-  EventStreamSerdeProvider as __EventStreamSerdeProvider,
-  Hash as __Hash,
-  HashConstructor as __HashConstructor,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  Logger as __Logger,
-  Provider as __Provider,
-  StreamCollector as __StreamCollector,
-  UrlParser as __UrlParser,
-  UserAgent as __UserAgent,
-} from "@aws-sdk/types";
-
-export type ServiceInputTypes =
-  | DeleteSessionCommandInput
-  | GetSessionCommandInput
-  | PutSessionCommandInput
-  | RecognizeTextCommandInput
-  | RecognizeUtteranceCommandInput
-  | StartConversationCommandInput;
-
-export type ServiceOutputTypes =
-  | DeleteSessionCommandOutput
-  | GetSessionCommandOutput
-  | PutSessionCommandOutput
-  | RecognizeTextCommandOutput
-  | RecognizeUtteranceCommandOutput
-  | StartConversationCommandOutput;
-
-export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-  /**
-   * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-   */
-  requestHandler?: __HttpHandler;
-
-  /**
-   * A constructor for a class implementing the {@link __Hash} interface
-   * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-   * @internal
-   */
-  sha256?: __HashConstructor;
-
-  /**
-   * The function that will be used to convert strings into HTTP endpoints.
-   * @internal
-   */
-  urlParser?: __UrlParser;
-
-  /**
-   * A function that can calculate the length of a request body.
-   * @internal
-   */
-  bodyLengthChecker?: (body: any) => number | undefined;
-
-  /**
-   * A function that converts a stream into an array of bytes.
-   * @internal
-   */
-  streamCollector?: __StreamCollector;
-
-  /**
-   * The function that will be used to convert a base64-encoded string to a byte array.
-   * @internal
-   */
-  base64Decoder?: __Decoder;
-
-  /**
-   * The function that will be used to convert binary data to a base64-encoded string.
-   * @internal
-   */
-  base64Encoder?: __Encoder;
-
-  /**
-   * The function that will be used to convert a UTF8-encoded string to a byte array.
-   * @internal
-   */
-  utf8Decoder?: __Decoder;
-
-  /**
-   * The function that will be used to convert binary data to a UTF-8 encoded string.
-   * @internal
-   */
-  utf8Encoder?: __Encoder;
-
-  /**
-   * The runtime environment.
-   * @internal
-   */
-  runtime?: string;
-
-  /**
-   * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-   * trait of an operation.
-   */
-  disableHostPrefix?: boolean;
-
-  /**
-   * Value for how many times a request will be made at most in case of retry.
-   */
-  maxAttempts?: number | __Provider<number>;
-
-  /**
-   * Specifies which retry algorithm to use.
-   */
-  retryMode?: string | __Provider<string>;
-
-  /**
-   * Optional logger for logging debug/info/warn/error.
-   */
-  logger?: __Logger;
-
-  /**
-   * Unique service identifier.
-   * @internal
-   */
-  serviceId?: string;
-
-  /**
-   * The AWS region to which this client will send requests
-   */
-  region?: string | __Provider<string>;
-
-  /**
-   * Default credentials provider; Not available in browser runtime.
-   * @internal
-   */
-  credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-
-  /**
-   * Fetch related hostname, signing name or signing region with given region.
-   * @internal
-   */
-  regionInfoProvider?: RegionInfoProvider;
-
-  /**
-   * The function that provides necessary utilities for handling request event stream.
-   * @internal
-   */
-  eventStreamPayloadHandlerProvider?: __EventStreamPayloadHandlerProvider;
-
-  /**
-   * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-   * @internal
-   */
-  defaultUserAgentProvider?: Provider<__UserAgent>;
-
-  /**
-   * The function that provides necessary utilities for generating and parsing event stream
-   */
-  eventStreamSerdeProvider?: __EventStreamSerdeProvider;
-}
-
-type LexRuntimeV2ClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> &
-  ClientDefaults &
-  RegionInputConfig &
-  EndpointsInputConfig &
-  RetryInputConfig &
-  HostHeaderInputConfig &
-  AwsAuthInputConfig &
-  EventStreamInputConfig &
-  UserAgentInputConfig &
-  EventStreamSerdeInputConfig;
-/**
- * The configuration interface of LexRuntimeV2Client class constructor that set the region, credentials and other options.
- */
-export interface LexRuntimeV2ClientConfig extends LexRuntimeV2ClientConfigType {}
-
-type LexRuntimeV2ClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> &
-  Required<ClientDefaults> &
-  RegionResolvedConfig &
-  EndpointsResolvedConfig &
-  RetryResolvedConfig &
-  HostHeaderResolvedConfig &
-  AwsAuthResolvedConfig &
-  EventStreamResolvedConfig &
-  UserAgentResolvedConfig &
-  EventStreamSerdeResolvedConfig;
-/**
- * The resolved configuration interface of LexRuntimeV2Client class. This is resolved and normalized from the {@link LexRuntimeV2ClientConfig | constructor configuration interface}.
- */
-export interface LexRuntimeV2ClientResolvedConfig extends LexRuntimeV2ClientResolvedConfigType {}
-
-/**
- * <p></p>
- */
-export class LexRuntimeV2Client extends __Client<
-  __HttpHandlerOptions,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-  LexRuntimeV2ClientResolvedConfig
-> {
-  /**
-   * The resolved configuration of LexRuntimeV2Client class. This is resolved and normalized from the {@link LexRuntimeV2ClientConfig | constructor configuration interface}.
-   */
-  readonly config: LexRuntimeV2ClientResolvedConfig;
-
-  constructor(configuration: LexRuntimeV2ClientConfig) {
-    let _config_0 = __getRuntimeConfig(configuration);
-    let _config_1 = resolveRegionConfig(_config_0);
-    let _config_2 = resolveEndpointsConfig(_config_1);
-    let _config_3 = resolveRetryConfig(_config_2);
-    let _config_4 = resolveHostHeaderConfig(_config_3);
-    let _config_5 = resolveAwsAuthConfig(_config_4);
-    let _config_6 = resolveEventStreamConfig(_config_5);
-    let _config_7 = resolveUserAgentConfig(_config_6);
-    let _config_8 = resolveEventStreamSerdeConfig(_config_7);
-    super(_config_8);
-    this.config = _config_8;
-    this.middlewareStack.use(getRetryPlugin(this.config));
-    this.middlewareStack.use(getContentLengthPlugin(this.config));
-    this.middlewareStack.use(getHostHeaderPlugin(this.config));
-    this.middlewareStack.use(getLoggerPlugin(this.config));
-    this.middlewareStack.use(getAwsAuthPlugin(this.config));
-    this.middlewareStack.use(getUserAgentPlugin(this.config));
-  }
-
-  /**
-   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-   */
-  destroy(): void {
-    super.destroy();
-  }
-}

package/commands/DeleteSessionCommand.ts

@@ -1,107 +0,0 @@
-import { LexRuntimeV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexRuntimeV2Client";
-import { DeleteSessionRequest, DeleteSessionResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteSessionCommand,
-  serializeAws_restJson1DeleteSessionCommand,
-} from "../protocols/Aws_restJson1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface DeleteSessionCommandInput extends DeleteSessionRequest {}
-export interface DeleteSessionCommandOutput extends DeleteSessionResponse, __MetadataBearer {}
-
-/**
- * <p>Removes session information for a specified bot, alias, and user ID. </p>
- *          <p>You can use this operation to restart a conversation with a bot.
- *          When you remove a session, the entire history of the session is removed
- *          so that you can start again.</p>
- *          <p>You don't need to delete a session. Sessions have a time limit and
- *          will expire. Set the session time limit when you create the bot. The
- *          default is 5 minutes, but you can specify anything between 1 minute and
- *          24 hours.</p>
- *          <p>If you specify a bot or alias ID that doesn't exist, you receive a
- *             <code>BadRequestException.</code>
- *          </p>
- *          <p>If the locale doesn't exist in the bot, or if the locale hasn't been
- *          enables for the alias, you receive a
- *          <code>BadRequestException</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LexRuntimeV2Client, DeleteSessionCommand } from "@aws-sdk/client-lex-runtime-v2"; // ES Modules import
- * // const { LexRuntimeV2Client, DeleteSessionCommand } = require("@aws-sdk/client-lex-runtime-v2"); // CommonJS import
- * const client = new LexRuntimeV2Client(config);
- * const command = new DeleteSessionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteSessionCommandInput} for command's `input` shape.
- * @see {@link DeleteSessionCommandOutput} for command's `response` shape.
- * @see {@link LexRuntimeV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteSessionCommand extends $Command<
-  DeleteSessionCommandInput,
-  DeleteSessionCommandOutput,
-  LexRuntimeV2ClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteSessionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexRuntimeV2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteSessionCommandInput, DeleteSessionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LexRuntimeV2Client";
-    const commandName = "DeleteSessionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteSessionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: DeleteSessionResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteSessionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteSessionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteSessionCommandOutput> {
-    return deserializeAws_restJson1DeleteSessionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}