@aws-sdk/client-lex-runtime-service 3.901.0 → 3.906.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist-cjs/index.js +951 -1124
  2. package/package.json +5 -5
package/dist-cjs/index.js CHANGED
@@ -1,1172 +1,999 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
1
+ 'use strict';
2
+
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
19
+
20
+ const resolveClientEndpointParameters = (options) => {
21
+ return Object.assign(options, {
22
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
23
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
24
+ defaultSigningName: "lex",
25
+ });
10
26
  };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
27
+ const commonParams = {
28
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
29
+ Endpoint: { type: "builtInParams", name: "endpoint" },
30
+ Region: { type: "builtInParams", name: "region" },
31
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
18
32
  };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- ActiveContextFilterSensitiveLog: () => ActiveContextFilterSensitiveLog,
25
- BadGatewayException: () => BadGatewayException,
26
- BadRequestException: () => BadRequestException,
27
- ConfirmationStatus: () => ConfirmationStatus,
28
- ConflictException: () => ConflictException,
29
- ContentType: () => ContentType,
30
- DeleteSessionCommand: () => DeleteSessionCommand,
31
- DependencyFailedException: () => DependencyFailedException,
32
- DialogActionFilterSensitiveLog: () => DialogActionFilterSensitiveLog,
33
- DialogActionType: () => DialogActionType,
34
- DialogState: () => DialogState,
35
- FulfillmentState: () => FulfillmentState,
36
- GetSessionCommand: () => GetSessionCommand,
37
- GetSessionResponseFilterSensitiveLog: () => GetSessionResponseFilterSensitiveLog,
38
- IntentSummaryFilterSensitiveLog: () => IntentSummaryFilterSensitiveLog,
39
- InternalFailureException: () => InternalFailureException,
40
- LexRuntimeService: () => LexRuntimeService,
41
- LexRuntimeServiceClient: () => LexRuntimeServiceClient,
42
- LexRuntimeServiceServiceException: () => LexRuntimeServiceServiceException,
43
- LimitExceededException: () => LimitExceededException,
44
- LoopDetectedException: () => LoopDetectedException,
45
- MessageFormatType: () => MessageFormatType,
46
- NotAcceptableException: () => NotAcceptableException,
47
- NotFoundException: () => NotFoundException,
48
- PostContentCommand: () => PostContentCommand,
49
- PostContentRequestFilterSensitiveLog: () => PostContentRequestFilterSensitiveLog,
50
- PostContentResponseFilterSensitiveLog: () => PostContentResponseFilterSensitiveLog,
51
- PostTextCommand: () => PostTextCommand,
52
- PostTextRequestFilterSensitiveLog: () => PostTextRequestFilterSensitiveLog,
53
- PostTextResponseFilterSensitiveLog: () => PostTextResponseFilterSensitiveLog,
54
- PredictedIntentFilterSensitiveLog: () => PredictedIntentFilterSensitiveLog,
55
- PutSessionCommand: () => PutSessionCommand,
56
- PutSessionRequestFilterSensitiveLog: () => PutSessionRequestFilterSensitiveLog,
57
- PutSessionResponseFilterSensitiveLog: () => PutSessionResponseFilterSensitiveLog,
58
- RequestTimeoutException: () => RequestTimeoutException,
59
- UnsupportedMediaTypeException: () => UnsupportedMediaTypeException,
60
- __Client: () => import_smithy_client.Client
61
- });
62
- module.exports = __toCommonJS(index_exports);
63
-
64
- // src/LexRuntimeServiceClient.ts
65
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
66
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
67
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
68
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
69
- var import_config_resolver = require("@smithy/config-resolver");
70
- var import_core = require("@smithy/core");
71
- var import_middleware_content_length = require("@smithy/middleware-content-length");
72
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
73
- var import_middleware_retry = require("@smithy/middleware-retry");
74
33
 
75
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
76
-
77
- // src/endpoint/EndpointParameters.ts
78
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
79
- return Object.assign(options, {
80
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
81
- useFipsEndpoint: options.useFipsEndpoint ?? false,
82
- defaultSigningName: "lex"
83
- });
84
- }, "resolveClientEndpointParameters");
85
- var commonParams = {
86
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
87
- Endpoint: { type: "builtInParams", name: "endpoint" },
88
- Region: { type: "builtInParams", name: "region" },
89
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
34
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
35
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
36
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
37
+ let _credentials = runtimeConfig.credentials;
38
+ return {
39
+ setHttpAuthScheme(httpAuthScheme) {
40
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
41
+ if (index === -1) {
42
+ _httpAuthSchemes.push(httpAuthScheme);
43
+ }
44
+ else {
45
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
46
+ }
47
+ },
48
+ httpAuthSchemes() {
49
+ return _httpAuthSchemes;
50
+ },
51
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
52
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
53
+ },
54
+ httpAuthSchemeProvider() {
55
+ return _httpAuthSchemeProvider;
56
+ },
57
+ setCredentials(credentials) {
58
+ _credentials = credentials;
59
+ },
60
+ credentials() {
61
+ return _credentials;
62
+ },
63
+ };
64
+ };
65
+ const resolveHttpAuthRuntimeConfig = (config) => {
66
+ return {
67
+ httpAuthSchemes: config.httpAuthSchemes(),
68
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
69
+ credentials: config.credentials(),
70
+ };
90
71
  };
91
72
 
92
- // src/LexRuntimeServiceClient.ts
93
- var import_runtimeConfig = require("././runtimeConfig");
94
-
95
- // src/runtimeExtensions.ts
96
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
97
- var import_protocol_http = require("@smithy/protocol-http");
98
- var import_smithy_client = require("@smithy/smithy-client");
73
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
74
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
75
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
76
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
77
+ };
99
78
 
100
- // src/auth/httpAuthExtensionConfiguration.ts
101
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
102
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
103
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
104
- let _credentials = runtimeConfig.credentials;
105
- return {
106
- setHttpAuthScheme(httpAuthScheme) {
107
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
108
- if (index === -1) {
109
- _httpAuthSchemes.push(httpAuthScheme);
110
- } else {
111
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
112
- }
113
- },
114
- httpAuthSchemes() {
115
- return _httpAuthSchemes;
116
- },
117
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
118
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
119
- },
120
- httpAuthSchemeProvider() {
121
- return _httpAuthSchemeProvider;
122
- },
123
- setCredentials(credentials) {
124
- _credentials = credentials;
125
- },
126
- credentials() {
127
- return _credentials;
79
+ class LexRuntimeServiceClient extends smithyClient.Client {
80
+ config;
81
+ constructor(...[configuration]) {
82
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
83
+ super(_config_0);
84
+ this.initConfig = _config_0;
85
+ const _config_1 = resolveClientEndpointParameters(_config_0);
86
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
87
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
88
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
89
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
90
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
91
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
92
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
93
+ this.config = _config_8;
94
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
95
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
96
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
97
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
98
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
99
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
100
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
101
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultLexRuntimeServiceHttpAuthSchemeParametersProvider,
102
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
103
+ "aws.auth#sigv4": config.credentials,
104
+ }),
105
+ }));
106
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
128
107
  }
129
- };
130
- }, "getHttpAuthExtensionConfiguration");
131
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
132
- return {
133
- httpAuthSchemes: config.httpAuthSchemes(),
134
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
135
- credentials: config.credentials()
136
- };
137
- }, "resolveHttpAuthRuntimeConfig");
138
-
139
- // src/runtimeExtensions.ts
140
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
141
- const extensionConfiguration = Object.assign(
142
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
143
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
144
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
145
- getHttpAuthExtensionConfiguration(runtimeConfig)
146
- );
147
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
148
- return Object.assign(
149
- runtimeConfig,
150
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
151
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
152
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
153
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
154
- );
155
- }, "resolveRuntimeExtensions");
108
+ destroy() {
109
+ super.destroy();
110
+ }
111
+ }
156
112
 
157
- // src/LexRuntimeServiceClient.ts
158
- var LexRuntimeServiceClient = class extends import_smithy_client.Client {
159
- static {
160
- __name(this, "LexRuntimeServiceClient");
161
- }
162
- /**
163
- * The resolved configuration of LexRuntimeServiceClient class. This is resolved and normalized from the {@link LexRuntimeServiceClientConfig | constructor configuration interface}.
164
- */
165
- config;
166
- constructor(...[configuration]) {
167
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
168
- super(_config_0);
169
- this.initConfig = _config_0;
170
- const _config_1 = resolveClientEndpointParameters(_config_0);
171
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
172
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
173
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
174
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
175
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
176
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
177
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
178
- this.config = _config_8;
179
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
180
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
181
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
182
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
183
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
184
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
185
- this.middlewareStack.use(
186
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
187
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultLexRuntimeServiceHttpAuthSchemeParametersProvider,
188
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
189
- "aws.auth#sigv4": config.credentials
190
- }), "identityProviderConfigProvider")
191
- })
192
- );
193
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
194
- }
195
- /**
196
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
197
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
198
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
199
- */
200
- destroy() {
201
- super.destroy();
202
- }
113
+ class LexRuntimeServiceServiceException extends smithyClient.ServiceException {
114
+ constructor(options) {
115
+ super(options);
116
+ Object.setPrototypeOf(this, LexRuntimeServiceServiceException.prototype);
117
+ }
118
+ }
119
+
120
+ class BadRequestException extends LexRuntimeServiceServiceException {
121
+ name = "BadRequestException";
122
+ $fault = "client";
123
+ constructor(opts) {
124
+ super({
125
+ name: "BadRequestException",
126
+ $fault: "client",
127
+ ...opts,
128
+ });
129
+ Object.setPrototypeOf(this, BadRequestException.prototype);
130
+ }
131
+ }
132
+ class ConflictException extends LexRuntimeServiceServiceException {
133
+ name = "ConflictException";
134
+ $fault = "client";
135
+ constructor(opts) {
136
+ super({
137
+ name: "ConflictException",
138
+ $fault: "client",
139
+ ...opts,
140
+ });
141
+ Object.setPrototypeOf(this, ConflictException.prototype);
142
+ }
143
+ }
144
+ class InternalFailureException extends LexRuntimeServiceServiceException {
145
+ name = "InternalFailureException";
146
+ $fault = "server";
147
+ constructor(opts) {
148
+ super({
149
+ name: "InternalFailureException",
150
+ $fault: "server",
151
+ ...opts,
152
+ });
153
+ Object.setPrototypeOf(this, InternalFailureException.prototype);
154
+ }
155
+ }
156
+ class LimitExceededException extends LexRuntimeServiceServiceException {
157
+ name = "LimitExceededException";
158
+ $fault = "client";
159
+ retryAfterSeconds;
160
+ constructor(opts) {
161
+ super({
162
+ name: "LimitExceededException",
163
+ $fault: "client",
164
+ ...opts,
165
+ });
166
+ Object.setPrototypeOf(this, LimitExceededException.prototype);
167
+ this.retryAfterSeconds = opts.retryAfterSeconds;
168
+ }
169
+ }
170
+ class NotFoundException extends LexRuntimeServiceServiceException {
171
+ name = "NotFoundException";
172
+ $fault = "client";
173
+ constructor(opts) {
174
+ super({
175
+ name: "NotFoundException",
176
+ $fault: "client",
177
+ ...opts,
178
+ });
179
+ Object.setPrototypeOf(this, NotFoundException.prototype);
180
+ }
181
+ }
182
+ const FulfillmentState = {
183
+ FAILED: "Failed",
184
+ FULFILLED: "Fulfilled",
185
+ READY_FOR_FULFILLMENT: "ReadyForFulfillment",
203
186
  };
