@aws-sdk/client-kinesis-analytics 3.185.0 → 3.188.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 (32) hide show
  1. package/CHANGELOG.md +16 -0
  2. package/dist-es/KinesisAnalytics.js +82 -89
  3. package/dist-es/KinesisAnalyticsClient.js +22 -28
  4. package/dist-es/commands/AddApplicationCloudWatchLoggingOptionCommand.js +21 -28
  5. package/dist-es/commands/AddApplicationInputCommand.js +21 -28
  6. package/dist-es/commands/AddApplicationInputProcessingConfigurationCommand.js +21 -28
  7. package/dist-es/commands/AddApplicationOutputCommand.js +21 -28
  8. package/dist-es/commands/AddApplicationReferenceDataSourceCommand.js +21 -28
  9. package/dist-es/commands/CreateApplicationCommand.js +21 -28
  10. package/dist-es/commands/DeleteApplicationCloudWatchLoggingOptionCommand.js +21 -28
  11. package/dist-es/commands/DeleteApplicationCommand.js +21 -28
  12. package/dist-es/commands/DeleteApplicationInputProcessingConfigurationCommand.js +21 -28
  13. package/dist-es/commands/DeleteApplicationOutputCommand.js +21 -28
  14. package/dist-es/commands/DeleteApplicationReferenceDataSourceCommand.js +21 -28
  15. package/dist-es/commands/DescribeApplicationCommand.js +21 -28
  16. package/dist-es/commands/DiscoverInputSchemaCommand.js +21 -28
  17. package/dist-es/commands/ListApplicationsCommand.js +21 -28
  18. package/dist-es/commands/ListTagsForResourceCommand.js +21 -28
  19. package/dist-es/commands/StartApplicationCommand.js +21 -28
  20. package/dist-es/commands/StopApplicationCommand.js +21 -28
  21. package/dist-es/commands/TagResourceCommand.js +21 -28
  22. package/dist-es/commands/UntagResourceCommand.js +21 -28
  23. package/dist-es/commands/UpdateApplicationCommand.js +21 -28
  24. package/dist-es/endpoints.js +8 -8
  25. package/dist-es/models/KinesisAnalyticsServiceException.js +5 -10
  26. package/dist-es/models/models_0.js +413 -228
  27. package/dist-es/protocols/Aws_json1_1.js +1793 -2068
  28. package/dist-es/runtimeConfig.browser.js +26 -12
  29. package/dist-es/runtimeConfig.js +30 -12
  30. package/dist-es/runtimeConfig.native.js +8 -5
  31. package/dist-es/runtimeConfig.shared.js +8 -11
  32. package/package.json +33 -33
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -1,2000 +1,1748 @@
1
- import { __assign, __awaiter, __generator } from "tslib";
2
1
  import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
3
2
  import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, throwDefaultError, } from "@aws-sdk/smithy-client";
4
3
  import { KinesisAnalyticsServiceException as __BaseException } from "../models/KinesisAnalyticsServiceException";
5
4
  import { CodeValidationException, ConcurrentModificationException, InvalidApplicationConfigurationException, InvalidArgumentException, LimitExceededException, ResourceInUseException, ResourceNotFoundException, ResourceProvisionedThroughputExceededException, ServiceUnavailableException, TooManyTagsException, UnableToDetectSchemaException, UnsupportedOperationException, } from "../models/models_0";
