@aws-sdk/client-lex-runtime-service 3.1075.0 → 3.1077.0

package/dist-cjs/index.js

@@ -1,21 +1,58 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
 const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require("@smithy/core");
-const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+const { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
 exports.$Command = Command;
 exports.__Client = Client;
-const { resolveRegionConfig } = require("@smithy/core/config");
-const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
-const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
-const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
-const { getSchemaSerdePlugin } = require("@smithy/core/schema");
-const { resolveHttpAuthSchemeConfig, defaultLexRuntimeServiceHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
-const { getRuntimeConfig } = require("./runtimeConfig");
-const { DeleteSession$, GetSession$, PostContent$, PostText$, PutSession$ } = require("./schemas/schemas_0");
-__exportStar(require("./schemas/schemas_0"), exports);
-__exportStar(require("./models/errors"), exports);
-const { LexRuntimeServiceServiceException } = require("./models/LexRuntimeServiceServiceException");
-exports.LexRuntimeServiceServiceException = LexRuntimeServiceServiceException;
+const { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require("@smithy/core/config");
+const { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { TypeRegistry, getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require("@aws-sdk/core/httpAuthSchemes");
+const { defaultProvider } = require("@aws-sdk/credential-provider-node");
+const { toUtf8, fromUtf8, sdkStreamMixin, toBase64, fromBase64, calculateBodyLength } = require("@smithy/core/serde");
+const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
+const { AwsRestJsonProtocol } = require("@aws-sdk/core/protocols");
+const { Sha256 } = require("@smithy/core/checksum");
+
+const defaultLexRuntimeServiceHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+        region: await normalizeProvider(config.region)() || (() => {
+            throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+        })(),
+    };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+    return {
+        schemeId: "aws.auth#sigv4",
+        signingProperties: {
+            name: "lex",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+const defaultLexRuntimeServiceHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        default: {
+            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+const resolveHttpAuthSchemeConfig = (config) => {
+    const config_0 = resolveAwsSdkSigV4Config(config);
+    return Object.assign(config_0, {
+        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
+    });
+};
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -31,6 +68,651 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
+var version = "3.1076.0";
+var packageInfo = {
+	version: version};
+
+const m = "ref";
+const a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "getAttr", g = "stringEquals", h = { [m]: "Endpoint" }, i = { [m]: d }, j = { "fn": f, "argv": [i, "name"] }, k = {}, l = [{ [m]: "Region" }];
+const _data = {
+    conditions: [
+        [c, [h]],
+        [c, l],
+        ["aws.partition", l, d],
+        [e, [{ [m]: "UseFIPS" }, b]],
+        [e, [{ [m]: "UseDualStack" }, b]],
+        [e, [{ fn: f, argv: [i, "supportsDualStack"] }, b]],
+        [e, [{ fn: f, argv: [i, "supportsFIPS"] }, b]],
+        [g, [j, "aws"]],
+        [g, [j, "aws-us-gov"]]
+    ],
+    results: [
+        [a],
+        [a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
+        [a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
+        [h, k],
+        ["https://runtime.lex-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", k],
+        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
+        ["https://runtime-fips.lex.{Region}.amazonaws.com", k],
+        ["https://runtime.lex-fips.{Region}.{PartitionResult#dnsSuffix}", k],
+        [a, "FIPS is enabled but this partition does not support FIPS"],
+        ["https://runtime.lex.{Region}.{PartitionResult#dualStackDnsSuffix}", k],
+        [a, "DualStack is enabled but this partition does not support DualStack"],
+        ["https://runtime.lex.{Region}.amazonaws.com", k],
+        ["https://runtime.lex.{Region}.{PartitionResult#dnsSuffix}", k],
+        [a, "Invalid Configuration: Missing Region"]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, 16, 3,
+    1, 4, r + 13,
+    2, 5, r + 13,
+    3, 10, 6,
+    4, 9, 7,
+    7, r + 11, 8,
+    8, r + 11, r + 12,
+    5, r + 9, r + 10,
+    4, 14, 11,
+    6, 12, r + 8,
+    7, r + 6, 13,
+    8, r + 6, r + 7,
+    5, 15, r + 5,
+    6, r + 4, r + 5,
+    3, r + 1, 17,
+    4, r + 2, r + 3,
+]);
+const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
+
+const cache = new EndpointCache({
+    size: 50,
+    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+});
+const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+class LexRuntimeServiceServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, LexRuntimeServiceServiceException.prototype);
+    }
+}
+
+class BadRequestException extends LexRuntimeServiceServiceException {
+    name = "BadRequestException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "BadRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BadRequestException.prototype);
+    }
+}
+class ConflictException extends LexRuntimeServiceServiceException {
+    name = "ConflictException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConflictException.prototype);
+    }
+}
+class InternalFailureException extends LexRuntimeServiceServiceException {
+    name = "InternalFailureException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "InternalFailureException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InternalFailureException.prototype);
+    }
+}
+class LimitExceededException extends LexRuntimeServiceServiceException {
+    name = "LimitExceededException";
+    $fault = "client";
+    retryAfterSeconds;
+    constructor(opts) {
+        super({
+            name: "LimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LimitExceededException.prototype);
+        this.retryAfterSeconds = opts.retryAfterSeconds;
+    }
+}
+class NotFoundException extends LexRuntimeServiceServiceException {
+    name = "NotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NotFoundException.prototype);
+    }
+}
+class BadGatewayException extends LexRuntimeServiceServiceException {
+    name = "BadGatewayException";
+    $fault = "server";
+    Message;
+    constructor(opts) {
+        super({
+            name: "BadGatewayException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BadGatewayException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class DependencyFailedException extends LexRuntimeServiceServiceException {
+    name = "DependencyFailedException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "DependencyFailedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DependencyFailedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class LoopDetectedException extends LexRuntimeServiceServiceException {
+    name = "LoopDetectedException";
+    $fault = "server";
+    Message;
+    constructor(opts) {
+        super({
+            name: "LoopDetectedException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LoopDetectedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class NotAcceptableException extends LexRuntimeServiceServiceException {
+    name = "NotAcceptableException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NotAcceptableException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NotAcceptableException.prototype);
+    }
+}
+class RequestTimeoutException extends LexRuntimeServiceServiceException {
+    name = "RequestTimeoutException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RequestTimeoutException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RequestTimeoutException.prototype);
+    }
+}
+class UnsupportedMediaTypeException extends LexRuntimeServiceServiceException {
+    name = "UnsupportedMediaTypeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UnsupportedMediaTypeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnsupportedMediaTypeException.prototype);
+    }
+}
+
+const _A = "Accept";
+const _AC = "ActiveContext";
+const _ACL = "ActiveContextsList";
+const _ACPM = "ActiveContextParametersMap";
+const _ACTTL = "ActiveContextTimeToLive";
+const _B = "Button";
+const _BGE = "BadGatewayException";
+const _BRE = "BadRequestException";
+const _BS = "BlobStream";
+const _CE = "ConflictException";
+const _CT = "Content-Type";
+const _DA = "DialogAction";
+const _DFE = "DependencyFailedException";
+const _DS = "DeleteSession";
+const _DSR = "DeleteSessionRequest";
+const _DSRe = "DeleteSessionResponse";
+const _GA = "GenericAttachment";
+const _GS = "GetSession";
+const _GSR = "GetSessionRequest";
+const _GSRe = "GetSessionResponse";
+const _IC = "IntentConfidence";
+const _IFE = "InternalFailureException";
+const _IL = "IntentList";
+const _IS = "IntentSummary";
+const _ISL = "IntentSummaryList";
+const _LDE = "LoopDetectedException";
+const _LEE = "LimitExceededException";
+const _M = "Message";
+const _NAE = "NotAcceptableException";
+const _NFE = "NotFoundException";
+const _PC = "PostContent";
+const _PCR = "PostContentRequest";
+const _PCRo = "PostContentResponse";
+const _PI = "PredictedIntent";
+const _PS = "PutSession";
+const _PSR = "PutSessionRequest";
+const _PSRu = "PutSessionResponse";
+const _PT = "PostText";
+const _PTR = "PostTextRequest";
+const _PTRo = "PostTextResponse";
+const _RA = "Retry-After";
+const _RC = "ResponseCard";
+const _RTE = "RequestTimeoutException";
+const _SJACS = "SynthesizedJsonActiveContextsString";
+const _SJAS = "SynthesizedJsonAttributesString";
+const _SJS = "SynthesizedJsonString";
+const _SM = "StringMap";
+const _SR = "SentimentResponse";
+const _SS = "SensitiveString";
+const _SSU = "SensitiveStringUnbounded";
+const _T = "Text";
+const _UMTE = "UnsupportedMediaTypeException";
+const _a = "application/json";
+const _aC = "activeContexts";
+const _aI = "alternativeIntents";
+const _aLU = "attachmentLinkUrl";
+const _aS = "audioStream";
+const _ac = "accept";
+const _b = "buttons";
+const _bA = "botAlias";
+const _bN = "botName";
+const _bV = "botVersion";
+const _c = "client";
+const _cL = "checkpointLabel";
+const _cLF = "checkpointLabelFilter";
+const _cS = "confirmationStatus";
+const _cT = "contentType";
+const _dA = "dialogAction";
+const _dAT = "dialogActionType";
+const _dS = "dialogState";
+const _e = "error";
+const _eIT = "encodedInputTranscript";
+const _eM = "encodedMessage";
+const _fS = "fulfillmentState";
+const _gA = "genericAttachments";
+const _gAL = "genericAttachmentList";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _iN = "intentName";
+const _iS = "inputStream";
+const _iT = "inputTranscript";
+const _iTn = "inputText";
+const _iU = "imageUrl";
+const _lOB = "listOfButtons";
+const _m = "message";
+const _mF = "messageFormat";
+const _mT = "mediaType";
+const _n = "name";
+const _nIC = "nluIntentConfidence";
+const _p = "parameters";
+const _rA = "requestAttributes";
+const _rAS = "retryAfterSeconds";
+const _rC = "responseCard";
+const _rISV = "recentIntentSummaryView";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.lexruntimeservice";
+const _sA = "sessionAttributes";
+const _sI = "sessionId";
+const _sL = "sentimentLabel";
+const _sR = "sentimentResponse";
+const _sS = "sentimentScore";
+const _sT = "subTitle";
+const _sTE = "slotToElicit";
+const _sc = "score";
+const _se = "server";
+const _sen = "sensitive";
+const _sl = "slots";
+const _st = "streaming";
+const _t = "text";
+const _tTL = "timeToLive";
+const _tTLIS = "timeToLiveInSeconds";
+const _tTLu = "turnsToLive";
+const _ti = "title";
+const _ty = "type";
+const _uI = "userId";
+const _v = "value";
+const _ve = "version";
+const _xalac = "x-amz-lex-active-contexts";
+const _xalai = "x-amz-lex-alternative-intents";
+const _xalbv = "x-amz-lex-bot-version";
+const _xalds = "x-amz-lex-dialog-state";
+const _xaleit = "x-amz-lex-encoded-input-transcript";
+const _xalem = "x-amz-lex-encoded-message";
+const _xalin = "x-amz-lex-intent-name";
+const _xalit = "x-amz-lex-input-transcript";
+const _xalm = "x-amz-lex-message";
+const _xalmf = "x-amz-lex-message-format";
+const _xalnic = "x-amz-lex-nlu-intent-confidence";
+const _xalra = "x-amz-lex-request-attributes";
+const _xals = "x-amz-lex-slots";
+const _xals_ = "x-amz-lex-sentiment";
+const _xalsa = "x-amz-lex-session-attributes";
+const _xalsi = "x-amz-lex-session-id";
+const _xalste = "x-amz-lex-slot-to-elicit";
+const n0 = "com.amazonaws.lexruntimeservice";
+const _s_registry = TypeRegistry.for(_s);
+var LexRuntimeServiceServiceException$ = [-3, _s, "LexRuntimeServiceServiceException", 0, [], []];
+_s_registry.registerError(LexRuntimeServiceServiceException$, LexRuntimeServiceServiceException);
+const n0_registry = TypeRegistry.for(n0);
+var BadGatewayException$ = [-3, n0, _BGE,
+    { [_e]: _se, [_hE]: 502 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(BadGatewayException$, BadGatewayException);
+var BadRequestException$ = [-3, n0, _BRE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(BadRequestException$, BadRequestException);
+var ConflictException$ = [-3, n0, _CE,
+    { [_e]: _c, [_hE]: 409 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ConflictException$, ConflictException);
+var DependencyFailedException$ = [-3, n0, _DFE,
+    { [_e]: _c, [_hE]: 424 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(DependencyFailedException$, DependencyFailedException);
+var InternalFailureException$ = [-3, n0, _IFE,
+    { [_e]: _se, [_hE]: 500 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InternalFailureException$, InternalFailureException);
+var LimitExceededException$ = [-3, n0, _LEE,
+    { [_e]: _c, [_hE]: 429 },
+    [_rAS, _m],
+    [[0, { [_hH]: _RA }], 0]
+];
+n0_registry.registerError(LimitExceededException$, LimitExceededException);
+var LoopDetectedException$ = [-3, n0, _LDE,
+    { [_e]: _se, [_hE]: 508 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(LoopDetectedException$, LoopDetectedException);
+var NotAcceptableException$ = [-3, n0, _NAE,
+    { [_e]: _c, [_hE]: 406 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(NotAcceptableException$, NotAcceptableException);
+var NotFoundException$ = [-3, n0, _NFE,
+    { [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(NotFoundException$, NotFoundException);
+var RequestTimeoutException$ = [-3, n0, _RTE,
+    { [_e]: _c, [_hE]: 408 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(RequestTimeoutException$, RequestTimeoutException);
+var UnsupportedMediaTypeException$ = [-3, n0, _UMTE,
+    { [_e]: _c, [_hE]: 415 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UnsupportedMediaTypeException$, UnsupportedMediaTypeException);
+const errorTypeRegistries = [
+    _s_registry,
+    n0_registry,
+];
+var BlobStream = [0, n0, _BS, { [_st]: 1 }, 42];
+var SensitiveString = [0, n0, _SS, 8, 0];
+var SensitiveStringUnbounded = [0, n0, _SSU, 8, 0];
+var SynthesizedJsonActiveContextsString = [0, n0, _SJACS, { [_mT]: _a, [_sen]: 1 }, 0];
+var SynthesizedJsonAttributesString = [0, n0, _SJAS, { [_mT]: _a, [_sen]: 1 }, 0];
+var SynthesizedJsonString = [0, n0, _SJS, { [_mT]: _a }, 0];
+var Text = [0, n0, _T, 8, 0];
+var ActiveContext$ = [3, n0, _AC,
+    0,
+    [_n, _tTL, _p],
+    [0, () => ActiveContextTimeToLive$, [() => ActiveContextParametersMap, 0]], 3
+];
+var ActiveContextTimeToLive$ = [3, n0, _ACTTL,
+    0,
+    [_tTLIS, _tTLu],
+    [1, 1]
+];
+var Button$ = [3, n0, _B,
+    0,
+    [_t, _v],
+    [0, 0], 2
+];
+var DeleteSessionRequest$ = [3, n0, _DSR,
+    0,
+    [_bN, _bA, _uI],
+    [[0, 1], [0, 1], [0, 1]], 3
+];
+var DeleteSessionResponse$ = [3, n0, _DSRe,
+    0,
+    [_bN, _bA, _uI, _sI],
+    [0, 0, 0, 0]
+];
+var DialogAction$ = [3, n0, _DA,
+    0,
+    [_ty, _iN, _sl, _sTE, _fS, _m, _mF],
+    [0, 0, [() => StringMap, 0], 0, 0, [() => Text, 0], 0], 1
+];
+var GenericAttachment$ = [3, n0, _GA,
+    0,
+    [_ti, _sT, _aLU, _iU, _b],
+    [0, 0, 0, 0, () => listOfButtons]
+];
+var GetSessionRequest$ = [3, n0, _GSR,
+    0,
+    [_bN, _bA, _uI, _cLF],
+    [[0, 1], [0, 1], [0, 1], [0, { [_hQ]: _cLF }]], 3
+];
+var GetSessionResponse$ = [3, n0, _GSRe,
+    0,
+    [_rISV, _sA, _sI, _dA, _aC],
+    [[() => IntentSummaryList, 0], [() => StringMap, 0], 0, [() => DialogAction$, 0], [() => ActiveContextsList, 0]]
+];
+var IntentConfidence$ = [3, n0, _IC,
+    0,
+    [_sc],
+    [1]
+];
+var IntentSummary$ = [3, n0, _IS,
+    0,
+    [_dAT, _iN, _cL, _sl, _cS, _fS, _sTE],
+    [0, 0, 0, [() => StringMap, 0], 0, 0, 0], 1
+];
+var PostContentRequest$ = [3, n0, _PCR,
+    0,
+    [_bN, _bA, _uI, _cT, _iS, _sA, _rA, _ac, _aC],
+    [[0, 1], [0, 1], [0, 1], [0, { [_hH]: _CT }], [() => BlobStream, 16], [() => SynthesizedJsonAttributesString, { [_hH]: _xalsa }], [() => SynthesizedJsonAttributesString, { [_hH]: _xalra }], [0, { [_hH]: _A }], [() => SynthesizedJsonActiveContextsString, { [_hH]: _xalac }]], 5
+];
+var PostContentResponse$ = [3, n0, _PCRo,
+    0,
+    [_cT, _iN, _nIC, _aI, _sl, _sA, _sR, _m, _eM, _mF, _dS, _sTE, _iT, _eIT, _aS, _bV, _sI, _aC],
+    [[0, { [_hH]: _CT }], [0, { [_hH]: _xalin }], [() => SynthesizedJsonString, { [_hH]: _xalnic }], [() => SynthesizedJsonString, { [_hH]: _xalai }], [() => SynthesizedJsonString, { [_hH]: _xals }], [() => SynthesizedJsonString, { [_hH]: _xalsa }], [0, { [_hH]: _xals_ }], [() => Text, { [_hH]: _xalm }], [() => SensitiveString, { [_hH]: _xalem }], [0, { [_hH]: _xalmf }], [0, { [_hH]: _xalds }], [0, { [_hH]: _xalste }], [0, { [_hH]: _xalit }], [() => SensitiveStringUnbounded, { [_hH]: _xaleit }], [() => BlobStream, 16], [0, { [_hH]: _xalbv }], [0, { [_hH]: _xalsi }], [() => SynthesizedJsonActiveContextsString, { [_hH]: _xalac }]]
+];
+var PostTextRequest$ = [3, n0, _PTR,
+    0,
+    [_bN, _bA, _uI, _iTn, _sA, _rA, _aC],
+    [[0, 1], [0, 1], [0, 1], [() => Text, 0], [() => StringMap, 0], [() => StringMap, 0], [() => ActiveContextsList, 0]], 4
+];
+var PostTextResponse$ = [3, n0, _PTRo,
+    0,
+    [_iN, _nIC, _aI, _sl, _sA, _m, _sR, _mF, _dS, _sTE, _rC, _sI, _bV, _aC],
+    [0, () => IntentConfidence$, [() => IntentList, 0], [() => StringMap, 0], [() => StringMap, 0], [() => Text, 0], () => SentimentResponse$, 0, 0, 0, () => ResponseCard$, 0, 0, [() => ActiveContextsList, 0]]
+];
+var PredictedIntent$ = [3, n0, _PI,
+    0,
+    [_iN, _nIC, _sl],
+    [0, () => IntentConfidence$, [() => StringMap, 0]]
+];
+var PutSessionRequest$ = [3, n0, _PSR,
+    0,
+    [_bN, _bA, _uI, _sA, _dA, _rISV, _ac, _aC],
+    [[0, 1], [0, 1], [0, 1], [() => StringMap, 0], [() => DialogAction$, 0], [() => IntentSummaryList, 0], [0, { [_hH]: _A }], [() => ActiveContextsList, 0]], 3
+];
+var PutSessionResponse$ = [3, n0, _PSRu,
+    0,
+    [_cT, _iN, _sl, _sA, _m, _eM, _mF, _dS, _sTE, _aS, _sI, _aC],
+    [[0, { [_hH]: _CT }], [0, { [_hH]: _xalin }], [() => SynthesizedJsonString, { [_hH]: _xals }], [() => SynthesizedJsonString, { [_hH]: _xalsa }], [() => Text, { [_hH]: _xalm }], [() => SensitiveString, { [_hH]: _xalem }], [0, { [_hH]: _xalmf }], [0, { [_hH]: _xalds }], [0, { [_hH]: _xalste }], [() => BlobStream, 16], [0, { [_hH]: _xalsi }], [() => SynthesizedJsonActiveContextsString, { [_hH]: _xalac }]]
+];
+var ResponseCard$ = [3, n0, _RC,
+    0,
+    [_ve, _cT, _gA],
+    [0, 0, () => genericAttachmentList]
+];
+var SentimentResponse$ = [3, n0, _SR,
+    0,
+    [_sL, _sS],
+    [0, 0]
+];
+var ActiveContextsList = [1, n0, _ACL,
+    8, [() => ActiveContext$,
+        0]
+];
+var genericAttachmentList = [1, n0, _gAL,
+    0, () => GenericAttachment$
+];
+var IntentList = [1, n0, _IL,
+    0, [() => PredictedIntent$,
+        0]
+];
+var IntentSummaryList = [1, n0, _ISL,
+    0, [() => IntentSummary$,
+        0]
+];
+var listOfButtons = [1, n0, _lOB,
+    0, () => Button$
+];
+var ActiveContextParametersMap = [2, n0, _ACPM,
+    0, [0,
+        0],
+    [() => Text,
+        0]
+];
+var StringMap = [2, n0, _SM,
+    8, 0, 0
+];
+var DeleteSession$ = [9, n0, _DS,
+    { [_h]: ["DELETE", "/bot/{botName}/alias/{botAlias}/user/{userId}/session", 200] }, () => DeleteSessionRequest$, () => DeleteSessionResponse$
+];
+var GetSession$ = [9, n0, _GS,
+    { [_h]: ["GET", "/bot/{botName}/alias/{botAlias}/user/{userId}/session", 200] }, () => GetSessionRequest$, () => GetSessionResponse$
+];
+var PostContent$ = [9, n0, _PC,
+    { [_h]: ["POST", "/bot/{botName}/alias/{botAlias}/user/{userId}/content", 200] }, () => PostContentRequest$, () => PostContentResponse$
+];
+var PostText$ = [9, n0, _PT,
+    { [_h]: ["POST", "/bot/{botName}/alias/{botAlias}/user/{userId}/text", 200] }, () => PostTextRequest$, () => PostTextResponse$
+];
+var PutSession$ = [9, n0, _PS,
+    { [_h]: ["POST", "/bot/{botName}/alias/{botAlias}/user/{userId}/session", 200] }, () => PutSessionRequest$, () => PutSessionResponse$
+];
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2016-11-28",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultLexRuntimeServiceHttpAuthSchemeProvider,
+        httpAuthSchemes: config?.httpAuthSchemes ?? [
+            {
+                schemeId: "aws.auth#sigv4",
+                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+                signer: new AwsSdkSigV4Signer(),
+            },
+        ],
+        logger: config?.logger ?? new NoOpLogger(),
+        protocol: config?.protocol ?? AwsRestJsonProtocol,
+        protocolSettings: config?.protocolSettings ?? {
+            defaultNamespace: "com.amazonaws.lexruntimeservice",
+            errorTypeRegistries,
+            version: "2016-11-28",
+            serviceTarget: "AWSDeepSenseRunTimeService",
+        },
+        sdkStreamMixin: config?.sdkStreamMixin ?? sdkStreamMixin,
+        serviceId: config?.serviceId ?? "Lex Runtime Service",
+        sha256: config?.sha256 ?? Sha256,
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};
+
+const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getRuntimeConfig$1(config);
+    emitWarningIfUnsupportedVersion$1(process.version);
+    const loaderConfig = {
+        profile: config?.profile,
+        logger: clientSharedValues.logger,
+    };
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
+        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            loadConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }, config),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig),
+    };
+};
+
 const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
     const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
     let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
@@ -217,16 +899,66 @@ const ContentType = {
     GENERIC: "application/vnd.amazonaws.card.generic",
 };
 
+exports.ActiveContext$ = ActiveContext$;
+exports.ActiveContextTimeToLive$ = ActiveContextTimeToLive$;
+exports.BadGatewayException = BadGatewayException;
+exports.BadGatewayException$ = BadGatewayException$;
+exports.BadRequestException = BadRequestException;
+exports.BadRequestException$ = BadRequestException$;
+exports.Button$ = Button$;
 exports.ConfirmationStatus = ConfirmationStatus;
+exports.ConflictException = ConflictException;
+exports.ConflictException$ = ConflictException$;
 exports.ContentType = ContentType;
+exports.DeleteSession$ = DeleteSession$;
 exports.DeleteSessionCommand = DeleteSessionCommand;
+exports.DeleteSessionRequest$ = DeleteSessionRequest$;
+exports.DeleteSessionResponse$ = DeleteSessionResponse$;
+exports.DependencyFailedException = DependencyFailedException;
+exports.DependencyFailedException$ = DependencyFailedException$;
+exports.DialogAction$ = DialogAction$;
 exports.DialogActionType = DialogActionType;
 exports.DialogState = DialogState;
 exports.FulfillmentState = FulfillmentState;
+exports.GenericAttachment$ = GenericAttachment$;
+exports.GetSession$ = GetSession$;
 exports.GetSessionCommand = GetSessionCommand;
+exports.GetSessionRequest$ = GetSessionRequest$;
+exports.GetSessionResponse$ = GetSessionResponse$;
+exports.IntentConfidence$ = IntentConfidence$;
+exports.IntentSummary$ = IntentSummary$;
+exports.InternalFailureException = InternalFailureException;
+exports.InternalFailureException$ = InternalFailureException$;
 exports.LexRuntimeService = LexRuntimeService;
 exports.LexRuntimeServiceClient = LexRuntimeServiceClient;
+exports.LexRuntimeServiceServiceException = LexRuntimeServiceServiceException;
+exports.LexRuntimeServiceServiceException$ = LexRuntimeServiceServiceException$;
+exports.LimitExceededException = LimitExceededException;
+exports.LimitExceededException$ = LimitExceededException$;
+exports.LoopDetectedException = LoopDetectedException;
+exports.LoopDetectedException$ = LoopDetectedException$;
 exports.MessageFormatType = MessageFormatType;
+exports.NotAcceptableException = NotAcceptableException;
+exports.NotAcceptableException$ = NotAcceptableException$;
+exports.NotFoundException = NotFoundException;
+exports.NotFoundException$ = NotFoundException$;
+exports.PostContent$ = PostContent$;
 exports.PostContentCommand = PostContentCommand;
+exports.PostContentRequest$ = PostContentRequest$;
+exports.PostContentResponse$ = PostContentResponse$;
+exports.PostText$ = PostText$;
 exports.PostTextCommand = PostTextCommand;
+exports.PostTextRequest$ = PostTextRequest$;
+exports.PostTextResponse$ = PostTextResponse$;
+exports.PredictedIntent$ = PredictedIntent$;
+exports.PutSession$ = PutSession$;
 exports.PutSessionCommand = PutSessionCommand;
+exports.PutSessionRequest$ = PutSessionRequest$;
+exports.PutSessionResponse$ = PutSessionResponse$;
+exports.RequestTimeoutException = RequestTimeoutException;
+exports.RequestTimeoutException$ = RequestTimeoutException$;
+exports.ResponseCard$ = ResponseCard$;
+exports.SentimentResponse$ = SentimentResponse$;
+exports.UnsupportedMediaTypeException = UnsupportedMediaTypeException;
+exports.UnsupportedMediaTypeException$ = UnsupportedMediaTypeException$;
+exports.errorTypeRegistries = errorTypeRegistries;