204
-
205
- // src/LexRuntimeService.ts
206
-
207
-
208
- // src/commands/DeleteSessionCommand.ts
209
-
210
- var import_middleware_serde = require("@smithy/middleware-serde");
211
-
212
-
213
- // src/protocols/Aws_restJson1.ts
214
- var import_core2 = require("@aws-sdk/core");
215
-
216
-
217
-
218
- // src/models/LexRuntimeServiceServiceException.ts
219
-
220
- var LexRuntimeServiceServiceException = class _LexRuntimeServiceServiceException extends import_smithy_client.ServiceException {
221
- static {
222
- __name(this, "LexRuntimeServiceServiceException");
223
- }
224
- /**
225
- * @internal
226
- */
227
- constructor(options) {
228
- super(options);
229
- Object.setPrototypeOf(this, _LexRuntimeServiceServiceException.prototype);
230
- }
187
+ const MessageFormatType = {
188
+ COMPOSITE: "Composite",
189
+ CUSTOM_PAYLOAD: "CustomPayload",
190
+ PLAIN_TEXT: "PlainText",
191
+ SSML: "SSML",
231
192
  };
193
+ const DialogActionType = {
194
+ CLOSE: "Close",
195
+ CONFIRM_INTENT: "ConfirmIntent",
196
+ DELEGATE: "Delegate",
197
+ ELICIT_INTENT: "ElicitIntent",
198
+ ELICIT_SLOT: "ElicitSlot",
199
+ };
200
+ const ConfirmationStatus = {
201
+ CONFIRMED: "Confirmed",
202
+ DENIED: "Denied",
203
+ NONE: "None",
204
+ };
205
+ class BadGatewayException extends LexRuntimeServiceServiceException {
206
+ name = "BadGatewayException";
207
+ $fault = "server";
208
+ Message;
209
+ constructor(opts) {
210
+ super({
211
+ name: "BadGatewayException",
212
+ $fault: "server",
213
+ ...opts,
214
+ });
215
+ Object.setPrototypeOf(this, BadGatewayException.prototype);
216
+ this.Message = opts.Message;
217
+ }
218
+ }
219
+ class DependencyFailedException extends LexRuntimeServiceServiceException {
220
+ name = "DependencyFailedException";
221
+ $fault = "client";
222
+ Message;
223
+ constructor(opts) {
224
+ super({
225
+ name: "DependencyFailedException",
226
+ $fault: "client",
227
+ ...opts,
228
+ });
229
+ Object.setPrototypeOf(this, DependencyFailedException.prototype);
230
+ this.Message = opts.Message;
231
+ }
232
+ }
233
+ class LoopDetectedException extends LexRuntimeServiceServiceException {
234
+ name = "LoopDetectedException";
235
+ $fault = "server";
236
+ Message;
237
+ constructor(opts) {
238
+ super({
239
+ name: "LoopDetectedException",
240
+ $fault: "server",
241
+ ...opts,
242
+ });
243
+ Object.setPrototypeOf(this, LoopDetectedException.prototype);
244
+ this.Message = opts.Message;
245
+ }
246
+ }
247
+ class NotAcceptableException extends LexRuntimeServiceServiceException {
248
+ name = "NotAcceptableException";
249
+ $fault = "client";
250
+ constructor(opts) {
251
+ super({
252
+ name: "NotAcceptableException",
253
+ $fault: "client",
254
+ ...opts,
255
+ });
256
+ Object.setPrototypeOf(this, NotAcceptableException.prototype);
257
+ }
258
+ }
259
+ const DialogState = {
260
+ CONFIRM_INTENT: "ConfirmIntent",
261
+ ELICIT_INTENT: "ElicitIntent",
262
+ ELICIT_SLOT: "ElicitSlot",
263
+ FAILED: "Failed",
264
+ FULFILLED: "Fulfilled",
265
+ READY_FOR_FULFILLMENT: "ReadyForFulfillment",
266
+ };
267
+ class RequestTimeoutException extends LexRuntimeServiceServiceException {
268
+ name = "RequestTimeoutException";
269
+ $fault = "client";
270
+ constructor(opts) {
271
+ super({
272
+ name: "RequestTimeoutException",
273
+ $fault: "client",
274
+ ...opts,
275
+ });
276
+ Object.setPrototypeOf(this, RequestTimeoutException.prototype);
277
+ }
278
+ }
279
+ class UnsupportedMediaTypeException extends LexRuntimeServiceServiceException {
280
+ name = "UnsupportedMediaTypeException";
281
+ $fault = "client";
282
+ constructor(opts) {
283
+ super({
284
+ name: "UnsupportedMediaTypeException",
285
+ $fault: "client",
286
+ ...opts,
287
+ });
288
+ Object.setPrototypeOf(this, UnsupportedMediaTypeException.prototype);
289
+ }
290
+ }
291
+ const ContentType = {
292
+ GENERIC: "application/vnd.amazonaws.card.generic",
293
+ };
294
+ const ActiveContextFilterSensitiveLog = (obj) => ({
295
+ ...obj,
296
+ ...(obj.parameters && { parameters: smithyClient.SENSITIVE_STRING }),
297
+ });
298
+ const DialogActionFilterSensitiveLog = (obj) => ({
299
+ ...obj,
300
+ ...(obj.slots && { slots: smithyClient.SENSITIVE_STRING }),
301
+ ...(obj.message && { message: smithyClient.SENSITIVE_STRING }),
302
+ });
303
+ const IntentSummaryFilterSensitiveLog = (obj) => ({
304
+ ...obj,
305
+ ...(obj.slots && { slots: smithyClient.SENSITIVE_STRING }),
306
+ });
307
+ const GetSessionResponseFilterSensitiveLog = (obj) => ({
308
+ ...obj,
309
+ ...(obj.recentIntentSummaryView && {
310
+ recentIntentSummaryView: obj.recentIntentSummaryView.map((item) => IntentSummaryFilterSensitiveLog(item)),
311
+ }),
312
+ ...(obj.sessionAttributes && { sessionAttributes: smithyClient.SENSITIVE_STRING }),
313
+ ...(obj.dialogAction && { dialogAction: DialogActionFilterSensitiveLog(obj.dialogAction) }),
314
+ ...(obj.activeContexts && { activeContexts: smithyClient.SENSITIVE_STRING }),
315
+ });
316
+ const PostContentRequestFilterSensitiveLog = (obj) => ({
317
+ ...obj,
318
+ ...(obj.sessionAttributes && { sessionAttributes: smithyClient.SENSITIVE_STRING }),
319
+ ...(obj.requestAttributes && { requestAttributes: smithyClient.SENSITIVE_STRING }),
320
+ ...(obj.activeContexts && { activeContexts: smithyClient.SENSITIVE_STRING }),
321
+ });
322
+ const PostContentResponseFilterSensitiveLog = (obj) => ({
323
+ ...obj,
324
+ ...(obj.message && { message: smithyClient.SENSITIVE_STRING }),
325
+ ...(obj.encodedMessage && { encodedMessage: smithyClient.SENSITIVE_STRING }),
326
+ ...(obj.encodedInputTranscript && { encodedInputTranscript: smithyClient.SENSITIVE_STRING }),
327
+ ...(obj.activeContexts && { activeContexts: smithyClient.SENSITIVE_STRING }),
328
+ });
329
+ const PostTextRequestFilterSensitiveLog = (obj) => ({
330
+ ...obj,
331
+ ...(obj.sessionAttributes && { sessionAttributes: smithyClient.SENSITIVE_STRING }),
332
+ ...(obj.requestAttributes && { requestAttributes: smithyClient.SENSITIVE_STRING }),
333
+ ...(obj.inputText && { inputText: smithyClient.SENSITIVE_STRING }),
334
+ ...(obj.activeContexts && { activeContexts: smithyClient.SENSITIVE_STRING }),
335
+ });
336
+ const PredictedIntentFilterSensitiveLog = (obj) => ({
337
+ ...obj,
338
+ ...(obj.slots && { slots: smithyClient.SENSITIVE_STRING }),
339
+ });
340
+ const PostTextResponseFilterSensitiveLog = (obj) => ({
341
+ ...obj,
342
+ ...(obj.alternativeIntents && {
343
+ alternativeIntents: obj.alternativeIntents.map((item) => PredictedIntentFilterSensitiveLog(item)),
344
+ }),
345
+ ...(obj.slots && { slots: smithyClient.SENSITIVE_STRING }),
346
+ ...(obj.sessionAttributes && { sessionAttributes: smithyClient.SENSITIVE_STRING }),
347
+ ...(obj.message && { message: smithyClient.SENSITIVE_STRING }),
348
+ ...(obj.activeContexts && { activeContexts: smithyClient.SENSITIVE_STRING }),
349
+ });
350
+ const PutSessionRequestFilterSensitiveLog = (obj) => ({
351
+ ...obj,
352
+ ...(obj.sessionAttributes && { sessionAttributes: smithyClient.SENSITIVE_STRING }),
353
+ ...(obj.dialogAction && { dialogAction: DialogActionFilterSensitiveLog(obj.dialogAction) }),
354
+ ...(obj.recentIntentSummaryView && {
355
+ recentIntentSummaryView: obj.recentIntentSummaryView.map((item) => IntentSummaryFilterSensitiveLog(item)),
356
+ }),
357
+ ...(obj.activeContexts && { activeContexts: smithyClient.SENSITIVE_STRING }),
358
+ });
359
+ const PutSessionResponseFilterSensitiveLog = (obj) => ({
360
+ ...obj,
361
+ ...(obj.message && { message: smithyClient.SENSITIVE_STRING }),
362
+ ...(obj.encodedMessage && { encodedMessage: smithyClient.SENSITIVE_STRING }),
363
+ ...(obj.activeContexts && { activeContexts: smithyClient.SENSITIVE_STRING }),
364
+ });
232
365
 
233
- // src/models/models_0.ts
234
-
235
- var BadRequestException = class _BadRequestException extends LexRuntimeServiceServiceException {
236
- static {
237
- __name(this, "BadRequestException");
238
- }
239
- name = "BadRequestException";
240
- $fault = "client";
241
- /**
242
- * @internal
243
- */
244
- constructor(opts) {
245
- super({
246
- name: "BadRequestException",
247
- $fault: "client",
248
- ...opts
366
+ const se_DeleteSessionCommand = async (input, context) => {
367
+ const b = core.requestBuilder(input, context);
368
+ const headers = {};
369
+ b.bp("/bot/{botName}/alias/{botAlias}/user/{userId}/session");
370
+ b.p("botName", () => input.botName, "{botName}", false);
371
+ b.p("botAlias", () => input.botAlias, "{botAlias}", false);
372
+ b.p("userId", () => input.userId, "{userId}", false);
373
+ let body;
374
+ b.m("DELETE").h(headers).b(body);
375
+ return b.build();
376
+ };
377
+ const se_GetSessionCommand = async (input, context) => {
378
+ const b = core.requestBuilder(input, context);
379
+ const headers = {};
380
+ b.bp("/bot/{botName}/alias/{botAlias}/user/{userId}/session");
381
+ b.p("botName", () => input.botName, "{botName}", false);
382
+ b.p("botAlias", () => input.botAlias, "{botAlias}", false);
383
+ b.p("userId", () => input.userId, "{userId}", false);
384
+ const query = smithyClient.map({
385
+ [_cLF]: [, input[_cLF]],
249
386
  });
250
- Object.setPrototypeOf(this, _BadRequestException.prototype);
251
- }
387
+ let body;
388
+ b.m("GET").h(headers).q(query).b(body);
389
+ return b.build();
252
390
  };
253
- var ConflictException = class _ConflictException extends LexRuntimeServiceServiceException {
254
- static {
255
- __name(this, "ConflictException");
256
- }
257
- name = "ConflictException";
258
- $fault = "client";
259
- /**
260
- * @internal
261
- */
262
- constructor(opts) {
263
- super({
264
- name: "ConflictException",
265
- $fault: "client",
266
- ...opts
391
+ const se_PostContentCommand = async (input, context) => {
392
+ const b = core.requestBuilder(input, context);
393
+ const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
394
+ "x-amz-content-sha256": "UNSIGNED-PAYLOAD",
395
+ [_ct]: input[_cT] || "application/octet-stream",
396
+ [_xalsa]: [
397
+ () => smithyClient.isSerializableHeaderValue(input[_sA]),
398
+ () => context.base64Encoder(Buffer.from(smithyClient.LazyJsonString.from(input[_sA]))),
399
+ ],
400
+ [_xalra]: [
401
+ () => smithyClient.isSerializableHeaderValue(input[_rA]),
402
+ () => context.base64Encoder(Buffer.from(smithyClient.LazyJsonString.from(input[_rA]))),
403
+ ],
404
+ [_a]: input[_a],
405
+ [_xalac]: [
406
+ () => smithyClient.isSerializableHeaderValue(input[_aC]),
407
+ () => context.base64Encoder(Buffer.from(smithyClient.LazyJsonString.from(input[_aC]))),
408
+ ],
267
409
  });
268
- Object.setPrototypeOf(this, _ConflictException.prototype);
269
- }
410
+ b.bp("/bot/{botName}/alias/{botAlias}/user/{userId}/content");
411
+ b.p("botName", () => input.botName, "{botName}", false);
412
+ b.p("botAlias", () => input.botAlias, "{botAlias}", false);
413
+ b.p("userId", () => input.userId, "{userId}", false);
414
+ let body;
415
+ if (input.inputStream !== undefined) {
416
+ body = input.inputStream;
417
+ }
418
+ b.m("POST").h(headers).b(body);
419
+ return b.build();
270
420
  };
271
- var InternalFailureException = class _InternalFailureException extends LexRuntimeServiceServiceException {
272
- static {
273
- __name(this, "InternalFailureException");
274
- }
275
- name = "InternalFailureException";
276
- $fault = "server";
277
- /**
278
- * @internal
279
- */
280
- constructor(opts) {
281
- super({
282
- name: "InternalFailureException",
283
- $fault: "server",
284
- ...opts
421
+ const se_PostTextCommand = async (input, context) => {
422
+ const b = core.requestBuilder(input, context);
423
+ const headers = {
424
+ "content-type": "application/json",
425
+ };
426
+ b.bp("/bot/{botName}/alias/{botAlias}/user/{userId}/text");
427
+ b.p("botName", () => input.botName, "{botName}", false);
428
+ b.p("botAlias", () => input.botAlias, "{botAlias}", false);
429
+ b.p("userId", () => input.userId, "{userId}", false);
430
+ let body;
431
+ body = JSON.stringify(smithyClient.take(input, {
432
+ activeContexts: (_) => smithyClient._json(_),
433
+ inputText: [],
434
+ requestAttributes: (_) => smithyClient._json(_),
435
+ sessionAttributes: (_) => smithyClient._json(_),
436
+ }));
437
+ b.m("POST").h(headers).b(body);
438
+ return b.build();
439
+ };
440
+ const se_PutSessionCommand = async (input, context) => {
441
+ const b = core.requestBuilder(input, context);
442
+ const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
443
+ "content-type": "application/json",
444
+ [_a]: input[_a],
285
445
  });
286
- Object.setPrototypeOf(this, _InternalFailureException.prototype);
287
- }
446
+ b.bp("/bot/{botName}/alias/{botAlias}/user/{userId}/session");
447
+ b.p("botName", () => input.botName, "{botName}", false);
448
+ b.p("botAlias", () => input.botAlias, "{botAlias}", false);
449
+ b.p("userId", () => input.userId, "{userId}", false);
450
+ let body;
451
+ body = JSON.stringify(smithyClient.take(input, {
452
+ activeContexts: (_) => smithyClient._json(_),
453
+ dialogAction: (_) => smithyClient._json(_),
454
+ recentIntentSummaryView: (_) => smithyClient._json(_),
455
+ sessionAttributes: (_) => smithyClient._json(_),
456
+ }));
457
+ b.m("POST").h(headers).b(body);
458
+ return b.build();
288
459
  };
289
- var LimitExceededException = class _LimitExceededException extends LexRuntimeServiceServiceException {
290
- static {
291
- __name(this, "LimitExceededException");
292
- }
293
- name = "LimitExceededException";
294
- $fault = "client";
295
- retryAfterSeconds;
296
- /**
297
- * @internal
298
- */
299
- constructor(opts) {
300
- super({
301
- name: "LimitExceededException",
302
- $fault: "client",
303
- ...opts
460
+ const de_DeleteSessionCommand = async (output, context) => {
461
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
462
+ return de_CommandError(output, context);
463
+ }
464
+ const contents = smithyClient.map({
465
+ $metadata: deserializeMetadata(output),
466
+ });
467
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
468
+ const doc = smithyClient.take(data, {
469
+ botAlias: smithyClient.expectString,
470
+ botName: smithyClient.expectString,
471
+ sessionId: smithyClient.expectString,
472
+ userId: smithyClient.expectString,
304
473
  });
305
- Object.setPrototypeOf(this, _LimitExceededException.prototype);
306
- this.retryAfterSeconds = opts.retryAfterSeconds;
307
- }
474
+ Object.assign(contents, doc);
475
+ return contents;
308
476
  };
309
- var NotFoundException = class _NotFoundException extends LexRuntimeServiceServiceException {
310
- static {
311
- __name(this, "NotFoundException");
312
- }
313
- name = "NotFoundException";
314
- $fault = "client";
315
- /**
316
- * @internal
317
- */
318
- constructor(opts) {
319
- super({
320
- name: "NotFoundException",
321
- $fault: "client",
322
- ...opts
477
+ const de_GetSessionCommand = async (output, context) => {
478
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
479
+ return de_CommandError(output, context);
480
+ }
481
+ const contents = smithyClient.map({
482
+ $metadata: deserializeMetadata(output),
483
+ });
484
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
485
+ const doc = smithyClient.take(data, {
486
+ activeContexts: smithyClient._json,
487
+ dialogAction: smithyClient._json,
488
+ recentIntentSummaryView: smithyClient._json,
489
+ sessionAttributes: smithyClient._json,
490
+ sessionId: smithyClient.expectString,
323
491
  });
324
- Object.setPrototypeOf(this, _NotFoundException.prototype);
325
- }
492
+ Object.assign(contents, doc);
493
+ return contents;
326
494
  };
327
- var FulfillmentState = {
328
- FAILED: "Failed",
329
- FULFILLED: "Fulfilled",
330
- READY_FOR_FULFILLMENT: "ReadyForFulfillment"
495
+ const de_PostContentCommand = async (output, context) => {
496
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
497
+ return de_CommandError(output, context);
498
+ }
499
+ const contents = smithyClient.map({
500
+ $metadata: deserializeMetadata(output),
501
+ [_cT]: [, output.headers[_ct]],
502
+ [_iN]: [, output.headers[_xalin]],
503
+ [_nIC]: [
504
+ () => void 0 !== output.headers[_xalnic],
505
+ () => smithyClient.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalnic])).toString("utf8")),
506
+ ],
507
+ [_aI]: [
508
+ () => void 0 !== output.headers[_xalai],
509
+ () => smithyClient.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalai])).toString("utf8")),
510
+ ],
511
+ [_s]: [
512
+ () => void 0 !== output.headers[_xals],
513
+ () => smithyClient.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xals])).toString("utf8")),
514
+ ],
515
+ [_sA]: [
516
+ () => void 0 !== output.headers[_xalsa],
517
+ () => smithyClient.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalsa])).toString("utf8")),
518
+ ],
519
+ [_sR]: [, output.headers[_xals_]],
520
+ [_m]: [, output.headers[_xalm]],
521
+ [_eM]: [, output.headers[_xalem]],
522
+ [_mF]: [, output.headers[_xalmf]],
523
+ [_dS]: [, output.headers[_xalds]],
524
+ [_sTE]: [, output.headers[_xalste]],
525
+ [_iT]: [, output.headers[_xalit]],
526
+ [_eIT]: [, output.headers[_xaleit]],
527
+ [_bV]: [, output.headers[_xalbv]],
528
+ [_sI]: [, output.headers[_xalsi]],
529
+ [_aC]: [
530
+ () => void 0 !== output.headers[_xalac],
531
+ () => smithyClient.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalac])).toString("utf8")),
532
+ ],
533
+ });
534
+ const data = output.body;
535
+ context.sdkStreamMixin(data);
536
+ contents.audioStream = data;
537
+ return contents;
331
538
  };