6
- export var serializeAws_json1_1AddApplicationCloudWatchLoggingOptionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
7
- var headers, body;
8
- return __generator(this, function (_a) {
9
- headers = {
10
- "content-type": "application/x-amz-json-1.1",
11
- "x-amz-target": "KinesisAnalytics_20150814.AddApplicationCloudWatchLoggingOption",
12
- };
13
- body = JSON.stringify(serializeAws_json1_1AddApplicationCloudWatchLoggingOptionRequest(input, context));
14
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
15
- });
16
- }); };
17
- export var serializeAws_json1_1AddApplicationInputCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
18
- var headers, body;
19
- return __generator(this, function (_a) {
20
- headers = {
21
- "content-type": "application/x-amz-json-1.1",
22
- "x-amz-target": "KinesisAnalytics_20150814.AddApplicationInput",
23
- };
24
- body = JSON.stringify(serializeAws_json1_1AddApplicationInputRequest(input, context));
25
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
26
- });
27
- }); };
28
- export var serializeAws_json1_1AddApplicationInputProcessingConfigurationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
29
- var headers, body;
30
- return __generator(this, function (_a) {
31
- headers = {
32
- "content-type": "application/x-amz-json-1.1",
33
- "x-amz-target": "KinesisAnalytics_20150814.AddApplicationInputProcessingConfiguration",
34
- };
35
- body = JSON.stringify(serializeAws_json1_1AddApplicationInputProcessingConfigurationRequest(input, context));
36
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
37
- });
38
- }); };
39
- export var serializeAws_json1_1AddApplicationOutputCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
40
- var headers, body;
41
- return __generator(this, function (_a) {
42
- headers = {
43
- "content-type": "application/x-amz-json-1.1",
44
- "x-amz-target": "KinesisAnalytics_20150814.AddApplicationOutput",
45
- };
46
- body = JSON.stringify(serializeAws_json1_1AddApplicationOutputRequest(input, context));
47
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
48
- });
49
- }); };
50
- export var serializeAws_json1_1AddApplicationReferenceDataSourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
51
- var headers, body;
52
- return __generator(this, function (_a) {
53
- headers = {
54
- "content-type": "application/x-amz-json-1.1",
55
- "x-amz-target": "KinesisAnalytics_20150814.AddApplicationReferenceDataSource",
56
- };
57
- body = JSON.stringify(serializeAws_json1_1AddApplicationReferenceDataSourceRequest(input, context));
58
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
59
- });
60
- }); };
61
- export var serializeAws_json1_1CreateApplicationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
62
- var headers, body;
63
- return __generator(this, function (_a) {
64
- headers = {
65
- "content-type": "application/x-amz-json-1.1",
66
- "x-amz-target": "KinesisAnalytics_20150814.CreateApplication",
67
- };
68
- body = JSON.stringify(serializeAws_json1_1CreateApplicationRequest(input, context));
69
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
70
- });
71
- }); };
72
- export var serializeAws_json1_1DeleteApplicationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
73
- var headers, body;
74
- return __generator(this, function (_a) {
75
- headers = {
76
- "content-type": "application/x-amz-json-1.1",
77
- "x-amz-target": "KinesisAnalytics_20150814.DeleteApplication",
78
- };
79
- body = JSON.stringify(serializeAws_json1_1DeleteApplicationRequest(input, context));
80
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
81
- });
82
- }); };
83
- export var serializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
84
- var headers, body;
85
- return __generator(this, function (_a) {
86
- headers = {
87
- "content-type": "application/x-amz-json-1.1",
88
- "x-amz-target": "KinesisAnalytics_20150814.DeleteApplicationCloudWatchLoggingOption",
89
- };
90
- body = JSON.stringify(serializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionRequest(input, context));
91
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
92
- });
93
- }); };
94
- export var serializeAws_json1_1DeleteApplicationInputProcessingConfigurationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
95
- var headers, body;
96
- return __generator(this, function (_a) {
97
- headers = {
98
- "content-type": "application/x-amz-json-1.1",
99
- "x-amz-target": "KinesisAnalytics_20150814.DeleteApplicationInputProcessingConfiguration",
100
- };
101
- body = JSON.stringify(serializeAws_json1_1DeleteApplicationInputProcessingConfigurationRequest(input, context));
102
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
103
- });
104
- }); };
105
- export var serializeAws_json1_1DeleteApplicationOutputCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
106
- var headers, body;
107
- return __generator(this, function (_a) {
108
- headers = {
109
- "content-type": "application/x-amz-json-1.1",
110
- "x-amz-target": "KinesisAnalytics_20150814.DeleteApplicationOutput",
111
- };
112
- body = JSON.stringify(serializeAws_json1_1DeleteApplicationOutputRequest(input, context));
113
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
114
- });
115
- }); };
116
- export var serializeAws_json1_1DeleteApplicationReferenceDataSourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
117
- var headers, body;
118
- return __generator(this, function (_a) {
119
- headers = {
120
- "content-type": "application/x-amz-json-1.1",
121
- "x-amz-target": "KinesisAnalytics_20150814.DeleteApplicationReferenceDataSource",
122
- };
123
- body = JSON.stringify(serializeAws_json1_1DeleteApplicationReferenceDataSourceRequest(input, context));
124
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
125
- });
126
- }); };
127
- export var serializeAws_json1_1DescribeApplicationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
128
- var headers, body;
129
- return __generator(this, function (_a) {
130
- headers = {
131
- "content-type": "application/x-amz-json-1.1",
132
- "x-amz-target": "KinesisAnalytics_20150814.DescribeApplication",
133
- };
134
- body = JSON.stringify(serializeAws_json1_1DescribeApplicationRequest(input, context));
135
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
136
- });
137
- }); };
138
- export var serializeAws_json1_1DiscoverInputSchemaCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
139
- var headers, body;
140
- return __generator(this, function (_a) {
141
- headers = {
142
- "content-type": "application/x-amz-json-1.1",
143
- "x-amz-target": "KinesisAnalytics_20150814.DiscoverInputSchema",
144
- };
145
- body = JSON.stringify(serializeAws_json1_1DiscoverInputSchemaRequest(input, context));
146
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
147
- });
148
- }); };
149
- export var serializeAws_json1_1ListApplicationsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
150
- var headers, body;
151
- return __generator(this, function (_a) {
152
- headers = {
153
- "content-type": "application/x-amz-json-1.1",
154
- "x-amz-target": "KinesisAnalytics_20150814.ListApplications",
155
- };
156
- body = JSON.stringify(serializeAws_json1_1ListApplicationsRequest(input, context));
157
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
158
- });
159
- }); };
160
- export var serializeAws_json1_1ListTagsForResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
161
- var headers, body;
162
- return __generator(this, function (_a) {
163
- headers = {
164
- "content-type": "application/x-amz-json-1.1",
165
- "x-amz-target": "KinesisAnalytics_20150814.ListTagsForResource",
166
- };
167
- body = JSON.stringify(serializeAws_json1_1ListTagsForResourceRequest(input, context));
168
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
169
- });
170
- }); };
171
- export var serializeAws_json1_1StartApplicationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
172
- var headers, body;
173
- return __generator(this, function (_a) {
174
- headers = {
175
- "content-type": "application/x-amz-json-1.1",
176
- "x-amz-target": "KinesisAnalytics_20150814.StartApplication",
177
- };
178
- body = JSON.stringify(serializeAws_json1_1StartApplicationRequest(input, context));
179
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
180
- });
181
- }); };
182
- export var serializeAws_json1_1StopApplicationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
183
- var headers, body;
184
- return __generator(this, function (_a) {
185
- headers = {
186
- "content-type": "application/x-amz-json-1.1",
187
- "x-amz-target": "KinesisAnalytics_20150814.StopApplication",
188
- };
189
- body = JSON.stringify(serializeAws_json1_1StopApplicationRequest(input, context));
190
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
191
- });
192
- }); };
193
- export var serializeAws_json1_1TagResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
194
- var headers, body;
195
- return __generator(this, function (_a) {
196
- headers = {
197
- "content-type": "application/x-amz-json-1.1",
198
- "x-amz-target": "KinesisAnalytics_20150814.TagResource",
199
- };
200
- body = JSON.stringify(serializeAws_json1_1TagResourceRequest(input, context));
201
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
202
- });
203
- }); };
204
- export var serializeAws_json1_1UntagResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
205
- var headers, body;
206
- return __generator(this, function (_a) {
207
- headers = {
208
- "content-type": "application/x-amz-json-1.1",
209
- "x-amz-target": "KinesisAnalytics_20150814.UntagResource",
210
- };
211
- body = JSON.stringify(serializeAws_json1_1UntagResourceRequest(input, context));
212
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
213
- });
214
- }); };
215
- export var serializeAws_json1_1UpdateApplicationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
216
- var headers, body;
217
- return __generator(this, function (_a) {
218
- headers = {
219
- "content-type": "application/x-amz-json-1.1",
220
- "x-amz-target": "KinesisAnalytics_20150814.UpdateApplication",
221
- };
222
- body = JSON.stringify(serializeAws_json1_1UpdateApplicationRequest(input, context));
223
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
224
- });
225
- }); };
226
- export var deserializeAws_json1_1AddApplicationCloudWatchLoggingOptionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
227
- var data, contents, response;
228
- return __generator(this, function (_a) {
229
- switch (_a.label) {
230
- case 0:
231
- if (output.statusCode >= 300) {
232
- return [2, deserializeAws_json1_1AddApplicationCloudWatchLoggingOptionCommandError(output, context)];
233
- }
234
- return [4, parseBody(output.body, context)];
235
- case 1:
236
- data = _a.sent();
237
- contents = {};
238
- contents = deserializeAws_json1_1AddApplicationCloudWatchLoggingOptionResponse(data, context);
239
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
240
- return [2, Promise.resolve(response)];
241
- }
242
- });
243
- }); };
244
- var deserializeAws_json1_1AddApplicationCloudWatchLoggingOptionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
245
- var parsedOutput, _a, errorCode, _b, parsedBody;
246
- var _c;
247
- return __generator(this, function (_d) {
248
- switch (_d.label) {
249
- case 0:
250
- _a = [__assign({}, output)];
251
- _c = {};
252
- return [4, parseErrorBody(output.body, context)];
253
- case 1:
254
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
255
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
256
- _b = errorCode;
257
- switch (_b) {
258
- case "ConcurrentModificationException": return [3, 2];
259
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
260
- case "InvalidArgumentException": return [3, 4];
261
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
262
- case "ResourceInUseException": return [3, 6];
263
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
264
- case "ResourceNotFoundException": return [3, 8];
265
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
266
- case "UnsupportedOperationException": return [3, 10];
267
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 10];
268
- }
269
- return [3, 12];
270
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
271
- case 3: throw _d.sent();
272
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
273
- case 5: throw _d.sent();
274
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
275
- case 7: throw _d.sent();
276
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
277
- case 9: throw _d.sent();
278
- case 10: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
279
- case 11: throw _d.sent();
280
- case 12:
281
- parsedBody = parsedOutput.body;
282
- throwDefaultError({
283
- output: output,
284
- parsedBody: parsedBody,
285
- exceptionCtor: __BaseException,
286
- errorCode: errorCode,
287
- });
288
- _d.label = 13;
289
- case 13: return [2];
290
- }
291
- });
292
- }); };
293
- export var deserializeAws_json1_1AddApplicationInputCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
294
- var data, contents, response;
295
- return __generator(this, function (_a) {
296
- switch (_a.label) {
297
- case 0:
298
- if (output.statusCode >= 300) {
299
- return [2, deserializeAws_json1_1AddApplicationInputCommandError(output, context)];
300
- }
301
- return [4, parseBody(output.body, context)];
302
- case 1:
303
- data = _a.sent();
304
- contents = {};
305
- contents = deserializeAws_json1_1AddApplicationInputResponse(data, context);
306
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
307
- return [2, Promise.resolve(response)];
308
- }
309
- });
310
- }); };
311
- var deserializeAws_json1_1AddApplicationInputCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
312
- var parsedOutput, _a, errorCode, _b, parsedBody;
313
- var _c;
314
- return __generator(this, function (_d) {
315
- switch (_d.label) {
316
- case 0:
317
- _a = [__assign({}, output)];
318
- _c = {};
319
- return [4, parseErrorBody(output.body, context)];
320
- case 1:
321
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
322
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
323
- _b = errorCode;
324
- switch (_b) {
325
- case "CodeValidationException": return [3, 2];
326
- case "com.amazonaws.kinesisanalytics#CodeValidationException": return [3, 2];
327
- case "ConcurrentModificationException": return [3, 4];
328
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 4];
329
- case "InvalidArgumentException": return [3, 6];
330
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 6];
331
- case "ResourceInUseException": return [3, 8];
332
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 8];
333
- case "ResourceNotFoundException": return [3, 10];
334
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 10];
335
- case "UnsupportedOperationException": return [3, 12];
336
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 12];
337
- }
338
- return [3, 14];
339
- case 2: return [4, deserializeAws_json1_1CodeValidationExceptionResponse(parsedOutput, context)];
340
- case 3: throw _d.sent();
341
- case 4: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
342
- case 5: throw _d.sent();
343
- case 6: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
344
- case 7: throw _d.sent();
345
- case 8: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
346
- case 9: throw _d.sent();
347
- case 10: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
348
- case 11: throw _d.sent();
349
- case 12: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
350
- case 13: throw _d.sent();
351
- case 14:
352
- parsedBody = parsedOutput.body;
353
- throwDefaultError({
354
- output: output,
355
- parsedBody: parsedBody,
356
- exceptionCtor: __BaseException,
357
- errorCode: errorCode,
358
- });
359
- _d.label = 15;
360
- case 15: return [2];
361
- }
362
- });
363
- }); };
364
- export var deserializeAws_json1_1AddApplicationInputProcessingConfigurationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
365
- var data, contents, response;
366
- return __generator(this, function (_a) {
367
- switch (_a.label) {
368
- case 0:
369
- if (output.statusCode >= 300) {
370
- return [2, deserializeAws_json1_1AddApplicationInputProcessingConfigurationCommandError(output, context)];
371
- }
372
- return [4, parseBody(output.body, context)];
373
- case 1:
374
- data = _a.sent();
375
- contents = {};
376
- contents = deserializeAws_json1_1AddApplicationInputProcessingConfigurationResponse(data, context);
377
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
378
- return [2, Promise.resolve(response)];
379
- }
380
- });
381
- }); };
382
- var deserializeAws_json1_1AddApplicationInputProcessingConfigurationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
383
- var parsedOutput, _a, errorCode, _b, parsedBody;
384
- var _c;
385
- return __generator(this, function (_d) {
386
- switch (_d.label) {
387
- case 0:
388
- _a = [__assign({}, output)];
389
- _c = {};
390
- return [4, parseErrorBody(output.body, context)];
391
- case 1:
392
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
393
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
394
- _b = errorCode;
395
- switch (_b) {
396
- case "ConcurrentModificationException": return [3, 2];
397
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
398
- case "InvalidArgumentException": return [3, 4];
399
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
400
- case "ResourceInUseException": return [3, 6];
401
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
402
- case "ResourceNotFoundException": return [3, 8];
403
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
404
- case "UnsupportedOperationException": return [3, 10];
405
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 10];
406
- }
407
- return [3, 12];
408
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
409
- case 3: throw _d.sent();
410
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
411
- case 5: throw _d.sent();
412
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
413
- case 7: throw _d.sent();
414
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
415
- case 9: throw _d.sent();
416
- case 10: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
417
- case 11: throw _d.sent();
418
- case 12:
419
- parsedBody = parsedOutput.body;
420
- throwDefaultError({
421
- output: output,
422
- parsedBody: parsedBody,
423
- exceptionCtor: __BaseException,
424
- errorCode: errorCode,
425
- });
426
- _d.label = 13;
427
- case 13: return [2];
428
- }
429
- });
430
- }); };
431
- export var deserializeAws_json1_1AddApplicationOutputCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
432
- var data, contents, response;
433
- return __generator(this, function (_a) {
434
- switch (_a.label) {
435
- case 0:
436
- if (output.statusCode >= 300) {
437
- return [2, deserializeAws_json1_1AddApplicationOutputCommandError(output, context)];
438
- }
439
- return [4, parseBody(output.body, context)];
440
- case 1:
441
- data = _a.sent();
442
- contents = {};
443
- contents = deserializeAws_json1_1AddApplicationOutputResponse(data, context);
444
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
445
- return [2, Promise.resolve(response)];
446
- }
447
- });
448
- }); };
449
- var deserializeAws_json1_1AddApplicationOutputCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
450
- var parsedOutput, _a, errorCode, _b, parsedBody;
451
- var _c;
452
- return __generator(this, function (_d) {
453
- switch (_d.label) {
454
- case 0:
455
- _a = [__assign({}, output)];
456
- _c = {};
457
- return [4, parseErrorBody(output.body, context)];
458
- case 1:
459
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
460
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
461
- _b = errorCode;
462
- switch (_b) {
463
- case "ConcurrentModificationException": return [3, 2];
464
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
465
- case "InvalidArgumentException": return [3, 4];
466
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
467
- case "ResourceInUseException": return [3, 6];
468
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
469
- case "ResourceNotFoundException": return [3, 8];
470
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
471
- case "UnsupportedOperationException": return [3, 10];
472
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 10];
473
- }
474
- return [3, 12];
475
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
476
- case 3: throw _d.sent();
477
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
478
- case 5: throw _d.sent();
479
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
480
- case 7: throw _d.sent();
481
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
482
- case 9: throw _d.sent();
483
- case 10: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
484
- case 11: throw _d.sent();
485
- case 12:
486
- parsedBody = parsedOutput.body;
487
- throwDefaultError({
488
- output: output,
489
- parsedBody: parsedBody,
490
- exceptionCtor: __BaseException,
491
- errorCode: errorCode,
492
- });
493
- _d.label = 13;
494
- case 13: return [2];
495
- }
496
- });
497
- }); };
498
- export var deserializeAws_json1_1AddApplicationReferenceDataSourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
499
- var data, contents, response;
500
- return __generator(this, function (_a) {
501
- switch (_a.label) {
502
- case 0:
503
- if (output.statusCode >= 300) {
504
- return [2, deserializeAws_json1_1AddApplicationReferenceDataSourceCommandError(output, context)];
505
- }
506
- return [4, parseBody(output.body, context)];
507
- case 1:
508
- data = _a.sent();
509
- contents = {};
510
- contents = deserializeAws_json1_1AddApplicationReferenceDataSourceResponse(data, context);
511
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
512
- return [2, Promise.resolve(response)];
513
- }
514
- });
515
- }); };
516
- var deserializeAws_json1_1AddApplicationReferenceDataSourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
517
- var parsedOutput, _a, errorCode, _b, parsedBody;
518
- var _c;
519
- return __generator(this, function (_d) {
520
- switch (_d.label) {
521
- case 0:
522
- _a = [__assign({}, output)];
523
- _c = {};
524
- return [4, parseErrorBody(output.body, context)];
525
- case 1:
526
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
527
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
528
- _b = errorCode;
529
- switch (_b) {
530
- case "ConcurrentModificationException": return [3, 2];
531
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
532
- case "InvalidArgumentException": return [3, 4];
533
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
534
- case "ResourceInUseException": return [3, 6];
535
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
536
- case "ResourceNotFoundException": return [3, 8];
537
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
538
- case "UnsupportedOperationException": return [3, 10];
539
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 10];
540
- }
541
- return [3, 12];
542
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
543
- case 3: throw _d.sent();
544
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
545
- case 5: throw _d.sent();
546
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
547
- case 7: throw _d.sent();
548
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
549
- case 9: throw _d.sent();
550
- case 10: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
551
- case 11: throw _d.sent();
552
- case 12:
553
- parsedBody = parsedOutput.body;
554
- throwDefaultError({
555
- output: output,
556
- parsedBody: parsedBody,
557
- exceptionCtor: __BaseException,
558
- errorCode: errorCode,
559
- });
560
- _d.label = 13;
561
- case 13: return [2];
562
- }
563
- });
564
- }); };
565
- export var deserializeAws_json1_1CreateApplicationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
566
- var data, contents, response;
567
- return __generator(this, function (_a) {
568
- switch (_a.label) {
569
- case 0:
570
- if (output.statusCode >= 300) {
571
- return [2, deserializeAws_json1_1CreateApplicationCommandError(output, context)];
572
- }
573
- return [4, parseBody(output.body, context)];
574
- case 1:
575
- data = _a.sent();
576
- contents = {};
577
- contents = deserializeAws_json1_1CreateApplicationResponse(data, context);
578
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
579
- return [2, Promise.resolve(response)];
580
- }
581
- });
582
- }); };
583
- var deserializeAws_json1_1CreateApplicationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
584
- var parsedOutput, _a, errorCode, _b, parsedBody;
585
- var _c;
586
- return __generator(this, function (_d) {
587
- switch (_d.label) {
588
- case 0:
589
- _a = [__assign({}, output)];
590
- _c = {};
591
- return [4, parseErrorBody(output.body, context)];
592
- case 1:
593
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
594
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
595
- _b = errorCode;
596
- switch (_b) {
597
- case "CodeValidationException": return [3, 2];
598
- case "com.amazonaws.kinesisanalytics#CodeValidationException": return [3, 2];
599
- case "ConcurrentModificationException": return [3, 4];
600
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 4];
601
- case "InvalidArgumentException": return [3, 6];
602
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 6];
603
- case "LimitExceededException": return [3, 8];
604
- case "com.amazonaws.kinesisanalytics#LimitExceededException": return [3, 8];
605
- case "ResourceInUseException": return [3, 10];
606
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 10];
607
- case "TooManyTagsException": return [3, 12];
608
- case "com.amazonaws.kinesisanalytics#TooManyTagsException": return [3, 12];
609
- }
610
- return [3, 14];
611
- case 2: return [4, deserializeAws_json1_1CodeValidationExceptionResponse(parsedOutput, context)];
612
- case 3: throw _d.sent();
613
- case 4: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
614
- case 5: throw _d.sent();
615
- case 6: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
616
- case 7: throw _d.sent();
617
- case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
618
- case 9: throw _d.sent();
619
- case 10: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
620
- case 11: throw _d.sent();
621
- case 12: return [4, deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context)];
622
- case 13: throw _d.sent();
623
- case 14:
624
- parsedBody = parsedOutput.body;
625
- throwDefaultError({
626
- output: output,
627
- parsedBody: parsedBody,
628
- exceptionCtor: __BaseException,
629
- errorCode: errorCode,
630
- });
631
- _d.label = 15;
632
- case 15: return [2];
633
- }
634
- });
635
- }); };
636
- export var deserializeAws_json1_1DeleteApplicationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
637
- var data, contents, response;
638
- return __generator(this, function (_a) {
639
- switch (_a.label) {
640
- case 0:
641
- if (output.statusCode >= 300) {
642
- return [2, deserializeAws_json1_1DeleteApplicationCommandError(output, context)];
643
- }
644
- return [4, parseBody(output.body, context)];
645
- case 1:
646
- data = _a.sent();
647
- contents = {};
648
- contents = deserializeAws_json1_1DeleteApplicationResponse(data, context);
649
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
650
- return [2, Promise.resolve(response)];
651
- }
652
- });
653
- }); };
654
- var deserializeAws_json1_1DeleteApplicationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
655
- var parsedOutput, _a, errorCode, _b, parsedBody;
656
- var _c;
657
- return __generator(this, function (_d) {
658
- switch (_d.label) {
659
- case 0:
660
- _a = [__assign({}, output)];
661
- _c = {};
662
- return [4, parseErrorBody(output.body, context)];
663
- case 1:
664
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
665
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
666
- _b = errorCode;
667
- switch (_b) {
668
- case "ConcurrentModificationException": return [3, 2];
669
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
670
- case "ResourceInUseException": return [3, 4];
671
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 4];
672
- case "ResourceNotFoundException": return [3, 6];
673
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 6];
674
- case "UnsupportedOperationException": return [3, 8];
675
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 8];
676
- }
677
- return [3, 10];
678
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
679
- case 3: throw _d.sent();
680
- case 4: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
681
- case 5: throw _d.sent();
682
- case 6: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
683
- case 7: throw _d.sent();
684
- case 8: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
685
- case 9: throw _d.sent();
686
- case 10:
687
- parsedBody = parsedOutput.body;
688
- throwDefaultError({
689
- output: output,
690
- parsedBody: parsedBody,
691
- exceptionCtor: __BaseException,
692
- errorCode: errorCode,
693
- });
694
- _d.label = 11;
695
- case 11: return [2];
696
- }
697
- });
698
- }); };
699
- export var deserializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
700
- var data, contents, response;
701
- return __generator(this, function (_a) {
702
- switch (_a.label) {
703
- case 0:
704
- if (output.statusCode >= 300) {
705
- return [2, deserializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionCommandError(output, context)];
706
- }
707
- return [4, parseBody(output.body, context)];
708
- case 1:
709
- data = _a.sent();
710
- contents = {};
711
- contents = deserializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionResponse(data, context);
712
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
713
- return [2, Promise.resolve(response)];
714
- }
715
- });
716
- }); };
717
- var deserializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
718
- var parsedOutput, _a, errorCode, _b, parsedBody;
719
- var _c;
720
- return __generator(this, function (_d) {
721
- switch (_d.label) {
722
- case 0:
723
- _a = [__assign({}, output)];
724
- _c = {};
725
- return [4, parseErrorBody(output.body, context)];
726
- case 1:
727
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
728
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
729
- _b = errorCode;
730
- switch (_b) {
731
- case "ConcurrentModificationException": return [3, 2];
732
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
733
- case "InvalidArgumentException": return [3, 4];
734
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
735
- case "ResourceInUseException": return [3, 6];
736
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
737
- case "ResourceNotFoundException": return [3, 8];
738
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
739
- case "UnsupportedOperationException": return [3, 10];
740
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 10];
741
- }
742
- return [3, 12];
743
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
744
- case 3: throw _d.sent();
745
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
746
- case 5: throw _d.sent();
747
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
748
- case 7: throw _d.sent();
749
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
750
- case 9: throw _d.sent();
751
- case 10: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
752
- case 11: throw _d.sent();
753
- case 12:
754
- parsedBody = parsedOutput.body;
755
- throwDefaultError({
756
- output: output,
757
- parsedBody: parsedBody,
758
- exceptionCtor: __BaseException,
759
- errorCode: errorCode,
760
- });
761
- _d.label = 13;
762
- case 13: return [2];
763
- }
764
- });
765
- }); };
766
- export var deserializeAws_json1_1DeleteApplicationInputProcessingConfigurationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
767
- var data, contents, response;
768
- return __generator(this, function (_a) {
769
- switch (_a.label) {
770
- case 0:
771
- if (output.statusCode >= 300) {
772
- return [2, deserializeAws_json1_1DeleteApplicationInputProcessingConfigurationCommandError(output, context)];
773
- }
774
- return [4, parseBody(output.body, context)];
775
- case 1:
776
- data = _a.sent();
777
- contents = {};
778
- contents = deserializeAws_json1_1DeleteApplicationInputProcessingConfigurationResponse(data, context);
779
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
780
- return [2, Promise.resolve(response)];
781
- }
782
- });
783
- }); };
784
- var deserializeAws_json1_1DeleteApplicationInputProcessingConfigurationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
785
- var parsedOutput, _a, errorCode, _b, parsedBody;
786
- var _c;
787
- return __generator(this, function (_d) {
788
- switch (_d.label) {
789
- case 0:
790
- _a = [__assign({}, output)];
791
- _c = {};
792
- return [4, parseErrorBody(output.body, context)];
793
- case 1:
794
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
795
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
796
- _b = errorCode;
797
- switch (_b) {
798
- case "ConcurrentModificationException": return [3, 2];
799
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
800
- case "InvalidArgumentException": return [3, 4];
801
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
802
- case "ResourceInUseException": return [3, 6];
803
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
804
- case "ResourceNotFoundException": return [3, 8];
805
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
806
- case "UnsupportedOperationException": return [3, 10];
807
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 10];
808
- }
809
- return [3, 12];
810
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
811
- case 3: throw _d.sent();
812
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
813
- case 5: throw _d.sent();
814
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
815
- case 7: throw _d.sent();
816
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
817
- case 9: throw _d.sent();
818
- case 10: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
819
- case 11: throw _d.sent();
820
- case 12:
821
- parsedBody = parsedOutput.body;
822
- throwDefaultError({
823
- output: output,
824
- parsedBody: parsedBody,
825
- exceptionCtor: __BaseException,
826
- errorCode: errorCode,
827
- });
828
- _d.label = 13;
829
- case 13: return [2];
830
- }
831
- });
832
- }); };
833
- export var deserializeAws_json1_1DeleteApplicationOutputCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
834
- var data, contents, response;
835
- return __generator(this, function (_a) {
836
- switch (_a.label) {
837
- case 0:
838
- if (output.statusCode >= 300) {
839
- return [2, deserializeAws_json1_1DeleteApplicationOutputCommandError(output, context)];
840
- }
841
- return [4, parseBody(output.body, context)];
842
- case 1:
843
- data = _a.sent();
844
- contents = {};
845
- contents = deserializeAws_json1_1DeleteApplicationOutputResponse(data, context);
846
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
847
- return [2, Promise.resolve(response)];
848
- }
849
- });
850
- }); };
851
- var deserializeAws_json1_1DeleteApplicationOutputCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
852
- var parsedOutput, _a, errorCode, _b, parsedBody;
853
- var _c;
854
- return __generator(this, function (_d) {
855
- switch (_d.label) {
856
- case 0:
857
- _a = [__assign({}, output)];
858
- _c = {};
859
- return [4, parseErrorBody(output.body, context)];
860
- case 1:
861
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
862
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
863
- _b = errorCode;
864
- switch (_b) {
865
- case "ConcurrentModificationException": return [3, 2];
866
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
867
- case "InvalidArgumentException": return [3, 4];
868
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
869
- case "ResourceInUseException": return [3, 6];
870
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
871
- case "ResourceNotFoundException": return [3, 8];
872
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
873
- case "UnsupportedOperationException": return [3, 10];
874
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 10];
875
- }
876
- return [3, 12];
877
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
878
- case 3: throw _d.sent();
879
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
880
- case 5: throw _d.sent();
881
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
882
- case 7: throw _d.sent();
883
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
884
- case 9: throw _d.sent();
885
- case 10: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
886
- case 11: throw _d.sent();
887
- case 12:
888
- parsedBody = parsedOutput.body;
889
- throwDefaultError({
890
- output: output,
891
- parsedBody: parsedBody,
892
- exceptionCtor: __BaseException,
893
- errorCode: errorCode,
894
- });
895
- _d.label = 13;
896
- case 13: return [2];
897
- }
898
- });
899
- }); };
900
- export var deserializeAws_json1_1DeleteApplicationReferenceDataSourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
901
- var data, contents, response;
902
- return __generator(this, function (_a) {
903
- switch (_a.label) {
904
- case 0:
905
- if (output.statusCode >= 300) {
906
- return [2, deserializeAws_json1_1DeleteApplicationReferenceDataSourceCommandError(output, context)];
907
- }
908
- return [4, parseBody(output.body, context)];
909
- case 1:
910
- data = _a.sent();
911
- contents = {};
912
- contents = deserializeAws_json1_1DeleteApplicationReferenceDataSourceResponse(data, context);
913
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
914
- return [2, Promise.resolve(response)];
915
- }
916
- });
917
- }); };
918
- var deserializeAws_json1_1DeleteApplicationReferenceDataSourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
919
- var parsedOutput, _a, errorCode, _b, parsedBody;
920
- var _c;
921
- return __generator(this, function (_d) {
922
- switch (_d.label) {
923
- case 0:
924
- _a = [__assign({}, output)];
925
- _c = {};
926
- return [4, parseErrorBody(output.body, context)];
927
- case 1:
928
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
929
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
930
- _b = errorCode;
931
- switch (_b) {
932
- case "ConcurrentModificationException": return [3, 2];
933
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
934
- case "InvalidArgumentException": return [3, 4];
935
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
936
- case "ResourceInUseException": return [3, 6];
937
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
938
- case "ResourceNotFoundException": return [3, 8];
939
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
940
- case "UnsupportedOperationException": return [3, 10];
941
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 10];
942
- }
943
- return [3, 12];
944
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
945
- case 3: throw _d.sent();
946
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
947
- case 5: throw _d.sent();
948
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
949
- case 7: throw _d.sent();
950
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
951
- case 9: throw _d.sent();
952
- case 10: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
953
- case 11: throw _d.sent();
954
- case 12:
955
- parsedBody = parsedOutput.body;
956
- throwDefaultError({
957
- output: output,
958
- parsedBody: parsedBody,
959
- exceptionCtor: __BaseException,
960
- errorCode: errorCode,
961
- });
962
- _d.label = 13;
963
- case 13: return [2];
964
- }
965
- });
966
- }); };
967
- export var deserializeAws_json1_1DescribeApplicationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
968
- var data, contents, response;
969
- return __generator(this, function (_a) {
970
- switch (_a.label) {
971
- case 0:
972
- if (output.statusCode >= 300) {
973
- return [2, deserializeAws_json1_1DescribeApplicationCommandError(output, context)];
974
- }
975
- return [4, parseBody(output.body, context)];
976
- case 1:
977
- data = _a.sent();
978
- contents = {};
979
- contents = deserializeAws_json1_1DescribeApplicationResponse(data, context);
980
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
981
- return [2, Promise.resolve(response)];
982
- }
983
- });
984
- }); };
985
- var deserializeAws_json1_1DescribeApplicationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
986
- var parsedOutput, _a, errorCode, _b, parsedBody;
987
- var _c;
988
- return __generator(this, function (_d) {
989
- switch (_d.label) {
990
- case 0:
991
- _a = [__assign({}, output)];
992
- _c = {};
993
- return [4, parseErrorBody(output.body, context)];
994
- case 1:
995
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
996
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
997
- _b = errorCode;
998
- switch (_b) {
999
- case "ResourceNotFoundException": return [3, 2];
1000
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 2];
1001
- case "UnsupportedOperationException": return [3, 4];
1002
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 4];
1003
- }
1004
- return [3, 6];
1005
- case 2: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
1006
- case 3: throw _d.sent();
1007
- case 4: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
1008
- case 5: throw _d.sent();
1009
- case 6:
1010
- parsedBody = parsedOutput.body;
1011
- throwDefaultError({
1012
- output: output,
1013
- parsedBody: parsedBody,
1014
- exceptionCtor: __BaseException,
1015
- errorCode: errorCode,
1016
- });
1017
- _d.label = 7;
1018
- case 7: return [2];
1019
- }
1020
- });
1021
- }); };
1022
- export var deserializeAws_json1_1DiscoverInputSchemaCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1023
- var data, contents, response;
1024
- return __generator(this, function (_a) {
1025
- switch (_a.label) {
1026
- case 0:
1027
- if (output.statusCode >= 300) {
1028
- return [2, deserializeAws_json1_1DiscoverInputSchemaCommandError(output, context)];
1029
- }
1030
- return [4, parseBody(output.body, context)];
1031
- case 1:
1032
- data = _a.sent();
1033
- contents = {};
1034
- contents = deserializeAws_json1_1DiscoverInputSchemaResponse(data, context);
1035
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1036
- return [2, Promise.resolve(response)];
1037
- }
1038
- });
1039
- }); };
1040
- var deserializeAws_json1_1DiscoverInputSchemaCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1041
- var parsedOutput, _a, errorCode, _b, parsedBody;
1042
- var _c;
1043
- return __generator(this, function (_d) {
1044
- switch (_d.label) {
1045
- case 0:
1046
- _a = [__assign({}, output)];
1047
- _c = {};
1048
- return [4, parseErrorBody(output.body, context)];
1049
- case 1:
1050
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1051
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1052
- _b = errorCode;
1053
- switch (_b) {
1054
- case "InvalidArgumentException": return [3, 2];
1055
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 2];
1056
- case "ResourceProvisionedThroughputExceededException": return [3, 4];
1057
- case "com.amazonaws.kinesisanalytics#ResourceProvisionedThroughputExceededException": return [3, 4];
1058
- case "ServiceUnavailableException": return [3, 6];
1059
- case "com.amazonaws.kinesisanalytics#ServiceUnavailableException": return [3, 6];
1060
- case "UnableToDetectSchemaException": return [3, 8];
1061
- case "com.amazonaws.kinesisanalytics#UnableToDetectSchemaException": return [3, 8];
1062
- }
1063
- return [3, 10];
1064
- case 2: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
1065
- case 3: throw _d.sent();
1066
- case 4: return [4, deserializeAws_json1_1ResourceProvisionedThroughputExceededExceptionResponse(parsedOutput, context)];
1067
- case 5: throw _d.sent();
1068
- case 6: return [4, deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context)];
1069
- case 7: throw _d.sent();
1070
- case 8: return [4, deserializeAws_json1_1UnableToDetectSchemaExceptionResponse(parsedOutput, context)];
1071
- case 9: throw _d.sent();
1072
- case 10:
1073
- parsedBody = parsedOutput.body;
1074
- throwDefaultError({
1075
- output: output,
1076
- parsedBody: parsedBody,
1077
- exceptionCtor: __BaseException,
1078
- errorCode: errorCode,
1079
- });
1080
- _d.label = 11;
1081
- case 11: return [2];
1082
- }
1083
- });
1084
- }); };
1085
- export var deserializeAws_json1_1ListApplicationsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1086
- var data, contents, response;
1087
- return __generator(this, function (_a) {
1088
- switch (_a.label) {
1089
- case 0:
1090
- if (output.statusCode >= 300) {
1091
- return [2, deserializeAws_json1_1ListApplicationsCommandError(output, context)];
1092
- }
1093
- return [4, parseBody(output.body, context)];
1094
- case 1:
1095
- data = _a.sent();
1096
- contents = {};
1097
- contents = deserializeAws_json1_1ListApplicationsResponse(data, context);
1098
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1099
- return [2, Promise.resolve(response)];
1100
- }
1101
- });
1102
- }); };
1103
- var deserializeAws_json1_1ListApplicationsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1104
- var parsedOutput, _a, errorCode, parsedBody;
1105
- var _b;
1106
- return __generator(this, function (_c) {
1107
- switch (_c.label) {
1108
- case 0:
1109
- _a = [__assign({}, output)];
1110
- _b = {};
1111
- return [4, parseErrorBody(output.body, context)];
1112
- case 1:
1113
- parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
1114
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1115
- parsedBody = parsedOutput.body;
1116
- throwDefaultError({
1117
- output: output,
1118
- parsedBody: parsedBody,
1119
- exceptionCtor: __BaseException,
1120
- errorCode: errorCode,
1121
- });
1122
- return [2];
1123
- }
1124
- });
1125
- }); };
1126
- export var deserializeAws_json1_1ListTagsForResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1127
- var data, contents, response;
1128
- return __generator(this, function (_a) {
1129
- switch (_a.label) {
1130
- case 0:
1131
- if (output.statusCode >= 300) {
1132
- return [2, deserializeAws_json1_1ListTagsForResourceCommandError(output, context)];
1133
- }
1134
- return [4, parseBody(output.body, context)];
1135
- case 1:
1136
- data = _a.sent();
1137
- contents = {};
1138
- contents = deserializeAws_json1_1ListTagsForResourceResponse(data, context);
1139
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1140
- return [2, Promise.resolve(response)];
1141
- }
1142
- });
1143
- }); };
1144
- var deserializeAws_json1_1ListTagsForResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1145
- var parsedOutput, _a, errorCode, _b, parsedBody;
1146
- var _c;
1147
- return __generator(this, function (_d) {
1148
- switch (_d.label) {
1149
- case 0:
1150
- _a = [__assign({}, output)];
1151
- _c = {};
1152
- return [4, parseErrorBody(output.body, context)];
1153
- case 1:
1154
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1155
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1156
- _b = errorCode;
1157
- switch (_b) {
1158
- case "ConcurrentModificationException": return [3, 2];
1159
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
1160
- case "InvalidArgumentException": return [3, 4];
1161
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
1162
- case "ResourceNotFoundException": return [3, 6];
1163
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 6];
1164
- }
1165
- return [3, 8];
1166
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
1167
- case 3: throw _d.sent();
1168
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
1169
- case 5: throw _d.sent();
1170
- case 6: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
1171
- case 7: throw _d.sent();
1172
- case 8:
1173
- parsedBody = parsedOutput.body;
1174
- throwDefaultError({
1175
- output: output,
1176
- parsedBody: parsedBody,
1177
- exceptionCtor: __BaseException,
1178
- errorCode: errorCode,
1179
- });
1180
- _d.label = 9;
1181
- case 9: return [2];
1182
- }
1183
- });
1184
- }); };
1185
- export var deserializeAws_json1_1StartApplicationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1186
- var data, contents, response;
1187
- return __generator(this, function (_a) {
1188
- switch (_a.label) {
1189
- case 0:
1190
- if (output.statusCode >= 300) {
1191
- return [2, deserializeAws_json1_1StartApplicationCommandError(output, context)];
1192
- }
1193
- return [4, parseBody(output.body, context)];
1194
- case 1:
1195
- data = _a.sent();
1196
- contents = {};
1197
- contents = deserializeAws_json1_1StartApplicationResponse(data, context);
1198
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1199
- return [2, Promise.resolve(response)];
1200
- }
1201
- });
1202
- }); };
1203
- var deserializeAws_json1_1StartApplicationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1204
- var parsedOutput, _a, errorCode, _b, parsedBody;
1205
- var _c;
1206
- return __generator(this, function (_d) {
1207
- switch (_d.label) {
1208
- case 0:
1209
- _a = [__assign({}, output)];
1210
- _c = {};
1211
- return [4, parseErrorBody(output.body, context)];
1212
- case 1:
1213
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1214
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1215
- _b = errorCode;
1216
- switch (_b) {
1217
- case "InvalidApplicationConfigurationException": return [3, 2];
1218
- case "com.amazonaws.kinesisanalytics#InvalidApplicationConfigurationException": return [3, 2];
1219
- case "InvalidArgumentException": return [3, 4];
1220
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
1221
- case "ResourceInUseException": return [3, 6];
1222
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
1223
- case "ResourceNotFoundException": return [3, 8];
1224
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
1225
- case "UnsupportedOperationException": return [3, 10];
1226
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 10];
1227
- }
1228
- return [3, 12];
1229
- case 2: return [4, deserializeAws_json1_1InvalidApplicationConfigurationExceptionResponse(parsedOutput, context)];
1230
- case 3: throw _d.sent();
1231
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
1232
- case 5: throw _d.sent();
1233
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
1234
- case 7: throw _d.sent();
1235
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
1236
- case 9: throw _d.sent();
1237
- case 10: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
1238
- case 11: throw _d.sent();
1239
- case 12:
1240
- parsedBody = parsedOutput.body;
1241
- throwDefaultError({
1242
- output: output,
1243
- parsedBody: parsedBody,
1244
- exceptionCtor: __BaseException,
1245
- errorCode: errorCode,
1246
- });
1247
- _d.label = 13;
1248
- case 13: return [2];
1249
- }
1250
- });
1251
- }); };
1252
- export var deserializeAws_json1_1StopApplicationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1253
- var data, contents, response;
1254
- return __generator(this, function (_a) {
1255
- switch (_a.label) {
1256
- case 0:
1257
- if (output.statusCode >= 300) {
1258
- return [2, deserializeAws_json1_1StopApplicationCommandError(output, context)];
1259
- }
1260
- return [4, parseBody(output.body, context)];
1261
- case 1:
1262
- data = _a.sent();
1263
- contents = {};
1264
- contents = deserializeAws_json1_1StopApplicationResponse(data, context);
1265
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1266
- return [2, Promise.resolve(response)];
1267
- }
1268
- });
1269
- }); };
1270
- var deserializeAws_json1_1StopApplicationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1271
- var parsedOutput, _a, errorCode, _b, parsedBody;
1272
- var _c;
1273
- return __generator(this, function (_d) {
1274
- switch (_d.label) {
1275
- case 0:
1276
- _a = [__assign({}, output)];
1277
- _c = {};
1278
- return [4, parseErrorBody(output.body, context)];
1279
- case 1:
1280
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1281
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1282
- _b = errorCode;
1283
- switch (_b) {
1284
- case "ResourceInUseException": return [3, 2];
1285
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 2];
1286
- case "ResourceNotFoundException": return [3, 4];
1287
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 4];
1288
- case "UnsupportedOperationException": return [3, 6];
1289
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 6];
1290
- }
1291
- return [3, 8];
1292
- case 2: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
1293
- case 3: throw _d.sent();
1294
- case 4: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
1295
- case 5: throw _d.sent();
1296
- case 6: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
1297
- case 7: throw _d.sent();
1298
- case 8:
1299
- parsedBody = parsedOutput.body;
1300
- throwDefaultError({
1301
- output: output,
1302
- parsedBody: parsedBody,
1303
- exceptionCtor: __BaseException,
1304
- errorCode: errorCode,
1305
- });
1306
- _d.label = 9;
1307
- case 9: return [2];
1308
- }
1309
- });
1310
- }); };
1311
- export var deserializeAws_json1_1TagResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1312
- var data, contents, response;
1313
- return __generator(this, function (_a) {
1314
- switch (_a.label) {
1315
- case 0:
1316
- if (output.statusCode >= 300) {
1317
- return [2, deserializeAws_json1_1TagResourceCommandError(output, context)];
1318
- }
1319
- return [4, parseBody(output.body, context)];
1320
- case 1:
1321
- data = _a.sent();
1322
- contents = {};
1323
- contents = deserializeAws_json1_1TagResourceResponse(data, context);
1324
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1325
- return [2, Promise.resolve(response)];
1326
- }
1327
- });
1328
- }); };
1329
- var deserializeAws_json1_1TagResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1330
- var parsedOutput, _a, errorCode, _b, parsedBody;
1331
- var _c;
1332
- return __generator(this, function (_d) {
1333
- switch (_d.label) {
1334
- case 0:
1335
- _a = [__assign({}, output)];
1336
- _c = {};
1337
- return [4, parseErrorBody(output.body, context)];
1338
- case 1:
1339
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1340
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1341
- _b = errorCode;
1342
- switch (_b) {
1343
- case "ConcurrentModificationException": return [3, 2];
1344
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
1345
- case "InvalidArgumentException": return [3, 4];
1346
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
1347
- case "ResourceInUseException": return [3, 6];
1348
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
1349
- case "ResourceNotFoundException": return [3, 8];
1350
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
1351
- case "TooManyTagsException": return [3, 10];
1352
- case "com.amazonaws.kinesisanalytics#TooManyTagsException": return [3, 10];
1353
- }
1354
- return [3, 12];
1355
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
1356
- case 3: throw _d.sent();
1357
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
1358
- case 5: throw _d.sent();
1359
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
1360
- case 7: throw _d.sent();
1361
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
1362
- case 9: throw _d.sent();
1363
- case 10: return [4, deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context)];
1364
- case 11: throw _d.sent();
1365
- case 12:
1366
- parsedBody = parsedOutput.body;
1367
- throwDefaultError({
1368
- output: output,
1369
- parsedBody: parsedBody,
1370
- exceptionCtor: __BaseException,
1371
- errorCode: errorCode,
1372
- });
1373
- _d.label = 13;
1374
- case 13: return [2];
1375
- }
1376
- });
1377
- }); };
1378
- export var deserializeAws_json1_1UntagResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1379
- var data, contents, response;
1380
- return __generator(this, function (_a) {
1381
- switch (_a.label) {
1382
- case 0:
1383
- if (output.statusCode >= 300) {
1384
- return [2, deserializeAws_json1_1UntagResourceCommandError(output, context)];
1385
- }
1386
- return [4, parseBody(output.body, context)];
1387
- case 1:
1388
- data = _a.sent();
1389
- contents = {};
1390
- contents = deserializeAws_json1_1UntagResourceResponse(data, context);
1391
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1392
- return [2, Promise.resolve(response)];
1393
- }
1394
- });
1395
- }); };
1396
- var deserializeAws_json1_1UntagResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1397
- var parsedOutput, _a, errorCode, _b, parsedBody;
1398
- var _c;
1399
- return __generator(this, function (_d) {
1400
- switch (_d.label) {
1401
- case 0:
1402
- _a = [__assign({}, output)];
1403
- _c = {};
1404
- return [4, parseErrorBody(output.body, context)];
1405
- case 1:
1406
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1407
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1408
- _b = errorCode;
1409
- switch (_b) {
1410
- case "ConcurrentModificationException": return [3, 2];
1411
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 2];
1412
- case "InvalidArgumentException": return [3, 4];
1413
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 4];
1414
- case "ResourceInUseException": return [3, 6];
1415
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 6];
1416
- case "ResourceNotFoundException": return [3, 8];
1417
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 8];
1418
- case "TooManyTagsException": return [3, 10];
1419
- case "com.amazonaws.kinesisanalytics#TooManyTagsException": return [3, 10];
1420
- }
1421
- return [3, 12];
1422
- case 2: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
1423
- case 3: throw _d.sent();
1424
- case 4: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
1425
- case 5: throw _d.sent();
1426
- case 6: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
1427
- case 7: throw _d.sent();
1428
- case 8: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
1429
- case 9: throw _d.sent();
1430
- case 10: return [4, deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context)];
1431
- case 11: throw _d.sent();
1432
- case 12:
1433
- parsedBody = parsedOutput.body;
1434
- throwDefaultError({
1435
- output: output,
1436
- parsedBody: parsedBody,
1437
- exceptionCtor: __BaseException,
1438
- errorCode: errorCode,
1439
- });
1440
- _d.label = 13;
1441
- case 13: return [2];
1442
- }
1443
- });
1444
- }); };
1445
- export var deserializeAws_json1_1UpdateApplicationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1446
- var data, contents, response;
1447
- return __generator(this, function (_a) {
1448
- switch (_a.label) {
1449
- case 0:
1450
- if (output.statusCode >= 300) {
1451
- return [2, deserializeAws_json1_1UpdateApplicationCommandError(output, context)];
1452
- }
1453
- return [4, parseBody(output.body, context)];
1454
- case 1:
1455
- data = _a.sent();
1456
- contents = {};
1457
- contents = deserializeAws_json1_1UpdateApplicationResponse(data, context);
1458
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1459
- return [2, Promise.resolve(response)];
1460
- }
1461
- });
1462
- }); };
1463
- var deserializeAws_json1_1UpdateApplicationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1464
- var parsedOutput, _a, errorCode, _b, parsedBody;
1465
- var _c;
1466
- return __generator(this, function (_d) {
1467
- switch (_d.label) {
1468
- case 0:
1469
- _a = [__assign({}, output)];
1470
- _c = {};
1471
- return [4, parseErrorBody(output.body, context)];
1472
- case 1:
1473
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1474
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1475
- _b = errorCode;
1476
- switch (_b) {
1477
- case "CodeValidationException": return [3, 2];
1478
- case "com.amazonaws.kinesisanalytics#CodeValidationException": return [3, 2];
1479
- case "ConcurrentModificationException": return [3, 4];
1480
- case "com.amazonaws.kinesisanalytics#ConcurrentModificationException": return [3, 4];
1481
- case "InvalidArgumentException": return [3, 6];
1482
- case "com.amazonaws.kinesisanalytics#InvalidArgumentException": return [3, 6];
1483
- case "ResourceInUseException": return [3, 8];
1484
- case "com.amazonaws.kinesisanalytics#ResourceInUseException": return [3, 8];
1485
- case "ResourceNotFoundException": return [3, 10];
1486
- case "com.amazonaws.kinesisanalytics#ResourceNotFoundException": return [3, 10];
1487
- case "UnsupportedOperationException": return [3, 12];
1488
- case "com.amazonaws.kinesisanalytics#UnsupportedOperationException": return [3, 12];
1489
- }
1490
- return [3, 14];
1491
- case 2: return [4, deserializeAws_json1_1CodeValidationExceptionResponse(parsedOutput, context)];
1492
- case 3: throw _d.sent();
1493
- case 4: return [4, deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context)];
1494
- case 5: throw _d.sent();
1495
- case 6: return [4, deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context)];
1496
- case 7: throw _d.sent();
1497
- case 8: return [4, deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)];
1498
- case 9: throw _d.sent();
1499
- case 10: return [4, deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)];
1500
- case 11: throw _d.sent();
1501
- case 12: return [4, deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context)];
1502
- case 13: throw _d.sent();
1503
- case 14:
1504
- parsedBody = parsedOutput.body;
1505
- throwDefaultError({
1506
- output: output,
1507
- parsedBody: parsedBody,
1508
- exceptionCtor: __BaseException,
1509
- errorCode: errorCode,
1510
- });
1511
- _d.label = 15;
1512
- case 15: return [2];
1513
- }
1514
- });
1515
- }); };
1516
- var deserializeAws_json1_1CodeValidationExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1517
- var body, deserialized, exception;
1518
- return __generator(this, function (_a) {
1519
- body = parsedOutput.body;
1520
- deserialized = deserializeAws_json1_1CodeValidationException(body, context);
1521
- exception = new CodeValidationException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1522
- return [2, __decorateServiceException(exception, body)];
1523
- });
1524
- }); };
1525
- var deserializeAws_json1_1ConcurrentModificationExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1526
- var body, deserialized, exception;
1527
- return __generator(this, function (_a) {
1528
- body = parsedOutput.body;
1529
- deserialized = deserializeAws_json1_1ConcurrentModificationException(body, context);
1530
- exception = new ConcurrentModificationException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1531
- return [2, __decorateServiceException(exception, body)];
1532
- });
1533
- }); };
1534
- var deserializeAws_json1_1InvalidApplicationConfigurationExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1535
- var body, deserialized, exception;
1536
- return __generator(this, function (_a) {
1537
- body = parsedOutput.body;
1538
- deserialized = deserializeAws_json1_1InvalidApplicationConfigurationException(body, context);
1539
- exception = new InvalidApplicationConfigurationException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1540
- return [2, __decorateServiceException(exception, body)];
1541
- });
1542
- }); };
1543
- var deserializeAws_json1_1InvalidArgumentExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1544
- var body, deserialized, exception;
1545
- return __generator(this, function (_a) {
1546
- body = parsedOutput.body;
1547
- deserialized = deserializeAws_json1_1InvalidArgumentException(body, context);
1548
- exception = new InvalidArgumentException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1549
- return [2, __decorateServiceException(exception, body)];
1550
- });
1551
- }); };
1552
- var deserializeAws_json1_1LimitExceededExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1553
- var body, deserialized, exception;
1554
- return __generator(this, function (_a) {
1555
- body = parsedOutput.body;
1556
- deserialized = deserializeAws_json1_1LimitExceededException(body, context);
1557
- exception = new LimitExceededException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1558
- return [2, __decorateServiceException(exception, body)];
1559
- });
1560
- }); };
1561
- var deserializeAws_json1_1ResourceInUseExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1562
- var body, deserialized, exception;
1563
- return __generator(this, function (_a) {
1564
- body = parsedOutput.body;
1565
- deserialized = deserializeAws_json1_1ResourceInUseException(body, context);
1566
- exception = new ResourceInUseException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1567
- return [2, __decorateServiceException(exception, body)];
1568
- });
1569
- }); };
1570
- var deserializeAws_json1_1ResourceNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1571
- var body, deserialized, exception;
1572
- return __generator(this, function (_a) {
1573
- body = parsedOutput.body;
1574
- deserialized = deserializeAws_json1_1ResourceNotFoundException(body, context);
1575
- exception = new ResourceNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1576
- return [2, __decorateServiceException(exception, body)];
1577
- });
1578
- }); };
1579
- var deserializeAws_json1_1ResourceProvisionedThroughputExceededExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1580
- var body, deserialized, exception;
1581
- return __generator(this, function (_a) {
1582
- body = parsedOutput.body;
1583
- deserialized = deserializeAws_json1_1ResourceProvisionedThroughputExceededException(body, context);
1584
- exception = new ResourceProvisionedThroughputExceededException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1585
- return [2, __decorateServiceException(exception, body)];
1586
- });
1587
- }); };
1588
- var deserializeAws_json1_1ServiceUnavailableExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1589
- var body, deserialized, exception;
1590
- return __generator(this, function (_a) {
1591
- body = parsedOutput.body;
1592
- deserialized = deserializeAws_json1_1ServiceUnavailableException(body, context);
1593
- exception = new ServiceUnavailableException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1594
- return [2, __decorateServiceException(exception, body)];
1595
- });
1596
- }); };
1597
- var deserializeAws_json1_1TooManyTagsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1598
- var body, deserialized, exception;
1599
- return __generator(this, function (_a) {
1600
- body = parsedOutput.body;
1601
- deserialized = deserializeAws_json1_1TooManyTagsException(body, context);
1602
- exception = new TooManyTagsException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1603
- return [2, __decorateServiceException(exception, body)];
1604
- });
1605
- }); };
1606
- var deserializeAws_json1_1UnableToDetectSchemaExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1607
- var body, deserialized, exception;
1608
- return __generator(this, function (_a) {
1609
- body = parsedOutput.body;
1610
- deserialized = deserializeAws_json1_1UnableToDetectSchemaException(body, context);
1611
- exception = new UnableToDetectSchemaException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1612
- return [2, __decorateServiceException(exception, body)];
1613
- });
1614
- }); };
1615
- var deserializeAws_json1_1UnsupportedOperationExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1616
- var body, deserialized, exception;
1617
- return __generator(this, function (_a) {
1618
- body = parsedOutput.body;
1619
- deserialized = deserializeAws_json1_1UnsupportedOperationException(body, context);
1620
- exception = new UnsupportedOperationException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1621
- return [2, __decorateServiceException(exception, body)];
1622
- });
1623
- }); };
1624
- var serializeAws_json1_1AddApplicationCloudWatchLoggingOptionRequest = function (input, context) {
1625
- return __assign(__assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CloudWatchLoggingOption != null && {
1626
- CloudWatchLoggingOption: serializeAws_json1_1CloudWatchLoggingOption(input.CloudWatchLoggingOption, context),
1627
- })), (input.CurrentApplicationVersionId != null && {
1628
- CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1629
- }));
1630
- };
1631
- var serializeAws_json1_1AddApplicationInputProcessingConfigurationRequest = function (input, context) {
1632
- return __assign(__assign(__assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CurrentApplicationVersionId != null && {
1633
- CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1634
- })), (input.InputId != null && { InputId: input.InputId })), (input.InputProcessingConfiguration != null && {
1635
- InputProcessingConfiguration: serializeAws_json1_1InputProcessingConfiguration(input.InputProcessingConfiguration, context),
1636
- }));
1637
- };
1638
- var serializeAws_json1_1AddApplicationInputRequest = function (input, context) {
1639
- return __assign(__assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CurrentApplicationVersionId != null && {
1640
- CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1641
- })), (input.Input != null && { Input: serializeAws_json1_1Input(input.Input, context) }));
1642
- };
1643
- var serializeAws_json1_1AddApplicationOutputRequest = function (input, context) {
1644
- return __assign(__assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CurrentApplicationVersionId != null && {
1645
- CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1646
- })), (input.Output != null && { Output: serializeAws_json1_1Output(input.Output, context) }));
1647
- };
1648
- var serializeAws_json1_1AddApplicationReferenceDataSourceRequest = function (input, context) {
1649
- return __assign(__assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CurrentApplicationVersionId != null && {
1650
- CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1651
- })), (input.ReferenceDataSource != null && {
1652
- ReferenceDataSource: serializeAws_json1_1ReferenceDataSource(input.ReferenceDataSource, context),
1653
- }));
1654
- };
1655
- var serializeAws_json1_1ApplicationUpdate = function (input, context) {
1656
- return __assign(__assign(__assign(__assign(__assign({}, (input.ApplicationCodeUpdate != null && { ApplicationCodeUpdate: input.ApplicationCodeUpdate })), (input.CloudWatchLoggingOptionUpdates != null && {
1657
- CloudWatchLoggingOptionUpdates: serializeAws_json1_1CloudWatchLoggingOptionUpdates(input.CloudWatchLoggingOptionUpdates, context),
1658
- })), (input.InputUpdates != null && { InputUpdates: serializeAws_json1_1InputUpdates(input.InputUpdates, context) })), (input.OutputUpdates != null && {
1659
- OutputUpdates: serializeAws_json1_1OutputUpdates(input.OutputUpdates, context),
1660
- })), (input.ReferenceDataSourceUpdates != null && {
1661
- ReferenceDataSourceUpdates: serializeAws_json1_1ReferenceDataSourceUpdates(input.ReferenceDataSourceUpdates, context),
1662
- }));
1663
- };
1664
- var serializeAws_json1_1CloudWatchLoggingOption = function (input, context) {
1665
- return __assign(__assign({}, (input.LogStreamARN != null && { LogStreamARN: input.LogStreamARN })), (input.RoleARN != null && { RoleARN: input.RoleARN }));
1666
- };
1667
- var serializeAws_json1_1CloudWatchLoggingOptions = function (input, context) {
5
+ export const serializeAws_json1_1AddApplicationCloudWatchLoggingOptionCommand = async (input, context) => {
6
+ const headers = {
7
+ "content-type": "application/x-amz-json-1.1",
8
+ "x-amz-target": "KinesisAnalytics_20150814.AddApplicationCloudWatchLoggingOption",
9
+ };
10
+ let body;
11
+ body = JSON.stringify(serializeAws_json1_1AddApplicationCloudWatchLoggingOptionRequest(input, context));
12
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
13
+ };
14
+ export const serializeAws_json1_1AddApplicationInputCommand = async (input, context) => {
15
+ const headers = {
16
+ "content-type": "application/x-amz-json-1.1",
17
+ "x-amz-target": "KinesisAnalytics_20150814.AddApplicationInput",
18
+ };
19
+ let body;
20
+ body = JSON.stringify(serializeAws_json1_1AddApplicationInputRequest(input, context));
21
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
22
+ };
23
+ export const serializeAws_json1_1AddApplicationInputProcessingConfigurationCommand = async (input, context) => {
24
+ const headers = {
25
+ "content-type": "application/x-amz-json-1.1",
26
+ "x-amz-target": "KinesisAnalytics_20150814.AddApplicationInputProcessingConfiguration",
27
+ };
28
+ let body;
29
+ body = JSON.stringify(serializeAws_json1_1AddApplicationInputProcessingConfigurationRequest(input, context));
30
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
31
+ };
32
+ export const serializeAws_json1_1AddApplicationOutputCommand = async (input, context) => {
33
+ const headers = {
34
+ "content-type": "application/x-amz-json-1.1",
35
+ "x-amz-target": "KinesisAnalytics_20150814.AddApplicationOutput",
36
+ };
37
+ let body;
38
+ body = JSON.stringify(serializeAws_json1_1AddApplicationOutputRequest(input, context));
39
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
40
+ };
41
+ export const serializeAws_json1_1AddApplicationReferenceDataSourceCommand = async (input, context) => {
42
+ const headers = {
43
+ "content-type": "application/x-amz-json-1.1",
44
+ "x-amz-target": "KinesisAnalytics_20150814.AddApplicationReferenceDataSource",
45
+ };
46
+ let body;
47
+ body = JSON.stringify(serializeAws_json1_1AddApplicationReferenceDataSourceRequest(input, context));
48
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
49
+ };
50
+ export const serializeAws_json1_1CreateApplicationCommand = async (input, context) => {
51
+ const headers = {
52
+ "content-type": "application/x-amz-json-1.1",
53
+ "x-amz-target": "KinesisAnalytics_20150814.CreateApplication",
54
+ };
55
+ let body;
56
+ body = JSON.stringify(serializeAws_json1_1CreateApplicationRequest(input, context));
57
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
58
+ };
59
+ export const serializeAws_json1_1DeleteApplicationCommand = async (input, context) => {
60
+ const headers = {
61
+ "content-type": "application/x-amz-json-1.1",
62
+ "x-amz-target": "KinesisAnalytics_20150814.DeleteApplication",
63
+ };
64
+ let body;
65
+ body = JSON.stringify(serializeAws_json1_1DeleteApplicationRequest(input, context));
66
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
67
+ };
68
+ export const serializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionCommand = async (input, context) => {
69
+ const headers = {
70
+ "content-type": "application/x-amz-json-1.1",
71
+ "x-amz-target": "KinesisAnalytics_20150814.DeleteApplicationCloudWatchLoggingOption",
72
+ };
73
+ let body;
74
+ body = JSON.stringify(serializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionRequest(input, context));
75
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
76
+ };
77
+ export const serializeAws_json1_1DeleteApplicationInputProcessingConfigurationCommand = async (input, context) => {
78
+ const headers = {
79
+ "content-type": "application/x-amz-json-1.1",
80
+ "x-amz-target": "KinesisAnalytics_20150814.DeleteApplicationInputProcessingConfiguration",
81
+ };
82
+ let body;
83
+ body = JSON.stringify(serializeAws_json1_1DeleteApplicationInputProcessingConfigurationRequest(input, context));
84
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
85
+ };
86
+ export const serializeAws_json1_1DeleteApplicationOutputCommand = async (input, context) => {
87
+ const headers = {
88
+ "content-type": "application/x-amz-json-1.1",
89
+ "x-amz-target": "KinesisAnalytics_20150814.DeleteApplicationOutput",
90
+ };
91
+ let body;
92
+ body = JSON.stringify(serializeAws_json1_1DeleteApplicationOutputRequest(input, context));
93
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
94
+ };
95
+ export const serializeAws_json1_1DeleteApplicationReferenceDataSourceCommand = async (input, context) => {
96
+ const headers = {
97
+ "content-type": "application/x-amz-json-1.1",
98
+ "x-amz-target": "KinesisAnalytics_20150814.DeleteApplicationReferenceDataSource",
99
+ };
100
+ let body;
101
+ body = JSON.stringify(serializeAws_json1_1DeleteApplicationReferenceDataSourceRequest(input, context));
102
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
103
+ };
104
+ export const serializeAws_json1_1DescribeApplicationCommand = async (input, context) => {
105
+ const headers = {
106
+ "content-type": "application/x-amz-json-1.1",
107
+ "x-amz-target": "KinesisAnalytics_20150814.DescribeApplication",
108
+ };
109
+ let body;
110
+ body = JSON.stringify(serializeAws_json1_1DescribeApplicationRequest(input, context));
111
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
112
+ };
113
+ export const serializeAws_json1_1DiscoverInputSchemaCommand = async (input, context) => {
114
+ const headers = {
115
+ "content-type": "application/x-amz-json-1.1",
116
+ "x-amz-target": "KinesisAnalytics_20150814.DiscoverInputSchema",
117
+ };
118
+ let body;
119
+ body = JSON.stringify(serializeAws_json1_1DiscoverInputSchemaRequest(input, context));
120
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
121
+ };
122
+ export const serializeAws_json1_1ListApplicationsCommand = async (input, context) => {
123
+ const headers = {
124
+ "content-type": "application/x-amz-json-1.1",
125
+ "x-amz-target": "KinesisAnalytics_20150814.ListApplications",
126
+ };
127
+ let body;
128
+ body = JSON.stringify(serializeAws_json1_1ListApplicationsRequest(input, context));
129
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
130
+ };
131
+ export const serializeAws_json1_1ListTagsForResourceCommand = async (input, context) => {
132
+ const headers = {
133
+ "content-type": "application/x-amz-json-1.1",
134
+ "x-amz-target": "KinesisAnalytics_20150814.ListTagsForResource",
135
+ };
136
+ let body;
137
+ body = JSON.stringify(serializeAws_json1_1ListTagsForResourceRequest(input, context));
138
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
139
+ };
140
+ export const serializeAws_json1_1StartApplicationCommand = async (input, context) => {
141
+ const headers = {
142
+ "content-type": "application/x-amz-json-1.1",
143
+ "x-amz-target": "KinesisAnalytics_20150814.StartApplication",
144
+ };
145
+ let body;
146
+ body = JSON.stringify(serializeAws_json1_1StartApplicationRequest(input, context));
147
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
148
+ };
149
+ export const serializeAws_json1_1StopApplicationCommand = async (input, context) => {
150
+ const headers = {
151
+ "content-type": "application/x-amz-json-1.1",
152
+ "x-amz-target": "KinesisAnalytics_20150814.StopApplication",
153
+ };
154
+ let body;
155
+ body = JSON.stringify(serializeAws_json1_1StopApplicationRequest(input, context));
156
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
157
+ };
158
+ export const serializeAws_json1_1TagResourceCommand = async (input, context) => {
159
+ const headers = {
160
+ "content-type": "application/x-amz-json-1.1",
161
+ "x-amz-target": "KinesisAnalytics_20150814.TagResource",
162
+ };
163
+ let body;
164
+ body = JSON.stringify(serializeAws_json1_1TagResourceRequest(input, context));
165
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
166
+ };
167
+ export const serializeAws_json1_1UntagResourceCommand = async (input, context) => {
168
+ const headers = {
169
+ "content-type": "application/x-amz-json-1.1",
170
+ "x-amz-target": "KinesisAnalytics_20150814.UntagResource",
171
+ };
172
+ let body;
173
+ body = JSON.stringify(serializeAws_json1_1UntagResourceRequest(input, context));
174
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
175
+ };
176
+ export const serializeAws_json1_1UpdateApplicationCommand = async (input, context) => {
177
+ const headers = {
178
+ "content-type": "application/x-amz-json-1.1",
179
+ "x-amz-target": "KinesisAnalytics_20150814.UpdateApplication",
180
+ };
181
+ let body;
182
+ body = JSON.stringify(serializeAws_json1_1UpdateApplicationRequest(input, context));
183
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
184
+ };
185
+ export const deserializeAws_json1_1AddApplicationCloudWatchLoggingOptionCommand = async (output, context) => {
186
+ if (output.statusCode >= 300) {
187
+ return deserializeAws_json1_1AddApplicationCloudWatchLoggingOptionCommandError(output, context);
188
+ }
189
+ const data = await parseBody(output.body, context);
190
+ let contents = {};
191
+ contents = deserializeAws_json1_1AddApplicationCloudWatchLoggingOptionResponse(data, context);
192
+ const response = {
193
+ $metadata: deserializeMetadata(output),
194
+ ...contents,
195
+ };
196
+ return Promise.resolve(response);
197
+ };
198
+ const deserializeAws_json1_1AddApplicationCloudWatchLoggingOptionCommandError = async (output, context) => {
199
+ const parsedOutput = {
200
+ ...output,
201
+ body: await parseErrorBody(output.body, context),
202
+ };
203
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
204
+ switch (errorCode) {
205
+ case "ConcurrentModificationException":
206
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
207
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
208
+ case "InvalidArgumentException":
209
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
210
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
211
+ case "ResourceInUseException":
212
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
213
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
214
+ case "ResourceNotFoundException":
215
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
216
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
217
+ case "UnsupportedOperationException":
218
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
219
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
220
+ default:
221
+ const parsedBody = parsedOutput.body;
222
+ throwDefaultError({
223
+ output,
224
+ parsedBody,
225
+ exceptionCtor: __BaseException,
226
+ errorCode,
227
+ });
228
+ }
229
+ };
230
+ export const deserializeAws_json1_1AddApplicationInputCommand = async (output, context) => {
231
+ if (output.statusCode >= 300) {
232
+ return deserializeAws_json1_1AddApplicationInputCommandError(output, context);
233
+ }
234
+ const data = await parseBody(output.body, context);
235
+ let contents = {};
236
+ contents = deserializeAws_json1_1AddApplicationInputResponse(data, context);
237
+ const response = {
238
+ $metadata: deserializeMetadata(output),
239
+ ...contents,
240
+ };
241
+ return Promise.resolve(response);
242
+ };
243
+ const deserializeAws_json1_1AddApplicationInputCommandError = async (output, context) => {
244
+ const parsedOutput = {
245
+ ...output,
246
+ body: await parseErrorBody(output.body, context),
247
+ };
248
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
249
+ switch (errorCode) {
250
+ case "CodeValidationException":
251
+ case "com.amazonaws.kinesisanalytics#CodeValidationException":
252
+ throw await deserializeAws_json1_1CodeValidationExceptionResponse(parsedOutput, context);
253
+ case "ConcurrentModificationException":
254
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
255
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
256
+ case "InvalidArgumentException":
257
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
258
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
259
+ case "ResourceInUseException":
260
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
261
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
262
+ case "ResourceNotFoundException":
263
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
264
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
265
+ case "UnsupportedOperationException":
266
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
267
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
268
+ default:
269
+ const parsedBody = parsedOutput.body;
270
+ throwDefaultError({
271
+ output,
272
+ parsedBody,
273
+ exceptionCtor: __BaseException,
274
+ errorCode,
275
+ });
276
+ }
277
+ };
278
+ export const deserializeAws_json1_1AddApplicationInputProcessingConfigurationCommand = async (output, context) => {
279
+ if (output.statusCode >= 300) {
280
+ return deserializeAws_json1_1AddApplicationInputProcessingConfigurationCommandError(output, context);
281
+ }
282
+ const data = await parseBody(output.body, context);
283
+ let contents = {};
284
+ contents = deserializeAws_json1_1AddApplicationInputProcessingConfigurationResponse(data, context);
285
+ const response = {
286
+ $metadata: deserializeMetadata(output),
287
+ ...contents,
288
+ };
289
+ return Promise.resolve(response);
290
+ };
291
+ const deserializeAws_json1_1AddApplicationInputProcessingConfigurationCommandError = async (output, context) => {
292
+ const parsedOutput = {
293
+ ...output,
294
+ body: await parseErrorBody(output.body, context),
295
+ };
296
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
297
+ switch (errorCode) {
298
+ case "ConcurrentModificationException":
299
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
300
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
301
+ case "InvalidArgumentException":
302
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
303
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
304
+ case "ResourceInUseException":
305
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
306
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
307
+ case "ResourceNotFoundException":
308
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
309
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
310
+ case "UnsupportedOperationException":
311
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
312
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
313
+ default:
314
+ const parsedBody = parsedOutput.body;
315
+ throwDefaultError({
316
+ output,
317
+ parsedBody,
318
+ exceptionCtor: __BaseException,
319
+ errorCode,
320
+ });
321
+ }
322
+ };
323
+ export const deserializeAws_json1_1AddApplicationOutputCommand = async (output, context) => {
324
+ if (output.statusCode >= 300) {
325
+ return deserializeAws_json1_1AddApplicationOutputCommandError(output, context);
326
+ }
327
+ const data = await parseBody(output.body, context);
328
+ let contents = {};
329
+ contents = deserializeAws_json1_1AddApplicationOutputResponse(data, context);
330
+ const response = {
331
+ $metadata: deserializeMetadata(output),
332
+ ...contents,
333
+ };
334
+ return Promise.resolve(response);
335
+ };
336
+ const deserializeAws_json1_1AddApplicationOutputCommandError = async (output, context) => {
337
+ const parsedOutput = {
338
+ ...output,
339
+ body: await parseErrorBody(output.body, context),
340
+ };
341
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
342
+ switch (errorCode) {
343
+ case "ConcurrentModificationException":
344
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
345
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
346
+ case "InvalidArgumentException":
347
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
348
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
349
+ case "ResourceInUseException":
350
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
351
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
352
+ case "ResourceNotFoundException":
353
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
354
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
355
+ case "UnsupportedOperationException":
356
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
357
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
358
+ default:
359
+ const parsedBody = parsedOutput.body;
360
+ throwDefaultError({
361
+ output,
362
+ parsedBody,
363
+ exceptionCtor: __BaseException,
364
+ errorCode,
365
+ });
366
+ }
367
+ };
368
+ export const deserializeAws_json1_1AddApplicationReferenceDataSourceCommand = async (output, context) => {
369
+ if (output.statusCode >= 300) {
370
+ return deserializeAws_json1_1AddApplicationReferenceDataSourceCommandError(output, context);
371
+ }
372
+ const data = await parseBody(output.body, context);
373
+ let contents = {};
374
+ contents = deserializeAws_json1_1AddApplicationReferenceDataSourceResponse(data, context);
375
+ const response = {
376
+ $metadata: deserializeMetadata(output),
377
+ ...contents,
378
+ };
379
+ return Promise.resolve(response);
380
+ };
381
+ const deserializeAws_json1_1AddApplicationReferenceDataSourceCommandError = async (output, context) => {
382
+ const parsedOutput = {
383
+ ...output,
384
+ body: await parseErrorBody(output.body, context),
385
+ };
386
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
387
+ switch (errorCode) {
388
+ case "ConcurrentModificationException":
389
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
390
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
391
+ case "InvalidArgumentException":
392
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
393
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
394
+ case "ResourceInUseException":
395
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
396
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
397
+ case "ResourceNotFoundException":
398
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
399
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
400
+ case "UnsupportedOperationException":
401
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
402
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
403
+ default:
404
+ const parsedBody = parsedOutput.body;
405
+ throwDefaultError({
406
+ output,
407
+ parsedBody,
408
+ exceptionCtor: __BaseException,
409
+ errorCode,
410
+ });
411
+ }
412
+ };
413
+ export const deserializeAws_json1_1CreateApplicationCommand = async (output, context) => {
414
+ if (output.statusCode >= 300) {
415
+ return deserializeAws_json1_1CreateApplicationCommandError(output, context);
416
+ }
417
+ const data = await parseBody(output.body, context);
418
+ let contents = {};
419
+ contents = deserializeAws_json1_1CreateApplicationResponse(data, context);
420
+ const response = {
421
+ $metadata: deserializeMetadata(output),
422
+ ...contents,
423
+ };
424
+ return Promise.resolve(response);
425
+ };
426
+ const deserializeAws_json1_1CreateApplicationCommandError = async (output, context) => {
427
+ const parsedOutput = {
428
+ ...output,
429
+ body: await parseErrorBody(output.body, context),
430
+ };
431
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
432
+ switch (errorCode) {
433
+ case "CodeValidationException":
434
+ case "com.amazonaws.kinesisanalytics#CodeValidationException":
435
+ throw await deserializeAws_json1_1CodeValidationExceptionResponse(parsedOutput, context);
436
+ case "ConcurrentModificationException":
437
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
438
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
439
+ case "InvalidArgumentException":
440
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
441
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
442
+ case "LimitExceededException":
443
+ case "com.amazonaws.kinesisanalytics#LimitExceededException":
444
+ throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
445
+ case "ResourceInUseException":
446
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
447
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
448
+ case "TooManyTagsException":
449
+ case "com.amazonaws.kinesisanalytics#TooManyTagsException":
450
+ throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
451
+ default:
452
+ const parsedBody = parsedOutput.body;
453
+ throwDefaultError({
454
+ output,
455
+ parsedBody,
456
+ exceptionCtor: __BaseException,
457
+ errorCode,
458
+ });
459
+ }
460
+ };
461
+ export const deserializeAws_json1_1DeleteApplicationCommand = async (output, context) => {
462
+ if (output.statusCode >= 300) {
463
+ return deserializeAws_json1_1DeleteApplicationCommandError(output, context);
464
+ }
465
+ const data = await parseBody(output.body, context);
466
+ let contents = {};
467
+ contents = deserializeAws_json1_1DeleteApplicationResponse(data, context);
468
+ const response = {
469
+ $metadata: deserializeMetadata(output),
470
+ ...contents,
471
+ };
472
+ return Promise.resolve(response);
473
+ };
474
+ const deserializeAws_json1_1DeleteApplicationCommandError = async (output, context) => {
475
+ const parsedOutput = {
476
+ ...output,
477
+ body: await parseErrorBody(output.body, context),
478
+ };
479
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
480
+ switch (errorCode) {
481
+ case "ConcurrentModificationException":
482
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
483
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
484
+ case "ResourceInUseException":
485
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
486
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
487
+ case "ResourceNotFoundException":
488
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
489
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
490
+ case "UnsupportedOperationException":
491
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
492
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
493
+ default:
494
+ const parsedBody = parsedOutput.body;
495
+ throwDefaultError({
496
+ output,
497
+ parsedBody,
498
+ exceptionCtor: __BaseException,
499
+ errorCode,
500
+ });
501
+ }
502
+ };
503
+ export const deserializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionCommand = async (output, context) => {
504
+ if (output.statusCode >= 300) {
505
+ return deserializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionCommandError(output, context);
506
+ }
507
+ const data = await parseBody(output.body, context);
508
+ let contents = {};
509
+ contents = deserializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionResponse(data, context);
510
+ const response = {
511
+ $metadata: deserializeMetadata(output),
512
+ ...contents,
513
+ };
514
+ return Promise.resolve(response);
515
+ };
516
+ const deserializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionCommandError = async (output, context) => {
517
+ const parsedOutput = {
518
+ ...output,
519
+ body: await parseErrorBody(output.body, context),
520
+ };
521
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
522
+ switch (errorCode) {
523
+ case "ConcurrentModificationException":
524
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
525
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
526
+ case "InvalidArgumentException":
527
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
528
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
529
+ case "ResourceInUseException":
530
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
531
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
532
+ case "ResourceNotFoundException":
533
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
534
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
535
+ case "UnsupportedOperationException":
536
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
537
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
538
+ default:
539
+ const parsedBody = parsedOutput.body;
540
+ throwDefaultError({
541
+ output,
542
+ parsedBody,
543
+ exceptionCtor: __BaseException,
544
+ errorCode,
545
+ });
546
+ }
547
+ };
548
+ export const deserializeAws_json1_1DeleteApplicationInputProcessingConfigurationCommand = async (output, context) => {
549
+ if (output.statusCode >= 300) {
550
+ return deserializeAws_json1_1DeleteApplicationInputProcessingConfigurationCommandError(output, context);
551
+ }
552
+ const data = await parseBody(output.body, context);
553
+ let contents = {};
554
+ contents = deserializeAws_json1_1DeleteApplicationInputProcessingConfigurationResponse(data, context);
555
+ const response = {
556
+ $metadata: deserializeMetadata(output),
557
+ ...contents,
558
+ };
559
+ return Promise.resolve(response);
560
+ };
561
+ const deserializeAws_json1_1DeleteApplicationInputProcessingConfigurationCommandError = async (output, context) => {
562
+ const parsedOutput = {
563
+ ...output,
564
+ body: await parseErrorBody(output.body, context),
565
+ };
566
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
567
+ switch (errorCode) {
568
+ case "ConcurrentModificationException":
569
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
570
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
571
+ case "InvalidArgumentException":
572
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
573
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
574
+ case "ResourceInUseException":
575
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
576
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
577
+ case "ResourceNotFoundException":
578
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
579
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
580
+ case "UnsupportedOperationException":
581
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
582
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
583
+ default:
584
+ const parsedBody = parsedOutput.body;
585
+ throwDefaultError({
586
+ output,
587
+ parsedBody,
588
+ exceptionCtor: __BaseException,
589
+ errorCode,
590
+ });
591
+ }
592
+ };
593
+ export const deserializeAws_json1_1DeleteApplicationOutputCommand = async (output, context) => {
594
+ if (output.statusCode >= 300) {
595
+ return deserializeAws_json1_1DeleteApplicationOutputCommandError(output, context);
596
+ }
597
+ const data = await parseBody(output.body, context);
598
+ let contents = {};
599
+ contents = deserializeAws_json1_1DeleteApplicationOutputResponse(data, context);
600
+ const response = {
601
+ $metadata: deserializeMetadata(output),
602
+ ...contents,
603
+ };
604
+ return Promise.resolve(response);
605
+ };
606
+ const deserializeAws_json1_1DeleteApplicationOutputCommandError = async (output, context) => {
607
+ const parsedOutput = {
608
+ ...output,
609
+ body: await parseErrorBody(output.body, context),
610
+ };
611
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
612
+ switch (errorCode) {
613
+ case "ConcurrentModificationException":
614
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
615
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
616
+ case "InvalidArgumentException":
617
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
618
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
619
+ case "ResourceInUseException":
620
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
621
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
622
+ case "ResourceNotFoundException":
623
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
624
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
625
+ case "UnsupportedOperationException":
626
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
627
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
628
+ default:
629
+ const parsedBody = parsedOutput.body;
630
+ throwDefaultError({
631
+ output,
632
+ parsedBody,
633
+ exceptionCtor: __BaseException,
634
+ errorCode,
635
+ });
636
+ }
637
+ };
638
+ export const deserializeAws_json1_1DeleteApplicationReferenceDataSourceCommand = async (output, context) => {
639
+ if (output.statusCode >= 300) {
640
+ return deserializeAws_json1_1DeleteApplicationReferenceDataSourceCommandError(output, context);
641
+ }
642
+ const data = await parseBody(output.body, context);
643
+ let contents = {};
644
+ contents = deserializeAws_json1_1DeleteApplicationReferenceDataSourceResponse(data, context);
645
+ const response = {
646
+ $metadata: deserializeMetadata(output),
647
+ ...contents,
648
+ };
649
+ return Promise.resolve(response);
650
+ };
651
+ const deserializeAws_json1_1DeleteApplicationReferenceDataSourceCommandError = async (output, context) => {
652
+ const parsedOutput = {
653
+ ...output,
654
+ body: await parseErrorBody(output.body, context),
655
+ };
656
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
657
+ switch (errorCode) {
658
+ case "ConcurrentModificationException":
659
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
660
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
661
+ case "InvalidArgumentException":
662
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
663
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
664
+ case "ResourceInUseException":
665
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
666
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
667
+ case "ResourceNotFoundException":
668
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
669
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
670
+ case "UnsupportedOperationException":
671
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
672
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
673
+ default:
674
+ const parsedBody = parsedOutput.body;
675
+ throwDefaultError({
676
+ output,
677
+ parsedBody,
678
+ exceptionCtor: __BaseException,
679
+ errorCode,
680
+ });
681
+ }
682
+ };
683
+ export const deserializeAws_json1_1DescribeApplicationCommand = async (output, context) => {
684
+ if (output.statusCode >= 300) {
685
+ return deserializeAws_json1_1DescribeApplicationCommandError(output, context);
686
+ }
687
+ const data = await parseBody(output.body, context);
688
+ let contents = {};
689
+ contents = deserializeAws_json1_1DescribeApplicationResponse(data, context);
690
+ const response = {
691
+ $metadata: deserializeMetadata(output),
692
+ ...contents,
693
+ };
694
+ return Promise.resolve(response);
695
+ };
696
+ const deserializeAws_json1_1DescribeApplicationCommandError = async (output, context) => {
697
+ const parsedOutput = {
698
+ ...output,
699
+ body: await parseErrorBody(output.body, context),
700
+ };
701
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
702
+ switch (errorCode) {
703
+ case "ResourceNotFoundException":
704
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
705
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
706
+ case "UnsupportedOperationException":
707
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
708
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
709
+ default:
710
+ const parsedBody = parsedOutput.body;
711
+ throwDefaultError({
712
+ output,
713
+ parsedBody,
714
+ exceptionCtor: __BaseException,
715
+ errorCode,
716
+ });
717
+ }
718
+ };
719
+ export const deserializeAws_json1_1DiscoverInputSchemaCommand = async (output, context) => {
720
+ if (output.statusCode >= 300) {
721
+ return deserializeAws_json1_1DiscoverInputSchemaCommandError(output, context);
722
+ }
723
+ const data = await parseBody(output.body, context);
724
+ let contents = {};
725
+ contents = deserializeAws_json1_1DiscoverInputSchemaResponse(data, context);
726
+ const response = {
727
+ $metadata: deserializeMetadata(output),
728
+ ...contents,
729
+ };
730
+ return Promise.resolve(response);
731
+ };
732
+ const deserializeAws_json1_1DiscoverInputSchemaCommandError = async (output, context) => {
733
+ const parsedOutput = {
734
+ ...output,
735
+ body: await parseErrorBody(output.body, context),
736
+ };
737
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
738
+ switch (errorCode) {
739
+ case "InvalidArgumentException":
740
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
741
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
742
+ case "ResourceProvisionedThroughputExceededException":
743
+ case "com.amazonaws.kinesisanalytics#ResourceProvisionedThroughputExceededException":
744
+ throw await deserializeAws_json1_1ResourceProvisionedThroughputExceededExceptionResponse(parsedOutput, context);
745
+ case "ServiceUnavailableException":
746
+ case "com.amazonaws.kinesisanalytics#ServiceUnavailableException":
747
+ throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
748
+ case "UnableToDetectSchemaException":
749
+ case "com.amazonaws.kinesisanalytics#UnableToDetectSchemaException":
750
+ throw await deserializeAws_json1_1UnableToDetectSchemaExceptionResponse(parsedOutput, context);
751
+ default:
752
+ const parsedBody = parsedOutput.body;
753
+ throwDefaultError({
754
+ output,
755
+ parsedBody,
756
+ exceptionCtor: __BaseException,
757
+ errorCode,
758
+ });
759
+ }
760
+ };
761
+ export const deserializeAws_json1_1ListApplicationsCommand = async (output, context) => {
762
+ if (output.statusCode >= 300) {
763
+ return deserializeAws_json1_1ListApplicationsCommandError(output, context);
764
+ }
765
+ const data = await parseBody(output.body, context);
766
+ let contents = {};
767
+ contents = deserializeAws_json1_1ListApplicationsResponse(data, context);
768
+ const response = {
769
+ $metadata: deserializeMetadata(output),
770
+ ...contents,
771
+ };
772
+ return Promise.resolve(response);
773
+ };
774
+ const deserializeAws_json1_1ListApplicationsCommandError = async (output, context) => {
775
+ const parsedOutput = {
776
+ ...output,
777
+ body: await parseErrorBody(output.body, context),
778
+ };
779
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
780
+ const parsedBody = parsedOutput.body;
781
+ throwDefaultError({
782
+ output,
783
+ parsedBody,
784
+ exceptionCtor: __BaseException,
785
+ errorCode,
786
+ });
787
+ };
788
+ export const deserializeAws_json1_1ListTagsForResourceCommand = async (output, context) => {
789
+ if (output.statusCode >= 300) {
790
+ return deserializeAws_json1_1ListTagsForResourceCommandError(output, context);
791
+ }
792
+ const data = await parseBody(output.body, context);
793
+ let contents = {};
794
+ contents = deserializeAws_json1_1ListTagsForResourceResponse(data, context);
795
+ const response = {
796
+ $metadata: deserializeMetadata(output),
797
+ ...contents,
798
+ };
799
+ return Promise.resolve(response);
800
+ };
801
+ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, context) => {
802
+ const parsedOutput = {
803
+ ...output,
804
+ body: await parseErrorBody(output.body, context),
805
+ };
806
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
807
+ switch (errorCode) {
808
+ case "ConcurrentModificationException":
809
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
810
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
811
+ case "InvalidArgumentException":
812
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
813
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
814
+ case "ResourceNotFoundException":
815
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
816
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
817
+ default:
818
+ const parsedBody = parsedOutput.body;
819
+ throwDefaultError({
820
+ output,
821
+ parsedBody,
822
+ exceptionCtor: __BaseException,
823
+ errorCode,
824
+ });
825
+ }
826
+ };
827
+ export const deserializeAws_json1_1StartApplicationCommand = async (output, context) => {
828
+ if (output.statusCode >= 300) {
829
+ return deserializeAws_json1_1StartApplicationCommandError(output, context);
830
+ }
831
+ const data = await parseBody(output.body, context);
832
+ let contents = {};
833
+ contents = deserializeAws_json1_1StartApplicationResponse(data, context);
834
+ const response = {
835
+ $metadata: deserializeMetadata(output),
836
+ ...contents,
837
+ };
838
+ return Promise.resolve(response);
839
+ };
840
+ const deserializeAws_json1_1StartApplicationCommandError = async (output, context) => {
841
+ const parsedOutput = {
842
+ ...output,
843
+ body: await parseErrorBody(output.body, context),
844
+ };
845
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
846
+ switch (errorCode) {
847
+ case "InvalidApplicationConfigurationException":
848
+ case "com.amazonaws.kinesisanalytics#InvalidApplicationConfigurationException":
849
+ throw await deserializeAws_json1_1InvalidApplicationConfigurationExceptionResponse(parsedOutput, context);
850
+ case "InvalidArgumentException":
851
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
852
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
853
+ case "ResourceInUseException":
854
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
855
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
856
+ case "ResourceNotFoundException":
857
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
858
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
859
+ case "UnsupportedOperationException":
860
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
861
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
862
+ default:
863
+ const parsedBody = parsedOutput.body;
864
+ throwDefaultError({
865
+ output,
866
+ parsedBody,
867
+ exceptionCtor: __BaseException,
868
+ errorCode,
869
+ });
870
+ }
871
+ };
872
+ export const deserializeAws_json1_1StopApplicationCommand = async (output, context) => {
873
+ if (output.statusCode >= 300) {
874
+ return deserializeAws_json1_1StopApplicationCommandError(output, context);
875
+ }
876
+ const data = await parseBody(output.body, context);
877
+ let contents = {};
878
+ contents = deserializeAws_json1_1StopApplicationResponse(data, context);
879
+ const response = {
880
+ $metadata: deserializeMetadata(output),
881
+ ...contents,
882
+ };
883
+ return Promise.resolve(response);
884
+ };
885
+ const deserializeAws_json1_1StopApplicationCommandError = async (output, context) => {
886
+ const parsedOutput = {
887
+ ...output,
888
+ body: await parseErrorBody(output.body, context),
889
+ };
890
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
891
+ switch (errorCode) {
892
+ case "ResourceInUseException":
893
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
894
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
895
+ case "ResourceNotFoundException":
896
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
897
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
898
+ case "UnsupportedOperationException":
899
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
900
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
901
+ default:
902
+ const parsedBody = parsedOutput.body;
903
+ throwDefaultError({
904
+ output,
905
+ parsedBody,
906
+ exceptionCtor: __BaseException,
907
+ errorCode,
908
+ });
909
+ }
910
+ };
911
+ export const deserializeAws_json1_1TagResourceCommand = async (output, context) => {
912
+ if (output.statusCode >= 300) {
913
+ return deserializeAws_json1_1TagResourceCommandError(output, context);
914
+ }
915
+ const data = await parseBody(output.body, context);
916
+ let contents = {};
917
+ contents = deserializeAws_json1_1TagResourceResponse(data, context);
918
+ const response = {
919
+ $metadata: deserializeMetadata(output),
920
+ ...contents,
921
+ };
922
+ return Promise.resolve(response);
923
+ };
924
+ const deserializeAws_json1_1TagResourceCommandError = async (output, context) => {
925
+ const parsedOutput = {
926
+ ...output,
927
+ body: await parseErrorBody(output.body, context),
928
+ };
929
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
930
+ switch (errorCode) {
931
+ case "ConcurrentModificationException":
932
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
933
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
934
+ case "InvalidArgumentException":
935
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
936
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
937
+ case "ResourceInUseException":
938
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
939
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
940
+ case "ResourceNotFoundException":
941
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
942
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
943
+ case "TooManyTagsException":
944
+ case "com.amazonaws.kinesisanalytics#TooManyTagsException":
945
+ throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
946
+ default:
947
+ const parsedBody = parsedOutput.body;
948
+ throwDefaultError({
949
+ output,
950
+ parsedBody,
951
+ exceptionCtor: __BaseException,
952
+ errorCode,
953
+ });
954
+ }
955
+ };
956
+ export const deserializeAws_json1_1UntagResourceCommand = async (output, context) => {
957
+ if (output.statusCode >= 300) {
958
+ return deserializeAws_json1_1UntagResourceCommandError(output, context);
959
+ }
960
+ const data = await parseBody(output.body, context);
961
+ let contents = {};
962
+ contents = deserializeAws_json1_1UntagResourceResponse(data, context);
963
+ const response = {
964
+ $metadata: deserializeMetadata(output),
965
+ ...contents,
966
+ };
967
+ return Promise.resolve(response);
968
+ };
969
+ const deserializeAws_json1_1UntagResourceCommandError = async (output, context) => {
970
+ const parsedOutput = {
971
+ ...output,
972
+ body: await parseErrorBody(output.body, context),
973
+ };
974
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
975
+ switch (errorCode) {
976
+ case "ConcurrentModificationException":
977
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
978
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
979
+ case "InvalidArgumentException":
980
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
981
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
982
+ case "ResourceInUseException":
983
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
984
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
985
+ case "ResourceNotFoundException":
986
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
987
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
988
+ case "TooManyTagsException":
989
+ case "com.amazonaws.kinesisanalytics#TooManyTagsException":
990
+ throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
991
+ default:
992
+ const parsedBody = parsedOutput.body;
993
+ throwDefaultError({
994
+ output,
995
+ parsedBody,
996
+ exceptionCtor: __BaseException,
997
+ errorCode,
998
+ });
999
+ }
1000
+ };
1001
+ export const deserializeAws_json1_1UpdateApplicationCommand = async (output, context) => {
1002
+ if (output.statusCode >= 300) {
1003
+ return deserializeAws_json1_1UpdateApplicationCommandError(output, context);
1004
+ }
1005
+ const data = await parseBody(output.body, context);
1006
+ let contents = {};
1007
+ contents = deserializeAws_json1_1UpdateApplicationResponse(data, context);
1008
+ const response = {
1009
+ $metadata: deserializeMetadata(output),
1010
+ ...contents,
1011
+ };
1012
+ return Promise.resolve(response);
1013
+ };
1014
+ const deserializeAws_json1_1UpdateApplicationCommandError = async (output, context) => {
1015
+ const parsedOutput = {
1016
+ ...output,
1017
+ body: await parseErrorBody(output.body, context),
1018
+ };
1019
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1020
+ switch (errorCode) {
1021
+ case "CodeValidationException":
1022
+ case "com.amazonaws.kinesisanalytics#CodeValidationException":
1023
+ throw await deserializeAws_json1_1CodeValidationExceptionResponse(parsedOutput, context);
1024
+ case "ConcurrentModificationException":
1025
+ case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
1026
+ throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
1027
+ case "InvalidArgumentException":
1028
+ case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
1029
+ throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
1030
+ case "ResourceInUseException":
1031
+ case "com.amazonaws.kinesisanalytics#ResourceInUseException":
1032
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
1033
+ case "ResourceNotFoundException":
1034
+ case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
1035
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1036
+ case "UnsupportedOperationException":
1037
+ case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
1038
+ throw await deserializeAws_json1_1UnsupportedOperationExceptionResponse(parsedOutput, context);
1039
+ default:
1040
+ const parsedBody = parsedOutput.body;
1041
+ throwDefaultError({
1042
+ output,
1043
+ parsedBody,
1044
+ exceptionCtor: __BaseException,
1045
+ errorCode,
1046
+ });
1047
+ }
1048
+ };
1049
+ const deserializeAws_json1_1CodeValidationExceptionResponse = async (parsedOutput, context) => {
1050
+ const body = parsedOutput.body;
1051
+ const deserialized = deserializeAws_json1_1CodeValidationException(body, context);
1052
+ const exception = new CodeValidationException({
1053
+ $metadata: deserializeMetadata(parsedOutput),
1054
+ ...deserialized,
1055
+ });
1056
+ return __decorateServiceException(exception, body);
1057
+ };
1058
+ const deserializeAws_json1_1ConcurrentModificationExceptionResponse = async (parsedOutput, context) => {
1059
+ const body = parsedOutput.body;
1060
+ const deserialized = deserializeAws_json1_1ConcurrentModificationException(body, context);
1061
+ const exception = new ConcurrentModificationException({
1062
+ $metadata: deserializeMetadata(parsedOutput),
1063
+ ...deserialized,
1064
+ });
1065
+ return __decorateServiceException(exception, body);
1066
+ };
1067
+ const deserializeAws_json1_1InvalidApplicationConfigurationExceptionResponse = async (parsedOutput, context) => {
1068
+ const body = parsedOutput.body;
1069
+ const deserialized = deserializeAws_json1_1InvalidApplicationConfigurationException(body, context);
1070
+ const exception = new InvalidApplicationConfigurationException({
1071
+ $metadata: deserializeMetadata(parsedOutput),
1072
+ ...deserialized,
1073
+ });
1074
+ return __decorateServiceException(exception, body);
1075
+ };
1076
+ const deserializeAws_json1_1InvalidArgumentExceptionResponse = async (parsedOutput, context) => {
1077
+ const body = parsedOutput.body;
1078
+ const deserialized = deserializeAws_json1_1InvalidArgumentException(body, context);
1079
+ const exception = new InvalidArgumentException({
1080
+ $metadata: deserializeMetadata(parsedOutput),
1081
+ ...deserialized,
1082
+ });
1083
+ return __decorateServiceException(exception, body);
1084
+ };
1085
+ const deserializeAws_json1_1LimitExceededExceptionResponse = async (parsedOutput, context) => {
1086
+ const body = parsedOutput.body;
1087
+ const deserialized = deserializeAws_json1_1LimitExceededException(body, context);
1088
+ const exception = new LimitExceededException({
1089
+ $metadata: deserializeMetadata(parsedOutput),
1090
+ ...deserialized,
1091
+ });
1092
+ return __decorateServiceException(exception, body);
1093
+ };
1094
+ const deserializeAws_json1_1ResourceInUseExceptionResponse = async (parsedOutput, context) => {
1095
+ const body = parsedOutput.body;
1096
+ const deserialized = deserializeAws_json1_1ResourceInUseException(body, context);
1097
+ const exception = new ResourceInUseException({
1098
+ $metadata: deserializeMetadata(parsedOutput),
1099
+ ...deserialized,
1100
+ });
1101
+ return __decorateServiceException(exception, body);
1102
+ };
1103
+ const deserializeAws_json1_1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
1104
+ const body = parsedOutput.body;
1105
+ const deserialized = deserializeAws_json1_1ResourceNotFoundException(body, context);
1106
+ const exception = new ResourceNotFoundException({
1107
+ $metadata: deserializeMetadata(parsedOutput),
1108
+ ...deserialized,
1109
+ });
1110
+ return __decorateServiceException(exception, body);
1111
+ };
1112
+ const deserializeAws_json1_1ResourceProvisionedThroughputExceededExceptionResponse = async (parsedOutput, context) => {
1113
+ const body = parsedOutput.body;
1114
+ const deserialized = deserializeAws_json1_1ResourceProvisionedThroughputExceededException(body, context);
1115
+ const exception = new ResourceProvisionedThroughputExceededException({
1116
+ $metadata: deserializeMetadata(parsedOutput),
1117
+ ...deserialized,
1118
+ });
1119
+ return __decorateServiceException(exception, body);
1120
+ };
1121
+ const deserializeAws_json1_1ServiceUnavailableExceptionResponse = async (parsedOutput, context) => {
1122
+ const body = parsedOutput.body;
1123
+ const deserialized = deserializeAws_json1_1ServiceUnavailableException(body, context);
1124
+ const exception = new ServiceUnavailableException({
1125
+ $metadata: deserializeMetadata(parsedOutput),
1126
+ ...deserialized,
1127
+ });
1128
+ return __decorateServiceException(exception, body);
1129
+ };
1130
+ const deserializeAws_json1_1TooManyTagsExceptionResponse = async (parsedOutput, context) => {
1131
+ const body = parsedOutput.body;
1132
+ const deserialized = deserializeAws_json1_1TooManyTagsException(body, context);
1133
+ const exception = new TooManyTagsException({
1134
+ $metadata: deserializeMetadata(parsedOutput),
1135
+ ...deserialized,
1136
+ });
1137
+ return __decorateServiceException(exception, body);
1138
+ };
1139
+ const deserializeAws_json1_1UnableToDetectSchemaExceptionResponse = async (parsedOutput, context) => {
1140
+ const body = parsedOutput.body;
1141
+ const deserialized = deserializeAws_json1_1UnableToDetectSchemaException(body, context);
1142
+ const exception = new UnableToDetectSchemaException({
1143
+ $metadata: deserializeMetadata(parsedOutput),
1144
+ ...deserialized,
1145
+ });
1146
+ return __decorateServiceException(exception, body);
1147
+ };
1148
+ const deserializeAws_json1_1UnsupportedOperationExceptionResponse = async (parsedOutput, context) => {
1149
+ const body = parsedOutput.body;
1150
+ const deserialized = deserializeAws_json1_1UnsupportedOperationException(body, context);
1151
+ const exception = new UnsupportedOperationException({
1152
+ $metadata: deserializeMetadata(parsedOutput),
1153
+ ...deserialized,
1154
+ });
1155
+ return __decorateServiceException(exception, body);
1156
+ };
1157
+ const serializeAws_json1_1AddApplicationCloudWatchLoggingOptionRequest = (input, context) => {
1158
+ return {
1159
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1160
+ ...(input.CloudWatchLoggingOption != null && {
1161
+ CloudWatchLoggingOption: serializeAws_json1_1CloudWatchLoggingOption(input.CloudWatchLoggingOption, context),
1162
+ }),
1163
+ ...(input.CurrentApplicationVersionId != null && {
1164
+ CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1165
+ }),
1166
+ };
1167
+ };
1168
+ const serializeAws_json1_1AddApplicationInputProcessingConfigurationRequest = (input, context) => {
1169
+ return {
1170
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1171
+ ...(input.CurrentApplicationVersionId != null && {
1172
+ CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1173
+ }),
1174
+ ...(input.InputId != null && { InputId: input.InputId }),
1175
+ ...(input.InputProcessingConfiguration != null && {
1176
+ InputProcessingConfiguration: serializeAws_json1_1InputProcessingConfiguration(input.InputProcessingConfiguration, context),
1177
+ }),
1178
+ };
1179
+ };
1180
+ const serializeAws_json1_1AddApplicationInputRequest = (input, context) => {
1181
+ return {
1182
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1183
+ ...(input.CurrentApplicationVersionId != null && {
1184
+ CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1185
+ }),
1186
+ ...(input.Input != null && { Input: serializeAws_json1_1Input(input.Input, context) }),
1187
+ };
1188
+ };
1189
+ const serializeAws_json1_1AddApplicationOutputRequest = (input, context) => {
1190
+ return {
1191
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1192
+ ...(input.CurrentApplicationVersionId != null && {
1193
+ CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1194
+ }),
1195
+ ...(input.Output != null && { Output: serializeAws_json1_1Output(input.Output, context) }),
1196
+ };
1197
+ };
1198
+ const serializeAws_json1_1AddApplicationReferenceDataSourceRequest = (input, context) => {
1199
+ return {
1200
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1201
+ ...(input.CurrentApplicationVersionId != null && {
1202
+ CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1203
+ }),
1204
+ ...(input.ReferenceDataSource != null && {
1205
+ ReferenceDataSource: serializeAws_json1_1ReferenceDataSource(input.ReferenceDataSource, context),
1206
+ }),
1207
+ };
1208
+ };
1209
+ const serializeAws_json1_1ApplicationUpdate = (input, context) => {
1210
+ return {
1211
+ ...(input.ApplicationCodeUpdate != null && { ApplicationCodeUpdate: input.ApplicationCodeUpdate }),
1212
+ ...(input.CloudWatchLoggingOptionUpdates != null && {
1213
+ CloudWatchLoggingOptionUpdates: serializeAws_json1_1CloudWatchLoggingOptionUpdates(input.CloudWatchLoggingOptionUpdates, context),
1214
+ }),
1215
+ ...(input.InputUpdates != null && { InputUpdates: serializeAws_json1_1InputUpdates(input.InputUpdates, context) }),
1216
+ ...(input.OutputUpdates != null && {
1217
+ OutputUpdates: serializeAws_json1_1OutputUpdates(input.OutputUpdates, context),
1218
+ }),
1219
+ ...(input.ReferenceDataSourceUpdates != null && {
1220
+ ReferenceDataSourceUpdates: serializeAws_json1_1ReferenceDataSourceUpdates(input.ReferenceDataSourceUpdates, context),
1221
+ }),
1222
+ };
1223
+ };
1224
+ const serializeAws_json1_1CloudWatchLoggingOption = (input, context) => {
1225
+ return {
1226
+ ...(input.LogStreamARN != null && { LogStreamARN: input.LogStreamARN }),
1227
+ ...(input.RoleARN != null && { RoleARN: input.RoleARN }),
1228
+ };
1229
+ };
1230
+ const serializeAws_json1_1CloudWatchLoggingOptions = (input, context) => {
1668
1231
  return input
1669
- .filter(function (e) { return e != null; })
1670
- .map(function (entry) {
1232
+ .filter((e) => e != null)
1233
+ .map((entry) => {
1671
1234
  return serializeAws_json1_1CloudWatchLoggingOption(entry, context);
1672
1235
  });
1673
1236
  };
1674
- var serializeAws_json1_1CloudWatchLoggingOptionUpdate = function (input, context) {
1675
- return __assign(__assign(__assign({}, (input.CloudWatchLoggingOptionId != null && { CloudWatchLoggingOptionId: input.CloudWatchLoggingOptionId })), (input.LogStreamARNUpdate != null && { LogStreamARNUpdate: input.LogStreamARNUpdate })), (input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }));
1237
+ const serializeAws_json1_1CloudWatchLoggingOptionUpdate = (input, context) => {
1238
+ return {
1239
+ ...(input.CloudWatchLoggingOptionId != null && { CloudWatchLoggingOptionId: input.CloudWatchLoggingOptionId }),
1240
+ ...(input.LogStreamARNUpdate != null && { LogStreamARNUpdate: input.LogStreamARNUpdate }),
1241
+ ...(input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }),
1242
+ };
1676
1243
  };
1677
- var serializeAws_json1_1CloudWatchLoggingOptionUpdates = function (input, context) {
1244
+ const serializeAws_json1_1CloudWatchLoggingOptionUpdates = (input, context) => {
1678
1245
  return input
1679
- .filter(function (e) { return e != null; })
1680
- .map(function (entry) {
1246
+ .filter((e) => e != null)
1247
+ .map((entry) => {
1681
1248
  return serializeAws_json1_1CloudWatchLoggingOptionUpdate(entry, context);
1682
1249
  });
1683
1250
  };
1684
- var serializeAws_json1_1CreateApplicationRequest = function (input, context) {
1685
- return __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (input.ApplicationCode != null && { ApplicationCode: input.ApplicationCode })), (input.ApplicationDescription != null && { ApplicationDescription: input.ApplicationDescription })), (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CloudWatchLoggingOptions != null && {
1686
- CloudWatchLoggingOptions: serializeAws_json1_1CloudWatchLoggingOptions(input.CloudWatchLoggingOptions, context),
1687
- })), (input.Inputs != null && { Inputs: serializeAws_json1_1Inputs(input.Inputs, context) })), (input.Outputs != null && { Outputs: serializeAws_json1_1Outputs(input.Outputs, context) })), (input.Tags != null && { Tags: serializeAws_json1_1Tags(input.Tags, context) }));
1688
- };
1689
- var serializeAws_json1_1CSVMappingParameters = function (input, context) {
1690
- return __assign(__assign({}, (input.RecordColumnDelimiter != null && { RecordColumnDelimiter: input.RecordColumnDelimiter })), (input.RecordRowDelimiter != null && { RecordRowDelimiter: input.RecordRowDelimiter }));
1691
- };
1692
- var serializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionRequest = function (input, context) {
1693
- return __assign(__assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CloudWatchLoggingOptionId != null && { CloudWatchLoggingOptionId: input.CloudWatchLoggingOptionId })), (input.CurrentApplicationVersionId != null && {
1694
- CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1695
- }));
1696
- };
1697
- var serializeAws_json1_1DeleteApplicationInputProcessingConfigurationRequest = function (input, context) {
1698
- return __assign(__assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CurrentApplicationVersionId != null && {
1699
- CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1700
- })), (input.InputId != null && { InputId: input.InputId }));
1701
- };
1702
- var serializeAws_json1_1DeleteApplicationOutputRequest = function (input, context) {
1703
- return __assign(__assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CurrentApplicationVersionId != null && {
1704
- CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1705
- })), (input.OutputId != null && { OutputId: input.OutputId }));
1706
- };
1707
- var serializeAws_json1_1DeleteApplicationReferenceDataSourceRequest = function (input, context) {
1708
- return __assign(__assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CurrentApplicationVersionId != null && {
1709
- CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1710
- })), (input.ReferenceId != null && { ReferenceId: input.ReferenceId }));
1711
- };
1712
- var serializeAws_json1_1DeleteApplicationRequest = function (input, context) {
1713
- return __assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.CreateTimestamp != null && { CreateTimestamp: Math.round(input.CreateTimestamp.getTime() / 1000) }));
1714
- };
1715
- var serializeAws_json1_1DescribeApplicationRequest = function (input, context) {
1716
- return __assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName }));
1717
- };
1718
- var serializeAws_json1_1DestinationSchema = function (input, context) {
1719
- return __assign({}, (input.RecordFormatType != null && { RecordFormatType: input.RecordFormatType }));
1720
- };
1721
- var serializeAws_json1_1DiscoverInputSchemaRequest = function (input, context) {
1722
- return __assign(__assign(__assign(__assign(__assign({}, (input.InputProcessingConfiguration != null && {
1723
- InputProcessingConfiguration: serializeAws_json1_1InputProcessingConfiguration(input.InputProcessingConfiguration, context),
1724
- })), (input.InputStartingPositionConfiguration != null && {
1725
- InputStartingPositionConfiguration: serializeAws_json1_1InputStartingPositionConfiguration(input.InputStartingPositionConfiguration, context),
1726
- })), (input.ResourceARN != null && { ResourceARN: input.ResourceARN })), (input.RoleARN != null && { RoleARN: input.RoleARN })), (input.S3Configuration != null && {
1727
- S3Configuration: serializeAws_json1_1S3Configuration(input.S3Configuration, context),
1728
- }));
1729
- };
1730
- var serializeAws_json1_1Input = function (input, context) {
1731
- return __assign(__assign(__assign(__assign(__assign(__assign({}, (input.InputParallelism != null && {
1732
- InputParallelism: serializeAws_json1_1InputParallelism(input.InputParallelism, context),
1733
- })), (input.InputProcessingConfiguration != null && {
1734
- InputProcessingConfiguration: serializeAws_json1_1InputProcessingConfiguration(input.InputProcessingConfiguration, context),
1735
- })), (input.InputSchema != null && { InputSchema: serializeAws_json1_1SourceSchema(input.InputSchema, context) })), (input.KinesisFirehoseInput != null && {
1736
- KinesisFirehoseInput: serializeAws_json1_1KinesisFirehoseInput(input.KinesisFirehoseInput, context),
1737
- })), (input.KinesisStreamsInput != null && {
1738
- KinesisStreamsInput: serializeAws_json1_1KinesisStreamsInput(input.KinesisStreamsInput, context),
1739
- })), (input.NamePrefix != null && { NamePrefix: input.NamePrefix }));
1740
- };
1741
- var serializeAws_json1_1InputConfiguration = function (input, context) {
1742
- return __assign(__assign({}, (input.Id != null && { Id: input.Id })), (input.InputStartingPositionConfiguration != null && {
1743
- InputStartingPositionConfiguration: serializeAws_json1_1InputStartingPositionConfiguration(input.InputStartingPositionConfiguration, context),
1744
- }));
1745
- };
1746
- var serializeAws_json1_1InputConfigurations = function (input, context) {
1251
+ const serializeAws_json1_1CreateApplicationRequest = (input, context) => {
1252
+ return {
1253
+ ...(input.ApplicationCode != null && { ApplicationCode: input.ApplicationCode }),
1254
+ ...(input.ApplicationDescription != null && { ApplicationDescription: input.ApplicationDescription }),
1255
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1256
+ ...(input.CloudWatchLoggingOptions != null && {
1257
+ CloudWatchLoggingOptions: serializeAws_json1_1CloudWatchLoggingOptions(input.CloudWatchLoggingOptions, context),
1258
+ }),
1259
+ ...(input.Inputs != null && { Inputs: serializeAws_json1_1Inputs(input.Inputs, context) }),
1260
+ ...(input.Outputs != null && { Outputs: serializeAws_json1_1Outputs(input.Outputs, context) }),
1261
+ ...(input.Tags != null && { Tags: serializeAws_json1_1Tags(input.Tags, context) }),
1262
+ };
1263
+ };
1264
+ const serializeAws_json1_1CSVMappingParameters = (input, context) => {
1265
+ return {
1266
+ ...(input.RecordColumnDelimiter != null && { RecordColumnDelimiter: input.RecordColumnDelimiter }),
1267
+ ...(input.RecordRowDelimiter != null && { RecordRowDelimiter: input.RecordRowDelimiter }),
1268
+ };
1269
+ };
1270
+ const serializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionRequest = (input, context) => {
1271
+ return {
1272
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1273
+ ...(input.CloudWatchLoggingOptionId != null && { CloudWatchLoggingOptionId: input.CloudWatchLoggingOptionId }),
1274
+ ...(input.CurrentApplicationVersionId != null && {
1275
+ CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1276
+ }),
1277
+ };
1278
+ };
1279
+ const serializeAws_json1_1DeleteApplicationInputProcessingConfigurationRequest = (input, context) => {
1280
+ return {
1281
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1282
+ ...(input.CurrentApplicationVersionId != null && {
1283
+ CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1284
+ }),
1285
+ ...(input.InputId != null && { InputId: input.InputId }),
1286
+ };
1287
+ };
1288
+ const serializeAws_json1_1DeleteApplicationOutputRequest = (input, context) => {
1289
+ return {
1290
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1291
+ ...(input.CurrentApplicationVersionId != null && {
1292
+ CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1293
+ }),
1294
+ ...(input.OutputId != null && { OutputId: input.OutputId }),
1295
+ };
1296
+ };
1297
+ const serializeAws_json1_1DeleteApplicationReferenceDataSourceRequest = (input, context) => {
1298
+ return {
1299
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1300
+ ...(input.CurrentApplicationVersionId != null && {
1301
+ CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1302
+ }),
1303
+ ...(input.ReferenceId != null && { ReferenceId: input.ReferenceId }),
1304
+ };
1305
+ };
1306
+ const serializeAws_json1_1DeleteApplicationRequest = (input, context) => {
1307
+ return {
1308
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1309
+ ...(input.CreateTimestamp != null && { CreateTimestamp: Math.round(input.CreateTimestamp.getTime() / 1000) }),
1310
+ };
1311
+ };
1312
+ const serializeAws_json1_1DescribeApplicationRequest = (input, context) => {
1313
+ return {
1314
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1315
+ };
1316
+ };
1317
+ const serializeAws_json1_1DestinationSchema = (input, context) => {
1318
+ return {
1319
+ ...(input.RecordFormatType != null && { RecordFormatType: input.RecordFormatType }),
1320
+ };
1321
+ };
1322
+ const serializeAws_json1_1DiscoverInputSchemaRequest = (input, context) => {
1323
+ return {
1324
+ ...(input.InputProcessingConfiguration != null && {
1325
+ InputProcessingConfiguration: serializeAws_json1_1InputProcessingConfiguration(input.InputProcessingConfiguration, context),
1326
+ }),
1327
+ ...(input.InputStartingPositionConfiguration != null && {
1328
+ InputStartingPositionConfiguration: serializeAws_json1_1InputStartingPositionConfiguration(input.InputStartingPositionConfiguration, context),
1329
+ }),
1330
+ ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
1331
+ ...(input.RoleARN != null && { RoleARN: input.RoleARN }),
1332
+ ...(input.S3Configuration != null && {
1333
+ S3Configuration: serializeAws_json1_1S3Configuration(input.S3Configuration, context),
1334
+ }),
1335
+ };
1336
+ };
1337
+ const serializeAws_json1_1Input = (input, context) => {
1338
+ return {
1339
+ ...(input.InputParallelism != null && {
1340
+ InputParallelism: serializeAws_json1_1InputParallelism(input.InputParallelism, context),
1341
+ }),
1342
+ ...(input.InputProcessingConfiguration != null && {
1343
+ InputProcessingConfiguration: serializeAws_json1_1InputProcessingConfiguration(input.InputProcessingConfiguration, context),
1344
+ }),
1345
+ ...(input.InputSchema != null && { InputSchema: serializeAws_json1_1SourceSchema(input.InputSchema, context) }),
1346
+ ...(input.KinesisFirehoseInput != null && {
1347
+ KinesisFirehoseInput: serializeAws_json1_1KinesisFirehoseInput(input.KinesisFirehoseInput, context),
1348
+ }),
1349
+ ...(input.KinesisStreamsInput != null && {
1350
+ KinesisStreamsInput: serializeAws_json1_1KinesisStreamsInput(input.KinesisStreamsInput, context),
1351
+ }),
1352
+ ...(input.NamePrefix != null && { NamePrefix: input.NamePrefix }),
1353
+ };
1354
+ };
1355
+ const serializeAws_json1_1InputConfiguration = (input, context) => {
1356
+ return {
1357
+ ...(input.Id != null && { Id: input.Id }),
1358
+ ...(input.InputStartingPositionConfiguration != null && {
1359
+ InputStartingPositionConfiguration: serializeAws_json1_1InputStartingPositionConfiguration(input.InputStartingPositionConfiguration, context),
1360
+ }),
1361
+ };
1362
+ };
1363
+ const serializeAws_json1_1InputConfigurations = (input, context) => {
1747
1364
  return input
1748
- .filter(function (e) { return e != null; })
1749
- .map(function (entry) {
1365
+ .filter((e) => e != null)
1366
+ .map((entry) => {
1750
1367
  return serializeAws_json1_1InputConfiguration(entry, context);
1751
1368
  });
1752
1369
  };
1753
- var serializeAws_json1_1InputLambdaProcessor = function (input, context) {
1754
- return __assign(__assign({}, (input.ResourceARN != null && { ResourceARN: input.ResourceARN })), (input.RoleARN != null && { RoleARN: input.RoleARN }));
1370
+ const serializeAws_json1_1InputLambdaProcessor = (input, context) => {
1371
+ return {
1372
+ ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
1373
+ ...(input.RoleARN != null && { RoleARN: input.RoleARN }),
1374
+ };
1755
1375
  };
1756
- var serializeAws_json1_1InputLambdaProcessorUpdate = function (input, context) {
1757
- return __assign(__assign({}, (input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate })), (input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }));
1376
+ const serializeAws_json1_1InputLambdaProcessorUpdate = (input, context) => {
1377
+ return {
1378
+ ...(input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate }),
1379
+ ...(input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }),
1380
+ };
1758
1381
  };
1759
- var serializeAws_json1_1InputParallelism = function (input, context) {
1760
- return __assign({}, (input.Count != null && { Count: input.Count }));
1382
+ const serializeAws_json1_1InputParallelism = (input, context) => {
1383
+ return {
1384
+ ...(input.Count != null && { Count: input.Count }),
1385
+ };
1761
1386
  };
1762
- var serializeAws_json1_1InputParallelismUpdate = function (input, context) {
1763
- return __assign({}, (input.CountUpdate != null && { CountUpdate: input.CountUpdate }));
1387
+ const serializeAws_json1_1InputParallelismUpdate = (input, context) => {
1388
+ return {
1389
+ ...(input.CountUpdate != null && { CountUpdate: input.CountUpdate }),
1390
+ };
1764
1391
  };
1765
- var serializeAws_json1_1InputProcessingConfiguration = function (input, context) {
1766
- return __assign({}, (input.InputLambdaProcessor != null && {
1767
- InputLambdaProcessor: serializeAws_json1_1InputLambdaProcessor(input.InputLambdaProcessor, context),
1768
- }));
1392
+ const serializeAws_json1_1InputProcessingConfiguration = (input, context) => {
1393
+ return {
1394
+ ...(input.InputLambdaProcessor != null && {
1395
+ InputLambdaProcessor: serializeAws_json1_1InputLambdaProcessor(input.InputLambdaProcessor, context),
1396
+ }),
1397
+ };
1769
1398
  };
1770
- var serializeAws_json1_1InputProcessingConfigurationUpdate = function (input, context) {
1771
- return __assign({}, (input.InputLambdaProcessorUpdate != null && {
1772
- InputLambdaProcessorUpdate: serializeAws_json1_1InputLambdaProcessorUpdate(input.InputLambdaProcessorUpdate, context),
1773
- }));
1399
+ const serializeAws_json1_1InputProcessingConfigurationUpdate = (input, context) => {
1400
+ return {
1401
+ ...(input.InputLambdaProcessorUpdate != null && {
1402
+ InputLambdaProcessorUpdate: serializeAws_json1_1InputLambdaProcessorUpdate(input.InputLambdaProcessorUpdate, context),
1403
+ }),
1404
+ };
1774
1405
  };
1775
- var serializeAws_json1_1Inputs = function (input, context) {
1406
+ const serializeAws_json1_1Inputs = (input, context) => {
1776
1407
  return input
1777
- .filter(function (e) { return e != null; })
1778
- .map(function (entry) {
1408
+ .filter((e) => e != null)
1409
+ .map((entry) => {
1779
1410
  return serializeAws_json1_1Input(entry, context);
1780
1411
  });
1781
1412
  };
1782
- var serializeAws_json1_1InputSchemaUpdate = function (input, context) {
1783
- return __assign(__assign(__assign({}, (input.RecordColumnUpdates != null && {
1784
- RecordColumnUpdates: serializeAws_json1_1RecordColumns(input.RecordColumnUpdates, context),
1785
- })), (input.RecordEncodingUpdate != null && { RecordEncodingUpdate: input.RecordEncodingUpdate })), (input.RecordFormatUpdate != null && {
1786
- RecordFormatUpdate: serializeAws_json1_1RecordFormat(input.RecordFormatUpdate, context),
1787
- }));
1788
- };
1789
- var serializeAws_json1_1InputStartingPositionConfiguration = function (input, context) {
1790
- return __assign({}, (input.InputStartingPosition != null && { InputStartingPosition: input.InputStartingPosition }));
1791
- };
1792
- var serializeAws_json1_1InputUpdate = function (input, context) {
1793
- return __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (input.InputId != null && { InputId: input.InputId })), (input.InputParallelismUpdate != null && {
1794
- InputParallelismUpdate: serializeAws_json1_1InputParallelismUpdate(input.InputParallelismUpdate, context),
1795
- })), (input.InputProcessingConfigurationUpdate != null && {
1796
- InputProcessingConfigurationUpdate: serializeAws_json1_1InputProcessingConfigurationUpdate(input.InputProcessingConfigurationUpdate, context),
1797
- })), (input.InputSchemaUpdate != null && {
1798
- InputSchemaUpdate: serializeAws_json1_1InputSchemaUpdate(input.InputSchemaUpdate, context),
1799
- })), (input.KinesisFirehoseInputUpdate != null && {
1800
- KinesisFirehoseInputUpdate: serializeAws_json1_1KinesisFirehoseInputUpdate(input.KinesisFirehoseInputUpdate, context),
1801
- })), (input.KinesisStreamsInputUpdate != null && {
1802
- KinesisStreamsInputUpdate: serializeAws_json1_1KinesisStreamsInputUpdate(input.KinesisStreamsInputUpdate, context),
1803
- })), (input.NamePrefixUpdate != null && { NamePrefixUpdate: input.NamePrefixUpdate }));
1804
- };
1805
- var serializeAws_json1_1InputUpdates = function (input, context) {
1413
+ const serializeAws_json1_1InputSchemaUpdate = (input, context) => {
1414
+ return {
1415
+ ...(input.RecordColumnUpdates != null && {
1416
+ RecordColumnUpdates: serializeAws_json1_1RecordColumns(input.RecordColumnUpdates, context),
1417
+ }),
1418
+ ...(input.RecordEncodingUpdate != null && { RecordEncodingUpdate: input.RecordEncodingUpdate }),
1419
+ ...(input.RecordFormatUpdate != null && {
1420
+ RecordFormatUpdate: serializeAws_json1_1RecordFormat(input.RecordFormatUpdate, context),
1421
+ }),
1422
+ };
1423
+ };
1424
+ const serializeAws_json1_1InputStartingPositionConfiguration = (input, context) => {
1425
+ return {
1426
+ ...(input.InputStartingPosition != null && { InputStartingPosition: input.InputStartingPosition }),
1427
+ };
1428
+ };
1429
+ const serializeAws_json1_1InputUpdate = (input, context) => {
1430
+ return {
1431
+ ...(input.InputId != null && { InputId: input.InputId }),
1432
+ ...(input.InputParallelismUpdate != null && {
1433
+ InputParallelismUpdate: serializeAws_json1_1InputParallelismUpdate(input.InputParallelismUpdate, context),
1434
+ }),
1435
+ ...(input.InputProcessingConfigurationUpdate != null && {
1436
+ InputProcessingConfigurationUpdate: serializeAws_json1_1InputProcessingConfigurationUpdate(input.InputProcessingConfigurationUpdate, context),
1437
+ }),
1438
+ ...(input.InputSchemaUpdate != null && {
1439
+ InputSchemaUpdate: serializeAws_json1_1InputSchemaUpdate(input.InputSchemaUpdate, context),
1440
+ }),
1441
+ ...(input.KinesisFirehoseInputUpdate != null && {
1442
+ KinesisFirehoseInputUpdate: serializeAws_json1_1KinesisFirehoseInputUpdate(input.KinesisFirehoseInputUpdate, context),
1443
+ }),
1444
+ ...(input.KinesisStreamsInputUpdate != null && {
1445
+ KinesisStreamsInputUpdate: serializeAws_json1_1KinesisStreamsInputUpdate(input.KinesisStreamsInputUpdate, context),
1446
+ }),
1447
+ ...(input.NamePrefixUpdate != null && { NamePrefixUpdate: input.NamePrefixUpdate }),
1448
+ };
1449
+ };
1450
+ const serializeAws_json1_1InputUpdates = (input, context) => {
1806
1451
  return input
1807
- .filter(function (e) { return e != null; })
1808
- .map(function (entry) {
1452
+ .filter((e) => e != null)
1453
+ .map((entry) => {
1809
1454
  return serializeAws_json1_1InputUpdate(entry, context);
1810
1455
  });
1811
1456
  };
1812
- var serializeAws_json1_1JSONMappingParameters = function (input, context) {
1813
- return __assign({}, (input.RecordRowPath != null && { RecordRowPath: input.RecordRowPath }));
1457
+ const serializeAws_json1_1JSONMappingParameters = (input, context) => {
1458
+ return {
1459
+ ...(input.RecordRowPath != null && { RecordRowPath: input.RecordRowPath }),
1460
+ };
1814
1461
  };
1815
- var serializeAws_json1_1KinesisFirehoseInput = function (input, context) {
1816
- return __assign(__assign({}, (input.ResourceARN != null && { ResourceARN: input.ResourceARN })), (input.RoleARN != null && { RoleARN: input.RoleARN }));
1462
+ const serializeAws_json1_1KinesisFirehoseInput = (input, context) => {
1463
+ return {
1464
+ ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
1465
+ ...(input.RoleARN != null && { RoleARN: input.RoleARN }),
1466
+ };
1817
1467
  };
1818
- var serializeAws_json1_1KinesisFirehoseInputUpdate = function (input, context) {
1819
- return __assign(__assign({}, (input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate })), (input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }));
1468
+ const serializeAws_json1_1KinesisFirehoseInputUpdate = (input, context) => {
1469
+ return {
1470
+ ...(input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate }),
1471
+ ...(input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }),
1472
+ };
1820
1473
  };
1821
- var serializeAws_json1_1KinesisFirehoseOutput = function (input, context) {
1822
- return __assign(__assign({}, (input.ResourceARN != null && { ResourceARN: input.ResourceARN })), (input.RoleARN != null && { RoleARN: input.RoleARN }));
1474
+ const serializeAws_json1_1KinesisFirehoseOutput = (input, context) => {
1475
+ return {
1476
+ ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
1477
+ ...(input.RoleARN != null && { RoleARN: input.RoleARN }),
1478
+ };
1823
1479
  };
1824
- var serializeAws_json1_1KinesisFirehoseOutputUpdate = function (input, context) {
1825
- return __assign(__assign({}, (input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate })), (input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }));
1480
+ const serializeAws_json1_1KinesisFirehoseOutputUpdate = (input, context) => {
1481
+ return {
1482
+ ...(input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate }),
1483
+ ...(input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }),
1484
+ };
1826
1485
  };
1827
- var serializeAws_json1_1KinesisStreamsInput = function (input, context) {
1828
- return __assign(__assign({}, (input.ResourceARN != null && { ResourceARN: input.ResourceARN })), (input.RoleARN != null && { RoleARN: input.RoleARN }));
1486
+ const serializeAws_json1_1KinesisStreamsInput = (input, context) => {
1487
+ return {
1488
+ ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
1489
+ ...(input.RoleARN != null && { RoleARN: input.RoleARN }),
1490
+ };
1829
1491
  };
1830
- var serializeAws_json1_1KinesisStreamsInputUpdate = function (input, context) {
1831
- return __assign(__assign({}, (input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate })), (input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }));
1492
+ const serializeAws_json1_1KinesisStreamsInputUpdate = (input, context) => {
1493
+ return {
1494
+ ...(input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate }),
1495
+ ...(input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }),
1496
+ };
1832
1497
  };
