@aws-sdk/client-data-pipeline 3.180.0 → 3.183.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 (35) hide show
  1. package/CHANGELOG.md +20 -0
  2. package/dist-cjs/protocols/Aws_json1_1.js +25 -19
  3. package/dist-es/DataPipeline.js +78 -85
  4. package/dist-es/DataPipelineClient.js +22 -28
  5. package/dist-es/commands/ActivatePipelineCommand.js +21 -28
  6. package/dist-es/commands/AddTagsCommand.js +21 -28
  7. package/dist-es/commands/CreatePipelineCommand.js +21 -28
  8. package/dist-es/commands/DeactivatePipelineCommand.js +21 -28
  9. package/dist-es/commands/DeletePipelineCommand.js +22 -29
  10. package/dist-es/commands/DescribeObjectsCommand.js +21 -28
  11. package/dist-es/commands/DescribePipelinesCommand.js +21 -28
  12. package/dist-es/commands/EvaluateExpressionCommand.js +21 -28
  13. package/dist-es/commands/GetPipelineDefinitionCommand.js +21 -28
  14. package/dist-es/commands/ListPipelinesCommand.js +21 -28
  15. package/dist-es/commands/PollForTaskCommand.js +21 -28
  16. package/dist-es/commands/PutPipelineDefinitionCommand.js +21 -28
  17. package/dist-es/commands/QueryObjectsCommand.js +21 -28
  18. package/dist-es/commands/RemoveTagsCommand.js +21 -28
  19. package/dist-es/commands/ReportTaskProgressCommand.js +21 -28
  20. package/dist-es/commands/ReportTaskRunnerHeartbeatCommand.js +21 -28
  21. package/dist-es/commands/SetStatusCommand.js +22 -29
  22. package/dist-es/commands/SetTaskStatusCommand.js +21 -28
  23. package/dist-es/commands/ValidatePipelineDefinitionCommand.js +21 -28
  24. package/dist-es/endpoints.js +8 -8
  25. package/dist-es/models/DataPipelineServiceException.js +5 -10
  26. package/dist-es/models/models_0.js +208 -107
  27. package/dist-es/pagination/DescribeObjectsPaginator.js +24 -67
  28. package/dist-es/pagination/ListPipelinesPaginator.js +24 -67
  29. package/dist-es/pagination/QueryObjectsPaginator.js +25 -68
  30. package/dist-es/protocols/Aws_json1_1.js +1323 -1667
  31. package/dist-es/runtimeConfig.browser.js +26 -12
  32. package/dist-es/runtimeConfig.js +30 -12
  33. package/dist-es/runtimeConfig.native.js +8 -5
  34. package/dist-es/runtimeConfig.shared.js +8 -11
  35. package/package.json +33 -33
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -1,1622 +1,1287 @@
1
- import { __assign, __awaiter, __generator, __read } from "tslib";
2
1
  import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
3
2
  import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectString as __expectString, throwDefaultError, } from "@aws-sdk/smithy-client";
4
3
  import { DataPipelineServiceException as __BaseException } from "../models/DataPipelineServiceException";
5
4
  import { InternalServiceError, InvalidRequestException, PipelineDeletedException, PipelineNotFoundException, TaskNotFoundException, } from "../models/models_0";