332
- var MessageFormatType = {
333
- COMPOSITE: "Composite",
334
- CUSTOM_PAYLOAD: "CustomPayload",
335
- PLAIN_TEXT: "PlainText",
336
- SSML: "SSML"
539
+ const de_PostTextCommand = async (output, context) => {
540
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
541
+ return de_CommandError(output, context);
542
+ }
543
+ const contents = smithyClient.map({
544
+ $metadata: deserializeMetadata(output),
545
+ });
546
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
547
+ const doc = smithyClient.take(data, {
548
+ activeContexts: smithyClient._json,
549
+ alternativeIntents: (_) => de_IntentList(_),
550
+ botVersion: smithyClient.expectString,
551
+ dialogState: smithyClient.expectString,
552
+ intentName: smithyClient.expectString,
553
+ message: smithyClient.expectString,
554
+ messageFormat: smithyClient.expectString,
555
+ nluIntentConfidence: (_) => de_IntentConfidence(_),
556
+ responseCard: smithyClient._json,
557
+ sentimentResponse: smithyClient._json,
558
+ sessionAttributes: smithyClient._json,
559
+ sessionId: smithyClient.expectString,
560
+ slotToElicit: smithyClient.expectString,
561
+ slots: smithyClient._json,
562
+ });
563
+ Object.assign(contents, doc);
564
+ return contents;
337
565
  };