1833
- var serializeAws_json1_1KinesisStreamsOutput = function (input, context) {
1834
- return __assign(__assign({}, (input.ResourceARN != null && { ResourceARN: input.ResourceARN })), (input.RoleARN != null && { RoleARN: input.RoleARN }));
1498
+ const serializeAws_json1_1KinesisStreamsOutput = (input, context) => {
1499
+ return {
1500
+ ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
1501
+ ...(input.RoleARN != null && { RoleARN: input.RoleARN }),
1502
+ };
1835
1503
  };
1836
- var serializeAws_json1_1KinesisStreamsOutputUpdate = function (input, context) {
1837
- return __assign(__assign({}, (input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate })), (input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }));
1504
+ const serializeAws_json1_1KinesisStreamsOutputUpdate = (input, context) => {
1505
+ return {
1506
+ ...(input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate }),
1507
+ ...(input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }),
1508
+ };
1838
1509
  };
1839
- var serializeAws_json1_1LambdaOutput = function (input, context) {
1840
- return __assign(__assign({}, (input.ResourceARN != null && { ResourceARN: input.ResourceARN })), (input.RoleARN != null && { RoleARN: input.RoleARN }));
1510
+ const serializeAws_json1_1LambdaOutput = (input, context) => {
1511
+ return {
1512
+ ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
1513
+ ...(input.RoleARN != null && { RoleARN: input.RoleARN }),
1514
+ };
1841
1515
  };
1842
- var serializeAws_json1_1LambdaOutputUpdate = function (input, context) {
1843
- return __assign(__assign({}, (input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate })), (input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }));
1516
+ const serializeAws_json1_1LambdaOutputUpdate = (input, context) => {
1517
+ return {
1518
+ ...(input.ResourceARNUpdate != null && { ResourceARNUpdate: input.ResourceARNUpdate }),
1519
+ ...(input.RoleARNUpdate != null && { RoleARNUpdate: input.RoleARNUpdate }),
1520
+ };
1844
1521
  };