6
- export var serializeAws_json1_1ActivatePipelineCommand = 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": "DataPipeline.ActivatePipeline",
12
- };
13
- body = JSON.stringify(serializeAws_json1_1ActivatePipelineInput(input, context));
14
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
15
- });
16
- }); };
17
- export var serializeAws_json1_1AddTagsCommand = 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": "DataPipeline.AddTags",
23
- };
24
- body = JSON.stringify(serializeAws_json1_1AddTagsInput(input, context));
25
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
26
- });
27
- }); };
28
- export var serializeAws_json1_1CreatePipelineCommand = 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": "DataPipeline.CreatePipeline",
34
- };
35
- body = JSON.stringify(serializeAws_json1_1CreatePipelineInput(input, context));
36
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
37
- });
38
- }); };
39
- export var serializeAws_json1_1DeactivatePipelineCommand = 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": "DataPipeline.DeactivatePipeline",
45
- };
46
- body = JSON.stringify(serializeAws_json1_1DeactivatePipelineInput(input, context));
47
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
48
- });
49
- }); };
50
- export var serializeAws_json1_1DeletePipelineCommand = 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": "DataPipeline.DeletePipeline",
56
- };
57
- body = JSON.stringify(serializeAws_json1_1DeletePipelineInput(input, context));
58
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
59
- });
60
- }); };
61
- export var serializeAws_json1_1DescribeObjectsCommand = 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": "DataPipeline.DescribeObjects",
67
- };
68
- body = JSON.stringify(serializeAws_json1_1DescribeObjectsInput(input, context));
69
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
70
- });
71
- }); };
72
- export var serializeAws_json1_1DescribePipelinesCommand = 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": "DataPipeline.DescribePipelines",
78
- };
79
- body = JSON.stringify(serializeAws_json1_1DescribePipelinesInput(input, context));
80
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
81
- });
82
- }); };
83
- export var serializeAws_json1_1EvaluateExpressionCommand = 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": "DataPipeline.EvaluateExpression",
89
- };
90
- body = JSON.stringify(serializeAws_json1_1EvaluateExpressionInput(input, context));
91
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
92
- });
93
- }); };
94
- export var serializeAws_json1_1GetPipelineDefinitionCommand = 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": "DataPipeline.GetPipelineDefinition",
100
- };
101
- body = JSON.stringify(serializeAws_json1_1GetPipelineDefinitionInput(input, context));
102
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
103
- });
104
- }); };
105
- export var serializeAws_json1_1ListPipelinesCommand = 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": "DataPipeline.ListPipelines",
111
- };
112
- body = JSON.stringify(serializeAws_json1_1ListPipelinesInput(input, context));
113
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
114
- });
115
- }); };
116
- export var serializeAws_json1_1PollForTaskCommand = 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": "DataPipeline.PollForTask",
122
- };
123
- body = JSON.stringify(serializeAws_json1_1PollForTaskInput(input, context));
124
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
125
- });
126
- }); };
127
- export var serializeAws_json1_1PutPipelineDefinitionCommand = 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": "DataPipeline.PutPipelineDefinition",
133
- };
134
- body = JSON.stringify(serializeAws_json1_1PutPipelineDefinitionInput(input, context));
135
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
136
- });
137
- }); };
138
- export var serializeAws_json1_1QueryObjectsCommand = 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": "DataPipeline.QueryObjects",
144
- };
145
- body = JSON.stringify(serializeAws_json1_1QueryObjectsInput(input, context));
146
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
147
- });
148
- }); };
149
- export var serializeAws_json1_1RemoveTagsCommand = 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": "DataPipeline.RemoveTags",
155
- };
156
- body = JSON.stringify(serializeAws_json1_1RemoveTagsInput(input, context));
157
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
158
- });
159
- }); };
160
- export var serializeAws_json1_1ReportTaskProgressCommand = 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": "DataPipeline.ReportTaskProgress",
166
- };
167
- body = JSON.stringify(serializeAws_json1_1ReportTaskProgressInput(input, context));
168
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
169
- });
170
- }); };
171
- export var serializeAws_json1_1ReportTaskRunnerHeartbeatCommand = 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": "DataPipeline.ReportTaskRunnerHeartbeat",
177
- };
178
- body = JSON.stringify(serializeAws_json1_1ReportTaskRunnerHeartbeatInput(input, context));
179
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
180
- });
181
- }); };
182
- export var serializeAws_json1_1SetStatusCommand = 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": "DataPipeline.SetStatus",
188
- };
189
- body = JSON.stringify(serializeAws_json1_1SetStatusInput(input, context));
190
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
191
- });
192
- }); };
193
- export var serializeAws_json1_1SetTaskStatusCommand = 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": "DataPipeline.SetTaskStatus",
199
- };
200
- body = JSON.stringify(serializeAws_json1_1SetTaskStatusInput(input, context));
201
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
202
- });
203
- }); };
204
- export var serializeAws_json1_1ValidatePipelineDefinitionCommand = 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": "DataPipeline.ValidatePipelineDefinition",
210
- };
211
- body = JSON.stringify(serializeAws_json1_1ValidatePipelineDefinitionInput(input, context));
212
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
213
- });
214
- }); };
215
- export var deserializeAws_json1_1ActivatePipelineCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
216
- var data, contents, response;
217
- return __generator(this, function (_a) {
218
- switch (_a.label) {
219
- case 0:
220
- if (output.statusCode >= 300) {
221
- return [2, deserializeAws_json1_1ActivatePipelineCommandError(output, context)];
222
- }
223
- return [4, parseBody(output.body, context)];
224
- case 1:
225
- data = _a.sent();
226
- contents = {};
227
- contents = deserializeAws_json1_1ActivatePipelineOutput(data, context);
228
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
229
- return [2, Promise.resolve(response)];
230
- }
231
- });
232
- }); };
233
- var deserializeAws_json1_1ActivatePipelineCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
234
- var parsedOutput, _a, errorCode, _b, parsedBody;
235
- var _c;
236
- return __generator(this, function (_d) {
237
- switch (_d.label) {
238
- case 0:
239
- _a = [__assign({}, output)];
240
- _c = {};
241
- return [4, parseBody(output.body, context)];
242
- case 1:
243
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
244
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
245
- _b = errorCode;
246
- switch (_b) {
247
- case "InternalServiceError": return [3, 2];
248
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
249
- case "InvalidRequestException": return [3, 4];
250
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
251
- case "PipelineDeletedException": return [3, 6];
252
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
253
- case "PipelineNotFoundException": return [3, 8];
254
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
255
- }
256
- return [3, 10];
257
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
258
- case 3: throw _d.sent();
259
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
260
- case 5: throw _d.sent();
261
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
262
- case 7: throw _d.sent();
263
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
264
- case 9: throw _d.sent();
265
- case 10:
266
- parsedBody = parsedOutput.body;
267
- throwDefaultError({
268
- output: output,
269
- parsedBody: parsedBody,
270
- exceptionCtor: __BaseException,
271
- errorCode: errorCode,
272
- });
273
- _d.label = 11;
274
- case 11: return [2];
275
- }
276
- });
277
- }); };
278
- export var deserializeAws_json1_1AddTagsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
279
- var data, contents, response;
280
- return __generator(this, function (_a) {
281
- switch (_a.label) {
282
- case 0:
283
- if (output.statusCode >= 300) {
284
- return [2, deserializeAws_json1_1AddTagsCommandError(output, context)];
285
- }
286
- return [4, parseBody(output.body, context)];
287
- case 1:
288
- data = _a.sent();
289
- contents = {};
290
- contents = deserializeAws_json1_1AddTagsOutput(data, context);
291
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
292
- return [2, Promise.resolve(response)];
293
- }
294
- });
295
- }); };
296
- var deserializeAws_json1_1AddTagsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
297
- var parsedOutput, _a, errorCode, _b, parsedBody;
298
- var _c;
299
- return __generator(this, function (_d) {
300
- switch (_d.label) {
301
- case 0:
302
- _a = [__assign({}, output)];
303
- _c = {};
304
- return [4, parseBody(output.body, context)];
305
- case 1:
306
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
307
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
308
- _b = errorCode;
309
- switch (_b) {
310
- case "InternalServiceError": return [3, 2];
311
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
312
- case "InvalidRequestException": return [3, 4];
313
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
314
- case "PipelineDeletedException": return [3, 6];
315
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
316
- case "PipelineNotFoundException": return [3, 8];
317
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
318
- }
319
- return [3, 10];
320
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
321
- case 3: throw _d.sent();
322
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
323
- case 5: throw _d.sent();
324
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
325
- case 7: throw _d.sent();
326
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
327
- case 9: throw _d.sent();
328
- case 10:
329
- parsedBody = parsedOutput.body;
330
- throwDefaultError({
331
- output: output,
332
- parsedBody: parsedBody,
333
- exceptionCtor: __BaseException,
334
- errorCode: errorCode,
335
- });
336
- _d.label = 11;
337
- case 11: return [2];
338
- }
339
- });
340
- }); };
341
- export var deserializeAws_json1_1CreatePipelineCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
342
- var data, contents, response;
343
- return __generator(this, function (_a) {
344
- switch (_a.label) {
345
- case 0:
346
- if (output.statusCode >= 300) {
347
- return [2, deserializeAws_json1_1CreatePipelineCommandError(output, context)];
348
- }
349
- return [4, parseBody(output.body, context)];
350
- case 1:
351
- data = _a.sent();
352
- contents = {};
353
- contents = deserializeAws_json1_1CreatePipelineOutput(data, context);
354
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
355
- return [2, Promise.resolve(response)];
356
- }
357
- });
358
- }); };
359
- var deserializeAws_json1_1CreatePipelineCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
360
- var parsedOutput, _a, errorCode, _b, parsedBody;
361
- var _c;
362
- return __generator(this, function (_d) {
363
- switch (_d.label) {
364
- case 0:
365
- _a = [__assign({}, output)];
366
- _c = {};
367
- return [4, parseBody(output.body, context)];
368
- case 1:
369
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
370
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
371
- _b = errorCode;
372
- switch (_b) {
373
- case "InternalServiceError": return [3, 2];
374
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
375
- case "InvalidRequestException": return [3, 4];
376
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
377
- }
378
- return [3, 6];
379
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
380
- case 3: throw _d.sent();
381
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
382
- case 5: throw _d.sent();
383
- case 6:
384
- parsedBody = parsedOutput.body;
385
- throwDefaultError({
386
- output: output,
387
- parsedBody: parsedBody,
388
- exceptionCtor: __BaseException,
389
- errorCode: errorCode,
390
- });
391
- _d.label = 7;
392
- case 7: return [2];
393
- }
394
- });
395
- }); };
396
- export var deserializeAws_json1_1DeactivatePipelineCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
397
- var data, contents, response;
398
- return __generator(this, function (_a) {
399
- switch (_a.label) {
400
- case 0:
401
- if (output.statusCode >= 300) {
402
- return [2, deserializeAws_json1_1DeactivatePipelineCommandError(output, context)];
403
- }
404
- return [4, parseBody(output.body, context)];
405
- case 1:
406
- data = _a.sent();
407
- contents = {};
408
- contents = deserializeAws_json1_1DeactivatePipelineOutput(data, context);
409
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
410
- return [2, Promise.resolve(response)];
411
- }
412
- });
413
- }); };
414
- var deserializeAws_json1_1DeactivatePipelineCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
415
- var parsedOutput, _a, errorCode, _b, parsedBody;
416
- var _c;
417
- return __generator(this, function (_d) {
418
- switch (_d.label) {
419
- case 0:
420
- _a = [__assign({}, output)];
421
- _c = {};
422
- return [4, parseBody(output.body, context)];
423
- case 1:
424
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
425
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
426
- _b = errorCode;
427
- switch (_b) {
428
- case "InternalServiceError": return [3, 2];
429
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
430
- case "InvalidRequestException": return [3, 4];
431
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
432
- case "PipelineDeletedException": return [3, 6];
433
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
434
- case "PipelineNotFoundException": return [3, 8];
435
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
436
- }
437
- return [3, 10];
438
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
439
- case 3: throw _d.sent();
440
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
441
- case 5: throw _d.sent();
442
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
443
- case 7: throw _d.sent();
444
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
445
- case 9: throw _d.sent();
446
- case 10:
447
- parsedBody = parsedOutput.body;
448
- throwDefaultError({
449
- output: output,
450
- parsedBody: parsedBody,
451
- exceptionCtor: __BaseException,
452
- errorCode: errorCode,
453
- });
454
- _d.label = 11;
455
- case 11: return [2];
456
- }
457
- });
458
- }); };
459
- export var deserializeAws_json1_1DeletePipelineCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
460
- var response;
461
- return __generator(this, function (_a) {
462
- switch (_a.label) {
463
- case 0:
464
- if (output.statusCode >= 300) {
465
- return [2, deserializeAws_json1_1DeletePipelineCommandError(output, context)];
466
- }
467
- return [4, collectBody(output.body, context)];
468
- case 1:
469
- _a.sent();
470
- response = {
471
- $metadata: deserializeMetadata(output),
472
- };
473
- return [2, Promise.resolve(response)];
474
- }
475
- });
476
- }); };
477
- var deserializeAws_json1_1DeletePipelineCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
478
- var parsedOutput, _a, errorCode, _b, parsedBody;
479
- var _c;
480
- return __generator(this, function (_d) {
481
- switch (_d.label) {
482
- case 0:
483
- _a = [__assign({}, output)];
484
- _c = {};
485
- return [4, parseBody(output.body, context)];
486
- case 1:
487
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
488
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
489
- _b = errorCode;
490
- switch (_b) {
491
- case "InternalServiceError": return [3, 2];
492
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
493
- case "InvalidRequestException": return [3, 4];
494
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
495
- case "PipelineNotFoundException": return [3, 6];
496
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 6];
497
- }
498
- return [3, 8];
499
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
500
- case 3: throw _d.sent();
501
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
502
- case 5: throw _d.sent();
503
- case 6: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
504
- case 7: throw _d.sent();
505
- case 8:
506
- parsedBody = parsedOutput.body;
507
- throwDefaultError({
508
- output: output,
509
- parsedBody: parsedBody,
510
- exceptionCtor: __BaseException,
511
- errorCode: errorCode,
512
- });
513
- _d.label = 9;
514
- case 9: return [2];
515
- }
516
- });
517
- }); };
518
- export var deserializeAws_json1_1DescribeObjectsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
519
- var data, contents, response;
520
- return __generator(this, function (_a) {
521
- switch (_a.label) {
522
- case 0:
523
- if (output.statusCode >= 300) {
524
- return [2, deserializeAws_json1_1DescribeObjectsCommandError(output, context)];
525
- }
526
- return [4, parseBody(output.body, context)];
527
- case 1:
528
- data = _a.sent();
529
- contents = {};
530
- contents = deserializeAws_json1_1DescribeObjectsOutput(data, context);
531
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
532
- return [2, Promise.resolve(response)];
533
- }
534
- });
535
- }); };
536
- var deserializeAws_json1_1DescribeObjectsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
537
- var parsedOutput, _a, errorCode, _b, parsedBody;
538
- var _c;
539
- return __generator(this, function (_d) {
540
- switch (_d.label) {
541
- case 0:
542
- _a = [__assign({}, output)];
543
- _c = {};
544
- return [4, parseBody(output.body, context)];
545
- case 1:
546
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
547
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
548
- _b = errorCode;
549
- switch (_b) {
550
- case "InternalServiceError": return [3, 2];
551
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
552
- case "InvalidRequestException": return [3, 4];
553
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
554
- case "PipelineDeletedException": return [3, 6];
555
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
556
- case "PipelineNotFoundException": return [3, 8];
557
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
558
- }
559
- return [3, 10];
560
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
561
- case 3: throw _d.sent();
562
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
563
- case 5: throw _d.sent();
564
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
565
- case 7: throw _d.sent();
566
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
567
- case 9: throw _d.sent();
568
- case 10:
569
- parsedBody = parsedOutput.body;
570
- throwDefaultError({
571
- output: output,
572
- parsedBody: parsedBody,
573
- exceptionCtor: __BaseException,
574
- errorCode: errorCode,
575
- });
576
- _d.label = 11;
577
- case 11: return [2];
578
- }
579
- });
580
- }); };
581
- export var deserializeAws_json1_1DescribePipelinesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
582
- var data, contents, response;
583
- return __generator(this, function (_a) {
584
- switch (_a.label) {
585
- case 0:
586
- if (output.statusCode >= 300) {
587
- return [2, deserializeAws_json1_1DescribePipelinesCommandError(output, context)];
588
- }
589
- return [4, parseBody(output.body, context)];
590
- case 1:
591
- data = _a.sent();
592
- contents = {};
593
- contents = deserializeAws_json1_1DescribePipelinesOutput(data, context);
594
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
595
- return [2, Promise.resolve(response)];
596
- }
597
- });
598
- }); };
599
- var deserializeAws_json1_1DescribePipelinesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
600
- var parsedOutput, _a, errorCode, _b, parsedBody;
601
- var _c;
602
- return __generator(this, function (_d) {
603
- switch (_d.label) {
604
- case 0:
605
- _a = [__assign({}, output)];
606
- _c = {};
607
- return [4, parseBody(output.body, context)];
608
- case 1:
609
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
610
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
611
- _b = errorCode;
612
- switch (_b) {
613
- case "InternalServiceError": return [3, 2];
614
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
615
- case "InvalidRequestException": return [3, 4];
616
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
617
- case "PipelineDeletedException": return [3, 6];
618
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
619
- case "PipelineNotFoundException": return [3, 8];
620
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
621
- }
622
- return [3, 10];
623
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
624
- case 3: throw _d.sent();
625
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
626
- case 5: throw _d.sent();
627
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
628
- case 7: throw _d.sent();
629
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
630
- case 9: throw _d.sent();
631
- case 10:
632
- parsedBody = parsedOutput.body;
633
- throwDefaultError({
634
- output: output,
635
- parsedBody: parsedBody,
636
- exceptionCtor: __BaseException,
637
- errorCode: errorCode,
638
- });
639
- _d.label = 11;
640
- case 11: return [2];
641
- }
642
- });
643
- }); };
644
- export var deserializeAws_json1_1EvaluateExpressionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
645
- var data, contents, response;
646
- return __generator(this, function (_a) {
647
- switch (_a.label) {
648
- case 0:
649
- if (output.statusCode >= 300) {
650
- return [2, deserializeAws_json1_1EvaluateExpressionCommandError(output, context)];
651
- }
652
- return [4, parseBody(output.body, context)];
653
- case 1:
654
- data = _a.sent();
655
- contents = {};
656
- contents = deserializeAws_json1_1EvaluateExpressionOutput(data, context);
657
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
658
- return [2, Promise.resolve(response)];
659
- }
660
- });
661
- }); };
662
- var deserializeAws_json1_1EvaluateExpressionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
663
- var parsedOutput, _a, errorCode, _b, parsedBody;
664
- var _c;
665
- return __generator(this, function (_d) {
666
- switch (_d.label) {
667
- case 0:
668
- _a = [__assign({}, output)];
669
- _c = {};
670
- return [4, parseBody(output.body, context)];
671
- case 1:
672
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
673
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
674
- _b = errorCode;
675
- switch (_b) {
676
- case "InternalServiceError": return [3, 2];
677
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
678
- case "InvalidRequestException": return [3, 4];
679
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
680
- case "PipelineDeletedException": return [3, 6];
681
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
682
- case "PipelineNotFoundException": return [3, 8];
683
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
684
- case "TaskNotFoundException": return [3, 10];
685
- case "com.amazonaws.datapipeline#TaskNotFoundException": return [3, 10];
686
- }
687
- return [3, 12];
688
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
689
- case 3: throw _d.sent();
690
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
691
- case 5: throw _d.sent();
692
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
693
- case 7: throw _d.sent();
694
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
695
- case 9: throw _d.sent();
696
- case 10: return [4, deserializeAws_json1_1TaskNotFoundExceptionResponse(parsedOutput, context)];
697
- case 11: throw _d.sent();
698
- case 12:
699
- parsedBody = parsedOutput.body;
700
- throwDefaultError({
701
- output: output,
702
- parsedBody: parsedBody,
703
- exceptionCtor: __BaseException,
704
- errorCode: errorCode,
705
- });
706
- _d.label = 13;
707
- case 13: return [2];
708
- }
709
- });
710
- }); };
711
- export var deserializeAws_json1_1GetPipelineDefinitionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
712
- var data, contents, response;
713
- return __generator(this, function (_a) {
714
- switch (_a.label) {
715
- case 0:
716
- if (output.statusCode >= 300) {
717
- return [2, deserializeAws_json1_1GetPipelineDefinitionCommandError(output, context)];
718
- }
719
- return [4, parseBody(output.body, context)];
720
- case 1:
721
- data = _a.sent();
722
- contents = {};
723
- contents = deserializeAws_json1_1GetPipelineDefinitionOutput(data, context);
724
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
725
- return [2, Promise.resolve(response)];
726
- }
727
- });
728
- }); };
729
- var deserializeAws_json1_1GetPipelineDefinitionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
730
- var parsedOutput, _a, errorCode, _b, parsedBody;
731
- var _c;
732
- return __generator(this, function (_d) {
733
- switch (_d.label) {
734
- case 0:
735
- _a = [__assign({}, output)];
736
- _c = {};
737
- return [4, parseBody(output.body, context)];
738
- case 1:
739
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
740
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
741
- _b = errorCode;
742
- switch (_b) {
743
- case "InternalServiceError": return [3, 2];
744
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
745
- case "InvalidRequestException": return [3, 4];
746
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
747
- case "PipelineDeletedException": return [3, 6];
748
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
749
- case "PipelineNotFoundException": return [3, 8];
750
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
751
- }
752
- return [3, 10];
753
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
754
- case 3: throw _d.sent();
755
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
756
- case 5: throw _d.sent();
757
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
758
- case 7: throw _d.sent();
759
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
760
- case 9: throw _d.sent();
761
- case 10:
762
- parsedBody = parsedOutput.body;
763
- throwDefaultError({
764
- output: output,
765
- parsedBody: parsedBody,
766
- exceptionCtor: __BaseException,
767
- errorCode: errorCode,
768
- });
769
- _d.label = 11;
770
- case 11: return [2];
771
- }
772
- });
773
- }); };
774
- export var deserializeAws_json1_1ListPipelinesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
775
- var data, contents, response;
776
- return __generator(this, function (_a) {
777
- switch (_a.label) {
778
- case 0:
779
- if (output.statusCode >= 300) {
780
- return [2, deserializeAws_json1_1ListPipelinesCommandError(output, context)];
781
- }
782
- return [4, parseBody(output.body, context)];
783
- case 1:
784
- data = _a.sent();
785
- contents = {};
786
- contents = deserializeAws_json1_1ListPipelinesOutput(data, context);
787
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
788
- return [2, Promise.resolve(response)];
789
- }
790
- });
791
- }); };
792
- var deserializeAws_json1_1ListPipelinesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
793
- var parsedOutput, _a, errorCode, _b, parsedBody;
794
- var _c;
795
- return __generator(this, function (_d) {
796
- switch (_d.label) {
797
- case 0:
798
- _a = [__assign({}, output)];
799
- _c = {};
800
- return [4, parseBody(output.body, context)];
801
- case 1:
802
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
803
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
804
- _b = errorCode;
805
- switch (_b) {
806
- case "InternalServiceError": return [3, 2];
807
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
808
- case "InvalidRequestException": return [3, 4];
809
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
810
- }
811
- return [3, 6];
812
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
813
- case 3: throw _d.sent();
814
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
815
- case 5: throw _d.sent();
816
- case 6:
817
- parsedBody = parsedOutput.body;
818
- throwDefaultError({
819
- output: output,
820
- parsedBody: parsedBody,
821
- exceptionCtor: __BaseException,
822
- errorCode: errorCode,
823
- });
824
- _d.label = 7;
825
- case 7: return [2];
826
- }
827
- });
828
- }); };
829
- export var deserializeAws_json1_1PollForTaskCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
830
- var data, contents, response;
831
- return __generator(this, function (_a) {
832
- switch (_a.label) {
833
- case 0:
834
- if (output.statusCode >= 300) {
835
- return [2, deserializeAws_json1_1PollForTaskCommandError(output, context)];
836
- }
837
- return [4, parseBody(output.body, context)];
838
- case 1:
839
- data = _a.sent();
840
- contents = {};
841
- contents = deserializeAws_json1_1PollForTaskOutput(data, context);
842
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
843
- return [2, Promise.resolve(response)];
844
- }
845
- });
846
- }); };
847
- var deserializeAws_json1_1PollForTaskCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
848
- var parsedOutput, _a, errorCode, _b, parsedBody;
849
- var _c;
850
- return __generator(this, function (_d) {
851
- switch (_d.label) {
852
- case 0:
853
- _a = [__assign({}, output)];
854
- _c = {};
855
- return [4, parseBody(output.body, context)];
856
- case 1:
857
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
858
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
859
- _b = errorCode;
860
- switch (_b) {
861
- case "InternalServiceError": return [3, 2];
862
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
863
- case "InvalidRequestException": return [3, 4];
864
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
865
- case "TaskNotFoundException": return [3, 6];
866
- case "com.amazonaws.datapipeline#TaskNotFoundException": return [3, 6];
867
- }
868
- return [3, 8];
869
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
870
- case 3: throw _d.sent();
871
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
872
- case 5: throw _d.sent();
873
- case 6: return [4, deserializeAws_json1_1TaskNotFoundExceptionResponse(parsedOutput, context)];
874
- case 7: throw _d.sent();
875
- case 8:
876
- parsedBody = parsedOutput.body;
877
- throwDefaultError({
878
- output: output,
879
- parsedBody: parsedBody,
880
- exceptionCtor: __BaseException,
881
- errorCode: errorCode,
882
- });
883
- _d.label = 9;
884
- case 9: return [2];
885
- }
886
- });
887
- }); };
888
- export var deserializeAws_json1_1PutPipelineDefinitionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
889
- var data, contents, response;
890
- return __generator(this, function (_a) {
891
- switch (_a.label) {
892
- case 0:
893
- if (output.statusCode >= 300) {
894
- return [2, deserializeAws_json1_1PutPipelineDefinitionCommandError(output, context)];
895
- }
896
- return [4, parseBody(output.body, context)];
897
- case 1:
898
- data = _a.sent();
899
- contents = {};
900
- contents = deserializeAws_json1_1PutPipelineDefinitionOutput(data, context);
901
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
902
- return [2, Promise.resolve(response)];
903
- }
904
- });
905
- }); };
906
- var deserializeAws_json1_1PutPipelineDefinitionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
907
- var parsedOutput, _a, errorCode, _b, parsedBody;
908
- var _c;
909
- return __generator(this, function (_d) {
910
- switch (_d.label) {
911
- case 0:
912
- _a = [__assign({}, output)];
913
- _c = {};
914
- return [4, parseBody(output.body, context)];
915
- case 1:
916
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
917
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
918
- _b = errorCode;
919
- switch (_b) {
920
- case "InternalServiceError": return [3, 2];
921
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
922
- case "InvalidRequestException": return [3, 4];
923
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
924
- case "PipelineDeletedException": return [3, 6];
925
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
926
- case "PipelineNotFoundException": return [3, 8];
927
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
928
- }
929
- return [3, 10];
930
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
931
- case 3: throw _d.sent();
932
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
933
- case 5: throw _d.sent();
934
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
935
- case 7: throw _d.sent();
936
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
937
- case 9: throw _d.sent();
938
- case 10:
939
- parsedBody = parsedOutput.body;
940
- throwDefaultError({
941
- output: output,
942
- parsedBody: parsedBody,
943
- exceptionCtor: __BaseException,
944
- errorCode: errorCode,
945
- });
946
- _d.label = 11;
947
- case 11: return [2];
948
- }
949
- });
950
- }); };
951
- export var deserializeAws_json1_1QueryObjectsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
952
- var data, contents, response;
953
- return __generator(this, function (_a) {
954
- switch (_a.label) {
955
- case 0:
956
- if (output.statusCode >= 300) {
957
- return [2, deserializeAws_json1_1QueryObjectsCommandError(output, context)];
958
- }
959
- return [4, parseBody(output.body, context)];
960
- case 1:
961
- data = _a.sent();
962
- contents = {};
963
- contents = deserializeAws_json1_1QueryObjectsOutput(data, context);
964
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
965
- return [2, Promise.resolve(response)];
966
- }
967
- });
968
- }); };
969
- var deserializeAws_json1_1QueryObjectsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
970
- var parsedOutput, _a, errorCode, _b, parsedBody;
971
- var _c;
972
- return __generator(this, function (_d) {
973
- switch (_d.label) {
974
- case 0:
975
- _a = [__assign({}, output)];
976
- _c = {};
977
- return [4, parseBody(output.body, context)];
978
- case 1:
979
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
980
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
981
- _b = errorCode;
982
- switch (_b) {
983
- case "InternalServiceError": return [3, 2];
984
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
985
- case "InvalidRequestException": return [3, 4];
986
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
987
- case "PipelineDeletedException": return [3, 6];
988
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
989
- case "PipelineNotFoundException": return [3, 8];
990
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
991
- }
992
- return [3, 10];
993
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
994
- case 3: throw _d.sent();
995
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
996
- case 5: throw _d.sent();
997
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
998
- case 7: throw _d.sent();
999
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
1000
- case 9: throw _d.sent();
1001
- case 10:
1002
- parsedBody = parsedOutput.body;
1003
- throwDefaultError({
1004
- output: output,
1005
- parsedBody: parsedBody,
1006
- exceptionCtor: __BaseException,
1007
- errorCode: errorCode,
1008
- });
1009
- _d.label = 11;
1010
- case 11: return [2];
1011
- }
1012
- });
1013
- }); };
1014
- export var deserializeAws_json1_1RemoveTagsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1015
- var data, contents, response;
1016
- return __generator(this, function (_a) {
1017
- switch (_a.label) {
1018
- case 0:
1019
- if (output.statusCode >= 300) {
1020
- return [2, deserializeAws_json1_1RemoveTagsCommandError(output, context)];
1021
- }
1022
- return [4, parseBody(output.body, context)];
1023
- case 1:
1024
- data = _a.sent();
1025
- contents = {};
1026
- contents = deserializeAws_json1_1RemoveTagsOutput(data, context);
1027
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1028
- return [2, Promise.resolve(response)];
1029
- }
1030
- });
1031
- }); };
1032
- var deserializeAws_json1_1RemoveTagsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1033
- var parsedOutput, _a, errorCode, _b, parsedBody;
1034
- var _c;
1035
- return __generator(this, function (_d) {
1036
- switch (_d.label) {
1037
- case 0:
1038
- _a = [__assign({}, output)];
1039
- _c = {};
1040
- return [4, parseBody(output.body, context)];
1041
- case 1:
1042
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1043
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1044
- _b = errorCode;
1045
- switch (_b) {
1046
- case "InternalServiceError": return [3, 2];
1047
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
1048
- case "InvalidRequestException": return [3, 4];
1049
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
1050
- case "PipelineDeletedException": return [3, 6];
1051
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
1052
- case "PipelineNotFoundException": return [3, 8];
1053
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
1054
- }
1055
- return [3, 10];
1056
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
1057
- case 3: throw _d.sent();
1058
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
1059
- case 5: throw _d.sent();
1060
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
1061
- case 7: throw _d.sent();
1062
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
1063
- case 9: throw _d.sent();
1064
- case 10:
1065
- parsedBody = parsedOutput.body;
1066
- throwDefaultError({
1067
- output: output,
1068
- parsedBody: parsedBody,
1069
- exceptionCtor: __BaseException,
1070
- errorCode: errorCode,
1071
- });
1072
- _d.label = 11;
1073
- case 11: return [2];
1074
- }
1075
- });
1076
- }); };
1077
- export var deserializeAws_json1_1ReportTaskProgressCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1078
- var data, contents, response;
1079
- return __generator(this, function (_a) {
1080
- switch (_a.label) {
1081
- case 0:
1082
- if (output.statusCode >= 300) {
1083
- return [2, deserializeAws_json1_1ReportTaskProgressCommandError(output, context)];
1084
- }
1085
- return [4, parseBody(output.body, context)];
1086
- case 1:
1087
- data = _a.sent();
1088
- contents = {};
1089
- contents = deserializeAws_json1_1ReportTaskProgressOutput(data, context);
1090
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1091
- return [2, Promise.resolve(response)];
1092
- }
1093
- });
1094
- }); };
1095
- var deserializeAws_json1_1ReportTaskProgressCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1096
- var parsedOutput, _a, errorCode, _b, parsedBody;
1097
- var _c;
1098
- return __generator(this, function (_d) {
1099
- switch (_d.label) {
1100
- case 0:
1101
- _a = [__assign({}, output)];
1102
- _c = {};
1103
- return [4, parseBody(output.body, context)];
1104
- case 1:
1105
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1106
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1107
- _b = errorCode;
1108
- switch (_b) {
1109
- case "InternalServiceError": return [3, 2];
1110
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
1111
- case "InvalidRequestException": return [3, 4];
1112
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
1113
- case "PipelineDeletedException": return [3, 6];
1114
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
1115
- case "PipelineNotFoundException": return [3, 8];
1116
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
1117
- case "TaskNotFoundException": return [3, 10];
1118
- case "com.amazonaws.datapipeline#TaskNotFoundException": return [3, 10];
1119
- }
1120
- return [3, 12];
1121
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
1122
- case 3: throw _d.sent();
1123
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
1124
- case 5: throw _d.sent();
1125
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
1126
- case 7: throw _d.sent();
1127
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
1128
- case 9: throw _d.sent();
1129
- case 10: return [4, deserializeAws_json1_1TaskNotFoundExceptionResponse(parsedOutput, context)];
1130
- case 11: throw _d.sent();
1131
- case 12:
1132
- parsedBody = parsedOutput.body;
1133
- throwDefaultError({
1134
- output: output,
1135
- parsedBody: parsedBody,
1136
- exceptionCtor: __BaseException,
1137
- errorCode: errorCode,
1138
- });
1139
- _d.label = 13;
1140
- case 13: return [2];
1141
- }
1142
- });
1143
- }); };
1144
- export var deserializeAws_json1_1ReportTaskRunnerHeartbeatCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1145
- var data, contents, response;
1146
- return __generator(this, function (_a) {
1147
- switch (_a.label) {
1148
- case 0:
1149
- if (output.statusCode >= 300) {
1150
- return [2, deserializeAws_json1_1ReportTaskRunnerHeartbeatCommandError(output, context)];
1151
- }
1152
- return [4, parseBody(output.body, context)];
1153
- case 1:
1154
- data = _a.sent();
1155
- contents = {};
1156
- contents = deserializeAws_json1_1ReportTaskRunnerHeartbeatOutput(data, context);
1157
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1158
- return [2, Promise.resolve(response)];
1159
- }
1160
- });
1161
- }); };
1162
- var deserializeAws_json1_1ReportTaskRunnerHeartbeatCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1163
- var parsedOutput, _a, errorCode, _b, parsedBody;
1164
- var _c;
1165
- return __generator(this, function (_d) {
1166
- switch (_d.label) {
1167
- case 0:
1168
- _a = [__assign({}, output)];
1169
- _c = {};
1170
- return [4, parseBody(output.body, context)];
1171
- case 1:
1172
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1173
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1174
- _b = errorCode;
1175
- switch (_b) {
1176
- case "InternalServiceError": return [3, 2];
1177
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
1178
- case "InvalidRequestException": return [3, 4];
1179
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
1180
- }
1181
- return [3, 6];
1182
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
1183
- case 3: throw _d.sent();
1184
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
1185
- case 5: throw _d.sent();
1186
- case 6:
1187
- parsedBody = parsedOutput.body;
1188
- throwDefaultError({
1189
- output: output,
1190
- parsedBody: parsedBody,
1191
- exceptionCtor: __BaseException,
1192
- errorCode: errorCode,
1193
- });
1194
- _d.label = 7;
1195
- case 7: return [2];
1196
- }
1197
- });
1198
- }); };
1199
- export var deserializeAws_json1_1SetStatusCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1200
- var response;
1201
- return __generator(this, function (_a) {
1202
- switch (_a.label) {
1203
- case 0:
1204
- if (output.statusCode >= 300) {
1205
- return [2, deserializeAws_json1_1SetStatusCommandError(output, context)];
1206
- }
1207
- return [4, collectBody(output.body, context)];
1208
- case 1:
1209
- _a.sent();
1210
- response = {
1211
- $metadata: deserializeMetadata(output),
1212
- };
1213
- return [2, Promise.resolve(response)];
1214
- }
1215
- });
1216
- }); };
1217
- var deserializeAws_json1_1SetStatusCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1218
- var parsedOutput, _a, errorCode, _b, parsedBody;
1219
- var _c;
1220
- return __generator(this, function (_d) {
1221
- switch (_d.label) {
1222
- case 0:
1223
- _a = [__assign({}, output)];
1224
- _c = {};
1225
- return [4, parseBody(output.body, context)];
1226
- case 1:
1227
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1228
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1229
- _b = errorCode;
1230
- switch (_b) {
1231
- case "InternalServiceError": return [3, 2];
1232
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
1233
- case "InvalidRequestException": return [3, 4];
1234
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
1235
- case "PipelineDeletedException": return [3, 6];
1236
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
1237
- case "PipelineNotFoundException": return [3, 8];
1238
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
1239
- }
1240
- return [3, 10];
1241
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
1242
- case 3: throw _d.sent();
1243
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
1244
- case 5: throw _d.sent();
1245
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
1246
- case 7: throw _d.sent();
1247
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
1248
- case 9: throw _d.sent();
1249
- case 10:
1250
- parsedBody = parsedOutput.body;
1251
- throwDefaultError({
1252
- output: output,
1253
- parsedBody: parsedBody,
1254
- exceptionCtor: __BaseException,
1255
- errorCode: errorCode,
1256
- });
1257
- _d.label = 11;
1258
- case 11: return [2];
1259
- }
1260
- });
1261
- }); };
1262
- export var deserializeAws_json1_1SetTaskStatusCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1263
- var data, contents, response;
1264
- return __generator(this, function (_a) {
1265
- switch (_a.label) {
1266
- case 0:
1267
- if (output.statusCode >= 300) {
1268
- return [2, deserializeAws_json1_1SetTaskStatusCommandError(output, context)];
1269
- }
1270
- return [4, parseBody(output.body, context)];
1271
- case 1:
1272
- data = _a.sent();
1273
- contents = {};
1274
- contents = deserializeAws_json1_1SetTaskStatusOutput(data, context);
1275
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1276
- return [2, Promise.resolve(response)];
1277
- }
1278
- });
1279
- }); };
1280
- var deserializeAws_json1_1SetTaskStatusCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1281
- var parsedOutput, _a, errorCode, _b, parsedBody;
1282
- var _c;
1283
- return __generator(this, function (_d) {
1284
- switch (_d.label) {
1285
- case 0:
1286
- _a = [__assign({}, output)];
1287
- _c = {};
1288
- return [4, parseBody(output.body, context)];
1289
- case 1:
1290
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1291
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1292
- _b = errorCode;
1293
- switch (_b) {
1294
- case "InternalServiceError": return [3, 2];
1295
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
1296
- case "InvalidRequestException": return [3, 4];
1297
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
1298
- case "PipelineDeletedException": return [3, 6];
1299
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
1300
- case "PipelineNotFoundException": return [3, 8];
1301
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
1302
- case "TaskNotFoundException": return [3, 10];
1303
- case "com.amazonaws.datapipeline#TaskNotFoundException": return [3, 10];
1304
- }
1305
- return [3, 12];
1306
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
1307
- case 3: throw _d.sent();
1308
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
1309
- case 5: throw _d.sent();
1310
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
1311
- case 7: throw _d.sent();
1312
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
1313
- case 9: throw _d.sent();
1314
- case 10: return [4, deserializeAws_json1_1TaskNotFoundExceptionResponse(parsedOutput, context)];
1315
- case 11: throw _d.sent();
1316
- case 12:
1317
- parsedBody = parsedOutput.body;
1318
- throwDefaultError({
1319
- output: output,
1320
- parsedBody: parsedBody,
1321
- exceptionCtor: __BaseException,
1322
- errorCode: errorCode,
1323
- });
1324
- _d.label = 13;
1325
- case 13: return [2];
1326
- }
1327
- });
1328
- }); };
1329
- export var deserializeAws_json1_1ValidatePipelineDefinitionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1330
- var data, contents, response;
1331
- return __generator(this, function (_a) {
1332
- switch (_a.label) {
1333
- case 0:
1334
- if (output.statusCode >= 300) {
1335
- return [2, deserializeAws_json1_1ValidatePipelineDefinitionCommandError(output, context)];
1336
- }
1337
- return [4, parseBody(output.body, context)];
1338
- case 1:
1339
- data = _a.sent();
1340
- contents = {};
1341
- contents = deserializeAws_json1_1ValidatePipelineDefinitionOutput(data, context);
1342
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1343
- return [2, Promise.resolve(response)];
1344
- }
1345
- });
1346
- }); };
1347
- var deserializeAws_json1_1ValidatePipelineDefinitionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1348
- var parsedOutput, _a, errorCode, _b, parsedBody;
1349
- var _c;
1350
- return __generator(this, function (_d) {
1351
- switch (_d.label) {
1352
- case 0:
1353
- _a = [__assign({}, output)];
1354
- _c = {};
1355
- return [4, parseBody(output.body, context)];
1356
- case 1:
1357
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1358
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1359
- _b = errorCode;
1360
- switch (_b) {
1361
- case "InternalServiceError": return [3, 2];
1362
- case "com.amazonaws.datapipeline#InternalServiceError": return [3, 2];
1363
- case "InvalidRequestException": return [3, 4];
1364
- case "com.amazonaws.datapipeline#InvalidRequestException": return [3, 4];
1365
- case "PipelineDeletedException": return [3, 6];
1366
- case "com.amazonaws.datapipeline#PipelineDeletedException": return [3, 6];
1367
- case "PipelineNotFoundException": return [3, 8];
1368
- case "com.amazonaws.datapipeline#PipelineNotFoundException": return [3, 8];
1369
- }
1370
- return [3, 10];
1371
- case 2: return [4, deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context)];
1372
- case 3: throw _d.sent();
1373
- case 4: return [4, deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)];
1374
- case 5: throw _d.sent();
1375
- case 6: return [4, deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context)];
1376
- case 7: throw _d.sent();
1377
- case 8: return [4, deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context)];
1378
- case 9: throw _d.sent();
1379
- case 10:
1380
- parsedBody = parsedOutput.body;
1381
- throwDefaultError({
1382
- output: output,
1383
- parsedBody: parsedBody,
1384
- exceptionCtor: __BaseException,
1385
- errorCode: errorCode,
1386
- });
1387
- _d.label = 11;
1388
- case 11: return [2];
1389
- }
1390
- });
1391
- }); };
1392
- var deserializeAws_json1_1InternalServiceErrorResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1393
- var body, deserialized, exception;
1394
- return __generator(this, function (_a) {
1395
- body = parsedOutput.body;
1396
- deserialized = deserializeAws_json1_1InternalServiceError(body, context);
1397
- exception = new InternalServiceError(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1398
- return [2, __decorateServiceException(exception, body)];
5
+ export const serializeAws_json1_1ActivatePipelineCommand = async (input, context) => {
6
+ const headers = {
7
+ "content-type": "application/x-amz-json-1.1",
8
+ "x-amz-target": "DataPipeline.ActivatePipeline",
9
+ };
10
+ let body;
11
+ body = JSON.stringify(serializeAws_json1_1ActivatePipelineInput(input, context));
12
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
13
+ };
14
+ export const serializeAws_json1_1AddTagsCommand = async (input, context) => {
15
+ const headers = {
16
+ "content-type": "application/x-amz-json-1.1",
17
+ "x-amz-target": "DataPipeline.AddTags",
18
+ };
19
+ let body;
20
+ body = JSON.stringify(serializeAws_json1_1AddTagsInput(input, context));
21
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
22
+ };
23
+ export const serializeAws_json1_1CreatePipelineCommand = async (input, context) => {
24
+ const headers = {
25
+ "content-type": "application/x-amz-json-1.1",
26
+ "x-amz-target": "DataPipeline.CreatePipeline",
27
+ };
28
+ let body;
29
+ body = JSON.stringify(serializeAws_json1_1CreatePipelineInput(input, context));
30
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
31
+ };
32
+ export const serializeAws_json1_1DeactivatePipelineCommand = async (input, context) => {
33
+ const headers = {
34
+ "content-type": "application/x-amz-json-1.1",
35
+ "x-amz-target": "DataPipeline.DeactivatePipeline",
36
+ };
37
+ let body;
38
+ body = JSON.stringify(serializeAws_json1_1DeactivatePipelineInput(input, context));
39
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
40
+ };
41
+ export const serializeAws_json1_1DeletePipelineCommand = async (input, context) => {
42
+ const headers = {
43
+ "content-type": "application/x-amz-json-1.1",
44
+ "x-amz-target": "DataPipeline.DeletePipeline",
45
+ };
46
+ let body;
47
+ body = JSON.stringify(serializeAws_json1_1DeletePipelineInput(input, context));
48
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
49
+ };
50
+ export const serializeAws_json1_1DescribeObjectsCommand = async (input, context) => {
51
+ const headers = {
52
+ "content-type": "application/x-amz-json-1.1",
53
+ "x-amz-target": "DataPipeline.DescribeObjects",
54
+ };
55
+ let body;
56
+ body = JSON.stringify(serializeAws_json1_1DescribeObjectsInput(input, context));
57
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
58
+ };
59
+ export const serializeAws_json1_1DescribePipelinesCommand = async (input, context) => {
60
+ const headers = {
61
+ "content-type": "application/x-amz-json-1.1",
62
+ "x-amz-target": "DataPipeline.DescribePipelines",
63
+ };
64
+ let body;
65
+ body = JSON.stringify(serializeAws_json1_1DescribePipelinesInput(input, context));
66
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
67
+ };
68
+ export const serializeAws_json1_1EvaluateExpressionCommand = async (input, context) => {
69
+ const headers = {
70
+ "content-type": "application/x-amz-json-1.1",
71
+ "x-amz-target": "DataPipeline.EvaluateExpression",
72
+ };
73
+ let body;
74
+ body = JSON.stringify(serializeAws_json1_1EvaluateExpressionInput(input, context));
75
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
76
+ };
77
+ export const serializeAws_json1_1GetPipelineDefinitionCommand = async (input, context) => {
78
+ const headers = {
79
+ "content-type": "application/x-amz-json-1.1",
80
+ "x-amz-target": "DataPipeline.GetPipelineDefinition",
81
+ };
82
+ let body;
83
+ body = JSON.stringify(serializeAws_json1_1GetPipelineDefinitionInput(input, context));
84
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
85
+ };
86
+ export const serializeAws_json1_1ListPipelinesCommand = async (input, context) => {
87
+ const headers = {
88
+ "content-type": "application/x-amz-json-1.1",
89
+ "x-amz-target": "DataPipeline.ListPipelines",
90
+ };
91
+ let body;
92
+ body = JSON.stringify(serializeAws_json1_1ListPipelinesInput(input, context));
93
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
94
+ };
95
+ export const serializeAws_json1_1PollForTaskCommand = async (input, context) => {
96
+ const headers = {
97
+ "content-type": "application/x-amz-json-1.1",
98
+ "x-amz-target": "DataPipeline.PollForTask",
99
+ };
100
+ let body;
101
+ body = JSON.stringify(serializeAws_json1_1PollForTaskInput(input, context));
102
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
103
+ };
104
+ export const serializeAws_json1_1PutPipelineDefinitionCommand = async (input, context) => {
105
+ const headers = {
106
+ "content-type": "application/x-amz-json-1.1",
107
+ "x-amz-target": "DataPipeline.PutPipelineDefinition",
108
+ };
109
+ let body;
110
+ body = JSON.stringify(serializeAws_json1_1PutPipelineDefinitionInput(input, context));
111
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
112
+ };
113
+ export const serializeAws_json1_1QueryObjectsCommand = async (input, context) => {
114
+ const headers = {
115
+ "content-type": "application/x-amz-json-1.1",
116
+ "x-amz-target": "DataPipeline.QueryObjects",
117
+ };
118
+ let body;
119
+ body = JSON.stringify(serializeAws_json1_1QueryObjectsInput(input, context));
120
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
121
+ };
122
+ export const serializeAws_json1_1RemoveTagsCommand = async (input, context) => {
123
+ const headers = {
124
+ "content-type": "application/x-amz-json-1.1",
125
+ "x-amz-target": "DataPipeline.RemoveTags",
126
+ };
127
+ let body;
128
+ body = JSON.stringify(serializeAws_json1_1RemoveTagsInput(input, context));
129
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
130
+ };
131
+ export const serializeAws_json1_1ReportTaskProgressCommand = async (input, context) => {
132
+ const headers = {
133
+ "content-type": "application/x-amz-json-1.1",
134
+ "x-amz-target": "DataPipeline.ReportTaskProgress",
135
+ };
136
+ let body;
137
+ body = JSON.stringify(serializeAws_json1_1ReportTaskProgressInput(input, context));
138
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
139
+ };
140
+ export const serializeAws_json1_1ReportTaskRunnerHeartbeatCommand = async (input, context) => {
141
+ const headers = {
142
+ "content-type": "application/x-amz-json-1.1",
143
+ "x-amz-target": "DataPipeline.ReportTaskRunnerHeartbeat",
144
+ };
145
+ let body;
146
+ body = JSON.stringify(serializeAws_json1_1ReportTaskRunnerHeartbeatInput(input, context));
147
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
148
+ };
149
+ export const serializeAws_json1_1SetStatusCommand = async (input, context) => {
150
+ const headers = {
151
+ "content-type": "application/x-amz-json-1.1",
152
+ "x-amz-target": "DataPipeline.SetStatus",
153
+ };
154
+ let body;
155
+ body = JSON.stringify(serializeAws_json1_1SetStatusInput(input, context));
156
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
157
+ };
158
+ export const serializeAws_json1_1SetTaskStatusCommand = async (input, context) => {
159
+ const headers = {
160
+ "content-type": "application/x-amz-json-1.1",
161
+ "x-amz-target": "DataPipeline.SetTaskStatus",
162
+ };
163
+ let body;
164
+ body = JSON.stringify(serializeAws_json1_1SetTaskStatusInput(input, context));
165
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
166
+ };
167
+ export const serializeAws_json1_1ValidatePipelineDefinitionCommand = async (input, context) => {
168
+ const headers = {
169
+ "content-type": "application/x-amz-json-1.1",
170
+ "x-amz-target": "DataPipeline.ValidatePipelineDefinition",
171
+ };
172
+ let body;
173
+ body = JSON.stringify(serializeAws_json1_1ValidatePipelineDefinitionInput(input, context));
174
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
175
+ };
176
+ export const deserializeAws_json1_1ActivatePipelineCommand = async (output, context) => {
177
+ if (output.statusCode >= 300) {
178
+ return deserializeAws_json1_1ActivatePipelineCommandError(output, context);
179
+ }
180
+ const data = await parseBody(output.body, context);
181
+ let contents = {};
182
+ contents = deserializeAws_json1_1ActivatePipelineOutput(data, context);
183
+ const response = {
184
+ $metadata: deserializeMetadata(output),
185
+ ...contents,
186
+ };
187
+ return Promise.resolve(response);
188
+ };
189
+ const deserializeAws_json1_1ActivatePipelineCommandError = async (output, context) => {
190
+ const parsedOutput = {
191
+ ...output,
192
+ body: await parseErrorBody(output.body, context),
193
+ };
194
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
195
+ switch (errorCode) {
196
+ case "InternalServiceError":
197
+ case "com.amazonaws.datapipeline#InternalServiceError":
198
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
199
+ case "InvalidRequestException":
200
+ case "com.amazonaws.datapipeline#InvalidRequestException":
201
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
202
+ case "PipelineDeletedException":
203
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
204
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
205
+ case "PipelineNotFoundException":
206
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
207
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
208
+ default:
209
+ const parsedBody = parsedOutput.body;
210
+ throwDefaultError({
211
+ output,
212
+ parsedBody,
213
+ exceptionCtor: __BaseException,
214
+ errorCode,
215
+ });
216
+ }
217
+ };
218
+ export const deserializeAws_json1_1AddTagsCommand = async (output, context) => {
219
+ if (output.statusCode >= 300) {
220
+ return deserializeAws_json1_1AddTagsCommandError(output, context);
221
+ }
222
+ const data = await parseBody(output.body, context);
223
+ let contents = {};
224
+ contents = deserializeAws_json1_1AddTagsOutput(data, context);
225
+ const response = {
226
+ $metadata: deserializeMetadata(output),
227
+ ...contents,
228
+ };
229
+ return Promise.resolve(response);
230
+ };
231
+ const deserializeAws_json1_1AddTagsCommandError = async (output, context) => {
232
+ const parsedOutput = {
233
+ ...output,
234
+ body: await parseErrorBody(output.body, context),
235
+ };
236
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
237
+ switch (errorCode) {
238
+ case "InternalServiceError":
239
+ case "com.amazonaws.datapipeline#InternalServiceError":
240
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
241
+ case "InvalidRequestException":
242
+ case "com.amazonaws.datapipeline#InvalidRequestException":
243
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
244
+ case "PipelineDeletedException":
245
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
246
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
247
+ case "PipelineNotFoundException":
248
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
249
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
250
+ default:
251
+ const parsedBody = parsedOutput.body;
252
+ throwDefaultError({
253
+ output,
254
+ parsedBody,
255
+ exceptionCtor: __BaseException,
256
+ errorCode,
257
+ });
258
+ }
259
+ };
260
+ export const deserializeAws_json1_1CreatePipelineCommand = async (output, context) => {
261
+ if (output.statusCode >= 300) {
262
+ return deserializeAws_json1_1CreatePipelineCommandError(output, context);
263
+ }
264
+ const data = await parseBody(output.body, context);
265
+ let contents = {};
266
+ contents = deserializeAws_json1_1CreatePipelineOutput(data, context);
267
+ const response = {
268
+ $metadata: deserializeMetadata(output),
269
+ ...contents,
270
+ };
271
+ return Promise.resolve(response);
272
+ };
273
+ const deserializeAws_json1_1CreatePipelineCommandError = async (output, context) => {
274
+ const parsedOutput = {
275
+ ...output,
276
+ body: await parseErrorBody(output.body, context),
277
+ };
278
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
279
+ switch (errorCode) {
280
+ case "InternalServiceError":
281
+ case "com.amazonaws.datapipeline#InternalServiceError":
282
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
283
+ case "InvalidRequestException":
284
+ case "com.amazonaws.datapipeline#InvalidRequestException":
285
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
286
+ default:
287
+ const parsedBody = parsedOutput.body;
288
+ throwDefaultError({
289
+ output,
290
+ parsedBody,
291
+ exceptionCtor: __BaseException,
292
+ errorCode,
293
+ });
294
+ }
295
+ };
296
+ export const deserializeAws_json1_1DeactivatePipelineCommand = async (output, context) => {
297
+ if (output.statusCode >= 300) {
298
+ return deserializeAws_json1_1DeactivatePipelineCommandError(output, context);
299
+ }
300
+ const data = await parseBody(output.body, context);
301
+ let contents = {};
302
+ contents = deserializeAws_json1_1DeactivatePipelineOutput(data, context);
303
+ const response = {
304
+ $metadata: deserializeMetadata(output),
305
+ ...contents,
306
+ };
307
+ return Promise.resolve(response);
308
+ };
309
+ const deserializeAws_json1_1DeactivatePipelineCommandError = async (output, context) => {
310
+ const parsedOutput = {
311
+ ...output,
312
+ body: await parseErrorBody(output.body, context),
313
+ };
314
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
315
+ switch (errorCode) {
316
+ case "InternalServiceError":
317
+ case "com.amazonaws.datapipeline#InternalServiceError":
318
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
319
+ case "InvalidRequestException":
320
+ case "com.amazonaws.datapipeline#InvalidRequestException":
321
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
322
+ case "PipelineDeletedException":
323
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
324
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
325
+ case "PipelineNotFoundException":
326
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
327
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
328
+ default:
329
+ const parsedBody = parsedOutput.body;
330
+ throwDefaultError({
331
+ output,
332
+ parsedBody,
333
+ exceptionCtor: __BaseException,
334
+ errorCode,
335
+ });
336
+ }
337
+ };
338
+ export const deserializeAws_json1_1DeletePipelineCommand = async (output, context) => {
339
+ if (output.statusCode >= 300) {
340
+ return deserializeAws_json1_1DeletePipelineCommandError(output, context);
341
+ }
342
+ await collectBody(output.body, context);
343
+ const response = {
344
+ $metadata: deserializeMetadata(output),
345
+ };
346
+ return Promise.resolve(response);
347
+ };
348
+ const deserializeAws_json1_1DeletePipelineCommandError = async (output, context) => {
349
+ const parsedOutput = {
350
+ ...output,
351
+ body: await parseErrorBody(output.body, context),
352
+ };
353
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
354
+ switch (errorCode) {
355
+ case "InternalServiceError":
356
+ case "com.amazonaws.datapipeline#InternalServiceError":
357
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
358
+ case "InvalidRequestException":
359
+ case "com.amazonaws.datapipeline#InvalidRequestException":
360
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
361
+ case "PipelineNotFoundException":
362
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
363
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
364
+ default:
365
+ const parsedBody = parsedOutput.body;
366
+ throwDefaultError({
367
+ output,
368
+ parsedBody,
369
+ exceptionCtor: __BaseException,
370
+ errorCode,
371
+ });
372
+ }
373
+ };
374
+ export const deserializeAws_json1_1DescribeObjectsCommand = async (output, context) => {
375
+ if (output.statusCode >= 300) {
376
+ return deserializeAws_json1_1DescribeObjectsCommandError(output, context);
377
+ }
378
+ const data = await parseBody(output.body, context);
379
+ let contents = {};
380
+ contents = deserializeAws_json1_1DescribeObjectsOutput(data, context);
381
+ const response = {
382
+ $metadata: deserializeMetadata(output),
383
+ ...contents,
384
+ };
385
+ return Promise.resolve(response);
386
+ };
387
+ const deserializeAws_json1_1DescribeObjectsCommandError = async (output, context) => {
388
+ const parsedOutput = {
389
+ ...output,
390
+ body: await parseErrorBody(output.body, context),
391
+ };
392
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
393
+ switch (errorCode) {
394
+ case "InternalServiceError":
395
+ case "com.amazonaws.datapipeline#InternalServiceError":
396
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
397
+ case "InvalidRequestException":
398
+ case "com.amazonaws.datapipeline#InvalidRequestException":
399
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
400
+ case "PipelineDeletedException":
401
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
402
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
403
+ case "PipelineNotFoundException":
404
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
405
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
406
+ default:
407
+ const parsedBody = parsedOutput.body;
408
+ throwDefaultError({
409
+ output,
410
+ parsedBody,
411
+ exceptionCtor: __BaseException,
412
+ errorCode,
413
+ });
414
+ }
415
+ };
416
+ export const deserializeAws_json1_1DescribePipelinesCommand = async (output, context) => {
417
+ if (output.statusCode >= 300) {
418
+ return deserializeAws_json1_1DescribePipelinesCommandError(output, context);
419
+ }
420
+ const data = await parseBody(output.body, context);
421
+ let contents = {};
422
+ contents = deserializeAws_json1_1DescribePipelinesOutput(data, context);
423
+ const response = {
424
+ $metadata: deserializeMetadata(output),
425
+ ...contents,
426
+ };
427
+ return Promise.resolve(response);
428
+ };
429
+ const deserializeAws_json1_1DescribePipelinesCommandError = async (output, context) => {
430
+ const parsedOutput = {
431
+ ...output,
432
+ body: await parseErrorBody(output.body, context),
433
+ };
434
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
435
+ switch (errorCode) {
436
+ case "InternalServiceError":
437
+ case "com.amazonaws.datapipeline#InternalServiceError":
438
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
439
+ case "InvalidRequestException":
440
+ case "com.amazonaws.datapipeline#InvalidRequestException":
441
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
442
+ case "PipelineDeletedException":
443
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
444
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
445
+ case "PipelineNotFoundException":
446
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
447
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
448
+ default:
449
+ const parsedBody = parsedOutput.body;
450
+ throwDefaultError({
451
+ output,
452
+ parsedBody,
453
+ exceptionCtor: __BaseException,
454
+ errorCode,
455
+ });
456
+ }
457
+ };
458
+ export const deserializeAws_json1_1EvaluateExpressionCommand = async (output, context) => {
459
+ if (output.statusCode >= 300) {
460
+ return deserializeAws_json1_1EvaluateExpressionCommandError(output, context);
461
+ }
462
+ const data = await parseBody(output.body, context);
463
+ let contents = {};
464
+ contents = deserializeAws_json1_1EvaluateExpressionOutput(data, context);
465
+ const response = {
466
+ $metadata: deserializeMetadata(output),
467
+ ...contents,
468
+ };
469
+ return Promise.resolve(response);
470
+ };
471
+ const deserializeAws_json1_1EvaluateExpressionCommandError = async (output, context) => {
472
+ const parsedOutput = {
473
+ ...output,
474
+ body: await parseErrorBody(output.body, context),
475
+ };
476
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
477
+ switch (errorCode) {
478
+ case "InternalServiceError":
479
+ case "com.amazonaws.datapipeline#InternalServiceError":
480
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
481
+ case "InvalidRequestException":
482
+ case "com.amazonaws.datapipeline#InvalidRequestException":
483
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
484
+ case "PipelineDeletedException":
485
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
486
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
487
+ case "PipelineNotFoundException":
488
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
489
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
490
+ case "TaskNotFoundException":
491
+ case "com.amazonaws.datapipeline#TaskNotFoundException":
492
+ throw await deserializeAws_json1_1TaskNotFoundExceptionResponse(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_1GetPipelineDefinitionCommand = async (output, context) => {
504
+ if (output.statusCode >= 300) {
505
+ return deserializeAws_json1_1GetPipelineDefinitionCommandError(output, context);
506
+ }
507
+ const data = await parseBody(output.body, context);
508
+ let contents = {};
509
+ contents = deserializeAws_json1_1GetPipelineDefinitionOutput(data, context);
510
+ const response = {
511
+ $metadata: deserializeMetadata(output),
512
+ ...contents,
513
+ };
514
+ return Promise.resolve(response);
515
+ };
516
+ const deserializeAws_json1_1GetPipelineDefinitionCommandError = 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 "InternalServiceError":
524
+ case "com.amazonaws.datapipeline#InternalServiceError":
525
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
526
+ case "InvalidRequestException":
527
+ case "com.amazonaws.datapipeline#InvalidRequestException":
528
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
529
+ case "PipelineDeletedException":
530
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
531
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
532
+ case "PipelineNotFoundException":
533
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
534
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
535
+ default:
536
+ const parsedBody = parsedOutput.body;
537
+ throwDefaultError({
538
+ output,
539
+ parsedBody,
540
+ exceptionCtor: __BaseException,
541
+ errorCode,
542
+ });
543
+ }
544
+ };
545
+ export const deserializeAws_json1_1ListPipelinesCommand = async (output, context) => {
546
+ if (output.statusCode >= 300) {
547
+ return deserializeAws_json1_1ListPipelinesCommandError(output, context);
548
+ }
549
+ const data = await parseBody(output.body, context);
550
+ let contents = {};
551
+ contents = deserializeAws_json1_1ListPipelinesOutput(data, context);
552
+ const response = {
553
+ $metadata: deserializeMetadata(output),
554
+ ...contents,
555
+ };
556
+ return Promise.resolve(response);
557
+ };
558
+ const deserializeAws_json1_1ListPipelinesCommandError = async (output, context) => {
559
+ const parsedOutput = {
560
+ ...output,
561
+ body: await parseErrorBody(output.body, context),
562
+ };
563
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
564
+ switch (errorCode) {
565
+ case "InternalServiceError":
566
+ case "com.amazonaws.datapipeline#InternalServiceError":
567
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
568
+ case "InvalidRequestException":
569
+ case "com.amazonaws.datapipeline#InvalidRequestException":
570
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
571
+ default:
572
+ const parsedBody = parsedOutput.body;
573
+ throwDefaultError({
574
+ output,
575
+ parsedBody,
576
+ exceptionCtor: __BaseException,
577
+ errorCode,
578
+ });
579
+ }
580
+ };
581
+ export const deserializeAws_json1_1PollForTaskCommand = async (output, context) => {
582
+ if (output.statusCode >= 300) {
583
+ return deserializeAws_json1_1PollForTaskCommandError(output, context);
584
+ }
585
+ const data = await parseBody(output.body, context);
586
+ let contents = {};
587
+ contents = deserializeAws_json1_1PollForTaskOutput(data, context);
588
+ const response = {
589
+ $metadata: deserializeMetadata(output),
590
+ ...contents,
591
+ };
592
+ return Promise.resolve(response);
593
+ };
594
+ const deserializeAws_json1_1PollForTaskCommandError = async (output, context) => {
595
+ const parsedOutput = {
596
+ ...output,
597
+ body: await parseErrorBody(output.body, context),
598
+ };
599
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
600
+ switch (errorCode) {
601
+ case "InternalServiceError":
602
+ case "com.amazonaws.datapipeline#InternalServiceError":
603
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
604
+ case "InvalidRequestException":
605
+ case "com.amazonaws.datapipeline#InvalidRequestException":
606
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
607
+ case "TaskNotFoundException":
608
+ case "com.amazonaws.datapipeline#TaskNotFoundException":
609
+ throw await deserializeAws_json1_1TaskNotFoundExceptionResponse(parsedOutput, context);
610
+ default:
611
+ const parsedBody = parsedOutput.body;
612
+ throwDefaultError({
613
+ output,
614
+ parsedBody,
615
+ exceptionCtor: __BaseException,
616
+ errorCode,
617
+ });
618
+ }
619
+ };
620
+ export const deserializeAws_json1_1PutPipelineDefinitionCommand = async (output, context) => {
621
+ if (output.statusCode >= 300) {
622
+ return deserializeAws_json1_1PutPipelineDefinitionCommandError(output, context);
623
+ }
624
+ const data = await parseBody(output.body, context);
625
+ let contents = {};
626
+ contents = deserializeAws_json1_1PutPipelineDefinitionOutput(data, context);
627
+ const response = {
628
+ $metadata: deserializeMetadata(output),
629
+ ...contents,
630
+ };
631
+ return Promise.resolve(response);
632
+ };
633
+ const deserializeAws_json1_1PutPipelineDefinitionCommandError = async (output, context) => {
634
+ const parsedOutput = {
635
+ ...output,
636
+ body: await parseErrorBody(output.body, context),
637
+ };
638
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
639
+ switch (errorCode) {
640
+ case "InternalServiceError":
641
+ case "com.amazonaws.datapipeline#InternalServiceError":
642
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
643
+ case "InvalidRequestException":
644
+ case "com.amazonaws.datapipeline#InvalidRequestException":
645
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
646
+ case "PipelineDeletedException":
647
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
648
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
649
+ case "PipelineNotFoundException":
650
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
651
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
652
+ default:
653
+ const parsedBody = parsedOutput.body;
654
+ throwDefaultError({
655
+ output,
656
+ parsedBody,
657
+ exceptionCtor: __BaseException,
658
+ errorCode,
659
+ });
660
+ }
661
+ };
662
+ export const deserializeAws_json1_1QueryObjectsCommand = async (output, context) => {
663
+ if (output.statusCode >= 300) {
664
+ return deserializeAws_json1_1QueryObjectsCommandError(output, context);
665
+ }
666
+ const data = await parseBody(output.body, context);
667
+ let contents = {};
668
+ contents = deserializeAws_json1_1QueryObjectsOutput(data, context);
669
+ const response = {
670
+ $metadata: deserializeMetadata(output),
671
+ ...contents,
672
+ };
673
+ return Promise.resolve(response);
674
+ };
675
+ const deserializeAws_json1_1QueryObjectsCommandError = async (output, context) => {
676
+ const parsedOutput = {
677
+ ...output,
678
+ body: await parseErrorBody(output.body, context),
679
+ };
680
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
681
+ switch (errorCode) {
682
+ case "InternalServiceError":
683
+ case "com.amazonaws.datapipeline#InternalServiceError":
684
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
685
+ case "InvalidRequestException":
686
+ case "com.amazonaws.datapipeline#InvalidRequestException":
687
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
688
+ case "PipelineDeletedException":
689
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
690
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
691
+ case "PipelineNotFoundException":
692
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
693
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
694
+ default:
695
+ const parsedBody = parsedOutput.body;
696
+ throwDefaultError({
697
+ output,
698
+ parsedBody,
699
+ exceptionCtor: __BaseException,
700
+ errorCode,
701
+ });
702
+ }
703
+ };
704
+ export const deserializeAws_json1_1RemoveTagsCommand = async (output, context) => {
705
+ if (output.statusCode >= 300) {
706
+ return deserializeAws_json1_1RemoveTagsCommandError(output, context);
707
+ }
708
+ const data = await parseBody(output.body, context);
709
+ let contents = {};
710
+ contents = deserializeAws_json1_1RemoveTagsOutput(data, context);
711
+ const response = {
712
+ $metadata: deserializeMetadata(output),
713
+ ...contents,
714
+ };
715
+ return Promise.resolve(response);
716
+ };
717
+ const deserializeAws_json1_1RemoveTagsCommandError = async (output, context) => {
718
+ const parsedOutput = {
719
+ ...output,
720
+ body: await parseErrorBody(output.body, context),
721
+ };
722
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
723
+ switch (errorCode) {
724
+ case "InternalServiceError":
725
+ case "com.amazonaws.datapipeline#InternalServiceError":
726
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
727
+ case "InvalidRequestException":
728
+ case "com.amazonaws.datapipeline#InvalidRequestException":
729
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
730
+ case "PipelineDeletedException":
731
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
732
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
733
+ case "PipelineNotFoundException":
734
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
735
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
736
+ default:
737
+ const parsedBody = parsedOutput.body;
738
+ throwDefaultError({
739
+ output,
740
+ parsedBody,
741
+ exceptionCtor: __BaseException,
742
+ errorCode,
743
+ });
744
+ }
745
+ };
746
+ export const deserializeAws_json1_1ReportTaskProgressCommand = async (output, context) => {
747
+ if (output.statusCode >= 300) {
748
+ return deserializeAws_json1_1ReportTaskProgressCommandError(output, context);
749
+ }
750
+ const data = await parseBody(output.body, context);
751
+ let contents = {};
752
+ contents = deserializeAws_json1_1ReportTaskProgressOutput(data, context);
753
+ const response = {
754
+ $metadata: deserializeMetadata(output),
755
+ ...contents,
756
+ };
757
+ return Promise.resolve(response);
758
+ };
759
+ const deserializeAws_json1_1ReportTaskProgressCommandError = async (output, context) => {
760
+ const parsedOutput = {
761
+ ...output,
762
+ body: await parseErrorBody(output.body, context),
763
+ };
764
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
765
+ switch (errorCode) {
766
+ case "InternalServiceError":
767
+ case "com.amazonaws.datapipeline#InternalServiceError":
768
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
769
+ case "InvalidRequestException":
770
+ case "com.amazonaws.datapipeline#InvalidRequestException":
771
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
772
+ case "PipelineDeletedException":
773
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
774
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
775
+ case "PipelineNotFoundException":
776
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
777
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
778
+ case "TaskNotFoundException":
779
+ case "com.amazonaws.datapipeline#TaskNotFoundException":
780
+ throw await deserializeAws_json1_1TaskNotFoundExceptionResponse(parsedOutput, context);
781
+ default:
782
+ const parsedBody = parsedOutput.body;
783
+ throwDefaultError({
784
+ output,
785
+ parsedBody,
786
+ exceptionCtor: __BaseException,
787
+ errorCode,
788
+ });
789
+ }
790
+ };
791
+ export const deserializeAws_json1_1ReportTaskRunnerHeartbeatCommand = async (output, context) => {
792
+ if (output.statusCode >= 300) {
793
+ return deserializeAws_json1_1ReportTaskRunnerHeartbeatCommandError(output, context);
794
+ }
795
+ const data = await parseBody(output.body, context);
796
+ let contents = {};
797
+ contents = deserializeAws_json1_1ReportTaskRunnerHeartbeatOutput(data, context);
798
+ const response = {
799
+ $metadata: deserializeMetadata(output),
800
+ ...contents,
801
+ };
802
+ return Promise.resolve(response);
803
+ };
804
+ const deserializeAws_json1_1ReportTaskRunnerHeartbeatCommandError = async (output, context) => {
805
+ const parsedOutput = {
806
+ ...output,
807
+ body: await parseErrorBody(output.body, context),
808
+ };
809
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
810
+ switch (errorCode) {
811
+ case "InternalServiceError":
812
+ case "com.amazonaws.datapipeline#InternalServiceError":
813
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
814
+ case "InvalidRequestException":
815
+ case "com.amazonaws.datapipeline#InvalidRequestException":
816
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(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_1SetStatusCommand = async (output, context) => {
828
+ if (output.statusCode >= 300) {
829
+ return deserializeAws_json1_1SetStatusCommandError(output, context);
830
+ }
831
+ await collectBody(output.body, context);
832
+ const response = {
833
+ $metadata: deserializeMetadata(output),
834
+ };
835
+ return Promise.resolve(response);
836
+ };
837
+ const deserializeAws_json1_1SetStatusCommandError = async (output, context) => {
838
+ const parsedOutput = {
839
+ ...output,
840
+ body: await parseErrorBody(output.body, context),
841
+ };
842
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
843
+ switch (errorCode) {
844
+ case "InternalServiceError":
845
+ case "com.amazonaws.datapipeline#InternalServiceError":
846
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
847
+ case "InvalidRequestException":
848
+ case "com.amazonaws.datapipeline#InvalidRequestException":
849
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
850
+ case "PipelineDeletedException":
851
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
852
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
853
+ case "PipelineNotFoundException":
854
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
855
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
856
+ default:
857
+ const parsedBody = parsedOutput.body;
858
+ throwDefaultError({
859
+ output,
860
+ parsedBody,
861
+ exceptionCtor: __BaseException,
862
+ errorCode,
863
+ });
864
+ }
865
+ };
866
+ export const deserializeAws_json1_1SetTaskStatusCommand = async (output, context) => {
867
+ if (output.statusCode >= 300) {
868
+ return deserializeAws_json1_1SetTaskStatusCommandError(output, context);
869
+ }
870
+ const data = await parseBody(output.body, context);
871
+ let contents = {};
872
+ contents = deserializeAws_json1_1SetTaskStatusOutput(data, context);
873
+ const response = {
874
+ $metadata: deserializeMetadata(output),
875
+ ...contents,
876
+ };
877
+ return Promise.resolve(response);
878
+ };
879
+ const deserializeAws_json1_1SetTaskStatusCommandError = async (output, context) => {
880
+ const parsedOutput = {
881
+ ...output,
882
+ body: await parseErrorBody(output.body, context),
883
+ };
884
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
885
+ switch (errorCode) {
886
+ case "InternalServiceError":
887
+ case "com.amazonaws.datapipeline#InternalServiceError":
888
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
889
+ case "InvalidRequestException":
890
+ case "com.amazonaws.datapipeline#InvalidRequestException":
891
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
892
+ case "PipelineDeletedException":
893
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
894
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
895
+ case "PipelineNotFoundException":
896
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
897
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
898
+ case "TaskNotFoundException":
899
+ case "com.amazonaws.datapipeline#TaskNotFoundException":
900
+ throw await deserializeAws_json1_1TaskNotFoundExceptionResponse(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_1ValidatePipelineDefinitionCommand = async (output, context) => {
912
+ if (output.statusCode >= 300) {
913
+ return deserializeAws_json1_1ValidatePipelineDefinitionCommandError(output, context);
914
+ }
915
+ const data = await parseBody(output.body, context);
916
+ let contents = {};
917
+ contents = deserializeAws_json1_1ValidatePipelineDefinitionOutput(data, context);
918
+ const response = {
919
+ $metadata: deserializeMetadata(output),
920
+ ...contents,
921
+ };
922
+ return Promise.resolve(response);
923
+ };
924
+ const deserializeAws_json1_1ValidatePipelineDefinitionCommandError = 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 "InternalServiceError":
932
+ case "com.amazonaws.datapipeline#InternalServiceError":
933
+ throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
934
+ case "InvalidRequestException":
935
+ case "com.amazonaws.datapipeline#InvalidRequestException":
936
+ throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
937
+ case "PipelineDeletedException":
938
+ case "com.amazonaws.datapipeline#PipelineDeletedException":
939
+ throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
940
+ case "PipelineNotFoundException":
941
+ case "com.amazonaws.datapipeline#PipelineNotFoundException":
942
+ throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
943
+ default:
944
+ const parsedBody = parsedOutput.body;
945
+ throwDefaultError({
946
+ output,
947
+ parsedBody,
948
+ exceptionCtor: __BaseException,
949
+ errorCode,
950
+ });
951
+ }
952
+ };
953
+ const deserializeAws_json1_1InternalServiceErrorResponse = async (parsedOutput, context) => {
954
+ const body = parsedOutput.body;
955
+ const deserialized = deserializeAws_json1_1InternalServiceError(body, context);
956
+ const exception = new InternalServiceError({
957
+ $metadata: deserializeMetadata(parsedOutput),
958
+ ...deserialized,
1399
959
  });
1400
- }); };
1401
- var deserializeAws_json1_1InvalidRequestExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1402
- var body, deserialized, exception;
1403
- return __generator(this, function (_a) {
1404
- body = parsedOutput.body;
1405
- deserialized = deserializeAws_json1_1InvalidRequestException(body, context);
1406
- exception = new InvalidRequestException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1407
- return [2, __decorateServiceException(exception, body)];
960
+ return __decorateServiceException(exception, body);
961
+ };
962
+ const deserializeAws_json1_1InvalidRequestExceptionResponse = async (parsedOutput, context) => {
963
+ const body = parsedOutput.body;
964
+ const deserialized = deserializeAws_json1_1InvalidRequestException(body, context);
965
+ const exception = new InvalidRequestException({
966
+ $metadata: deserializeMetadata(parsedOutput),
967
+ ...deserialized,
1408
968
  });
1409
- }); };
1410
- var deserializeAws_json1_1PipelineDeletedExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1411
- var body, deserialized, exception;
1412
- return __generator(this, function (_a) {
1413
- body = parsedOutput.body;
1414
- deserialized = deserializeAws_json1_1PipelineDeletedException(body, context);
1415
- exception = new PipelineDeletedException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1416
- return [2, __decorateServiceException(exception, body)];
969
+ return __decorateServiceException(exception, body);
970
+ };
971
+ const deserializeAws_json1_1PipelineDeletedExceptionResponse = async (parsedOutput, context) => {
972
+ const body = parsedOutput.body;
973
+ const deserialized = deserializeAws_json1_1PipelineDeletedException(body, context);
974
+ const exception = new PipelineDeletedException({
975
+ $metadata: deserializeMetadata(parsedOutput),
976
+ ...deserialized,
1417
977
  });
1418
- }); };
1419
- var deserializeAws_json1_1PipelineNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1420
- var body, deserialized, exception;
1421
- return __generator(this, function (_a) {
1422
- body = parsedOutput.body;
1423
- deserialized = deserializeAws_json1_1PipelineNotFoundException(body, context);
1424
- exception = new PipelineNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1425
- return [2, __decorateServiceException(exception, body)];
978
+ return __decorateServiceException(exception, body);
979
+ };
980
+ const deserializeAws_json1_1PipelineNotFoundExceptionResponse = async (parsedOutput, context) => {
981
+ const body = parsedOutput.body;
982
+ const deserialized = deserializeAws_json1_1PipelineNotFoundException(body, context);
983
+ const exception = new PipelineNotFoundException({
984
+ $metadata: deserializeMetadata(parsedOutput),
985
+ ...deserialized,
1426
986
  });
1427
- }); };
1428
- var deserializeAws_json1_1TaskNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1429
- var body, deserialized, exception;
1430
- return __generator(this, function (_a) {
1431
- body = parsedOutput.body;
1432
- deserialized = deserializeAws_json1_1TaskNotFoundException(body, context);
1433
- exception = new TaskNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1434
- return [2, __decorateServiceException(exception, body)];
987
+ return __decorateServiceException(exception, body);
988
+ };
989
+ const deserializeAws_json1_1TaskNotFoundExceptionResponse = async (parsedOutput, context) => {
990
+ const body = parsedOutput.body;
991
+ const deserialized = deserializeAws_json1_1TaskNotFoundException(body, context);
992
+ const exception = new TaskNotFoundException({
993
+ $metadata: deserializeMetadata(parsedOutput),
994
+ ...deserialized,
1435
995
  });
1436
- }); };
1437
- var serializeAws_json1_1ActivatePipelineInput = function (input, context) {
1438
- return __assign(__assign(__assign({}, (input.parameterValues != null && {
1439
- parameterValues: serializeAws_json1_1ParameterValueList(input.parameterValues, context),
1440
- })), (input.pipelineId != null && { pipelineId: input.pipelineId })), (input.startTimestamp != null && { startTimestamp: Math.round(input.startTimestamp.getTime() / 1000) }));
996
+ return __decorateServiceException(exception, body);
997
+ };
998
+ const serializeAws_json1_1ActivatePipelineInput = (input, context) => {
999
+ return {
1000
+ ...(input.parameterValues != null && {
1001
+ parameterValues: serializeAws_json1_1ParameterValueList(input.parameterValues, context),
1002
+ }),
1003
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1004
+ ...(input.startTimestamp != null && { startTimestamp: Math.round(input.startTimestamp.getTime() / 1000) }),
1005
+ };
1441
1006
  };
1442
- var serializeAws_json1_1AddTagsInput = function (input, context) {
1443
- return __assign(__assign({}, (input.pipelineId != null && { pipelineId: input.pipelineId })), (input.tags != null && { tags: serializeAws_json1_1tagList(input.tags, context) }));
1007
+ const serializeAws_json1_1AddTagsInput = (input, context) => {
1008
+ return {
1009
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1010
+ ...(input.tags != null && { tags: serializeAws_json1_1tagList(input.tags, context) }),
1011
+ };
1444
1012
  };
1445
- var serializeAws_json1_1CreatePipelineInput = function (input, context) {
1446
- return __assign(__assign(__assign(__assign({}, (input.description != null && { description: input.description })), (input.name != null && { name: input.name })), (input.tags != null && { tags: serializeAws_json1_1tagList(input.tags, context) })), (input.uniqueId != null && { uniqueId: input.uniqueId }));
1013
+ const serializeAws_json1_1CreatePipelineInput = (input, context) => {
1014
+ return {
1015
+ ...(input.description != null && { description: input.description }),
1016
+ ...(input.name != null && { name: input.name }),
1017
+ ...(input.tags != null && { tags: serializeAws_json1_1tagList(input.tags, context) }),
1018
+ ...(input.uniqueId != null && { uniqueId: input.uniqueId }),
1019
+ };
1447
1020
  };
1448
- var serializeAws_json1_1DeactivatePipelineInput = function (input, context) {
1449
- return __assign(__assign({}, (input.cancelActive != null && { cancelActive: input.cancelActive })), (input.pipelineId != null && { pipelineId: input.pipelineId }));
1021
+ const serializeAws_json1_1DeactivatePipelineInput = (input, context) => {
1022
+ return {
1023
+ ...(input.cancelActive != null && { cancelActive: input.cancelActive }),
1024
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1025
+ };
1450
1026
  };
1451
- var serializeAws_json1_1DeletePipelineInput = function (input, context) {
1452
- return __assign({}, (input.pipelineId != null && { pipelineId: input.pipelineId }));
1027
+ const serializeAws_json1_1DeletePipelineInput = (input, context) => {
1028
+ return {
1029
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1030
+ };
1453
1031
  };
1454
- var serializeAws_json1_1DescribeObjectsInput = function (input, context) {
1455
- return __assign(__assign(__assign(__assign({}, (input.evaluateExpressions != null && { evaluateExpressions: input.evaluateExpressions })), (input.marker != null && { marker: input.marker })), (input.objectIds != null && { objectIds: serializeAws_json1_1idList(input.objectIds, context) })), (input.pipelineId != null && { pipelineId: input.pipelineId }));
1032
+ const serializeAws_json1_1DescribeObjectsInput = (input, context) => {
1033
+ return {
1034
+ ...(input.evaluateExpressions != null && { evaluateExpressions: input.evaluateExpressions }),
1035
+ ...(input.marker != null && { marker: input.marker }),
1036
+ ...(input.objectIds != null && { objectIds: serializeAws_json1_1idList(input.objectIds, context) }),
1037
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1038
+ };
1456
1039
  };
1457
- var serializeAws_json1_1DescribePipelinesInput = function (input, context) {
1458
- return __assign({}, (input.pipelineIds != null && { pipelineIds: serializeAws_json1_1idList(input.pipelineIds, context) }));
1040
+ const serializeAws_json1_1DescribePipelinesInput = (input, context) => {
1041
+ return {
1042
+ ...(input.pipelineIds != null && { pipelineIds: serializeAws_json1_1idList(input.pipelineIds, context) }),
1043
+ };
1459
1044
  };
1460
- var serializeAws_json1_1EvaluateExpressionInput = function (input, context) {
1461
- return __assign(__assign(__assign({}, (input.expression != null && { expression: input.expression })), (input.objectId != null && { objectId: input.objectId })), (input.pipelineId != null && { pipelineId: input.pipelineId }));
1045
+ const serializeAws_json1_1EvaluateExpressionInput = (input, context) => {
1046
+ return {
1047
+ ...(input.expression != null && { expression: input.expression }),
1048
+ ...(input.objectId != null && { objectId: input.objectId }),
1049
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1050
+ };
1462
1051
  };
1463
- var serializeAws_json1_1Field = function (input, context) {
1464
- return __assign(__assign(__assign({}, (input.key != null && { key: input.key })), (input.refValue != null && { refValue: input.refValue })), (input.stringValue != null && { stringValue: input.stringValue }));
1052
+ const serializeAws_json1_1Field = (input, context) => {
1053
+ return {
1054
+ ...(input.key != null && { key: input.key }),
1055
+ ...(input.refValue != null && { refValue: input.refValue }),
1056
+ ...(input.stringValue != null && { stringValue: input.stringValue }),
1057
+ };
1465
1058
  };
1466
- var serializeAws_json1_1fieldList = function (input, context) {
1059
+ const serializeAws_json1_1fieldList = (input, context) => {
1467
1060
  return input
1468
- .filter(function (e) { return e != null; })
1469
- .map(function (entry) {
1061
+ .filter((e) => e != null)
1062
+ .map((entry) => {
1470
1063
  return serializeAws_json1_1Field(entry, context);
1471
1064
  });
1472
1065
  };
1473
- var serializeAws_json1_1GetPipelineDefinitionInput = function (input, context) {
1474
- return __assign(__assign({}, (input.pipelineId != null && { pipelineId: input.pipelineId })), (input.version != null && { version: input.version }));
1066
+ const serializeAws_json1_1GetPipelineDefinitionInput = (input, context) => {
1067
+ return {
1068
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1069
+ ...(input.version != null && { version: input.version }),
1070
+ };
1475
1071
  };
1476
- var serializeAws_json1_1idList = function (input, context) {
1072
+ const serializeAws_json1_1idList = (input, context) => {
1477
1073
  return input
1478
- .filter(function (e) { return e != null; })
1479
- .map(function (entry) {
1074
+ .filter((e) => e != null)
1075
+ .map((entry) => {
1480
1076
  return entry;
1481
1077
  });
1482
1078
  };
1483
- var serializeAws_json1_1InstanceIdentity = function (input, context) {
1484
- return __assign(__assign({}, (input.document != null && { document: input.document })), (input.signature != null && { signature: input.signature }));
1079
+ const serializeAws_json1_1InstanceIdentity = (input, context) => {
1080
+ return {
1081
+ ...(input.document != null && { document: input.document }),
1082
+ ...(input.signature != null && { signature: input.signature }),
1083
+ };
1485
1084
  };
1486
- var serializeAws_json1_1ListPipelinesInput = function (input, context) {
1487
- return __assign({}, (input.marker != null && { marker: input.marker }));
1085
+ const serializeAws_json1_1ListPipelinesInput = (input, context) => {
1086
+ return {
1087
+ ...(input.marker != null && { marker: input.marker }),
1088
+ };
1488
1089
  };
1489
- var serializeAws_json1_1Operator = function (input, context) {
1490
- return __assign(__assign({}, (input.type != null && { type: input.type })), (input.values != null && { values: serializeAws_json1_1stringList(input.values, context) }));
1090
+ const serializeAws_json1_1Operator = (input, context) => {
1091
+ return {
1092
+ ...(input.type != null && { type: input.type }),
1093
+ ...(input.values != null && { values: serializeAws_json1_1stringList(input.values, context) }),
1094
+ };
1491
1095
  };
1492
- var serializeAws_json1_1ParameterAttribute = function (input, context) {
1493
- return __assign(__assign({}, (input.key != null && { key: input.key })), (input.stringValue != null && { stringValue: input.stringValue }));
1096
+ const serializeAws_json1_1ParameterAttribute = (input, context) => {
1097
+ return {
1098
+ ...(input.key != null && { key: input.key }),
1099
+ ...(input.stringValue != null && { stringValue: input.stringValue }),
1100
+ };
1494
1101
  };
1495
- var serializeAws_json1_1ParameterAttributeList = function (input, context) {
1102
+ const serializeAws_json1_1ParameterAttributeList = (input, context) => {
1496
1103
  return input
1497
- .filter(function (e) { return e != null; })
1498
- .map(function (entry) {
1104
+ .filter((e) => e != null)
1105
+ .map((entry) => {
1499
1106
  return serializeAws_json1_1ParameterAttribute(entry, context);
1500
1107
  });
1501
1108
  };
1502
- var serializeAws_json1_1ParameterObject = function (input, context) {
1503
- return __assign(__assign({}, (input.attributes != null && {
1504
- attributes: serializeAws_json1_1ParameterAttributeList(input.attributes, context),
1505
- })), (input.id != null && { id: input.id }));
1109
+ const serializeAws_json1_1ParameterObject = (input, context) => {
1110
+ return {
1111
+ ...(input.attributes != null && {
1112
+ attributes: serializeAws_json1_1ParameterAttributeList(input.attributes, context),
1113
+ }),
1114
+ ...(input.id != null && { id: input.id }),
1115
+ };
1506
1116
  };
1507
- var serializeAws_json1_1ParameterObjectList = function (input, context) {
1117
+ const serializeAws_json1_1ParameterObjectList = (input, context) => {
1508
1118
  return input
1509
- .filter(function (e) { return e != null; })
1510
- .map(function (entry) {
1119
+ .filter((e) => e != null)
1120
+ .map((entry) => {
1511
1121
  return serializeAws_json1_1ParameterObject(entry, context);
1512
1122
  });
1513
1123
  };
1514
- var serializeAws_json1_1ParameterValue = function (input, context) {
1515
- return __assign(__assign({}, (input.id != null && { id: input.id })), (input.stringValue != null && { stringValue: input.stringValue }));
1124
+ const serializeAws_json1_1ParameterValue = (input, context) => {
1125
+ return {
1126
+ ...(input.id != null && { id: input.id }),
1127
+ ...(input.stringValue != null && { stringValue: input.stringValue }),
1128
+ };
1516
1129
  };
1517
- var serializeAws_json1_1ParameterValueList = function (input, context) {
1130
+ const serializeAws_json1_1ParameterValueList = (input, context) => {
1518
1131
  return input
1519
- .filter(function (e) { return e != null; })
1520
- .map(function (entry) {
1132
+ .filter((e) => e != null)
1133
+ .map((entry) => {
1521
1134
  return serializeAws_json1_1ParameterValue(entry, context);
1522
1135
  });
1523
1136
  };
1524
- var serializeAws_json1_1PipelineObject = function (input, context) {
1525
- return __assign(__assign(__assign({}, (input.fields != null && { fields: serializeAws_json1_1fieldList(input.fields, context) })), (input.id != null && { id: input.id })), (input.name != null && { name: input.name }));
1137
+ const serializeAws_json1_1PipelineObject = (input, context) => {
1138
+ return {
1139
+ ...(input.fields != null && { fields: serializeAws_json1_1fieldList(input.fields, context) }),
1140
+ ...(input.id != null && { id: input.id }),
1141
+ ...(input.name != null && { name: input.name }),
1142
+ };
1526
1143
  };
1527
- var serializeAws_json1_1PipelineObjectList = function (input, context) {
1144
+ const serializeAws_json1_1PipelineObjectList = (input, context) => {
1528
1145
  return input
1529
- .filter(function (e) { return e != null; })
1530
- .map(function (entry) {
1146
+ .filter((e) => e != null)
1147
+ .map((entry) => {
1531
1148
  return serializeAws_json1_1PipelineObject(entry, context);
1532
1149
  });
1533
1150
  };
1534
- var serializeAws_json1_1PollForTaskInput = function (input, context) {
1535
- return __assign(__assign(__assign({}, (input.hostname != null && { hostname: input.hostname })), (input.instanceIdentity != null && {
1536
- instanceIdentity: serializeAws_json1_1InstanceIdentity(input.instanceIdentity, context),
1537
- })), (input.workerGroup != null && { workerGroup: input.workerGroup }));
1151
+ const serializeAws_json1_1PollForTaskInput = (input, context) => {
1152
+ return {
1153
+ ...(input.hostname != null && { hostname: input.hostname }),
1154
+ ...(input.instanceIdentity != null && {
1155
+ instanceIdentity: serializeAws_json1_1InstanceIdentity(input.instanceIdentity, context),
1156
+ }),
1157
+ ...(input.workerGroup != null && { workerGroup: input.workerGroup }),
1158
+ };
1538
1159
  };
1539
- var serializeAws_json1_1PutPipelineDefinitionInput = function (input, context) {
1540
- return __assign(__assign(__assign(__assign({}, (input.parameterObjects != null && {
1541
- parameterObjects: serializeAws_json1_1ParameterObjectList(input.parameterObjects, context),
1542
- })), (input.parameterValues != null && {
1543
- parameterValues: serializeAws_json1_1ParameterValueList(input.parameterValues, context),
1544
- })), (input.pipelineId != null && { pipelineId: input.pipelineId })), (input.pipelineObjects != null && {
1545
- pipelineObjects: serializeAws_json1_1PipelineObjectList(input.pipelineObjects, context),
1546
- }));
1160
+ const serializeAws_json1_1PutPipelineDefinitionInput = (input, context) => {
1161
+ return {
1162
+ ...(input.parameterObjects != null && {
1163
+ parameterObjects: serializeAws_json1_1ParameterObjectList(input.parameterObjects, context),
1164
+ }),
1165
+ ...(input.parameterValues != null && {
1166
+ parameterValues: serializeAws_json1_1ParameterValueList(input.parameterValues, context),
1167
+ }),
1168
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1169
+ ...(input.pipelineObjects != null && {
1170
+ pipelineObjects: serializeAws_json1_1PipelineObjectList(input.pipelineObjects, context),
1171
+ }),
1172
+ };
1547
1173
  };
1548
- var serializeAws_json1_1Query = function (input, context) {
1549
- return __assign({}, (input.selectors != null && { selectors: serializeAws_json1_1SelectorList(input.selectors, context) }));
1174
+ const serializeAws_json1_1Query = (input, context) => {
1175
+ return {
1176
+ ...(input.selectors != null && { selectors: serializeAws_json1_1SelectorList(input.selectors, context) }),
1177
+ };
1550
1178
  };
1551
- var serializeAws_json1_1QueryObjectsInput = function (input, context) {
1552
- return __assign(__assign(__assign(__assign(__assign({}, (input.limit != null && { limit: input.limit })), (input.marker != null && { marker: input.marker })), (input.pipelineId != null && { pipelineId: input.pipelineId })), (input.query != null && { query: serializeAws_json1_1Query(input.query, context) })), (input.sphere != null && { sphere: input.sphere }));
1179
+ const serializeAws_json1_1QueryObjectsInput = (input, context) => {
1180
+ return {
1181
+ ...(input.limit != null && { limit: input.limit }),
1182
+ ...(input.marker != null && { marker: input.marker }),
1183
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1184
+ ...(input.query != null && { query: serializeAws_json1_1Query(input.query, context) }),
1185
+ ...(input.sphere != null && { sphere: input.sphere }),
1186
+ };
1553
1187
  };
1554
- var serializeAws_json1_1RemoveTagsInput = function (input, context) {
1555
- return __assign(__assign({}, (input.pipelineId != null && { pipelineId: input.pipelineId })), (input.tagKeys != null && { tagKeys: serializeAws_json1_1stringList(input.tagKeys, context) }));
1188
+ const serializeAws_json1_1RemoveTagsInput = (input, context) => {
1189
+ return {
1190
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1191
+ ...(input.tagKeys != null && { tagKeys: serializeAws_json1_1stringList(input.tagKeys, context) }),
1192
+ };
1556
1193
  };
1557
- var serializeAws_json1_1ReportTaskProgressInput = function (input, context) {
1558
- return __assign(__assign({}, (input.fields != null && { fields: serializeAws_json1_1fieldList(input.fields, context) })), (input.taskId != null && { taskId: input.taskId }));
1194
+ const serializeAws_json1_1ReportTaskProgressInput = (input, context) => {
1195
+ return {
1196
+ ...(input.fields != null && { fields: serializeAws_json1_1fieldList(input.fields, context) }),
1197
+ ...(input.taskId != null && { taskId: input.taskId }),
1198
+ };
1559
1199
  };
1560
- var serializeAws_json1_1ReportTaskRunnerHeartbeatInput = function (input, context) {
1561
- return __assign(__assign(__assign({}, (input.hostname != null && { hostname: input.hostname })), (input.taskrunnerId != null && { taskrunnerId: input.taskrunnerId })), (input.workerGroup != null && { workerGroup: input.workerGroup }));
1200
+ const serializeAws_json1_1ReportTaskRunnerHeartbeatInput = (input, context) => {
1201
+ return {
1202
+ ...(input.hostname != null && { hostname: input.hostname }),
1203
+ ...(input.taskrunnerId != null && { taskrunnerId: input.taskrunnerId }),
1204
+ ...(input.workerGroup != null && { workerGroup: input.workerGroup }),
1205
+ };
1562
1206
  };
1563
- var serializeAws_json1_1Selector = function (input, context) {
1564
- return __assign(__assign({}, (input.fieldName != null && { fieldName: input.fieldName })), (input.operator != null && { operator: serializeAws_json1_1Operator(input.operator, context) }));
1207
+ const serializeAws_json1_1Selector = (input, context) => {
1208
+ return {
1209
+ ...(input.fieldName != null && { fieldName: input.fieldName }),
1210
+ ...(input.operator != null && { operator: serializeAws_json1_1Operator(input.operator, context) }),
1211
+ };
1565
1212
  };
1566
- var serializeAws_json1_1SelectorList = function (input, context) {
1213
+ const serializeAws_json1_1SelectorList = (input, context) => {
1567
1214
  return input
1568
- .filter(function (e) { return e != null; })
1569
- .map(function (entry) {
1215
+ .filter((e) => e != null)
1216
+ .map((entry) => {
1570
1217
  return serializeAws_json1_1Selector(entry, context);
1571
1218
  });
1572
1219
  };
1573
- var serializeAws_json1_1SetStatusInput = function (input, context) {
1574
- return __assign(__assign(__assign({}, (input.objectIds != null && { objectIds: serializeAws_json1_1idList(input.objectIds, context) })), (input.pipelineId != null && { pipelineId: input.pipelineId })), (input.status != null && { status: input.status }));
1220
+ const serializeAws_json1_1SetStatusInput = (input, context) => {
1221
+ return {
1222
+ ...(input.objectIds != null && { objectIds: serializeAws_json1_1idList(input.objectIds, context) }),
1223
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1224
+ ...(input.status != null && { status: input.status }),
1225
+ };
1575
1226
  };
1576
- var serializeAws_json1_1SetTaskStatusInput = function (input, context) {
1577
- return __assign(__assign(__assign(__assign(__assign({}, (input.errorId != null && { errorId: input.errorId })), (input.errorMessage != null && { errorMessage: input.errorMessage })), (input.errorStackTrace != null && { errorStackTrace: input.errorStackTrace })), (input.taskId != null && { taskId: input.taskId })), (input.taskStatus != null && { taskStatus: input.taskStatus }));
1227
+ const serializeAws_json1_1SetTaskStatusInput = (input, context) => {
1228
+ return {
1229
+ ...(input.errorId != null && { errorId: input.errorId }),
1230
+ ...(input.errorMessage != null && { errorMessage: input.errorMessage }),
1231
+ ...(input.errorStackTrace != null && { errorStackTrace: input.errorStackTrace }),
1232
+ ...(input.taskId != null && { taskId: input.taskId }),
1233
+ ...(input.taskStatus != null && { taskStatus: input.taskStatus }),
1234
+ };
1578
1235
  };
1579
- var serializeAws_json1_1stringList = function (input, context) {
1236
+ const serializeAws_json1_1stringList = (input, context) => {
1580
1237
  return input
1581
- .filter(function (e) { return e != null; })
1582
- .map(function (entry) {
1238
+ .filter((e) => e != null)
1239
+ .map((entry) => {
1583
1240
  return entry;
1584
1241
  });
1585
1242
  };
1586
- var serializeAws_json1_1Tag = function (input, context) {
1587
- return __assign(__assign({}, (input.key != null && { key: input.key })), (input.value != null && { value: input.value }));
1243
+ const serializeAws_json1_1Tag = (input, context) => {
1244
+ return {
1245
+ ...(input.key != null && { key: input.key }),
1246
+ ...(input.value != null && { value: input.value }),
1247
+ };
1588
1248
  };
1589
- var serializeAws_json1_1tagList = function (input, context) {
1249
+ const serializeAws_json1_1tagList = (input, context) => {
1590
1250
  return input
1591
- .filter(function (e) { return e != null; })
1592
- .map(function (entry) {
1251
+ .filter((e) => e != null)
1252
+ .map((entry) => {
1593
1253
  return serializeAws_json1_1Tag(entry, context);
1594
1254
  });
1595
1255
  };
1596
- var serializeAws_json1_1ValidatePipelineDefinitionInput = function (input, context) {
1597
- return __assign(__assign(__assign(__assign({}, (input.parameterObjects != null && {
1598
- parameterObjects: serializeAws_json1_1ParameterObjectList(input.parameterObjects, context),
1599
- })), (input.parameterValues != null && {
1600
- parameterValues: serializeAws_json1_1ParameterValueList(input.parameterValues, context),
1601
- })), (input.pipelineId != null && { pipelineId: input.pipelineId })), (input.pipelineObjects != null && {
1602
- pipelineObjects: serializeAws_json1_1PipelineObjectList(input.pipelineObjects, context),
1603
- }));
1256
+ const serializeAws_json1_1ValidatePipelineDefinitionInput = (input, context) => {
1257
+ return {
1258
+ ...(input.parameterObjects != null && {
1259
+ parameterObjects: serializeAws_json1_1ParameterObjectList(input.parameterObjects, context),
1260
+ }),
1261
+ ...(input.parameterValues != null && {
1262
+ parameterValues: serializeAws_json1_1ParameterValueList(input.parameterValues, context),
1263
+ }),
1264
+ ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
1265
+ ...(input.pipelineObjects != null && {
1266
+ pipelineObjects: serializeAws_json1_1PipelineObjectList(input.pipelineObjects, context),
1267
+ }),
1268
+ };
1604
1269
  };
1605
- var deserializeAws_json1_1ActivatePipelineOutput = function (output, context) {
1270
+ const deserializeAws_json1_1ActivatePipelineOutput = (output, context) => {
1606
1271
  return {};
1607
1272
  };
1608
- var deserializeAws_json1_1AddTagsOutput = function (output, context) {
1273
+ const deserializeAws_json1_1AddTagsOutput = (output, context) => {
1609
1274
  return {};
1610
1275
  };
1611
- var deserializeAws_json1_1CreatePipelineOutput = function (output, context) {
1276
+ const deserializeAws_json1_1CreatePipelineOutput = (output, context) => {
1612
1277
  return {
1613
1278
  pipelineId: __expectString(output.pipelineId),
1614
1279
  };
1615
1280
  };
1616
- var deserializeAws_json1_1DeactivatePipelineOutput = function (output, context) {
1281
+ const deserializeAws_json1_1DeactivatePipelineOutput = (output, context) => {
1617
1282
  return {};
1618
1283
  };
1619
- var deserializeAws_json1_1DescribeObjectsOutput = function (output, context) {
1284
+ const deserializeAws_json1_1DescribeObjectsOutput = (output, context) => {
1620
1285
  return {
1621
1286
  hasMoreResults: __expectBoolean(output.hasMoreResults),
1622
1287
  marker: __expectString(output.marker),
@@ -1625,29 +1290,29 @@ var deserializeAws_json1_1DescribeObjectsOutput = function (output, context) {
1625
1290
  : undefined,
1626
1291
  };
1627
1292
  };
1628
- var deserializeAws_json1_1DescribePipelinesOutput = function (output, context) {
1293
+ const deserializeAws_json1_1DescribePipelinesOutput = (output, context) => {
1629
1294
  return {
1630
1295
  pipelineDescriptionList: output.pipelineDescriptionList != null
1631
1296
  ? deserializeAws_json1_1PipelineDescriptionList(output.pipelineDescriptionList, context)
1632
1297
  : undefined,
1633
1298
  };
1634
1299
  };
1635
- var deserializeAws_json1_1EvaluateExpressionOutput = function (output, context) {
1300
+ const deserializeAws_json1_1EvaluateExpressionOutput = (output, context) => {
1636
1301
  return {
1637
1302
  evaluatedExpression: __expectString(output.evaluatedExpression),
1638
1303
  };
1639
1304
  };
1640
- var deserializeAws_json1_1Field = function (output, context) {
1305
+ const deserializeAws_json1_1Field = (output, context) => {
1641
1306
  return {
1642
1307
  key: __expectString(output.key),
1643
1308
  refValue: __expectString(output.refValue),
1644
1309
  stringValue: __expectString(output.stringValue),
1645
1310
  };
1646
1311
  };
1647
- var deserializeAws_json1_1fieldList = function (output, context) {
1648
- var retVal = (output || [])
1649
- .filter(function (e) { return e != null; })
1650
- .map(function (entry) {
1312
+ const deserializeAws_json1_1fieldList = (output, context) => {
1313
+ const retVal = (output || [])
1314
+ .filter((e) => e != null)
1315
+ .map((entry) => {
1651
1316
  if (entry === null) {
1652
1317
  return null;
1653
1318
  }
@@ -1655,7 +1320,7 @@ var deserializeAws_json1_1fieldList = function (output, context) {
1655
1320
  });
1656
1321
  return retVal;
1657
1322
  };
1658
- var deserializeAws_json1_1GetPipelineDefinitionOutput = function (output, context) {
1323
+ const deserializeAws_json1_1GetPipelineDefinitionOutput = (output, context) => {
1659
1324
  return {
1660
1325
  parameterObjects: output.parameterObjects != null
1661
1326
  ? deserializeAws_json1_1ParameterObjectList(output.parameterObjects, context)
@@ -1668,10 +1333,10 @@ var deserializeAws_json1_1GetPipelineDefinitionOutput = function (output, contex
1668
1333
  : undefined,
1669
1334
  };
1670
1335
  };
1671
- var deserializeAws_json1_1idList = function (output, context) {
1672
- var retVal = (output || [])
1673
- .filter(function (e) { return e != null; })
1674
- .map(function (entry) {
1336
+ const deserializeAws_json1_1idList = (output, context) => {
1337
+ const retVal = (output || [])
1338
+ .filter((e) => e != null)
1339
+ .map((entry) => {
1675
1340
  if (entry === null) {
1676
1341
  return null;
1677
1342
  }
@@ -1679,33 +1344,33 @@ var deserializeAws_json1_1idList = function (output, context) {
1679
1344
  });
1680
1345
  return retVal;
1681
1346
  };
1682
- var deserializeAws_json1_1InternalServiceError = function (output, context) {
1347
+ const deserializeAws_json1_1InternalServiceError = (output, context) => {
1683
1348
  return {
1684
1349
  message: __expectString(output.message),
1685
1350
  };
1686
1351
  };
1687
- var deserializeAws_json1_1InvalidRequestException = function (output, context) {
1352
+ const deserializeAws_json1_1InvalidRequestException = (output, context) => {
1688
1353
  return {
1689
1354
  message: __expectString(output.message),
1690
1355
  };
1691
1356
  };
1692
- var deserializeAws_json1_1ListPipelinesOutput = function (output, context) {
1357
+ const deserializeAws_json1_1ListPipelinesOutput = (output, context) => {
1693
1358
  return {
1694
1359
  hasMoreResults: __expectBoolean(output.hasMoreResults),
1695
1360
  marker: __expectString(output.marker),
1696
1361
  pipelineIdList: output.pipelineIdList != null ? deserializeAws_json1_1pipelineList(output.pipelineIdList, context) : undefined,
1697
1362
  };
1698
1363
  };
1699
- var deserializeAws_json1_1ParameterAttribute = function (output, context) {
1364
+ const deserializeAws_json1_1ParameterAttribute = (output, context) => {
1700
1365
  return {
1701
1366
  key: __expectString(output.key),
1702
1367
  stringValue: __expectString(output.stringValue),
1703
1368
  };
1704
1369
  };
1705
- var deserializeAws_json1_1ParameterAttributeList = function (output, context) {
1706
- var retVal = (output || [])
1707
- .filter(function (e) { return e != null; })
1708
- .map(function (entry) {
1370
+ const deserializeAws_json1_1ParameterAttributeList = (output, context) => {
1371
+ const retVal = (output || [])
1372
+ .filter((e) => e != null)
1373
+ .map((entry) => {
1709
1374
  if (entry === null) {
1710
1375
  return null;
1711
1376
  }
@@ -1713,16 +1378,16 @@ var deserializeAws_json1_1ParameterAttributeList = function (output, context) {
1713
1378
  });
1714
1379
  return retVal;
1715
1380
  };
1716
- var deserializeAws_json1_1ParameterObject = function (output, context) {
1381
+ const deserializeAws_json1_1ParameterObject = (output, context) => {
1717
1382
  return {
1718
1383
  attributes: output.attributes != null ? deserializeAws_json1_1ParameterAttributeList(output.attributes, context) : undefined,
1719
1384
  id: __expectString(output.id),
1720
1385
  };
1721
1386
  };
1722
- var deserializeAws_json1_1ParameterObjectList = function (output, context) {
1723
- var retVal = (output || [])
1724
- .filter(function (e) { return e != null; })
1725
- .map(function (entry) {
1387
+ const deserializeAws_json1_1ParameterObjectList = (output, context) => {
1388
+ const retVal = (output || [])
1389
+ .filter((e) => e != null)
1390
+ .map((entry) => {
1726
1391
  if (entry === null) {
1727
1392
  return null;
1728
1393
  }
@@ -1730,16 +1395,16 @@ var deserializeAws_json1_1ParameterObjectList = function (output, context) {
1730
1395
  });
1731
1396
  return retVal;
1732
1397
  };
1733
- var deserializeAws_json1_1ParameterValue = function (output, context) {
1398
+ const deserializeAws_json1_1ParameterValue = (output, context) => {
1734
1399
  return {
1735
1400
  id: __expectString(output.id),
1736
1401
  stringValue: __expectString(output.stringValue),
1737
1402
  };
1738
1403
  };
1739
- var deserializeAws_json1_1ParameterValueList = function (output, context) {
1740
- var retVal = (output || [])
1741
- .filter(function (e) { return e != null; })
1742
- .map(function (entry) {
1404
+ const deserializeAws_json1_1ParameterValueList = (output, context) => {
1405
+ const retVal = (output || [])
1406
+ .filter((e) => e != null)
1407
+ .map((entry) => {
1743
1408
  if (entry === null) {
1744
1409
  return null;
1745
1410
  }
@@ -1747,12 +1412,12 @@ var deserializeAws_json1_1ParameterValueList = function (output, context) {
1747
1412
  });
1748
1413
  return retVal;
1749
1414
  };
1750
- var deserializeAws_json1_1PipelineDeletedException = function (output, context) {
1415
+ const deserializeAws_json1_1PipelineDeletedException = (output, context) => {
1751
1416
  return {
1752
1417
  message: __expectString(output.message),
1753
1418
  };
1754
1419
  };
1755
- var deserializeAws_json1_1PipelineDescription = function (output, context) {
1420
+ const deserializeAws_json1_1PipelineDescription = (output, context) => {
1756
1421
  return {
1757
1422
  description: __expectString(output.description),
1758
1423
  fields: output.fields != null ? deserializeAws_json1_1fieldList(output.fields, context) : undefined,
@@ -1761,10 +1426,10 @@ var deserializeAws_json1_1PipelineDescription = function (output, context) {
1761
1426
  tags: output.tags != null ? deserializeAws_json1_1tagList(output.tags, context) : undefined,
1762
1427
  };
1763
1428
  };
1764
- var deserializeAws_json1_1PipelineDescriptionList = function (output, context) {
1765
- var retVal = (output || [])
1766
- .filter(function (e) { return e != null; })
1767
- .map(function (entry) {
1429
+ const deserializeAws_json1_1PipelineDescriptionList = (output, context) => {
1430
+ const retVal = (output || [])
1431
+ .filter((e) => e != null)
1432
+ .map((entry) => {
1768
1433
  if (entry === null) {
1769
1434
  return null;
1770
1435
  }
@@ -1772,16 +1437,16 @@ var deserializeAws_json1_1PipelineDescriptionList = function (output, context) {
1772
1437
  });
1773
1438
  return retVal;
1774
1439
  };
1775
- var deserializeAws_json1_1PipelineIdName = function (output, context) {
1440
+ const deserializeAws_json1_1PipelineIdName = (output, context) => {
1776
1441
  return {
1777
1442
  id: __expectString(output.id),
1778
1443
  name: __expectString(output.name),
1779
1444
  };
1780
1445
  };
1781
- var deserializeAws_json1_1pipelineList = function (output, context) {
1782
- var retVal = (output || [])
1783
- .filter(function (e) { return e != null; })
1784
- .map(function (entry) {
1446
+ const deserializeAws_json1_1pipelineList = (output, context) => {
1447
+ const retVal = (output || [])
1448
+ .filter((e) => e != null)
1449
+ .map((entry) => {
1785
1450
  if (entry === null) {
1786
1451
  return null;
1787
1452
  }
@@ -1789,22 +1454,22 @@ var deserializeAws_json1_1pipelineList = function (output, context) {
1789
1454
  });
1790
1455
  return retVal;
1791
1456
  };
1792
- var deserializeAws_json1_1PipelineNotFoundException = function (output, context) {
1457
+ const deserializeAws_json1_1PipelineNotFoundException = (output, context) => {
1793
1458
  return {
1794
1459
  message: __expectString(output.message),
1795
1460
  };
1796
1461
  };
1797
- var deserializeAws_json1_1PipelineObject = function (output, context) {
1462
+ const deserializeAws_json1_1PipelineObject = (output, context) => {
1798
1463
  return {
1799
1464
  fields: output.fields != null ? deserializeAws_json1_1fieldList(output.fields, context) : undefined,
1800
1465
  id: __expectString(output.id),
1801
1466
  name: __expectString(output.name),
1802
1467
  };
1803
1468
  };
1804
- var deserializeAws_json1_1PipelineObjectList = function (output, context) {
1805
- var retVal = (output || [])
1806
- .filter(function (e) { return e != null; })
1807
- .map(function (entry) {
1469
+ const deserializeAws_json1_1PipelineObjectList = (output, context) => {
1470
+ const retVal = (output || [])
1471
+ .filter((e) => e != null)
1472
+ .map((entry) => {
1808
1473
  if (entry === null) {
1809
1474
  return null;
1810
1475
  }
@@ -1812,22 +1477,23 @@ var deserializeAws_json1_1PipelineObjectList = function (output, context) {
1812
1477
  });
1813
1478
  return retVal;
1814
1479
  };
1815
- var deserializeAws_json1_1PipelineObjectMap = function (output, context) {
1816
- return Object.entries(output).reduce(function (acc, _a) {
1817
- var _b;
1818
- var _c = __read(_a, 2), key = _c[0], value = _c[1];
1480
+ const deserializeAws_json1_1PipelineObjectMap = (output, context) => {
1481
+ return Object.entries(output).reduce((acc, [key, value]) => {
1819
1482
  if (value === null) {
1820
1483
  return acc;
1821
1484
  }
1822
- return __assign(__assign({}, acc), (_b = {}, _b[key] = deserializeAws_json1_1PipelineObject(value, context), _b));
1485
+ return {
1486
+ ...acc,
1487
+ [key]: deserializeAws_json1_1PipelineObject(value, context),
1488
+ };
1823
1489
  }, {});
1824
1490
  };
1825
- var deserializeAws_json1_1PollForTaskOutput = function (output, context) {
1491
+ const deserializeAws_json1_1PollForTaskOutput = (output, context) => {
1826
1492
  return {
1827
1493
  taskObject: output.taskObject != null ? deserializeAws_json1_1TaskObject(output.taskObject, context) : undefined,
1828
1494
  };
1829
1495
  };
1830
- var deserializeAws_json1_1PutPipelineDefinitionOutput = function (output, context) {
1496
+ const deserializeAws_json1_1PutPipelineDefinitionOutput = (output, context) => {
1831
1497
  return {
1832
1498
  errored: __expectBoolean(output.errored),
1833
1499
  validationErrors: output.validationErrors != null
@@ -1838,39 +1504,39 @@ var deserializeAws_json1_1PutPipelineDefinitionOutput = function (output, contex
1838
1504
  : undefined,
1839
1505
  };
1840
1506
  };
1841
- var deserializeAws_json1_1QueryObjectsOutput = function (output, context) {
1507
+ const deserializeAws_json1_1QueryObjectsOutput = (output, context) => {
1842
1508
  return {
1843
1509
  hasMoreResults: __expectBoolean(output.hasMoreResults),
1844
1510
  ids: output.ids != null ? deserializeAws_json1_1idList(output.ids, context) : undefined,
1845
1511
  marker: __expectString(output.marker),
1846
1512
  };
1847
1513
  };
1848
- var deserializeAws_json1_1RemoveTagsOutput = function (output, context) {
1514
+ const deserializeAws_json1_1RemoveTagsOutput = (output, context) => {
1849
1515
  return {};
1850
1516
  };
1851
- var deserializeAws_json1_1ReportTaskProgressOutput = function (output, context) {
1517
+ const deserializeAws_json1_1ReportTaskProgressOutput = (output, context) => {
1852
1518
  return {
1853
1519
  canceled: __expectBoolean(output.canceled),
1854
1520
  };
1855
1521
  };
1856
- var deserializeAws_json1_1ReportTaskRunnerHeartbeatOutput = function (output, context) {
1522
+ const deserializeAws_json1_1ReportTaskRunnerHeartbeatOutput = (output, context) => {
1857
1523
  return {
1858
1524
  terminate: __expectBoolean(output.terminate),
1859
1525
  };
1860
1526
  };
1861
- var deserializeAws_json1_1SetTaskStatusOutput = function (output, context) {
1527
+ const deserializeAws_json1_1SetTaskStatusOutput = (output, context) => {
1862
1528
  return {};
1863
1529
  };
1864
- var deserializeAws_json1_1Tag = function (output, context) {
1530
+ const deserializeAws_json1_1Tag = (output, context) => {
1865
1531
  return {
1866
1532
  key: __expectString(output.key),
1867
1533
  value: __expectString(output.value),
1868
1534
  };
1869
1535
  };
1870
- var deserializeAws_json1_1tagList = function (output, context) {
1871
- var retVal = (output || [])
1872
- .filter(function (e) { return e != null; })
1873
- .map(function (entry) {
1536
+ const deserializeAws_json1_1tagList = (output, context) => {
1537
+ const retVal = (output || [])
1538
+ .filter((e) => e != null)
1539
+ .map((entry) => {
1874
1540
  if (entry === null) {
1875
1541
  return null;
1876
1542
  }
@@ -1878,12 +1544,12 @@ var deserializeAws_json1_1tagList = function (output, context) {
1878
1544
  });
1879
1545
  return retVal;
1880
1546
  };
1881
- var deserializeAws_json1_1TaskNotFoundException = function (output, context) {
1547
+ const deserializeAws_json1_1TaskNotFoundException = (output, context) => {
1882
1548
  return {
1883
1549
  message: __expectString(output.message),
1884
1550
  };
1885
1551
  };
1886
- var deserializeAws_json1_1TaskObject = function (output, context) {
1552
+ const deserializeAws_json1_1TaskObject = (output, context) => {
1887
1553
  return {
1888
1554
  attemptId: __expectString(output.attemptId),
1889
1555
  objects: output.objects != null ? deserializeAws_json1_1PipelineObjectMap(output.objects, context) : undefined,
@@ -1891,7 +1557,7 @@ var deserializeAws_json1_1TaskObject = function (output, context) {
1891
1557
  taskId: __expectString(output.taskId),
1892
1558
  };
1893
1559
  };
1894
- var deserializeAws_json1_1ValidatePipelineDefinitionOutput = function (output, context) {
1560
+ const deserializeAws_json1_1ValidatePipelineDefinitionOutput = (output, context) => {
1895
1561
  return {
1896
1562
  errored: __expectBoolean(output.errored),
1897
1563
  validationErrors: output.validationErrors != null
@@ -1902,16 +1568,16 @@ var deserializeAws_json1_1ValidatePipelineDefinitionOutput = function (output, c
1902
1568
  : undefined,
1903
1569
  };
1904
1570
  };
1905
- var deserializeAws_json1_1ValidationError = function (output, context) {
1571
+ const deserializeAws_json1_1ValidationError = (output, context) => {
1906
1572
  return {
1907
1573
  errors: output.errors != null ? deserializeAws_json1_1validationMessages(output.errors, context) : undefined,
1908
1574
  id: __expectString(output.id),
1909
1575
  };
1910
1576
  };
1911
- var deserializeAws_json1_1ValidationErrors = function (output, context) {
1912
- var retVal = (output || [])
1913
- .filter(function (e) { return e != null; })
1914
- .map(function (entry) {
1577
+ const deserializeAws_json1_1ValidationErrors = (output, context) => {
1578
+ const retVal = (output || [])
1579
+ .filter((e) => e != null)
1580
+ .map((entry) => {
1915
1581
  if (entry === null) {
1916
1582
  return null;
1917
1583
  }
@@ -1919,10 +1585,10 @@ var deserializeAws_json1_1ValidationErrors = function (output, context) {
1919
1585
  });
1920
1586
  return retVal;
1921
1587
  };
1922
- var deserializeAws_json1_1validationMessages = function (output, context) {
1923
- var retVal = (output || [])
1924
- .filter(function (e) { return e != null; })
1925
- .map(function (entry) {
1588
+ const deserializeAws_json1_1validationMessages = (output, context) => {
1589
+ const retVal = (output || [])
1590
+ .filter((e) => e != null)
1591
+ .map((entry) => {
1926
1592
  if (entry === null) {
1927
1593
  return null;
1928
1594
  }
@@ -1930,16 +1596,16 @@ var deserializeAws_json1_1validationMessages = function (output, context) {
1930
1596
  });
1931
1597
  return retVal;
1932
1598
  };
1933
- var deserializeAws_json1_1ValidationWarning = function (output, context) {
1599
+ const deserializeAws_json1_1ValidationWarning = (output, context) => {
1934
1600
  return {
1935
1601
  id: __expectString(output.id),
1936
1602
  warnings: output.warnings != null ? deserializeAws_json1_1validationMessages(output.warnings, context) : undefined,
1937
1603
  };
1938
1604
  };
1939
- var deserializeAws_json1_1ValidationWarnings = function (output, context) {
1940
- var retVal = (output || [])
1941
- .filter(function (e) { return e != null; })
1942
- .map(function (entry) {
1605
+ const deserializeAws_json1_1ValidationWarnings = (output, context) => {
1606
+ const retVal = (output || [])
1607
+ .filter((e) => e != null)
1608
+ .map((entry) => {
1943
1609
  if (entry === null) {
1944
1610
  return null;
1945
1611
  }
@@ -1947,62 +1613,52 @@ var deserializeAws_json1_1ValidationWarnings = function (output, context) {
1947
1613
  });
1948
1614
  return retVal;
1949
1615
  };
1950
- var deserializeMetadata = function (output) {
1951
- var _a;
1952
- return ({
1953
- httpStatusCode: output.statusCode,
1954
- requestId: (_a = output.headers["x-amzn-requestid"]) !== null && _a !== void 0 ? _a : output.headers["x-amzn-request-id"],
1955
- extendedRequestId: output.headers["x-amz-id-2"],
1956
- cfId: output.headers["x-amz-cf-id"],
1957
- });
1958
- };
1959
- var collectBody = function (streamBody, context) {
1960
- if (streamBody === void 0) { streamBody = new Uint8Array(); }
1616
+ const deserializeMetadata = (output) => ({
1617
+ httpStatusCode: output.statusCode,
1618
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"],
1619
+ extendedRequestId: output.headers["x-amz-id-2"],
1620
+ cfId: output.headers["x-amz-cf-id"],
1621
+ });
1622
+ const collectBody = (streamBody = new Uint8Array(), context) => {
1961
1623
  if (streamBody instanceof Uint8Array) {
1962
1624
  return Promise.resolve(streamBody);
1963
1625
  }
1964
1626
  return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
1965
1627
  };
1966
- var collectBodyString = function (streamBody, context) {
1967
- return collectBody(streamBody, context).then(function (body) { return context.utf8Encoder(body); });
1968
- };
1969
- var buildHttpRpcRequest = function (context, headers, path, resolvedHostname, body) { return __awaiter(void 0, void 0, void 0, function () {
1970
- var _a, hostname, _b, protocol, port, basePath, contents;
1971
- return __generator(this, function (_c) {
1972
- switch (_c.label) {
1973
- case 0: return [4, context.endpoint()];
1974
- case 1:
1975
- _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
1976
- contents = {
1977
- protocol: protocol,
1978
- hostname: hostname,
1979
- port: port,
1980
- method: "POST",
1981
- path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
1982
- headers: headers,
1983
- };
1984
- if (resolvedHostname !== undefined) {
1985
- contents.hostname = resolvedHostname;
1986
- }
1987
- if (body !== undefined) {
1988
- contents.body = body;
1989
- }
1990
- return [2, new __HttpRequest(contents)];
1991
- }
1992
- });
1993
- }); };
1994
- var parseBody = function (streamBody, context) {
1995
- return collectBodyString(streamBody, context).then(function (encoded) {
1996
- if (encoded.length) {
1997
- return JSON.parse(encoded);
1998
- }
1999
- return {};
2000
- });
1628
+ const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
1629
+ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
1630
+ const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1631
+ const contents = {
1632
+ protocol,
1633
+ hostname,
1634
+ port,
1635
+ method: "POST",
1636
+ path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
1637
+ headers,
1638
+ };
1639
+ if (resolvedHostname !== undefined) {
1640
+ contents.hostname = resolvedHostname;
1641
+ }
1642
+ if (body !== undefined) {
1643
+ contents.body = body;
1644
+ }
1645
+ return new __HttpRequest(contents);
2001
1646
  };
2002
- var loadRestJsonErrorCode = function (output, data) {
2003
- var findKey = function (object, key) { return Object.keys(object).find(function (k) { return k.toLowerCase() === key.toLowerCase(); }); };
2004
- var sanitizeErrorCode = function (rawValue) {
2005
- var cleanValue = rawValue;
1647
+ const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
1648
+ if (encoded.length) {
1649
+ return JSON.parse(encoded);
1650
+ }
1651
+ return {};
1652
+ });
1653
+ const parseErrorBody = async (errorBody, context) => {
1654
+ const value = await parseBody(errorBody, context);
1655
+ value.message = value.message ?? value.Message;
1656
+ return value;
1657
+ };
1658
+ const loadRestJsonErrorCode = (output, data) => {
1659
+ const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
1660
+ const sanitizeErrorCode = (rawValue) => {
1661
+ let cleanValue = rawValue;
2006
1662
  if (typeof cleanValue === "number") {
2007
1663
  cleanValue = cleanValue.toString();
2008
1664
  }
@@ -2017,7 +1673,7 @@ var loadRestJsonErrorCode = function (output, data) {
2017
1673
  }
2018
1674
  return cleanValue;
2019
1675
  };
2020
- var headerKey = findKey(output.headers, "x-amzn-errortype");
1676
+ const headerKey = findKey(output.headers, "x-amzn-errortype");
2021
1677
  if (headerKey !== undefined) {
2022
1678
  return sanitizeErrorCode(output.headers[headerKey]);
2023
1679
  }