338
- var DialogActionType = {
339
- CLOSE: "Close",
340
- CONFIRM_INTENT: "ConfirmIntent",
341
- DELEGATE: "Delegate",
342
- ELICIT_INTENT: "ElicitIntent",
343
- ELICIT_SLOT: "ElicitSlot"
566
+ const de_PutSessionCommand = async (output, context) => {
567
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
568
+ return de_CommandError(output, context);
569
+ }
570
+ const contents = smithyClient.map({
571
+ $metadata: deserializeMetadata(output),
572
+ [_cT]: [, output.headers[_ct]],
573
+ [_iN]: [, output.headers[_xalin]],
574
+ [_s]: [
575
+ () => void 0 !== output.headers[_xals],
576
+ () => smithyClient.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xals])).toString("utf8")),
577
+ ],
578
+ [_sA]: [
579
+ () => void 0 !== output.headers[_xalsa],
580
+ () => smithyClient.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalsa])).toString("utf8")),
581
+ ],
582
+ [_m]: [, output.headers[_xalm]],
583
+ [_eM]: [, output.headers[_xalem]],
584
+ [_mF]: [, output.headers[_xalmf]],
585
+ [_dS]: [, output.headers[_xalds]],
586
+ [_sTE]: [, output.headers[_xalste]],
587
+ [_sI]: [, output.headers[_xalsi]],
588
+ [_aC]: [
589
+ () => void 0 !== output.headers[_xalac],
590
+ () => smithyClient.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalac])).toString("utf8")),
591
+ ],
592
+ });
593
+ const data = output.body;
594
+ context.sdkStreamMixin(data);
595
+ contents.audioStream = data;
596
+ return contents;
344
597
  };