1845
- var serializeAws_json1_1ListApplicationsRequest = function (input, context) {
1846
- return __assign(__assign({}, (input.ExclusiveStartApplicationName != null && {
1847
- ExclusiveStartApplicationName: input.ExclusiveStartApplicationName,
1848
- })), (input.Limit != null && { Limit: input.Limit }));
1522
+ const serializeAws_json1_1ListApplicationsRequest = (input, context) => {
1523
+ return {
1524
+ ...(input.ExclusiveStartApplicationName != null && {
1525
+ ExclusiveStartApplicationName: input.ExclusiveStartApplicationName,
1526
+ }),
1527
+ ...(input.Limit != null && { Limit: input.Limit }),
1528
+ };
1849
1529
  };
1850
- var serializeAws_json1_1ListTagsForResourceRequest = function (input, context) {
1851
- return __assign({}, (input.ResourceARN != null && { ResourceARN: input.ResourceARN }));
1530
+ const serializeAws_json1_1ListTagsForResourceRequest = (input, context) => {
1531
+ return {
1532
+ ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
1533
+ };
1852
1534
  };
1853
- var serializeAws_json1_1MappingParameters = function (input, context) {
1854
- return __assign(__assign({}, (input.CSVMappingParameters != null && {
1855
- CSVMappingParameters: serializeAws_json1_1CSVMappingParameters(input.CSVMappingParameters, context),
1856
- })), (input.JSONMappingParameters != null && {
1857
- JSONMappingParameters: serializeAws_json1_1JSONMappingParameters(input.JSONMappingParameters, context),
1858
- }));
1535
+ const serializeAws_json1_1MappingParameters = (input, context) => {
1536
+ return {
1537
+ ...(input.CSVMappingParameters != null && {
1538
+ CSVMappingParameters: serializeAws_json1_1CSVMappingParameters(input.CSVMappingParameters, context),
1539
+ }),
1540
+ ...(input.JSONMappingParameters != null && {
1541
+ JSONMappingParameters: serializeAws_json1_1JSONMappingParameters(input.JSONMappingParameters, context),
1542
+ }),
1543
+ };
1859
1544
  };
1860
- var serializeAws_json1_1Output = function (input, context) {
1861
- return __assign(__assign(__assign(__assign(__assign({}, (input.DestinationSchema != null && {
1862
- DestinationSchema: serializeAws_json1_1DestinationSchema(input.DestinationSchema, context),
1863
- })), (input.KinesisFirehoseOutput != null && {
1864
- KinesisFirehoseOutput: serializeAws_json1_1KinesisFirehoseOutput(input.KinesisFirehoseOutput, context),
1865
- })), (input.KinesisStreamsOutput != null && {
1866
- KinesisStreamsOutput: serializeAws_json1_1KinesisStreamsOutput(input.KinesisStreamsOutput, context),
1867
- })), (input.LambdaOutput != null && { LambdaOutput: serializeAws_json1_1LambdaOutput(input.LambdaOutput, context) })), (input.Name != null && { Name: input.Name }));
1545
+ const serializeAws_json1_1Output = (input, context) => {
1546
+ return {
1547
+ ...(input.DestinationSchema != null && {
1548
+ DestinationSchema: serializeAws_json1_1DestinationSchema(input.DestinationSchema, context),
1549
+ }),
1550
+ ...(input.KinesisFirehoseOutput != null && {
1551
+ KinesisFirehoseOutput: serializeAws_json1_1KinesisFirehoseOutput(input.KinesisFirehoseOutput, context),
1552
+ }),
1553
+ ...(input.KinesisStreamsOutput != null && {
1554
+ KinesisStreamsOutput: serializeAws_json1_1KinesisStreamsOutput(input.KinesisStreamsOutput, context),
1555
+ }),
1556
+ ...(input.LambdaOutput != null && { LambdaOutput: serializeAws_json1_1LambdaOutput(input.LambdaOutput, context) }),
1557
+ ...(input.Name != null && { Name: input.Name }),
1558
+ };
1868
1559
  };
1869
- var serializeAws_json1_1Outputs = function (input, context) {
1560
+ const serializeAws_json1_1Outputs = (input, context) => {
1870
1561
  return input
1871
- .filter(function (e) { return e != null; })
1872
- .map(function (entry) {
1562
+ .filter((e) => e != null)
1563
+ .map((entry) => {
1873
1564
  return serializeAws_json1_1Output(entry, context);
1874
1565
  });
1875
1566
  };
1876
- var serializeAws_json1_1OutputUpdate = function (input, context) {
1877
- return __assign(__assign(__assign(__assign(__assign(__assign({}, (input.DestinationSchemaUpdate != null && {
1878
- DestinationSchemaUpdate: serializeAws_json1_1DestinationSchema(input.DestinationSchemaUpdate, context),
1879
- })), (input.KinesisFirehoseOutputUpdate != null && {
1880
- KinesisFirehoseOutputUpdate: serializeAws_json1_1KinesisFirehoseOutputUpdate(input.KinesisFirehoseOutputUpdate, context),
1881
- })), (input.KinesisStreamsOutputUpdate != null && {
1882
- KinesisStreamsOutputUpdate: serializeAws_json1_1KinesisStreamsOutputUpdate(input.KinesisStreamsOutputUpdate, context),
1883
- })), (input.LambdaOutputUpdate != null && {
1884
- LambdaOutputUpdate: serializeAws_json1_1LambdaOutputUpdate(input.LambdaOutputUpdate, context),
1885
- })), (input.NameUpdate != null && { NameUpdate: input.NameUpdate })), (input.OutputId != null && { OutputId: input.OutputId }));
1886
- };
1887
- var serializeAws_json1_1OutputUpdates = function (input, context) {
1567
+ const serializeAws_json1_1OutputUpdate = (input, context) => {
1568
+ return {
1569
+ ...(input.DestinationSchemaUpdate != null && {
1570
+ DestinationSchemaUpdate: serializeAws_json1_1DestinationSchema(input.DestinationSchemaUpdate, context),
1571
+ }),
1572
+ ...(input.KinesisFirehoseOutputUpdate != null && {
1573
+ KinesisFirehoseOutputUpdate: serializeAws_json1_1KinesisFirehoseOutputUpdate(input.KinesisFirehoseOutputUpdate, context),
1574
+ }),
1575
+ ...(input.KinesisStreamsOutputUpdate != null && {
1576
+ KinesisStreamsOutputUpdate: serializeAws_json1_1KinesisStreamsOutputUpdate(input.KinesisStreamsOutputUpdate, context),
1577
+ }),
1578
+ ...(input.LambdaOutputUpdate != null && {
1579
+ LambdaOutputUpdate: serializeAws_json1_1LambdaOutputUpdate(input.LambdaOutputUpdate, context),
1580
+ }),
1581
+ ...(input.NameUpdate != null && { NameUpdate: input.NameUpdate }),
1582
+ ...(input.OutputId != null && { OutputId: input.OutputId }),
1583
+ };
1584
+ };
1585
+ const serializeAws_json1_1OutputUpdates = (input, context) => {
1888
1586
  return input
1889
- .filter(function (e) { return e != null; })
1890
- .map(function (entry) {
1587
+ .filter((e) => e != null)
1588
+ .map((entry) => {
1891
1589
  return serializeAws_json1_1OutputUpdate(entry, context);
1892
1590
  });
1893
1591
  };
1894
- var serializeAws_json1_1RecordColumn = function (input, context) {
1895
- return __assign(__assign(__assign({}, (input.Mapping != null && { Mapping: input.Mapping })), (input.Name != null && { Name: input.Name })), (input.SqlType != null && { SqlType: input.SqlType }));
1592
+ const serializeAws_json1_1RecordColumn = (input, context) => {
1593
+ return {
1594
+ ...(input.Mapping != null && { Mapping: input.Mapping }),
1595
+ ...(input.Name != null && { Name: input.Name }),
1596
+ ...(input.SqlType != null && { SqlType: input.SqlType }),
1597
+ };
1896
1598
  };
1897
- var serializeAws_json1_1RecordColumns = function (input, context) {
1599
+ const serializeAws_json1_1RecordColumns = (input, context) => {
1898
1600
  return input
1899
- .filter(function (e) { return e != null; })
1900
- .map(function (entry) {
1601
+ .filter((e) => e != null)
1602
+ .map((entry) => {
1901
1603
  return serializeAws_json1_1RecordColumn(entry, context);
1902
1604
  });
1903
1605
  };
1904
- var serializeAws_json1_1RecordFormat = function (input, context) {
1905
- return __assign(__assign({}, (input.MappingParameters != null && {
1906
- MappingParameters: serializeAws_json1_1MappingParameters(input.MappingParameters, context),
1907
- })), (input.RecordFormatType != null && { RecordFormatType: input.RecordFormatType }));
1908
- };
1909
- var serializeAws_json1_1ReferenceDataSource = function (input, context) {
1910
- return __assign(__assign(__assign({}, (input.ReferenceSchema != null && {
1911
- ReferenceSchema: serializeAws_json1_1SourceSchema(input.ReferenceSchema, context),
1912
- })), (input.S3ReferenceDataSource != null && {
1913
- S3ReferenceDataSource: serializeAws_json1_1S3ReferenceDataSource(input.S3ReferenceDataSource, context),
1914
- })), (input.TableName != null && { TableName: input.TableName }));
1915
- };
1916
- var serializeAws_json1_1ReferenceDataSourceUpdate = function (input, context) {
1917
- return __assign(__assign(__assign(__assign({}, (input.ReferenceId != null && { ReferenceId: input.ReferenceId })), (input.ReferenceSchemaUpdate != null && {
1918
- ReferenceSchemaUpdate: serializeAws_json1_1SourceSchema(input.ReferenceSchemaUpdate, context),
1919
- })), (input.S3ReferenceDataSourceUpdate != null && {
1920
- S3ReferenceDataSourceUpdate: serializeAws_json1_1S3ReferenceDataSourceUpdate(input.S3ReferenceDataSourceUpdate, context),
1921
- })), (input.TableNameUpdate != null && { TableNameUpdate: input.TableNameUpdate }));
1922
- };
1923
- var serializeAws_json1_1ReferenceDataSourceUpdates = function (input, context) {
1606
+ const serializeAws_json1_1RecordFormat = (input, context) => {
1607
+ return {
1608
+ ...(input.MappingParameters != null && {
1609
+ MappingParameters: serializeAws_json1_1MappingParameters(input.MappingParameters, context),
1610
+ }),
1611
+ ...(input.RecordFormatType != null && { RecordFormatType: input.RecordFormatType }),
1612
+ };
1613
+ };
1614
+ const serializeAws_json1_1ReferenceDataSource = (input, context) => {
1615
+ return {
1616
+ ...(input.ReferenceSchema != null && {
1617
+ ReferenceSchema: serializeAws_json1_1SourceSchema(input.ReferenceSchema, context),
1618
+ }),
1619
+ ...(input.S3ReferenceDataSource != null && {
1620
+ S3ReferenceDataSource: serializeAws_json1_1S3ReferenceDataSource(input.S3ReferenceDataSource, context),
1621
+ }),
1622
+ ...(input.TableName != null && { TableName: input.TableName }),
1623
+ };
1624
+ };
1625
+ const serializeAws_json1_1ReferenceDataSourceUpdate = (input, context) => {
1626
+ return {
1627
+ ...(input.ReferenceId != null && { ReferenceId: input.ReferenceId }),
1628
+ ...(input.ReferenceSchemaUpdate != null && {
1629
+ ReferenceSchemaUpdate: serializeAws_json1_1SourceSchema(input.ReferenceSchemaUpdate, context),
1630
+ }),
1631
+ ...(input.S3ReferenceDataSourceUpdate != null && {
1632
+ S3ReferenceDataSourceUpdate: serializeAws_json1_1S3ReferenceDataSourceUpdate(input.S3ReferenceDataSourceUpdate, context),
1633
+ }),
1634
+ ...(input.TableNameUpdate != null && { TableNameUpdate: input.TableNameUpdate }),
1635
+ };
1636
+ };
1637
+ const serializeAws_json1_1ReferenceDataSourceUpdates = (input, context) => {
1924
1638
  return input
1925
- .filter(function (e) { return e != null; })
1926
- .map(function (entry) {
1639
+ .filter((e) => e != null)
1640
+ .map((entry) => {
1927
1641
  return serializeAws_json1_1ReferenceDataSourceUpdate(entry, context);
1928
1642
  });
1929
1643
  };
1930
- var serializeAws_json1_1S3Configuration = function (input, context) {
1931
- return __assign(__assign(__assign({}, (input.BucketARN != null && { BucketARN: input.BucketARN })), (input.FileKey != null && { FileKey: input.FileKey })), (input.RoleARN != null && { RoleARN: input.RoleARN }));
1644
+ const serializeAws_json1_1S3Configuration = (input, context) => {
1645
+ return {
1646
+ ...(input.BucketARN != null && { BucketARN: input.BucketARN }),
1647
+ ...(input.FileKey != null && { FileKey: input.FileKey }),
1648
+ ...(input.RoleARN != null && { RoleARN: input.RoleARN }),
1649
+ };
1932
1650
  };
1933
- var serializeAws_json1_1S3ReferenceDataSource = function (input, context) {
1934
- return __assign(__assign(__assign({}, (input.BucketARN != null && { BucketARN: input.BucketARN })), (input.FileKey != null && { FileKey: input.FileKey })), (input.ReferenceRoleARN != null && { ReferenceRoleARN: input.ReferenceRoleARN }));
1651
+ const serializeAws_json1_1S3ReferenceDataSource = (input, context) => {
1652
+ return {
1653
+ ...(input.BucketARN != null && { BucketARN: input.BucketARN }),
1654
+ ...(input.FileKey != null && { FileKey: input.FileKey }),
1655
+ ...(input.ReferenceRoleARN != null && { ReferenceRoleARN: input.ReferenceRoleARN }),
1656
+ };
1935
1657
  };
1936
- var serializeAws_json1_1S3ReferenceDataSourceUpdate = function (input, context) {
1937
- return __assign(__assign(__assign({}, (input.BucketARNUpdate != null && { BucketARNUpdate: input.BucketARNUpdate })), (input.FileKeyUpdate != null && { FileKeyUpdate: input.FileKeyUpdate })), (input.ReferenceRoleARNUpdate != null && { ReferenceRoleARNUpdate: input.ReferenceRoleARNUpdate }));
1658
+ const serializeAws_json1_1S3ReferenceDataSourceUpdate = (input, context) => {
1659
+ return {
1660
+ ...(input.BucketARNUpdate != null && { BucketARNUpdate: input.BucketARNUpdate }),
1661
+ ...(input.FileKeyUpdate != null && { FileKeyUpdate: input.FileKeyUpdate }),
1662
+ ...(input.ReferenceRoleARNUpdate != null && { ReferenceRoleARNUpdate: input.ReferenceRoleARNUpdate }),
1663
+ };
1938
1664
  };
1939
- var serializeAws_json1_1SourceSchema = function (input, context) {
1940
- return __assign(__assign(__assign({}, (input.RecordColumns != null && {
1941
- RecordColumns: serializeAws_json1_1RecordColumns(input.RecordColumns, context),
1942
- })), (input.RecordEncoding != null && { RecordEncoding: input.RecordEncoding })), (input.RecordFormat != null && { RecordFormat: serializeAws_json1_1RecordFormat(input.RecordFormat, context) }));
1665
+ const serializeAws_json1_1SourceSchema = (input, context) => {
1666
+ return {
1667
+ ...(input.RecordColumns != null && {
1668
+ RecordColumns: serializeAws_json1_1RecordColumns(input.RecordColumns, context),
1669
+ }),
1670
+ ...(input.RecordEncoding != null && { RecordEncoding: input.RecordEncoding }),
1671
+ ...(input.RecordFormat != null && { RecordFormat: serializeAws_json1_1RecordFormat(input.RecordFormat, context) }),
1672
+ };
1943
1673
  };
1944
- var serializeAws_json1_1StartApplicationRequest = function (input, context) {
1945
- return __assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.InputConfigurations != null && {
1946
- InputConfigurations: serializeAws_json1_1InputConfigurations(input.InputConfigurations, context),
1947
- }));
1674
+ const serializeAws_json1_1StartApplicationRequest = (input, context) => {
1675
+ return {
1676
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1677
+ ...(input.InputConfigurations != null && {
1678
+ InputConfigurations: serializeAws_json1_1InputConfigurations(input.InputConfigurations, context),
1679
+ }),
1680
+ };
1948
1681
  };
1949
- var serializeAws_json1_1StopApplicationRequest = function (input, context) {
1950
- return __assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName }));
1682
+ const serializeAws_json1_1StopApplicationRequest = (input, context) => {
1683
+ return {
1684
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1685
+ };
1951
1686
  };
1952
- var serializeAws_json1_1Tag = function (input, context) {
1953
- return __assign(__assign({}, (input.Key != null && { Key: input.Key })), (input.Value != null && { Value: input.Value }));
1687
+ const serializeAws_json1_1Tag = (input, context) => {
1688
+ return {
1689
+ ...(input.Key != null && { Key: input.Key }),
1690
+ ...(input.Value != null && { Value: input.Value }),
1691
+ };
1954
1692
  };
1955
- var serializeAws_json1_1TagKeys = function (input, context) {
1693
+ const serializeAws_json1_1TagKeys = (input, context) => {
1956
1694
  return input
1957
- .filter(function (e) { return e != null; })
1958
- .map(function (entry) {
1695
+ .filter((e) => e != null)
1696
+ .map((entry) => {
1959
1697
  return entry;
1960
1698
  });
1961
1699
  };
1962
- var serializeAws_json1_1TagResourceRequest = function (input, context) {
1963
- return __assign(__assign({}, (input.ResourceARN != null && { ResourceARN: input.ResourceARN })), (input.Tags != null && { Tags: serializeAws_json1_1Tags(input.Tags, context) }));
1700
+ const serializeAws_json1_1TagResourceRequest = (input, context) => {
1701
+ return {
1702
+ ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
1703
+ ...(input.Tags != null && { Tags: serializeAws_json1_1Tags(input.Tags, context) }),
1704
+ };
1964
1705
  };
1965
- var serializeAws_json1_1Tags = function (input, context) {
1706
+ const serializeAws_json1_1Tags = (input, context) => {
1966
1707
  return input
1967
- .filter(function (e) { return e != null; })
1968
- .map(function (entry) {
1708
+ .filter((e) => e != null)
1709
+ .map((entry) => {
1969
1710
  return serializeAws_json1_1Tag(entry, context);
1970
1711
  });
1971
1712
  };
1972
- var serializeAws_json1_1UntagResourceRequest = function (input, context) {
1973
- return __assign(__assign({}, (input.ResourceARN != null && { ResourceARN: input.ResourceARN })), (input.TagKeys != null && { TagKeys: serializeAws_json1_1TagKeys(input.TagKeys, context) }));
1713
+ const serializeAws_json1_1UntagResourceRequest = (input, context) => {
1714
+ return {
1715
+ ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
1716
+ ...(input.TagKeys != null && { TagKeys: serializeAws_json1_1TagKeys(input.TagKeys, context) }),
1717
+ };
1974
1718
  };
1975
- var serializeAws_json1_1UpdateApplicationRequest = function (input, context) {
1976
- return __assign(__assign(__assign({}, (input.ApplicationName != null && { ApplicationName: input.ApplicationName })), (input.ApplicationUpdate != null && {
1977
- ApplicationUpdate: serializeAws_json1_1ApplicationUpdate(input.ApplicationUpdate, context),
1978
- })), (input.CurrentApplicationVersionId != null && {
1979
- CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1980
- }));
1719
+ const serializeAws_json1_1UpdateApplicationRequest = (input, context) => {
1720
+ return {
1721
+ ...(input.ApplicationName != null && { ApplicationName: input.ApplicationName }),
1722
+ ...(input.ApplicationUpdate != null && {
1723
+ ApplicationUpdate: serializeAws_json1_1ApplicationUpdate(input.ApplicationUpdate, context),
1724
+ }),
1725
+ ...(input.CurrentApplicationVersionId != null && {
1726
+ CurrentApplicationVersionId: input.CurrentApplicationVersionId,
1727
+ }),
1728
+ };
1981
1729
  };
1982
- var deserializeAws_json1_1AddApplicationCloudWatchLoggingOptionResponse = function (output, context) {
1730
+ const deserializeAws_json1_1AddApplicationCloudWatchLoggingOptionResponse = (output, context) => {
1983
1731
  return {};
1984
1732
  };
1985
- var deserializeAws_json1_1AddApplicationInputProcessingConfigurationResponse = function (output, context) {
1733
+ const deserializeAws_json1_1AddApplicationInputProcessingConfigurationResponse = (output, context) => {
1986
1734
  return {};
1987
1735
  };
1988
- var deserializeAws_json1_1AddApplicationInputResponse = function (output, context) {
1736
+ const deserializeAws_json1_1AddApplicationInputResponse = (output, context) => {
1989
1737
  return {};
1990
1738
  };
1991
- var deserializeAws_json1_1AddApplicationOutputResponse = function (output, context) {
1739
+ const deserializeAws_json1_1AddApplicationOutputResponse = (output, context) => {
1992
1740
  return {};
1993
1741
  };
1994
- var deserializeAws_json1_1AddApplicationReferenceDataSourceResponse = function (output, context) {
1742
+ const deserializeAws_json1_1AddApplicationReferenceDataSourceResponse = (output, context) => {
1995
1743
  return {};
1996
1744
  };
1997
- var deserializeAws_json1_1ApplicationDetail = function (output, context) {
1745
+ const deserializeAws_json1_1ApplicationDetail = (output, context) => {
1998
1746
  return {
1999
1747
  ApplicationARN: __expectString(output.ApplicationARN),
2000
1748
  ApplicationCode: __expectString(output.ApplicationCode),
@@ -2022,10 +1770,10 @@ var deserializeAws_json1_1ApplicationDetail = function (output, context) {
2022
1770
  : undefined,
2023
1771
  };
2024
1772
  };
2025
- var deserializeAws_json1_1ApplicationSummaries = function (output, context) {
2026
- var retVal = (output || [])
2027
- .filter(function (e) { return e != null; })
2028
- .map(function (entry) {
1773
+ const deserializeAws_json1_1ApplicationSummaries = (output, context) => {
1774
+ const retVal = (output || [])
1775
+ .filter((e) => e != null)
1776
+ .map((entry) => {
2029
1777
  if (entry === null) {
2030
1778
  return null;
2031
1779
  }
@@ -2033,24 +1781,24 @@ var deserializeAws_json1_1ApplicationSummaries = function (output, context) {
2033
1781
  });
2034
1782
  return retVal;
2035
1783
  };
2036
- var deserializeAws_json1_1ApplicationSummary = function (output, context) {
1784
+ const deserializeAws_json1_1ApplicationSummary = (output, context) => {
2037
1785
  return {
2038
1786
  ApplicationARN: __expectString(output.ApplicationARN),
2039
1787
  ApplicationName: __expectString(output.ApplicationName),
2040
1788
  ApplicationStatus: __expectString(output.ApplicationStatus),
2041
1789
  };
2042
1790
  };
2043
- var deserializeAws_json1_1CloudWatchLoggingOptionDescription = function (output, context) {
1791
+ const deserializeAws_json1_1CloudWatchLoggingOptionDescription = (output, context) => {
2044
1792
  return {
2045
1793
  CloudWatchLoggingOptionId: __expectString(output.CloudWatchLoggingOptionId),
2046
1794
  LogStreamARN: __expectString(output.LogStreamARN),
2047
1795
  RoleARN: __expectString(output.RoleARN),
2048
1796
  };
2049
1797
  };
2050
- var deserializeAws_json1_1CloudWatchLoggingOptionDescriptions = function (output, context) {
2051
- var retVal = (output || [])
2052
- .filter(function (e) { return e != null; })
2053
- .map(function (entry) {
1798
+ const deserializeAws_json1_1CloudWatchLoggingOptionDescriptions = (output, context) => {
1799
+ const retVal = (output || [])
1800
+ .filter((e) => e != null)
1801
+ .map((entry) => {
2054
1802
  if (entry === null) {
2055
1803
  return null;
2056
1804
  }
@@ -2058,57 +1806,57 @@ var deserializeAws_json1_1CloudWatchLoggingOptionDescriptions = function (output
2058
1806
  });
2059
1807
  return retVal;
2060
1808
  };
2061
- var deserializeAws_json1_1CodeValidationException = function (output, context) {
1809
+ const deserializeAws_json1_1CodeValidationException = (output, context) => {
2062
1810
  return {
2063
1811
  message: __expectString(output.message),
2064
1812
  };
2065
1813
  };
2066
- var deserializeAws_json1_1ConcurrentModificationException = function (output, context) {
1814
+ const deserializeAws_json1_1ConcurrentModificationException = (output, context) => {
2067
1815
  return {
2068
1816
  message: __expectString(output.message),
2069
1817
  };
2070
1818
  };
2071
- var deserializeAws_json1_1CreateApplicationResponse = function (output, context) {
1819
+ const deserializeAws_json1_1CreateApplicationResponse = (output, context) => {
2072
1820
  return {
2073
1821
  ApplicationSummary: output.ApplicationSummary != null
2074
1822
  ? deserializeAws_json1_1ApplicationSummary(output.ApplicationSummary, context)
2075
1823
  : undefined,
2076
1824
  };
2077
1825
  };
2078
- var deserializeAws_json1_1CSVMappingParameters = function (output, context) {
1826
+ const deserializeAws_json1_1CSVMappingParameters = (output, context) => {
2079
1827
  return {
2080
1828
  RecordColumnDelimiter: __expectString(output.RecordColumnDelimiter),
2081
1829
  RecordRowDelimiter: __expectString(output.RecordRowDelimiter),
2082
1830
  };
2083
1831
  };
2084
- var deserializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionResponse = function (output, context) {
1832
+ const deserializeAws_json1_1DeleteApplicationCloudWatchLoggingOptionResponse = (output, context) => {
2085
1833
  return {};
2086
1834
  };
2087
- var deserializeAws_json1_1DeleteApplicationInputProcessingConfigurationResponse = function (output, context) {
1835
+ const deserializeAws_json1_1DeleteApplicationInputProcessingConfigurationResponse = (output, context) => {
2088
1836
  return {};
2089
1837
  };
2090
- var deserializeAws_json1_1DeleteApplicationOutputResponse = function (output, context) {
1838
+ const deserializeAws_json1_1DeleteApplicationOutputResponse = (output, context) => {
2091
1839
  return {};
2092
1840
  };
2093
- var deserializeAws_json1_1DeleteApplicationReferenceDataSourceResponse = function (output, context) {
1841
+ const deserializeAws_json1_1DeleteApplicationReferenceDataSourceResponse = (output, context) => {
2094
1842
  return {};
2095
1843
  };
2096
- var deserializeAws_json1_1DeleteApplicationResponse = function (output, context) {
1844
+ const deserializeAws_json1_1DeleteApplicationResponse = (output, context) => {
2097
1845
  return {};
2098
1846
  };
2099
- var deserializeAws_json1_1DescribeApplicationResponse = function (output, context) {
1847
+ const deserializeAws_json1_1DescribeApplicationResponse = (output, context) => {
2100
1848
  return {
2101
1849
  ApplicationDetail: output.ApplicationDetail != null
2102
1850
  ? deserializeAws_json1_1ApplicationDetail(output.ApplicationDetail, context)
2103
1851
  : undefined,
2104
1852
  };
2105
1853
  };
2106
- var deserializeAws_json1_1DestinationSchema = function (output, context) {
1854
+ const deserializeAws_json1_1DestinationSchema = (output, context) => {
2107
1855
  return {
2108
1856
  RecordFormatType: __expectString(output.RecordFormatType),
2109
1857
  };
2110
1858
  };
2111
- var deserializeAws_json1_1DiscoverInputSchemaResponse = function (output, context) {
1859
+ const deserializeAws_json1_1DiscoverInputSchemaResponse = (output, context) => {
2112
1860
  return {
2113
1861
  InputSchema: output.InputSchema != null ? deserializeAws_json1_1SourceSchema(output.InputSchema, context) : undefined,
2114
1862
  ParsedInputRecords: output.ParsedInputRecords != null
@@ -2122,10 +1870,10 @@ var deserializeAws_json1_1DiscoverInputSchemaResponse = function (output, contex
2122
1870
  : undefined,
2123
1871
  };
2124
1872
  };
2125
- var deserializeAws_json1_1InAppStreamNames = function (output, context) {
2126
- var retVal = (output || [])
2127
- .filter(function (e) { return e != null; })
2128
- .map(function (entry) {
1873
+ const deserializeAws_json1_1InAppStreamNames = (output, context) => {
1874
+ const retVal = (output || [])
1875
+ .filter((e) => e != null)
1876
+ .map((entry) => {
2129
1877
  if (entry === null) {
2130
1878
  return null;
2131
1879
  }
@@ -2133,7 +1881,7 @@ var deserializeAws_json1_1InAppStreamNames = function (output, context) {
2133
1881
  });
2134
1882
  return retVal;
2135
1883
  };
2136
- var deserializeAws_json1_1InputDescription = function (output, context) {
1884
+ const deserializeAws_json1_1InputDescription = (output, context) => {
2137
1885
  return {
2138
1886
  InAppStreamNames: output.InAppStreamNames != null
2139
1887
  ? deserializeAws_json1_1InAppStreamNames(output.InAppStreamNames, context)
@@ -2158,10 +1906,10 @@ var deserializeAws_json1_1InputDescription = function (output, context) {
2158
1906
  NamePrefix: __expectString(output.NamePrefix),
2159
1907
  };
2160
1908
  };
2161
- var deserializeAws_json1_1InputDescriptions = function (output, context) {
2162
- var retVal = (output || [])
2163
- .filter(function (e) { return e != null; })
2164
- .map(function (entry) {
1909
+ const deserializeAws_json1_1InputDescriptions = (output, context) => {
1910
+ const retVal = (output || [])
1911
+ .filter((e) => e != null)
1912
+ .map((entry) => {
2165
1913
  if (entry === null) {
2166
1914
  return null;
2167
1915
  }
@@ -2169,80 +1917,80 @@ var deserializeAws_json1_1InputDescriptions = function (output, context) {
2169
1917
  });
2170
1918
  return retVal;
2171
1919
  };
2172
- var deserializeAws_json1_1InputLambdaProcessorDescription = function (output, context) {
1920
+ const deserializeAws_json1_1InputLambdaProcessorDescription = (output, context) => {
2173
1921
  return {
2174
1922
  ResourceARN: __expectString(output.ResourceARN),
2175
1923
  RoleARN: __expectString(output.RoleARN),
2176
1924
  };
2177
1925
  };
2178
- var deserializeAws_json1_1InputParallelism = function (output, context) {
1926
+ const deserializeAws_json1_1InputParallelism = (output, context) => {
2179
1927
  return {
2180
1928
  Count: __expectInt32(output.Count),
2181
1929
  };
2182
1930
  };
2183
- var deserializeAws_json1_1InputProcessingConfigurationDescription = function (output, context) {
1931
+ const deserializeAws_json1_1InputProcessingConfigurationDescription = (output, context) => {
2184
1932
  return {
2185
1933
  InputLambdaProcessorDescription: output.InputLambdaProcessorDescription != null
2186
1934
  ? deserializeAws_json1_1InputLambdaProcessorDescription(output.InputLambdaProcessorDescription, context)
2187
1935
  : undefined,
2188
1936
  };
2189
1937
  };
2190
- var deserializeAws_json1_1InputStartingPositionConfiguration = function (output, context) {
1938
+ const deserializeAws_json1_1InputStartingPositionConfiguration = (output, context) => {
2191
1939
  return {
2192
1940
  InputStartingPosition: __expectString(output.InputStartingPosition),
2193
1941
  };
2194
1942
  };
2195
- var deserializeAws_json1_1InvalidApplicationConfigurationException = function (output, context) {
1943
+ const deserializeAws_json1_1InvalidApplicationConfigurationException = (output, context) => {
2196
1944
  return {
2197
1945
  message: __expectString(output.message),
2198
1946
  };
2199
1947
  };
2200
- var deserializeAws_json1_1InvalidArgumentException = function (output, context) {
1948
+ const deserializeAws_json1_1InvalidArgumentException = (output, context) => {
2201
1949
  return {
2202
1950
  message: __expectString(output.message),
2203
1951
  };
2204
1952
  };
2205
- var deserializeAws_json1_1JSONMappingParameters = function (output, context) {
1953
+ const deserializeAws_json1_1JSONMappingParameters = (output, context) => {
2206
1954
  return {
2207
1955
  RecordRowPath: __expectString(output.RecordRowPath),
2208
1956
  };
2209
1957
  };
2210
- var deserializeAws_json1_1KinesisFirehoseInputDescription = function (output, context) {
1958
+ const deserializeAws_json1_1KinesisFirehoseInputDescription = (output, context) => {
2211
1959
  return {
2212
1960
  ResourceARN: __expectString(output.ResourceARN),
2213
1961
  RoleARN: __expectString(output.RoleARN),
2214
1962
  };
2215
1963
  };
2216
- var deserializeAws_json1_1KinesisFirehoseOutputDescription = function (output, context) {
1964
+ const deserializeAws_json1_1KinesisFirehoseOutputDescription = (output, context) => {
2217
1965
  return {
2218
1966
  ResourceARN: __expectString(output.ResourceARN),
2219
1967
  RoleARN: __expectString(output.RoleARN),
2220
1968
  };
2221
1969
  };
2222
- var deserializeAws_json1_1KinesisStreamsInputDescription = function (output, context) {
1970
+ const deserializeAws_json1_1KinesisStreamsInputDescription = (output, context) => {
2223
1971
  return {
2224
1972
  ResourceARN: __expectString(output.ResourceARN),
2225
1973
  RoleARN: __expectString(output.RoleARN),
2226
1974
  };
2227
1975
  };
2228
- var deserializeAws_json1_1KinesisStreamsOutputDescription = function (output, context) {
1976
+ const deserializeAws_json1_1KinesisStreamsOutputDescription = (output, context) => {
2229
1977
  return {
2230
1978
  ResourceARN: __expectString(output.ResourceARN),
2231
1979
  RoleARN: __expectString(output.RoleARN),
2232
1980
  };
2233
1981
  };
2234
- var deserializeAws_json1_1LambdaOutputDescription = function (output, context) {
1982
+ const deserializeAws_json1_1LambdaOutputDescription = (output, context) => {
2235
1983
  return {
2236
1984
  ResourceARN: __expectString(output.ResourceARN),
2237
1985
  RoleARN: __expectString(output.RoleARN),
2238
1986
  };
2239
1987
  };
2240
- var deserializeAws_json1_1LimitExceededException = function (output, context) {
1988
+ const deserializeAws_json1_1LimitExceededException = (output, context) => {
2241
1989
  return {
2242
1990
  message: __expectString(output.message),
2243
1991
  };
2244
1992
  };
2245
- var deserializeAws_json1_1ListApplicationsResponse = function (output, context) {
1993
+ const deserializeAws_json1_1ListApplicationsResponse = (output, context) => {
2246
1994
  return {
2247
1995
  ApplicationSummaries: output.ApplicationSummaries != null
2248
1996
  ? deserializeAws_json1_1ApplicationSummaries(output.ApplicationSummaries, context)
@@ -2250,12 +1998,12 @@ var deserializeAws_json1_1ListApplicationsResponse = function (output, context)
2250
1998
  HasMoreApplications: __expectBoolean(output.HasMoreApplications),
2251
1999
  };
2252
2000
  };
2253
- var deserializeAws_json1_1ListTagsForResourceResponse = function (output, context) {
2001
+ const deserializeAws_json1_1ListTagsForResourceResponse = (output, context) => {
2254
2002
  return {
2255
2003
  Tags: output.Tags != null ? deserializeAws_json1_1Tags(output.Tags, context) : undefined,
2256
2004
  };
2257
2005
  };
2258
- var deserializeAws_json1_1MappingParameters = function (output, context) {
2006
+ const deserializeAws_json1_1MappingParameters = (output, context) => {
2259
2007
  return {
2260
2008
  CSVMappingParameters: output.CSVMappingParameters != null
2261
2009
  ? deserializeAws_json1_1CSVMappingParameters(output.CSVMappingParameters, context)
@@ -2265,7 +2013,7 @@ var deserializeAws_json1_1MappingParameters = function (output, context) {
2265
2013
  : undefined,
2266
2014
  };
2267
2015
  };
2268
- var deserializeAws_json1_1OutputDescription = function (output, context) {
2016
+ const deserializeAws_json1_1OutputDescription = (output, context) => {
2269
2017
  return {
2270
2018
  DestinationSchema: output.DestinationSchema != null
2271
2019
  ? deserializeAws_json1_1DestinationSchema(output.DestinationSchema, context)
@@ -2283,10 +2031,10 @@ var deserializeAws_json1_1OutputDescription = function (output, context) {
2283
2031
  OutputId: __expectString(output.OutputId),
2284
2032
  };
2285
2033
  };
2286
- var deserializeAws_json1_1OutputDescriptions = function (output, context) {
2287
- var retVal = (output || [])
2288
- .filter(function (e) { return e != null; })
2289
- .map(function (entry) {
2034
+ const deserializeAws_json1_1OutputDescriptions = (output, context) => {
2035
+ const retVal = (output || [])
2036
+ .filter((e) => e != null)
2037
+ .map((entry) => {
2290
2038
  if (entry === null) {
2291
2039
  return null;
2292
2040
  }
@@ -2294,10 +2042,10 @@ var deserializeAws_json1_1OutputDescriptions = function (output, context) {
2294
2042
  });
2295
2043
  return retVal;
2296
2044
  };
2297
- var deserializeAws_json1_1ParsedInputRecord = function (output, context) {
2298
- var retVal = (output || [])
2299
- .filter(function (e) { return e != null; })
2300
- .map(function (entry) {
2045
+ const deserializeAws_json1_1ParsedInputRecord = (output, context) => {
2046
+ const retVal = (output || [])
2047
+ .filter((e) => e != null)
2048
+ .map((entry) => {
2301
2049
  if (entry === null) {
2302
2050
  return null;
2303
2051
  }
@@ -2305,10 +2053,10 @@ var deserializeAws_json1_1ParsedInputRecord = function (output, context) {
2305
2053
  });
2306
2054
  return retVal;
2307
2055
  };
2308
- var deserializeAws_json1_1ParsedInputRecords = function (output, context) {
2309
- var retVal = (output || [])
2310
- .filter(function (e) { return e != null; })
2311
- .map(function (entry) {
2056
+ const deserializeAws_json1_1ParsedInputRecords = (output, context) => {
2057
+ const retVal = (output || [])
2058
+ .filter((e) => e != null)
2059
+ .map((entry) => {
2312
2060
  if (entry === null) {
2313
2061
  return null;
2314
2062
  }
@@ -2316,10 +2064,10 @@ var deserializeAws_json1_1ParsedInputRecords = function (output, context) {
2316
2064
  });
2317
2065
  return retVal;
2318
2066
  };
2319
- var deserializeAws_json1_1ProcessedInputRecords = function (output, context) {
2320
- var retVal = (output || [])
2321
- .filter(function (e) { return e != null; })
2322
- .map(function (entry) {
2067
+ const deserializeAws_json1_1ProcessedInputRecords = (output, context) => {
2068
+ const retVal = (output || [])
2069
+ .filter((e) => e != null)
2070
+ .map((entry) => {
2323
2071
  if (entry === null) {
2324
2072
  return null;
2325
2073
  }
@@ -2327,10 +2075,10 @@ var deserializeAws_json1_1ProcessedInputRecords = function (output, context) {
2327
2075
  });
2328
2076
  return retVal;
2329
2077
  };
2330
- var deserializeAws_json1_1RawInputRecords = function (output, context) {
2331
- var retVal = (output || [])
2332
- .filter(function (e) { return e != null; })
2333
- .map(function (entry) {
2078
+ const deserializeAws_json1_1RawInputRecords = (output, context) => {
2079
+ const retVal = (output || [])
2080
+ .filter((e) => e != null)
2081
+ .map((entry) => {
2334
2082
  if (entry === null) {
2335
2083
  return null;
2336
2084
  }
@@ -2338,17 +2086,17 @@ var deserializeAws_json1_1RawInputRecords = function (output, context) {
2338
2086
  });
2339
2087
  return retVal;
2340
2088
  };
2341
- var deserializeAws_json1_1RecordColumn = function (output, context) {
2089
+ const deserializeAws_json1_1RecordColumn = (output, context) => {
2342
2090
  return {
2343
2091
  Mapping: __expectString(output.Mapping),
2344
2092
  Name: __expectString(output.Name),
2345
2093
  SqlType: __expectString(output.SqlType),
2346
2094
  };
2347
2095
  };
2348
- var deserializeAws_json1_1RecordColumns = function (output, context) {
2349
- var retVal = (output || [])
2350
- .filter(function (e) { return e != null; })
2351
- .map(function (entry) {
2096
+ const deserializeAws_json1_1RecordColumns = (output, context) => {
2097
+ const retVal = (output || [])
2098
+ .filter((e) => e != null)
2099
+ .map((entry) => {
2352
2100
  if (entry === null) {
2353
2101
  return null;
2354
2102
  }
@@ -2356,7 +2104,7 @@ var deserializeAws_json1_1RecordColumns = function (output, context) {
2356
2104
  });
2357
2105
  return retVal;
2358
2106
  };
2359
- var deserializeAws_json1_1RecordFormat = function (output, context) {
2107
+ const deserializeAws_json1_1RecordFormat = (output, context) => {
2360
2108
  return {
2361
2109
  MappingParameters: output.MappingParameters != null
2362
2110
  ? deserializeAws_json1_1MappingParameters(output.MappingParameters, context)
@@ -2364,7 +2112,7 @@ var deserializeAws_json1_1RecordFormat = function (output, context) {
2364
2112
  RecordFormatType: __expectString(output.RecordFormatType),
2365
2113
  };
2366
2114
  };
2367
- var deserializeAws_json1_1ReferenceDataSourceDescription = function (output, context) {
2115
+ const deserializeAws_json1_1ReferenceDataSourceDescription = (output, context) => {
2368
2116
  return {
2369
2117
  ReferenceId: __expectString(output.ReferenceId),
2370
2118
  ReferenceSchema: output.ReferenceSchema != null ? deserializeAws_json1_1SourceSchema(output.ReferenceSchema, context) : undefined,
@@ -2374,10 +2122,10 @@ var deserializeAws_json1_1ReferenceDataSourceDescription = function (output, con
2374
2122
  TableName: __expectString(output.TableName),
2375
2123
  };
2376
2124
  };
2377
- var deserializeAws_json1_1ReferenceDataSourceDescriptions = function (output, context) {
2378
- var retVal = (output || [])
2379
- .filter(function (e) { return e != null; })
2380
- .map(function (entry) {
2125
+ const deserializeAws_json1_1ReferenceDataSourceDescriptions = (output, context) => {
2126
+ const retVal = (output || [])
2127
+ .filter((e) => e != null)
2128
+ .map((entry) => {
2381
2129
  if (entry === null) {
2382
2130
  return null;
2383
2131
  }
@@ -2385,59 +2133,59 @@ var deserializeAws_json1_1ReferenceDataSourceDescriptions = function (output, co
2385
2133
  });
2386
2134
  return retVal;
2387
2135
  };
2388
- var deserializeAws_json1_1ResourceInUseException = function (output, context) {
2136
+ const deserializeAws_json1_1ResourceInUseException = (output, context) => {
2389
2137
  return {
2390
2138
  message: __expectString(output.message),
2391
2139
  };
2392
2140
  };
2393
- var deserializeAws_json1_1ResourceNotFoundException = function (output, context) {
2141
+ const deserializeAws_json1_1ResourceNotFoundException = (output, context) => {
2394
2142
  return {
2395
2143
  message: __expectString(output.message),
2396
2144
  };
2397
2145
  };
2398
- var deserializeAws_json1_1ResourceProvisionedThroughputExceededException = function (output, context) {
2146
+ const deserializeAws_json1_1ResourceProvisionedThroughputExceededException = (output, context) => {
2399
2147
  return {
2400
2148
  message: __expectString(output.message),
2401
2149
  };
2402
2150
  };
2403
- var deserializeAws_json1_1S3ReferenceDataSourceDescription = function (output, context) {
2151
+ const deserializeAws_json1_1S3ReferenceDataSourceDescription = (output, context) => {
2404
2152
  return {
2405
2153
  BucketARN: __expectString(output.BucketARN),
2406
2154
  FileKey: __expectString(output.FileKey),
2407
2155
  ReferenceRoleARN: __expectString(output.ReferenceRoleARN),
2408
2156
  };
2409
2157
  };
2410
- var deserializeAws_json1_1ServiceUnavailableException = function (output, context) {
2158
+ const deserializeAws_json1_1ServiceUnavailableException = (output, context) => {
2411
2159
  return {
2412
2160
  message: __expectString(output.message),
2413
2161
  };
2414
2162
  };
2415
- var deserializeAws_json1_1SourceSchema = function (output, context) {
2163
+ const deserializeAws_json1_1SourceSchema = (output, context) => {
2416
2164
  return {
2417
2165
  RecordColumns: output.RecordColumns != null ? deserializeAws_json1_1RecordColumns(output.RecordColumns, context) : undefined,
2418
2166
  RecordEncoding: __expectString(output.RecordEncoding),
2419
2167
  RecordFormat: output.RecordFormat != null ? deserializeAws_json1_1RecordFormat(output.RecordFormat, context) : undefined,
2420
2168
  };
2421
2169
  };
2422
- var deserializeAws_json1_1StartApplicationResponse = function (output, context) {
2170
+ const deserializeAws_json1_1StartApplicationResponse = (output, context) => {
2423
2171
  return {};
2424
2172
  };
2425
- var deserializeAws_json1_1StopApplicationResponse = function (output, context) {
2173
+ const deserializeAws_json1_1StopApplicationResponse = (output, context) => {
2426
2174
  return {};
2427
2175
  };
2428
- var deserializeAws_json1_1Tag = function (output, context) {
2176
+ const deserializeAws_json1_1Tag = (output, context) => {
2429
2177
  return {
2430
2178
  Key: __expectString(output.Key),
2431
2179
  Value: __expectString(output.Value),
2432
2180
  };
2433
2181
  };
2434
- var deserializeAws_json1_1TagResourceResponse = function (output, context) {
2182
+ const deserializeAws_json1_1TagResourceResponse = (output, context) => {
2435
2183
  return {};
2436
2184
  };
2437
- var deserializeAws_json1_1Tags = function (output, context) {
2438
- var retVal = (output || [])
2439
- .filter(function (e) { return e != null; })
2440
- .map(function (entry) {
2185
+ const deserializeAws_json1_1Tags = (output, context) => {
2186
+ const retVal = (output || [])
2187
+ .filter((e) => e != null)
2188
+ .map((entry) => {
2441
2189
  if (entry === null) {
2442
2190
  return null;
2443
2191
  }
@@ -2445,12 +2193,12 @@ var deserializeAws_json1_1Tags = function (output, context) {
2445
2193
  });
2446
2194
  return retVal;
2447
2195
  };
2448
- var deserializeAws_json1_1TooManyTagsException = function (output, context) {
2196
+ const deserializeAws_json1_1TooManyTagsException = (output, context) => {
2449
2197
  return {
2450
2198
  message: __expectString(output.message),
2451
2199
  };
2452
2200
  };
2453
- var deserializeAws_json1_1UnableToDetectSchemaException = function (output, context) {
2201
+ const deserializeAws_json1_1UnableToDetectSchemaException = (output, context) => {
2454
2202
  return {
2455
2203
  ProcessedInputRecords: output.ProcessedInputRecords != null
2456
2204
  ? deserializeAws_json1_1ProcessedInputRecords(output.ProcessedInputRecords, context)
@@ -2461,86 +2209,63 @@ var deserializeAws_json1_1UnableToDetectSchemaException = function (output, cont
2461
2209
  message: __expectString(output.message),
2462
2210
  };
2463
2211
  };
2464
- var deserializeAws_json1_1UnsupportedOperationException = function (output, context) {
2212
+ const deserializeAws_json1_1UnsupportedOperationException = (output, context) => {
2465
2213
  return {
2466
2214
  message: __expectString(output.message),
2467
2215
  };
2468
2216
  };
2469
- var deserializeAws_json1_1UntagResourceResponse = function (output, context) {
2217
+ const deserializeAws_json1_1UntagResourceResponse = (output, context) => {
2470
2218
  return {};
2471
2219
  };
2472
- var deserializeAws_json1_1UpdateApplicationResponse = function (output, context) {
2220
+ const deserializeAws_json1_1UpdateApplicationResponse = (output, context) => {
2473
2221
  return {};
2474
2222
  };
2475
- var deserializeMetadata = function (output) {
2476
- var _a, _b;
2477
- return ({
2478
- httpStatusCode: output.statusCode,
2479
- requestId: (_b = (_a = output.headers["x-amzn-requestid"]) !== null && _a !== void 0 ? _a : output.headers["x-amzn-request-id"]) !== null && _b !== void 0 ? _b : output.headers["x-amz-request-id"],
2480
- extendedRequestId: output.headers["x-amz-id-2"],
2481
- cfId: output.headers["x-amz-cf-id"],
2482
- });
2483
- };
2484
- var collectBody = function (streamBody, context) {
2485
- if (streamBody === void 0) { streamBody = new Uint8Array(); }
2223
+ const deserializeMetadata = (output) => ({
2224
+ httpStatusCode: output.statusCode,
2225
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
2226
+ extendedRequestId: output.headers["x-amz-id-2"],
2227
+ cfId: output.headers["x-amz-cf-id"],
2228
+ });
2229
+ const collectBody = (streamBody = new Uint8Array(), context) => {
2486
2230
  if (streamBody instanceof Uint8Array) {
2487
2231
  return Promise.resolve(streamBody);
2488
2232
  }
2489
2233
  return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
2490
2234
  };
2491
- var collectBodyString = function (streamBody, context) {
2492
- return collectBody(streamBody, context).then(function (body) { return context.utf8Encoder(body); });
2493
- };
2494
- var buildHttpRpcRequest = function (context, headers, path, resolvedHostname, body) { return __awaiter(void 0, void 0, void 0, function () {
2495
- var _a, hostname, _b, protocol, port, basePath, contents;
2496
- return __generator(this, function (_c) {
2497
- switch (_c.label) {
2498
- case 0: return [4, context.endpoint()];
2499
- case 1:
2500
- _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
2501
- contents = {
2502
- protocol: protocol,
2503
- hostname: hostname,
2504
- port: port,
2505
- method: "POST",
2506
- path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
2507
- headers: headers,
2508
- };
2509
- if (resolvedHostname !== undefined) {
2510
- contents.hostname = resolvedHostname;
2511
- }
2512
- if (body !== undefined) {
2513
- contents.body = body;
2514
- }
2515
- return [2, new __HttpRequest(contents)];
2516
- }
2517
- });
2518
- }); };
2519
- var parseBody = function (streamBody, context) {
2520
- return collectBodyString(streamBody, context).then(function (encoded) {
2521
- if (encoded.length) {
2522
- return JSON.parse(encoded);
2523
- }
2524
- return {};
2525
- });
2235
+ const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
2236
+ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
2237
+ const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2238
+ const contents = {
2239
+ protocol,
2240
+ hostname,
2241
+ port,
2242
+ method: "POST",
2243
+ path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
2244
+ headers,
2245
+ };
2246
+ if (resolvedHostname !== undefined) {
2247
+ contents.hostname = resolvedHostname;
2248
+ }
2249
+ if (body !== undefined) {
2250
+ contents.body = body;
2251
+ }
2252
+ return new __HttpRequest(contents);
2526
2253
  };
2527
- var parseErrorBody = function (errorBody, context) { return __awaiter(void 0, void 0, void 0, function () {
2528
- var value;
2529
- var _a;
2530
- return __generator(this, function (_b) {
2531
- switch (_b.label) {
2532
- case 0: return [4, parseBody(errorBody, context)];
2533
- case 1:
2534
- value = _b.sent();
2535
- value.message = (_a = value.message) !== null && _a !== void 0 ? _a : value.Message;
2536
- return [2, value];
2537
- }
2538
- });
2539
- }); };
2540
- var loadRestJsonErrorCode = function (output, data) {
2541
- var findKey = function (object, key) { return Object.keys(object).find(function (k) { return k.toLowerCase() === key.toLowerCase(); }); };
2542
- var sanitizeErrorCode = function (rawValue) {
2543
- var cleanValue = rawValue;
2254
+ const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
2255
+ if (encoded.length) {
2256
+ return JSON.parse(encoded);
2257
+ }
2258
+ return {};
2259
+ });
2260
+ const parseErrorBody = async (errorBody, context) => {
2261
+ const value = await parseBody(errorBody, context);
2262
+ value.message = value.message ?? value.Message;
2263
+ return value;
2264
+ };
2265
+ const loadRestJsonErrorCode = (output, data) => {
2266
+ const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
2267
+ const sanitizeErrorCode = (rawValue) => {
2268
+ let cleanValue = rawValue;
2544
2269
  if (typeof cleanValue === "number") {
2545
2270
  cleanValue = cleanValue.toString();
2546
2271
  }
@@ -2555,7 +2280,7 @@ var loadRestJsonErrorCode = function (output, data) {
2555
2280
  }
2556
2281
  return cleanValue;
2557
2282
  };
2558
- var headerKey = findKey(output.headers, "x-amzn-errortype");
2283
+ const headerKey = findKey(output.headers, "x-amzn-errortype");
2559
2284
  if (headerKey !== undefined) {
2560
2285
  return sanitizeErrorCode(output.headers[headerKey]);
2561
2286
  }