345
- var ConfirmationStatus = {
346
- CONFIRMED: "Confirmed",
347
- DENIED: "Denied",
348
- NONE: "None"
598
+ const de_CommandError = async (output, context) => {
599
+ const parsedOutput = {
600
+ ...output,
601
+ body: await core$1.parseJsonErrorBody(output.body, context),
602
+ };
603
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
604
+ switch (errorCode) {
605
+ case "BadRequestException":
606
+ case "com.amazonaws.lexruntimeservice#BadRequestException":
607
+ throw await de_BadRequestExceptionRes(parsedOutput);
608
+ case "ConflictException":
609
+ case "com.amazonaws.lexruntimeservice#ConflictException":
610
+ throw await de_ConflictExceptionRes(parsedOutput);
611
+ case "InternalFailureException":
612
+ case "com.amazonaws.lexruntimeservice#InternalFailureException":
613
+ throw await de_InternalFailureExceptionRes(parsedOutput);
614
+ case "LimitExceededException":
615
+ case "com.amazonaws.lexruntimeservice#LimitExceededException":
616
+ throw await de_LimitExceededExceptionRes(parsedOutput);
617
+ case "NotFoundException":
618
+ case "com.amazonaws.lexruntimeservice#NotFoundException":
619
+ throw await de_NotFoundExceptionRes(parsedOutput);
620
+ case "BadGatewayException":
621
+ case "com.amazonaws.lexruntimeservice#BadGatewayException":
622
+ throw await de_BadGatewayExceptionRes(parsedOutput);
623
+ case "DependencyFailedException":
624
+ case "com.amazonaws.lexruntimeservice#DependencyFailedException":
625
+ throw await de_DependencyFailedExceptionRes(parsedOutput);
626
+ case "LoopDetectedException":
627
+ case "com.amazonaws.lexruntimeservice#LoopDetectedException":
628
+ throw await de_LoopDetectedExceptionRes(parsedOutput);
629
+ case "NotAcceptableException":
630
+ case "com.amazonaws.lexruntimeservice#NotAcceptableException":
631
+ throw await de_NotAcceptableExceptionRes(parsedOutput);
632
+ case "RequestTimeoutException":
633
+ case "com.amazonaws.lexruntimeservice#RequestTimeoutException":
634
+ throw await de_RequestTimeoutExceptionRes(parsedOutput);
635
+ case "UnsupportedMediaTypeException":
636
+ case "com.amazonaws.lexruntimeservice#UnsupportedMediaTypeException":
637
+ throw await de_UnsupportedMediaTypeExceptionRes(parsedOutput);
638
+ default:
639
+ const parsedBody = parsedOutput.body;
640
+ return throwDefaultError({
641
+ output,
642
+ parsedBody,
643
+ errorCode,
644
+ });
645
+ }
349
646
  };
350
- var BadGatewayException = class _BadGatewayException extends LexRuntimeServiceServiceException {
351
- static {
352
- __name(this, "BadGatewayException");
353
- }
354
- name = "BadGatewayException";
355
- $fault = "server";
356
- Message;
357
- /**
358
- * @internal
359
- */
360
- constructor(opts) {
361
- super({
362
- name: "BadGatewayException",
363
- $fault: "server",
364
- ...opts
647
+ const throwDefaultError = smithyClient.withBaseException(LexRuntimeServiceServiceException);
648
+ const de_BadGatewayExceptionRes = async (parsedOutput, context) => {
649
+ const contents = smithyClient.map({});
650
+ const data = parsedOutput.body;
651
+ const doc = smithyClient.take(data, {
652
+ Message: smithyClient.expectString,
365
653
  });
366
- Object.setPrototypeOf(this, _BadGatewayException.prototype);
367
- this.Message = opts.Message;
368
- }
654
+ Object.assign(contents, doc);
655
+ const exception = new BadGatewayException({
656
+ $metadata: deserializeMetadata(parsedOutput),
657
+ ...contents,
658
+ });
659
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
369
660
  };
370
- var DependencyFailedException = class _DependencyFailedException extends LexRuntimeServiceServiceException {
371
- static {
372
- __name(this, "DependencyFailedException");
373
- }
374
- name = "DependencyFailedException";
375
- $fault = "client";
376
- Message;
377
- /**
378
- * @internal
379
- */
380
- constructor(opts) {
381
- super({
382
- name: "DependencyFailedException",
383
- $fault: "client",
384
- ...opts
661
+ const de_BadRequestExceptionRes = async (parsedOutput, context) => {
662
+ const contents = smithyClient.map({});
663
+ const data = parsedOutput.body;
664
+ const doc = smithyClient.take(data, {
665
+ message: smithyClient.expectString,
666
+ });
667
+ Object.assign(contents, doc);
668
+ const exception = new BadRequestException({
669
+ $metadata: deserializeMetadata(parsedOutput),
670
+ ...contents,
385
671
  });
386
- Object.setPrototypeOf(this, _DependencyFailedException.prototype);
387
- this.Message = opts.Message;
388
- }
672
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
389
673
  };
390
- var LoopDetectedException = class _LoopDetectedException extends LexRuntimeServiceServiceException {
391
- static {
392
- __name(this, "LoopDetectedException");
393
- }
394
- name = "LoopDetectedException";
395
- $fault = "server";
396
- Message;
397
- /**
398
- * @internal
399
- */
400
- constructor(opts) {
401
- super({
402
- name: "LoopDetectedException",
403
- $fault: "server",
404
- ...opts
674
+ const de_ConflictExceptionRes = async (parsedOutput, context) => {
675
+ const contents = smithyClient.map({});
676
+ const data = parsedOutput.body;
677
+ const doc = smithyClient.take(data, {
678
+ message: smithyClient.expectString,
679
+ });
680
+ Object.assign(contents, doc);
681
+ const exception = new ConflictException({
682
+ $metadata: deserializeMetadata(parsedOutput),
683
+ ...contents,
405
684
  });
406
- Object.setPrototypeOf(this, _LoopDetectedException.prototype);
407
- this.Message = opts.Message;
408
- }
685
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
409
686
  };
410
- var NotAcceptableException = class _NotAcceptableException extends LexRuntimeServiceServiceException {
411
- static {
412
- __name(this, "NotAcceptableException");
413
- }
414
- name = "NotAcceptableException";
415
- $fault = "client";
416
- /**
417
- * @internal
418
- */
419
- constructor(opts) {
420
- super({
421
- name: "NotAcceptableException",
422
- $fault: "client",
423
- ...opts
687
+ const de_DependencyFailedExceptionRes = async (parsedOutput, context) => {
688
+ const contents = smithyClient.map({});
689
+ const data = parsedOutput.body;
690
+ const doc = smithyClient.take(data, {
691
+ Message: smithyClient.expectString,
424
692
  });
425
- Object.setPrototypeOf(this, _NotAcceptableException.prototype);
426
- }
693
+ Object.assign(contents, doc);
694
+ const exception = new DependencyFailedException({
695
+ $metadata: deserializeMetadata(parsedOutput),
696
+ ...contents,
697
+ });
698
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
427
699
  };
428
- var DialogState = {
429
- CONFIRM_INTENT: "ConfirmIntent",
430
- ELICIT_INTENT: "ElicitIntent",
431
- ELICIT_SLOT: "ElicitSlot",
432
- FAILED: "Failed",
433
- FULFILLED: "Fulfilled",
434
- READY_FOR_FULFILLMENT: "ReadyForFulfillment"
700
+ const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
701
+ const contents = smithyClient.map({});
702
+ const data = parsedOutput.body;
703
+ const doc = smithyClient.take(data, {
704
+ message: smithyClient.expectString,
705
+ });
706
+ Object.assign(contents, doc);
707
+ const exception = new InternalFailureException({
708
+ $metadata: deserializeMetadata(parsedOutput),
709
+ ...contents,
710
+ });
711
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
435
712
  };
436
- var RequestTimeoutException = class _RequestTimeoutException extends LexRuntimeServiceServiceException {
437
- static {
438
- __name(this, "RequestTimeoutException");
439
- }
440
- name = "RequestTimeoutException";
441
- $fault = "client";
442
- /**
443
- * @internal
444
- */
445
- constructor(opts) {
446
- super({
447
- name: "RequestTimeoutException",
448
- $fault: "client",
449
- ...opts
713
+ const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
714
+ const contents = smithyClient.map({
715
+ [_rAS]: [, parsedOutput.headers[_ra]],
716
+ });
717
+ const data = parsedOutput.body;
718
+ const doc = smithyClient.take(data, {
719
+ message: smithyClient.expectString,
450
720
  });
451
- Object.setPrototypeOf(this, _RequestTimeoutException.prototype);
452
- }
721
+ Object.assign(contents, doc);
722
+ const exception = new LimitExceededException({
723
+ $metadata: deserializeMetadata(parsedOutput),
724
+ ...contents,
725
+ });
726
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
453
727
  };
454
- var UnsupportedMediaTypeException = class _UnsupportedMediaTypeException extends LexRuntimeServiceServiceException {
455
- static {
456
- __name(this, "UnsupportedMediaTypeException");
457
- }
458
- name = "UnsupportedMediaTypeException";
459
- $fault = "client";
460
- /**
461
- * @internal
462
- */
463
- constructor(opts) {
464
- super({
465
- name: "UnsupportedMediaTypeException",
466
- $fault: "client",
467
- ...opts
728
+ const de_LoopDetectedExceptionRes = async (parsedOutput, context) => {
729
+ const contents = smithyClient.map({});
730
+ const data = parsedOutput.body;
731
+ const doc = smithyClient.take(data, {
732
+ Message: smithyClient.expectString,
733
+ });
734
+ Object.assign(contents, doc);
735
+ const exception = new LoopDetectedException({
736
+ $metadata: deserializeMetadata(parsedOutput),
737
+ ...contents,
468
738
  });
469
- Object.setPrototypeOf(this, _UnsupportedMediaTypeException.prototype);
470
- }
739
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
471
740
  };
472
- var ContentType = {
473
- GENERIC: "application/vnd.amazonaws.card.generic"
741
+ const de_NotAcceptableExceptionRes = async (parsedOutput, context) => {
742
+ const contents = smithyClient.map({});
743
+ const data = parsedOutput.body;
744
+ const doc = smithyClient.take(data, {
745
+ message: smithyClient.expectString,
746
+ });
747
+ Object.assign(contents, doc);
748
+ const exception = new NotAcceptableException({
749
+ $metadata: deserializeMetadata(parsedOutput),
750
+ ...contents,
751
+ });
752
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
474
753
  };
475
- var ActiveContextFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
476
- ...obj,
477
- ...obj.parameters && { parameters: import_smithy_client.SENSITIVE_STRING }
478
- }), "ActiveContextFilterSensitiveLog");
479
- var DialogActionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
480
- ...obj,
481
- ...obj.slots && { slots: import_smithy_client.SENSITIVE_STRING },
482
- ...obj.message && { message: import_smithy_client.SENSITIVE_STRING }
483
- }), "DialogActionFilterSensitiveLog");
484
- var IntentSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
485
- ...obj,
486
- ...obj.slots && { slots: import_smithy_client.SENSITIVE_STRING }
487
- }), "IntentSummaryFilterSensitiveLog");
488
- var GetSessionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
489
- ...obj,
490
- ...obj.recentIntentSummaryView && {
491
- recentIntentSummaryView: obj.recentIntentSummaryView.map((item) => IntentSummaryFilterSensitiveLog(item))
492
- },
493
- ...obj.sessionAttributes && { sessionAttributes: import_smithy_client.SENSITIVE_STRING },
494
- ...obj.dialogAction && { dialogAction: DialogActionFilterSensitiveLog(obj.dialogAction) },
495
- ...obj.activeContexts && { activeContexts: import_smithy_client.SENSITIVE_STRING }
496
- }), "GetSessionResponseFilterSensitiveLog");
497
- var PostContentRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
498
- ...obj,
499
- ...obj.sessionAttributes && { sessionAttributes: import_smithy_client.SENSITIVE_STRING },
500
- ...obj.requestAttributes && { requestAttributes: import_smithy_client.SENSITIVE_STRING },
501
- ...obj.activeContexts && { activeContexts: import_smithy_client.SENSITIVE_STRING }
502
- }), "PostContentRequestFilterSensitiveLog");
503
- var PostContentResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
504
- ...obj,
505
- ...obj.message && { message: import_smithy_client.SENSITIVE_STRING },
506
- ...obj.encodedMessage && { encodedMessage: import_smithy_client.SENSITIVE_STRING },
507
- ...obj.encodedInputTranscript && { encodedInputTranscript: import_smithy_client.SENSITIVE_STRING },
508
- ...obj.activeContexts && { activeContexts: import_smithy_client.SENSITIVE_STRING }
509
- }), "PostContentResponseFilterSensitiveLog");
510
- var PostTextRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
511
- ...obj,
512
- ...obj.sessionAttributes && { sessionAttributes: import_smithy_client.SENSITIVE_STRING },
513
- ...obj.requestAttributes && { requestAttributes: import_smithy_client.SENSITIVE_STRING },
514
- ...obj.inputText && { inputText: import_smithy_client.SENSITIVE_STRING },
515
- ...obj.activeContexts && { activeContexts: import_smithy_client.SENSITIVE_STRING }
516
- }), "PostTextRequestFilterSensitiveLog");
517
- var PredictedIntentFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
518
- ...obj,
519
- ...obj.slots && { slots: import_smithy_client.SENSITIVE_STRING }
520
- }), "PredictedIntentFilterSensitiveLog");
521
- var PostTextResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
522
- ...obj,
523
- ...obj.alternativeIntents && {
524
- alternativeIntents: obj.alternativeIntents.map((item) => PredictedIntentFilterSensitiveLog(item))
525
- },
526
- ...obj.slots && { slots: import_smithy_client.SENSITIVE_STRING },
527
- ...obj.sessionAttributes && { sessionAttributes: import_smithy_client.SENSITIVE_STRING },
528
- ...obj.message && { message: import_smithy_client.SENSITIVE_STRING },
529
- ...obj.activeContexts && { activeContexts: import_smithy_client.SENSITIVE_STRING }
530
- }), "PostTextResponseFilterSensitiveLog");
531
- var PutSessionRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
532
- ...obj,
533
- ...obj.sessionAttributes && { sessionAttributes: import_smithy_client.SENSITIVE_STRING },
534
- ...obj.dialogAction && { dialogAction: DialogActionFilterSensitiveLog(obj.dialogAction) },
535
- ...obj.recentIntentSummaryView && {
536
- recentIntentSummaryView: obj.recentIntentSummaryView.map((item) => IntentSummaryFilterSensitiveLog(item))
537
- },
538
- ...obj.activeContexts && { activeContexts: import_smithy_client.SENSITIVE_STRING }
539
- }), "PutSessionRequestFilterSensitiveLog");
540
- var PutSessionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
541
- ...obj,
542
- ...obj.message && { message: import_smithy_client.SENSITIVE_STRING },
543
- ...obj.encodedMessage && { encodedMessage: import_smithy_client.SENSITIVE_STRING },
544
- ...obj.activeContexts && { activeContexts: import_smithy_client.SENSITIVE_STRING }
545
- }), "PutSessionResponseFilterSensitiveLog");
546
-
547
- // src/protocols/Aws_restJson1.ts
548
- var se_DeleteSessionCommand = /* @__PURE__ */ __name(async (input, context) => {
549
- const b = (0, import_core.requestBuilder)(input, context);
550
- const headers = {};
551
- b.bp("/bot/{botName}/alias/{botAlias}/user/{userId}/session");
552
- b.p("botName", () => input.botName, "{botName}", false);
553
- b.p("botAlias", () => input.botAlias, "{botAlias}", false);
554
- b.p("userId", () => input.userId, "{userId}", false);
555
- let body;
556
- b.m("DELETE").h(headers).b(body);
557
- return b.build();
558
- }, "se_DeleteSessionCommand");
559
- var se_GetSessionCommand = /* @__PURE__ */ __name(async (input, context) => {
560
- const b = (0, import_core.requestBuilder)(input, context);
561
- const headers = {};
562
- b.bp("/bot/{botName}/alias/{botAlias}/user/{userId}/session");
563
- b.p("botName", () => input.botName, "{botName}", false);
564
- b.p("botAlias", () => input.botAlias, "{botAlias}", false);
565
- b.p("userId", () => input.userId, "{userId}", false);
566
- const query = (0, import_smithy_client.map)({
567
- [_cLF]: [, input[_cLF]]
568
- });
569
- let body;
570
- b.m("GET").h(headers).q(query).b(body);
571
- return b.build();
572
- }, "se_GetSessionCommand");
573
- var se_PostContentCommand = /* @__PURE__ */ __name(async (input, context) => {
574
- const b = (0, import_core.requestBuilder)(input, context);
575
- const headers = (0, import_smithy_client.map)({}, import_smithy_client.isSerializableHeaderValue, {
576
- "x-amz-content-sha256": "UNSIGNED-PAYLOAD",
577
- [_ct]: input[_cT] || "application/octet-stream",
578
- [_xalsa]: [
579
- () => (0, import_smithy_client.isSerializableHeaderValue)(input[_sA]),
580
- () => context.base64Encoder(Buffer.from(import_smithy_client.LazyJsonString.from(input[_sA])))
581
- ],
582
- [_xalra]: [
583
- () => (0, import_smithy_client.isSerializableHeaderValue)(input[_rA]),
584
- () => context.base64Encoder(Buffer.from(import_smithy_client.LazyJsonString.from(input[_rA])))
585
- ],
586
- [_a]: input[_a],
587
- [_xalac]: [
588
- () => (0, import_smithy_client.isSerializableHeaderValue)(input[_aC]),
589
- () => context.base64Encoder(Buffer.from(import_smithy_client.LazyJsonString.from(input[_aC])))
590
- ]
591
- });
592
- b.bp("/bot/{botName}/alias/{botAlias}/user/{userId}/content");
593
- b.p("botName", () => input.botName, "{botName}", false);
594
- b.p("botAlias", () => input.botAlias, "{botAlias}", false);
595
- b.p("userId", () => input.userId, "{userId}", false);
596
- let body;
597
- if (input.inputStream !== void 0) {
598
- body = input.inputStream;
599
- }
600
- b.m("POST").h(headers).b(body);
601
- return b.build();
602
- }, "se_PostContentCommand");
603
- var se_PostTextCommand = /* @__PURE__ */ __name(async (input, context) => {
604
- const b = (0, import_core.requestBuilder)(input, context);
605
- const headers = {
606
- "content-type": "application/json"
607
- };
608
- b.bp("/bot/{botName}/alias/{botAlias}/user/{userId}/text");
609
- b.p("botName", () => input.botName, "{botName}", false);
610
- b.p("botAlias", () => input.botAlias, "{botAlias}", false);
611
- b.p("userId", () => input.userId, "{userId}", false);
612
- let body;
613
- body = JSON.stringify(
614
- (0, import_smithy_client.take)(input, {
615
- activeContexts: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "activeContexts"),
616
- inputText: [],
617
- requestAttributes: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "requestAttributes"),
618
- sessionAttributes: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "sessionAttributes")
619
- })
620
- );
621
- b.m("POST").h(headers).b(body);
622
- return b.build();
623
- }, "se_PostTextCommand");
624
- var se_PutSessionCommand = /* @__PURE__ */ __name(async (input, context) => {
625
- const b = (0, import_core.requestBuilder)(input, context);
626
- const headers = (0, import_smithy_client.map)({}, import_smithy_client.isSerializableHeaderValue, {
627
- "content-type": "application/json",
628
- [_a]: input[_a]
629
- });
630
- b.bp("/bot/{botName}/alias/{botAlias}/user/{userId}/session");
631
- b.p("botName", () => input.botName, "{botName}", false);
632
- b.p("botAlias", () => input.botAlias, "{botAlias}", false);
633
- b.p("userId", () => input.userId, "{userId}", false);
634
- let body;
635
- body = JSON.stringify(
636
- (0, import_smithy_client.take)(input, {
637
- activeContexts: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "activeContexts"),
638
- dialogAction: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "dialogAction"),
639
- recentIntentSummaryView: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "recentIntentSummaryView"),
640
- sessionAttributes: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "sessionAttributes")
641
- })
642
- );
643
- b.m("POST").h(headers).b(body);
644
- return b.build();
645
- }, "se_PutSessionCommand");
646
- var de_DeleteSessionCommand = /* @__PURE__ */ __name(async (output, context) => {
647
- if (output.statusCode !== 200 && output.statusCode >= 300) {
648
- return de_CommandError(output, context);
649
- }
650
- const contents = (0, import_smithy_client.map)({
651
- $metadata: deserializeMetadata(output)
652
- });
653
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
654
- const doc = (0, import_smithy_client.take)(data, {
655
- botAlias: import_smithy_client.expectString,
656
- botName: import_smithy_client.expectString,
657
- sessionId: import_smithy_client.expectString,
658
- userId: import_smithy_client.expectString
659
- });
660
- Object.assign(contents, doc);
661
- return contents;
662
- }, "de_DeleteSessionCommand");
663
- var de_GetSessionCommand = /* @__PURE__ */ __name(async (output, context) => {
664
- if (output.statusCode !== 200 && output.statusCode >= 300) {
665
- return de_CommandError(output, context);
666
- }
667
- const contents = (0, import_smithy_client.map)({
668
- $metadata: deserializeMetadata(output)
669
- });
670
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
671
- const doc = (0, import_smithy_client.take)(data, {
672
- activeContexts: import_smithy_client._json,
673
- dialogAction: import_smithy_client._json,
674
- recentIntentSummaryView: import_smithy_client._json,
675
- sessionAttributes: import_smithy_client._json,
676
- sessionId: import_smithy_client.expectString
677
- });
678
- Object.assign(contents, doc);
679
- return contents;
680
- }, "de_GetSessionCommand");
681
- var de_PostContentCommand = /* @__PURE__ */ __name(async (output, context) => {
682
- if (output.statusCode !== 200 && output.statusCode >= 300) {
683
- return de_CommandError(output, context);
684
- }
685
- const contents = (0, import_smithy_client.map)({
686
- $metadata: deserializeMetadata(output),
687
- [_cT]: [, output.headers[_ct]],
688
- [_iN]: [, output.headers[_xalin]],
689
- [_nIC]: [
690
- () => void 0 !== output.headers[_xalnic],
691
- () => import_smithy_client.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalnic])).toString("utf8"))
692
- ],
693
- [_aI]: [
694
- () => void 0 !== output.headers[_xalai],
695
- () => import_smithy_client.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalai])).toString("utf8"))
696
- ],
697
- [_s]: [
698
- () => void 0 !== output.headers[_xals],
699
- () => import_smithy_client.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xals])).toString("utf8"))
700
- ],
701
- [_sA]: [
702
- () => void 0 !== output.headers[_xalsa],
703
- () => import_smithy_client.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalsa])).toString("utf8"))
704
- ],
705
- [_sR]: [, output.headers[_xals_]],
706
- [_m]: [, output.headers[_xalm]],
707
- [_eM]: [, output.headers[_xalem]],
708
- [_mF]: [, output.headers[_xalmf]],
709
- [_dS]: [, output.headers[_xalds]],
710
- [_sTE]: [, output.headers[_xalste]],
711
- [_iT]: [, output.headers[_xalit]],
712
- [_eIT]: [, output.headers[_xaleit]],
713
- [_bV]: [, output.headers[_xalbv]],
714
- [_sI]: [, output.headers[_xalsi]],
715
- [_aC]: [
716
- () => void 0 !== output.headers[_xalac],
717
- () => import_smithy_client.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalac])).toString("utf8"))
718
- ]
719
- });
720
- const data = output.body;
721
- context.sdkStreamMixin(data);
722
- contents.audioStream = data;
723
- return contents;
724
- }, "de_PostContentCommand");
725
- var de_PostTextCommand = /* @__PURE__ */ __name(async (output, context) => {
726
- if (output.statusCode !== 200 && output.statusCode >= 300) {
727
- return de_CommandError(output, context);
728
- }
729
- const contents = (0, import_smithy_client.map)({
730
- $metadata: deserializeMetadata(output)
731
- });
732
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
733
- const doc = (0, import_smithy_client.take)(data, {
734
- activeContexts: import_smithy_client._json,
735
- alternativeIntents: /* @__PURE__ */ __name((_) => de_IntentList(_, context), "alternativeIntents"),
736
- botVersion: import_smithy_client.expectString,
737
- dialogState: import_smithy_client.expectString,
738
- intentName: import_smithy_client.expectString,
739
- message: import_smithy_client.expectString,
740
- messageFormat: import_smithy_client.expectString,
741
- nluIntentConfidence: /* @__PURE__ */ __name((_) => de_IntentConfidence(_, context), "nluIntentConfidence"),
742
- responseCard: import_smithy_client._json,
743
- sentimentResponse: import_smithy_client._json,
744
- sessionAttributes: import_smithy_client._json,
745
- sessionId: import_smithy_client.expectString,
746
- slotToElicit: import_smithy_client.expectString,
747
- slots: import_smithy_client._json
748
- });
749
- Object.assign(contents, doc);
750
- return contents;
751
- }, "de_PostTextCommand");
752
- var de_PutSessionCommand = /* @__PURE__ */ __name(async (output, context) => {
753
- if (output.statusCode !== 200 && output.statusCode >= 300) {
754
- return de_CommandError(output, context);
755
- }
756
- const contents = (0, import_smithy_client.map)({
757
- $metadata: deserializeMetadata(output),
758
- [_cT]: [, output.headers[_ct]],
759
- [_iN]: [, output.headers[_xalin]],
760
- [_s]: [
761
- () => void 0 !== output.headers[_xals],
762
- () => import_smithy_client.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xals])).toString("utf8"))
763
- ],
764
- [_sA]: [
765
- () => void 0 !== output.headers[_xalsa],
766
- () => import_smithy_client.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalsa])).toString("utf8"))
767
- ],
768
- [_m]: [, output.headers[_xalm]],
769
- [_eM]: [, output.headers[_xalem]],
770
- [_mF]: [, output.headers[_xalmf]],
771
- [_dS]: [, output.headers[_xalds]],
772
- [_sTE]: [, output.headers[_xalste]],
773
- [_sI]: [, output.headers[_xalsi]],
774
- [_aC]: [
775
- () => void 0 !== output.headers[_xalac],
776
- () => import_smithy_client.LazyJsonString.from(Buffer.from(context.base64Decoder(output.headers[_xalac])).toString("utf8"))
777
- ]
778
- });
779
- const data = output.body;
780
- context.sdkStreamMixin(data);
781
- contents.audioStream = data;
782
- return contents;
783
- }, "de_PutSessionCommand");
784
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
785
- const parsedOutput = {
786
- ...output,
787
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
788
- };
789
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
790
- switch (errorCode) {
791
- case "BadRequestException":
792
- case "com.amazonaws.lexruntimeservice#BadRequestException":
793
- throw await de_BadRequestExceptionRes(parsedOutput, context);
794
- case "ConflictException":
795
- case "com.amazonaws.lexruntimeservice#ConflictException":
796
- throw await de_ConflictExceptionRes(parsedOutput, context);
797
- case "InternalFailureException":
798
- case "com.amazonaws.lexruntimeservice#InternalFailureException":
799
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
800
- case "LimitExceededException":
801
- case "com.amazonaws.lexruntimeservice#LimitExceededException":
802
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
803
- case "NotFoundException":
804
- case "com.amazonaws.lexruntimeservice#NotFoundException":
805
- throw await de_NotFoundExceptionRes(parsedOutput, context);
806
- case "BadGatewayException":
807
- case "com.amazonaws.lexruntimeservice#BadGatewayException":
808
- throw await de_BadGatewayExceptionRes(parsedOutput, context);
809
- case "DependencyFailedException":
810
- case "com.amazonaws.lexruntimeservice#DependencyFailedException":
811
- throw await de_DependencyFailedExceptionRes(parsedOutput, context);
812
- case "LoopDetectedException":
813
- case "com.amazonaws.lexruntimeservice#LoopDetectedException":
814
- throw await de_LoopDetectedExceptionRes(parsedOutput, context);
815
- case "NotAcceptableException":
816
- case "com.amazonaws.lexruntimeservice#NotAcceptableException":
817
- throw await de_NotAcceptableExceptionRes(parsedOutput, context);
818
- case "RequestTimeoutException":
819
- case "com.amazonaws.lexruntimeservice#RequestTimeoutException":
820
- throw await de_RequestTimeoutExceptionRes(parsedOutput, context);
821
- case "UnsupportedMediaTypeException":
822
- case "com.amazonaws.lexruntimeservice#UnsupportedMediaTypeException":
823
- throw await de_UnsupportedMediaTypeExceptionRes(parsedOutput, context);
824
- default:
825
- const parsedBody = parsedOutput.body;
826
- return throwDefaultError({
827
- output,
828
- parsedBody,
829
- errorCode
830
- });
831
- }
832
- }, "de_CommandError");
833
- var throwDefaultError = (0, import_smithy_client.withBaseException)(LexRuntimeServiceServiceException);
834
- var de_BadGatewayExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
835
- const contents = (0, import_smithy_client.map)({});
836
- const data = parsedOutput.body;
837
- const doc = (0, import_smithy_client.take)(data, {
838
- Message: import_smithy_client.expectString
839
- });
840
- Object.assign(contents, doc);
841
- const exception = new BadGatewayException({
842
- $metadata: deserializeMetadata(parsedOutput),
843
- ...contents
844
- });
845
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
846
- }, "de_BadGatewayExceptionRes");
847
- var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
848
- const contents = (0, import_smithy_client.map)({});
849
- const data = parsedOutput.body;
850
- const doc = (0, import_smithy_client.take)(data, {
851
- message: import_smithy_client.expectString
852
- });
853
- Object.assign(contents, doc);
854
- const exception = new BadRequestException({
855
- $metadata: deserializeMetadata(parsedOutput),
856
- ...contents
857
- });
858
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
859
- }, "de_BadRequestExceptionRes");
860
- var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
861
- const contents = (0, import_smithy_client.map)({});
862
- const data = parsedOutput.body;
863
- const doc = (0, import_smithy_client.take)(data, {
864
- message: import_smithy_client.expectString
865
- });
866
- Object.assign(contents, doc);
867
- const exception = new ConflictException({
868
- $metadata: deserializeMetadata(parsedOutput),
869
- ...contents
870
- });
871
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
872
- }, "de_ConflictExceptionRes");
873
- var de_DependencyFailedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
874
- const contents = (0, import_smithy_client.map)({});
875
- const data = parsedOutput.body;
876
- const doc = (0, import_smithy_client.take)(data, {
877
- Message: import_smithy_client.expectString
878
- });
879
- Object.assign(contents, doc);
880
- const exception = new DependencyFailedException({
881
- $metadata: deserializeMetadata(parsedOutput),
882
- ...contents
883
- });
884
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
885
- }, "de_DependencyFailedExceptionRes");
886
- var de_InternalFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
887
- const contents = (0, import_smithy_client.map)({});
888
- const data = parsedOutput.body;
889
- const doc = (0, import_smithy_client.take)(data, {
890
- message: import_smithy_client.expectString
891
- });
892
- Object.assign(contents, doc);
893
- const exception = new InternalFailureException({
894
- $metadata: deserializeMetadata(parsedOutput),
895
- ...contents
896
- });
897
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
898
- }, "de_InternalFailureExceptionRes");
899
- var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
900
- const contents = (0, import_smithy_client.map)({
901
- [_rAS]: [, parsedOutput.headers[_ra]]
902
- });
903
- const data = parsedOutput.body;
904
- const doc = (0, import_smithy_client.take)(data, {
905
- message: import_smithy_client.expectString
906
- });
907
- Object.assign(contents, doc);
908
- const exception = new LimitExceededException({
909
- $metadata: deserializeMetadata(parsedOutput),
910
- ...contents
911
- });
912
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
913
- }, "de_LimitExceededExceptionRes");
914
- var de_LoopDetectedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
915
- const contents = (0, import_smithy_client.map)({});
916
- const data = parsedOutput.body;
917
- const doc = (0, import_smithy_client.take)(data, {
918
- Message: import_smithy_client.expectString
919
- });
920
- Object.assign(contents, doc);
921
- const exception = new LoopDetectedException({
922
- $metadata: deserializeMetadata(parsedOutput),
923
- ...contents
924
- });
925
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
926
- }, "de_LoopDetectedExceptionRes");
927
- var de_NotAcceptableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
928
- const contents = (0, import_smithy_client.map)({});
929
- const data = parsedOutput.body;
930
- const doc = (0, import_smithy_client.take)(data, {
931
- message: import_smithy_client.expectString
932
- });
933
- Object.assign(contents, doc);
934
- const exception = new NotAcceptableException({
935
- $metadata: deserializeMetadata(parsedOutput),
936
- ...contents
937
- });
938
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
939
- }, "de_NotAcceptableExceptionRes");
940
- var de_NotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
941
- const contents = (0, import_smithy_client.map)({});
942
- const data = parsedOutput.body;
943
- const doc = (0, import_smithy_client.take)(data, {
944
- message: import_smithy_client.expectString
945
- });
946
- Object.assign(contents, doc);
947
- const exception = new NotFoundException({
948
- $metadata: deserializeMetadata(parsedOutput),
949
- ...contents
950
- });
951
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
952
- }, "de_NotFoundExceptionRes");
953
- var de_RequestTimeoutExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
954
- const contents = (0, import_smithy_client.map)({});
955
- const data = parsedOutput.body;
956
- const doc = (0, import_smithy_client.take)(data, {
957
- message: import_smithy_client.expectString
958
- });
959
- Object.assign(contents, doc);
960
- const exception = new RequestTimeoutException({
961
- $metadata: deserializeMetadata(parsedOutput),
962
- ...contents
963
- });
964
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
965
- }, "de_RequestTimeoutExceptionRes");
966
- var de_UnsupportedMediaTypeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
967
- const contents = (0, import_smithy_client.map)({});
968
- const data = parsedOutput.body;
969
- const doc = (0, import_smithy_client.take)(data, {
970
- message: import_smithy_client.expectString
971
- });
972
- Object.assign(contents, doc);
973
- const exception = new UnsupportedMediaTypeException({
974
- $metadata: deserializeMetadata(parsedOutput),
975
- ...contents
976
- });
977
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
978
- }, "de_UnsupportedMediaTypeExceptionRes");
979
- var de_IntentConfidence = /* @__PURE__ */ __name((output, context) => {
980
- return (0, import_smithy_client.take)(output, {
981
- score: import_smithy_client.limitedParseDouble
982
- });
983
- }, "de_IntentConfidence");
984
- var de_IntentList = /* @__PURE__ */ __name((output, context) => {
985
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
986
- return de_PredictedIntent(entry, context);
987
- });
988
- return retVal;
989
- }, "de_IntentList");
990
- var de_PredictedIntent = /* @__PURE__ */ __name((output, context) => {
991
- return (0, import_smithy_client.take)(output, {
992
- intentName: import_smithy_client.expectString,
993
- nluIntentConfidence: /* @__PURE__ */ __name((_) => de_IntentConfidence(_, context), "nluIntentConfidence"),
994
- slots: import_smithy_client._json
995
- });
996
- }, "de_PredictedIntent");
997
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
998
- httpStatusCode: output.statusCode,
999
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1000
- extendedRequestId: output.headers["x-amz-id-2"],
1001
- cfId: output.headers["x-amz-cf-id"]
1002
- }), "deserializeMetadata");
1003
- var _a = "accept";
1004
- var _aC = "activeContexts";
1005
- var _aI = "alternativeIntents";
1006
- var _bV = "botVersion";
1007
- var _cLF = "checkpointLabelFilter";
1008
- var _cT = "contentType";
1009
- var _ct = "content-type";
1010
- var _dS = "dialogState";
1011
- var _eIT = "encodedInputTranscript";
1012
- var _eM = "encodedMessage";
1013
- var _iN = "intentName";
1014
- var _iT = "inputTranscript";
1015
- var _m = "message";
1016
- var _mF = "messageFormat";
1017
- var _nIC = "nluIntentConfidence";
1018
- var _rA = "requestAttributes";
1019
- var _rAS = "retryAfterSeconds";
1020
- var _ra = "retry-after";
1021
- var _s = "slots";
1022
- var _sA = "sessionAttributes";
1023
- var _sI = "sessionId";
1024
- var _sR = "sentimentResponse";
1025
- var _sTE = "slotToElicit";
1026
- var _xalac = "x-amz-lex-active-contexts";
1027
- var _xalai = "x-amz-lex-alternative-intents";
1028
- var _xalbv = "x-amz-lex-bot-version";
1029
- var _xalds = "x-amz-lex-dialog-state";
1030
- var _xaleit = "x-amz-lex-encoded-input-transcript";
1031
- var _xalem = "x-amz-lex-encoded-message";
1032
- var _xalin = "x-amz-lex-intent-name";
1033
- var _xalit = "x-amz-lex-input-transcript";
1034
- var _xalm = "x-amz-lex-message";
1035
- var _xalmf = "x-amz-lex-message-format";
1036
- var _xalnic = "x-amz-lex-nlu-intent-confidence";
1037
- var _xalra = "x-amz-lex-request-attributes";
1038
- var _xals = "x-amz-lex-slots";
1039
- var _xals_ = "x-amz-lex-sentiment";
1040
- var _xalsa = "x-amz-lex-session-attributes";
1041
- var _xalsi = "x-amz-lex-session-id";
1042
- var _xalste = "x-amz-lex-slot-to-elicit";
1043
-
1044
- // src/commands/DeleteSessionCommand.ts
1045
- var DeleteSessionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1046
- return [
1047
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1048
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1049
- ];
1050
- }).s("AWSDeepSenseRunTimeService", "DeleteSession", {}).n("LexRuntimeServiceClient", "DeleteSessionCommand").f(void 0, void 0).ser(se_DeleteSessionCommand).de(de_DeleteSessionCommand).build() {
1051
- static {
1052
- __name(this, "DeleteSessionCommand");
1053
- }
754
+ const de_NotFoundExceptionRes = async (parsedOutput, context) => {
755
+ const contents = smithyClient.map({});
756
+ const data = parsedOutput.body;
757
+ const doc = smithyClient.take(data, {
758
+ message: smithyClient.expectString,
759
+ });
760
+ Object.assign(contents, doc);
761
+ const exception = new NotFoundException({
762
+ $metadata: deserializeMetadata(parsedOutput),
763
+ ...contents,
764
+ });
765
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1054
766
  };
1055
-
1056
- // src/commands/GetSessionCommand.ts
1057
-
1058
-
1059
-
1060
- var GetSessionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1061
- return [
1062
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1063
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1064
- ];
1065
- }).s("AWSDeepSenseRunTimeService", "GetSession", {}).n("LexRuntimeServiceClient", "GetSessionCommand").f(void 0, GetSessionResponseFilterSensitiveLog).ser(se_GetSessionCommand).de(de_GetSessionCommand).build() {
1066
- static {
1067
- __name(this, "GetSessionCommand");
1068
- }
767
+ const de_RequestTimeoutExceptionRes = async (parsedOutput, context) => {
768
+ const contents = smithyClient.map({});
769
+ const data = parsedOutput.body;
770
+ const doc = smithyClient.take(data, {
771
+ message: smithyClient.expectString,
772
+ });
773
+ Object.assign(contents, doc);
774
+ const exception = new RequestTimeoutException({
775
+ $metadata: deserializeMetadata(parsedOutput),
776
+ ...contents,
777
+ });
778
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1069
779
  };
1070
-
1071
- // src/commands/PostContentCommand.ts
1072
-
1073
-
1074
-
1075
- var PostContentCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1076
- return [
1077
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1078
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1079
- ];
1080
- }).s("AWSDeepSenseRunTimeService", "PostContent", {}).n("LexRuntimeServiceClient", "PostContentCommand").f(PostContentRequestFilterSensitiveLog, PostContentResponseFilterSensitiveLog).ser(se_PostContentCommand).de(de_PostContentCommand).build() {
1081
- static {
1082
- __name(this, "PostContentCommand");
1083
- }
780
+ const de_UnsupportedMediaTypeExceptionRes = async (parsedOutput, context) => {
781
+ const contents = smithyClient.map({});
782
+ const data = parsedOutput.body;
783
+ const doc = smithyClient.take(data, {
784
+ message: smithyClient.expectString,
785
+ });
786
+ Object.assign(contents, doc);
787
+ const exception = new UnsupportedMediaTypeException({
788
+ $metadata: deserializeMetadata(parsedOutput),
789
+ ...contents,
790
+ });
791
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1084
792
  };
1085
-
1086
- // src/commands/PostTextCommand.ts
1087
-
1088
-
1089
-
1090
- var PostTextCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1091
- return [
1092
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1093
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1094
- ];
1095
- }).s("AWSDeepSenseRunTimeService", "PostText", {}).n("LexRuntimeServiceClient", "PostTextCommand").f(PostTextRequestFilterSensitiveLog, PostTextResponseFilterSensitiveLog).ser(se_PostTextCommand).de(de_PostTextCommand).build() {
1096
- static {
1097
- __name(this, "PostTextCommand");
1098
- }
793
+ const de_IntentConfidence = (output, context) => {
794
+ return smithyClient.take(output, {
795
+ score: smithyClient.limitedParseDouble,
796
+ });
1099
797
  };
1100
-
1101
- // src/commands/PutSessionCommand.ts
1102
-
1103
-
1104
-
1105
- var PutSessionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1106
- return [
1107
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1108
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1109
- ];
1110
- }).s("AWSDeepSenseRunTimeService", "PutSession", {}).n("LexRuntimeServiceClient", "PutSessionCommand").f(PutSessionRequestFilterSensitiveLog, PutSessionResponseFilterSensitiveLog).ser(se_PutSessionCommand).de(de_PutSessionCommand).build() {
1111
- static {
1112
- __name(this, "PutSessionCommand");
1113
- }
798
+ const de_IntentList = (output, context) => {
799
+ const retVal = (output || [])
800
+ .filter((e) => e != null)
801
+ .map((entry) => {
802
+ return de_PredictedIntent(entry);
803
+ });
804
+ return retVal;
1114
805
  };
1115
-
1116
- // src/LexRuntimeService.ts
1117
- var commands = {
1118
- DeleteSessionCommand,
1119
- GetSessionCommand,
1120
- PostContentCommand,
1121
- PostTextCommand,
1122
- PutSessionCommand
806
+ const de_PredictedIntent = (output, context) => {
807
+ return smithyClient.take(output, {
808
+ intentName: smithyClient.expectString,
809
+ nluIntentConfidence: (_) => de_IntentConfidence(_),
810
+ slots: smithyClient._json,
811
+ });
1123
812
  };
1124
- var LexRuntimeService = class extends LexRuntimeServiceClient {
1125
- static {
1126
- __name(this, "LexRuntimeService");
1127
- }
813
+ const deserializeMetadata = (output) => ({
814
+ httpStatusCode: output.statusCode,
815
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
816
+ extendedRequestId: output.headers["x-amz-id-2"],
817
+ cfId: output.headers["x-amz-cf-id"],
818
+ });
819
+ const _a = "accept";
820
+ const _aC = "activeContexts";
821
+ const _aI = "alternativeIntents";
822
+ const _bV = "botVersion";
823
+ const _cLF = "checkpointLabelFilter";
824
+ const _cT = "contentType";
825
+ const _ct = "content-type";
826
+ const _dS = "dialogState";
827
+ const _eIT = "encodedInputTranscript";
828
+ const _eM = "encodedMessage";
829
+ const _iN = "intentName";
830
+ const _iT = "inputTranscript";
831
+ const _m = "message";
832
+ const _mF = "messageFormat";
833
+ const _nIC = "nluIntentConfidence";
834
+ const _rA = "requestAttributes";
835
+ const _rAS = "retryAfterSeconds";
836
+ const _ra = "retry-after";
837
+ const _s = "slots";
838
+ const _sA = "sessionAttributes";
839
+ const _sI = "sessionId";
840
+ const _sR = "sentimentResponse";
841
+ const _sTE = "slotToElicit";
842
+ const _xalac = "x-amz-lex-active-contexts";
843
+ const _xalai = "x-amz-lex-alternative-intents";
844
+ const _xalbv = "x-amz-lex-bot-version";
845
+ const _xalds = "x-amz-lex-dialog-state";
846
+ const _xaleit = "x-amz-lex-encoded-input-transcript";
847
+ const _xalem = "x-amz-lex-encoded-message";
848
+ const _xalin = "x-amz-lex-intent-name";
849
+ const _xalit = "x-amz-lex-input-transcript";
850
+ const _xalm = "x-amz-lex-message";
851
+ const _xalmf = "x-amz-lex-message-format";
852
+ const _xalnic = "x-amz-lex-nlu-intent-confidence";
853
+ const _xalra = "x-amz-lex-request-attributes";
854
+ const _xals = "x-amz-lex-slots";
855
+ const _xals_ = "x-amz-lex-sentiment";
856
+ const _xalsa = "x-amz-lex-session-attributes";
857
+ const _xalsi = "x-amz-lex-session-id";
858
+ const _xalste = "x-amz-lex-slot-to-elicit";
859
+
860
+ class DeleteSessionCommand extends smithyClient.Command
861
+ .classBuilder()
862
+ .ep(commonParams)
863
+ .m(function (Command, cs, config, o) {
864
+ return [
865
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
866
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
867
+ ];
868
+ })
869
+ .s("AWSDeepSenseRunTimeService", "DeleteSession", {})
870
+ .n("LexRuntimeServiceClient", "DeleteSessionCommand")
871
+ .f(void 0, void 0)
872
+ .ser(se_DeleteSessionCommand)
873
+ .de(de_DeleteSessionCommand)
874
+ .build() {
875
+ }
876
+
877
+ class GetSessionCommand extends smithyClient.Command
878
+ .classBuilder()
879
+ .ep(commonParams)
880
+ .m(function (Command, cs, config, o) {
881
+ return [
882
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
883
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
884
+ ];
885
+ })
886
+ .s("AWSDeepSenseRunTimeService", "GetSession", {})
887
+ .n("LexRuntimeServiceClient", "GetSessionCommand")
888
+ .f(void 0, GetSessionResponseFilterSensitiveLog)
889
+ .ser(se_GetSessionCommand)
890
+ .de(de_GetSessionCommand)
891
+ .build() {
892
+ }
893
+
894
+ class PostContentCommand extends smithyClient.Command
895
+ .classBuilder()
896
+ .ep(commonParams)
897
+ .m(function (Command, cs, config, o) {
898
+ return [
899
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
900
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
901
+ ];
902
+ })
903
+ .s("AWSDeepSenseRunTimeService", "PostContent", {})
904
+ .n("LexRuntimeServiceClient", "PostContentCommand")
905
+ .f(PostContentRequestFilterSensitiveLog, PostContentResponseFilterSensitiveLog)
906
+ .ser(se_PostContentCommand)
907
+ .de(de_PostContentCommand)
908
+ .build() {
909
+ }
910
+
911
+ class PostTextCommand extends smithyClient.Command
912
+ .classBuilder()
913
+ .ep(commonParams)
914
+ .m(function (Command, cs, config, o) {
915
+ return [
916
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
917
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
918
+ ];
919
+ })
920
+ .s("AWSDeepSenseRunTimeService", "PostText", {})
921
+ .n("LexRuntimeServiceClient", "PostTextCommand")
922
+ .f(PostTextRequestFilterSensitiveLog, PostTextResponseFilterSensitiveLog)
923
+ .ser(se_PostTextCommand)
924
+ .de(de_PostTextCommand)
925
+ .build() {
926
+ }
927
+
928
+ class PutSessionCommand extends smithyClient.Command
929
+ .classBuilder()
930
+ .ep(commonParams)
931
+ .m(function (Command, cs, config, o) {
932
+ return [
933
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
934
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
935
+ ];
936
+ })
937
+ .s("AWSDeepSenseRunTimeService", "PutSession", {})
938
+ .n("LexRuntimeServiceClient", "PutSessionCommand")
939
+ .f(PutSessionRequestFilterSensitiveLog, PutSessionResponseFilterSensitiveLog)
940
+ .ser(se_PutSessionCommand)
941
+ .de(de_PutSessionCommand)
942
+ .build() {
943
+ }
944
+
945
+ const commands = {
946
+ DeleteSessionCommand,
947
+ GetSessionCommand,
948
+ PostContentCommand,
949
+ PostTextCommand,
950
+ PutSessionCommand,
1128
951
  };
1129
- (0, import_smithy_client.createAggregatedClient)(commands, LexRuntimeService);
1130
- // Annotate the CommonJS export names for ESM import in node:
952
+ class LexRuntimeService extends LexRuntimeServiceClient {
953
+ }
954
+ smithyClient.createAggregatedClient(commands, LexRuntimeService);
1131
955
 
1132
- 0 && (module.exports = {
1133
- LexRuntimeServiceServiceException,
1134
- __Client,
1135
- LexRuntimeServiceClient,
1136
- LexRuntimeService,
1137
- $Command,
1138
- DeleteSessionCommand,
1139
- GetSessionCommand,
1140
- PostContentCommand,
1141
- PostTextCommand,
1142
- PutSessionCommand,
1143
- BadRequestException,
1144
- ConflictException,
1145
- InternalFailureException,
1146
- LimitExceededException,
1147
- NotFoundException,
1148
- FulfillmentState,
1149
- MessageFormatType,
1150
- DialogActionType,
1151
- ConfirmationStatus,
1152
- BadGatewayException,
1153
- DependencyFailedException,
1154
- LoopDetectedException,
1155
- NotAcceptableException,
1156
- DialogState,
1157
- RequestTimeoutException,
1158
- UnsupportedMediaTypeException,
1159
- ContentType,
1160
- ActiveContextFilterSensitiveLog,
1161
- DialogActionFilterSensitiveLog,
1162
- IntentSummaryFilterSensitiveLog,
1163
- GetSessionResponseFilterSensitiveLog,
1164
- PostContentRequestFilterSensitiveLog,
1165
- PostContentResponseFilterSensitiveLog,
1166
- PostTextRequestFilterSensitiveLog,
1167
- PredictedIntentFilterSensitiveLog,
1168
- PostTextResponseFilterSensitiveLog,
1169
- PutSessionRequestFilterSensitiveLog,
1170
- PutSessionResponseFilterSensitiveLog
956
+ Object.defineProperty(exports, "$Command", {
957
+ enumerable: true,
958
+ get: function () { return smithyClient.Command; }
1171
959
  });
1172
-
960
+ Object.defineProperty(exports, "__Client", {
961
+ enumerable: true,
962
+ get: function () { return smithyClient.Client; }
963
+ });
964
+ exports.ActiveContextFilterSensitiveLog = ActiveContextFilterSensitiveLog;
965
+ exports.BadGatewayException = BadGatewayException;
966
+ exports.BadRequestException = BadRequestException;
967
+ exports.ConfirmationStatus = ConfirmationStatus;
968
+ exports.ConflictException = ConflictException;
969
+ exports.ContentType = ContentType;
970
+ exports.DeleteSessionCommand = DeleteSessionCommand;
971
+ exports.DependencyFailedException = DependencyFailedException;
972
+ exports.DialogActionFilterSensitiveLog = DialogActionFilterSensitiveLog;
973
+ exports.DialogActionType = DialogActionType;
974
+ exports.DialogState = DialogState;
975
+ exports.FulfillmentState = FulfillmentState;
976
+ exports.GetSessionCommand = GetSessionCommand;
977
+ exports.GetSessionResponseFilterSensitiveLog = GetSessionResponseFilterSensitiveLog;
978
+ exports.IntentSummaryFilterSensitiveLog = IntentSummaryFilterSensitiveLog;
979
+ exports.InternalFailureException = InternalFailureException;
980
+ exports.LexRuntimeService = LexRuntimeService;
981
+ exports.LexRuntimeServiceClient = LexRuntimeServiceClient;
982
+ exports.LexRuntimeServiceServiceException = LexRuntimeServiceServiceException;
983
+ exports.LimitExceededException = LimitExceededException;
984
+ exports.LoopDetectedException = LoopDetectedException;
985
+ exports.MessageFormatType = MessageFormatType;
986
+ exports.NotAcceptableException = NotAcceptableException;
987
+ exports.NotFoundException = NotFoundException;
988
+ exports.PostContentCommand = PostContentCommand;
989
+ exports.PostContentRequestFilterSensitiveLog = PostContentRequestFilterSensitiveLog;
990
+ exports.PostContentResponseFilterSensitiveLog = PostContentResponseFilterSensitiveLog;
991
+ exports.PostTextCommand = PostTextCommand;
992
+ exports.PostTextRequestFilterSensitiveLog = PostTextRequestFilterSensitiveLog;
993
+ exports.PostTextResponseFilterSensitiveLog = PostTextResponseFilterSensitiveLog;
994
+ exports.PredictedIntentFilterSensitiveLog = PredictedIntentFilterSensitiveLog;
995
+ exports.PutSessionCommand = PutSessionCommand;
996
+ exports.PutSessionRequestFilterSensitiveLog = PutSessionRequestFilterSensitiveLog;
997
+ exports.PutSessionResponseFilterSensitiveLog = PutSessionResponseFilterSensitiveLog;
998
+ exports.RequestTimeoutException = RequestTimeoutException;
999
+ exports.UnsupportedMediaTypeException = UnsupportedMediaTypeException;