@aws-sdk/client-mediaconvert 3.141.0 → 3.142.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 (4) hide show
  1. package/CHANGELOG.md +11 -0
  2. package/dist-cjs/protocols/Aws_restJson1.js +302 -628
  3. package/dist-es/protocols/Aws_restJson1.js +401 -620
  4. package/package.json +6 -6
package/dist-cjs/protocols/Aws_restJson1.js CHANGED
@@ -32,16 +32,7 @@ const serializeAws_restJson1CancelJobCommand = async (input, context) => {
32
32
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
33
33
  const headers = {};
34
34
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/jobs/{Id}";
35
- if (input.Id !== undefined) {
36
- const labelValue = input.Id;
37
- if (labelValue.length <= 0) {
38
- throw new Error("Empty value provided for input HTTP label: Id.");
39
- }
40
- resolvedPath = resolvedPath.replace("{Id}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
41
- }
42
- else {
43
- throw new Error("No value provided for input HTTP label: Id.");
44
- }
35
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
45
36
  let body;
46
37
  return new protocol_http_1.HttpRequest({
47
38
  protocol,
@@ -185,16 +176,7 @@ const serializeAws_restJson1DeleteJobTemplateCommand = async (input, context) =>
185
176
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
186
177
  const headers = {};
187
178
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/jobTemplates/{Name}";
188
- if (input.Name !== undefined) {
189
- const labelValue = input.Name;
190
- if (labelValue.length <= 0) {
191
- throw new Error("Empty value provided for input HTTP label: Name.");
192
- }
193
- resolvedPath = resolvedPath.replace("{Name}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
194
- }
195
- else {
196
- throw new Error("No value provided for input HTTP label: Name.");
197
- }
179
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
198
180
  let body;
199
181
  return new protocol_http_1.HttpRequest({
200
182
  protocol,
@@ -230,16 +212,7 @@ const serializeAws_restJson1DeletePresetCommand = async (input, context) => {
230
212
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
231
213
  const headers = {};
232
214
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/presets/{Name}";
233
- if (input.Name !== undefined) {
234
- const labelValue = input.Name;
235
- if (labelValue.length <= 0) {
236
- throw new Error("Empty value provided for input HTTP label: Name.");
237
- }
238
- resolvedPath = resolvedPath.replace("{Name}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
239
- }
240
- else {
241
- throw new Error("No value provided for input HTTP label: Name.");
242
- }
215
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
243
216
  let body;
244
217
  return new protocol_http_1.HttpRequest({
245
218
  protocol,
@@ -256,16 +229,7 @@ const serializeAws_restJson1DeleteQueueCommand = async (input, context) => {
256
229
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
257
230
  const headers = {};
258
231
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/queues/{Name}";
259
- if (input.Name !== undefined) {
260
- const labelValue = input.Name;
261
- if (labelValue.length <= 0) {
262
- throw new Error("Empty value provided for input HTTP label: Name.");
263
- }
264
- resolvedPath = resolvedPath.replace("{Name}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
265
- }
266
- else {
267
- throw new Error("No value provided for input HTTP label: Name.");
268
- }
232
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
269
233
  let body;
270
234
  return new protocol_http_1.HttpRequest({
271
235
  protocol,
@@ -305,16 +269,7 @@ const serializeAws_restJson1DisassociateCertificateCommand = async (input, conte
305
269
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
306
270
  const headers = {};
307
271
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/certificates/{Arn}";
308
- if (input.Arn !== undefined) {
309
- const labelValue = input.Arn;
310
- if (labelValue.length <= 0) {
311
- throw new Error("Empty value provided for input HTTP label: Arn.");
312
- }
313
- resolvedPath = resolvedPath.replace("{Arn}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
314
- }
315
- else {
316
- throw new Error("No value provided for input HTTP label: Arn.");
317
- }
272
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
318
273
  let body;
319
274
  return new protocol_http_1.HttpRequest({
320
275
  protocol,
@@ -331,16 +286,7 @@ const serializeAws_restJson1GetJobCommand = async (input, context) => {
331
286
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
332
287
  const headers = {};
333
288
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/jobs/{Id}";
334
- if (input.Id !== undefined) {
335
- const labelValue = input.Id;
336
- if (labelValue.length <= 0) {
337
- throw new Error("Empty value provided for input HTTP label: Id.");
338
- }
339
- resolvedPath = resolvedPath.replace("{Id}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
340
- }
341
- else {
342
- throw new Error("No value provided for input HTTP label: Id.");
343
- }
289
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
344
290
  let body;
345
291
  return new protocol_http_1.HttpRequest({
346
292
  protocol,
@@ -357,16 +303,7 @@ const serializeAws_restJson1GetJobTemplateCommand = async (input, context) => {
357
303
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
358
304
  const headers = {};
359
305
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/jobTemplates/{Name}";
360
- if (input.Name !== undefined) {
361
- const labelValue = input.Name;
362
- if (labelValue.length <= 0) {
363
- throw new Error("Empty value provided for input HTTP label: Name.");
364
- }
365
- resolvedPath = resolvedPath.replace("{Name}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
366
- }
367
- else {
368
- throw new Error("No value provided for input HTTP label: Name.");
369
- }
306
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
370
307
  let body;
371
308
  return new protocol_http_1.HttpRequest({
372
309
  protocol,
@@ -402,16 +339,7 @@ const serializeAws_restJson1GetPresetCommand = async (input, context) => {
402
339
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
403
340
  const headers = {};
404
341
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/presets/{Name}";
405
- if (input.Name !== undefined) {
406
- const labelValue = input.Name;
407
- if (labelValue.length <= 0) {
408
- throw new Error("Empty value provided for input HTTP label: Name.");
409
- }
410
- resolvedPath = resolvedPath.replace("{Name}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
411
- }
412
- else {
413
- throw new Error("No value provided for input HTTP label: Name.");
414
- }
342
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
415
343
  let body;
416
344
  return new protocol_http_1.HttpRequest({
417
345
  protocol,
@@ -428,16 +356,7 @@ const serializeAws_restJson1GetQueueCommand = async (input, context) => {
428
356
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
429
357
  const headers = {};
430
358
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/queues/{Name}";
431
- if (input.Name !== undefined) {
432
- const labelValue = input.Name;
433
- if (labelValue.length <= 0) {
434
- throw new Error("Empty value provided for input HTTP label: Name.");
435
- }
436
- resolvedPath = resolvedPath.replace("{Name}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
437
- }
438
- else {
439
- throw new Error("No value provided for input HTTP label: Name.");
440
- }
359
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
441
360
  let body;
442
361
  return new protocol_http_1.HttpRequest({
443
362
  protocol,
@@ -454,13 +373,13 @@ const serializeAws_restJson1ListJobsCommand = async (input, context) => {
454
373
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
455
374
  const headers = {};
456
375
  const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/jobs";
457
- const query = {
458
- ...(input.MaxResults !== undefined && { maxResults: input.MaxResults.toString() }),
459
- ...(input.NextToken !== undefined && { nextToken: input.NextToken }),
460
- ...(input.Order !== undefined && { order: input.Order }),
461
- ...(input.Queue !== undefined && { queue: input.Queue }),
462
- ...(input.Status !== undefined && { status: input.Status }),
463
- };
376
+ const query = map({
377
+ maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
378
+ nextToken: [, input.NextToken],
379
+ order: [, input.Order],
380
+ queue: [, input.Queue],
381
+ status: [, input.Status],
382
+ });
464
383
  let body;
465
384
  return new protocol_http_1.HttpRequest({
466
385
  protocol,
@@ -478,13 +397,13 @@ const serializeAws_restJson1ListJobTemplatesCommand = async (input, context) =>
478
397
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
479
398
  const headers = {};
480
399
  const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/jobTemplates";
481
- const query = {
482
- ...(input.Category !== undefined && { category: input.Category }),
483
- ...(input.ListBy !== undefined && { listBy: input.ListBy }),
484
- ...(input.MaxResults !== undefined && { maxResults: input.MaxResults.toString() }),
485
- ...(input.NextToken !== undefined && { nextToken: input.NextToken }),
486
- ...(input.Order !== undefined && { order: input.Order }),
487
- };
400
+ const query = map({
401
+ category: [, input.Category],
402
+ listBy: [, input.ListBy],
403
+ maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
404
+ nextToken: [, input.NextToken],
405
+ order: [, input.Order],
406
+ });
488
407
  let body;
489
408
  return new protocol_http_1.HttpRequest({
490
409
  protocol,
@@ -502,13 +421,13 @@ const serializeAws_restJson1ListPresetsCommand = async (input, context) => {
502
421
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
503
422
  const headers = {};
504
423
  const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/presets";
505
- const query = {
506
- ...(input.Category !== undefined && { category: input.Category }),
507
- ...(input.ListBy !== undefined && { listBy: input.ListBy }),
508
- ...(input.MaxResults !== undefined && { maxResults: input.MaxResults.toString() }),
509
- ...(input.NextToken !== undefined && { nextToken: input.NextToken }),
510
- ...(input.Order !== undefined && { order: input.Order }),
511
- };
424
+ const query = map({
425
+ category: [, input.Category],
426
+ listBy: [, input.ListBy],
427
+ maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
428
+ nextToken: [, input.NextToken],
429
+ order: [, input.Order],
430
+ });
512
431
  let body;
513
432
  return new protocol_http_1.HttpRequest({
514
433
  protocol,
@@ -526,12 +445,12 @@ const serializeAws_restJson1ListQueuesCommand = async (input, context) => {
526
445
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
527
446
  const headers = {};
528
447
  const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/queues";
529
- const query = {
530
- ...(input.ListBy !== undefined && { listBy: input.ListBy }),
531
- ...(input.MaxResults !== undefined && { maxResults: input.MaxResults.toString() }),
532
- ...(input.NextToken !== undefined && { nextToken: input.NextToken }),
533
- ...(input.Order !== undefined && { order: input.Order }),
534
- };
448
+ const query = map({
449
+ listBy: [, input.ListBy],
450
+ maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
451
+ nextToken: [, input.NextToken],
452
+ order: [, input.Order],
453
+ });
535
454
  let body;
536
455
  return new protocol_http_1.HttpRequest({
537
456
  protocol,
@@ -549,16 +468,7 @@ const serializeAws_restJson1ListTagsForResourceCommand = async (input, context)
549
468
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
550
469
  const headers = {};
551
470
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/tags/{Arn}";
552
- if (input.Arn !== undefined) {
553
- const labelValue = input.Arn;
554
- if (labelValue.length <= 0) {
555
- throw new Error("Empty value provided for input HTTP label: Arn.");
556
- }
557
- resolvedPath = resolvedPath.replace("{Arn}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
558
- }
559
- else {
560
- throw new Error("No value provided for input HTTP label: Arn.");
561
- }
471
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
562
472
  let body;
563
473
  return new protocol_http_1.HttpRequest({
564
474
  protocol,
@@ -620,16 +530,7 @@ const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
620
530
  "content-type": "application/json",
621
531
  };
622
532
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/tags/{Arn}";
623
- if (input.Arn !== undefined) {
624
- const labelValue = input.Arn;
625
- if (labelValue.length <= 0) {
626
- throw new Error("Empty value provided for input HTTP label: Arn.");
627
- }
628
- resolvedPath = resolvedPath.replace("{Arn}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
629
- }
630
- else {
631
- throw new Error("No value provided for input HTTP label: Arn.");
632
- }
533
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
633
534
  let body;
634
535
  body = JSON.stringify({
635
536
  ...(input.TagKeys != null && { tagKeys: serializeAws_restJson1__listOf__string(input.TagKeys, context) }),
@@ -651,16 +552,7 @@ const serializeAws_restJson1UpdateJobTemplateCommand = async (input, context) =>
651
552
  "content-type": "application/json",
652
553
  };
653
554
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/jobTemplates/{Name}";
654
- if (input.Name !== undefined) {
655
- const labelValue = input.Name;
656
- if (labelValue.length <= 0) {
657
- throw new Error("Empty value provided for input HTTP label: Name.");
658
- }
659
- resolvedPath = resolvedPath.replace("{Name}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
660
- }
661
- else {
662
- throw new Error("No value provided for input HTTP label: Name.");
663
- }
555
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
664
556
  let body;
665
557
  body = JSON.stringify({
666
558
  ...(input.AccelerationSettings != null && {
@@ -693,16 +585,7 @@ const serializeAws_restJson1UpdatePresetCommand = async (input, context) => {
693
585
  "content-type": "application/json",
694
586
  };
695
587
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/presets/{Name}";
696
- if (input.Name !== undefined) {
697
- const labelValue = input.Name;
698
- if (labelValue.length <= 0) {
699
- throw new Error("Empty value provided for input HTTP label: Name.");
700
- }
701
- resolvedPath = resolvedPath.replace("{Name}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
702
- }
703
- else {
704
- throw new Error("No value provided for input HTTP label: Name.");
705
- }
588
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
706
589
  let body;
707
590
  body = JSON.stringify({
708
591
  ...(input.Category != null && { category: input.Category }),
@@ -726,16 +609,7 @@ const serializeAws_restJson1UpdateQueueCommand = async (input, context) => {
726
609
  "content-type": "application/json",
727
610
  };
728
611
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/2017-08-29/queues/{Name}";
729
- if (input.Name !== undefined) {
730
- const labelValue = input.Name;
731
- if (labelValue.length <= 0) {
732
- throw new Error("Empty value provided for input HTTP label: Name.");
733
- }
734
- resolvedPath = resolvedPath.replace("{Name}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
735
- }
736
- else {
737
- throw new Error("No value provided for input HTTP label: Name.");
738
- }
612
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
739
613
  let body;
740
614
  body = JSON.stringify({
741
615
  ...(input.Description != null && { description: input.Description }),
@@ -759,11 +633,11 @@ const deserializeAws_restJson1AssociateCertificateCommand = async (output, conte
759
633
  if (output.statusCode !== 201 && output.statusCode >= 300) {
760
634
  return deserializeAws_restJson1AssociateCertificateCommandError(output, context);
761
635
  }
762
- const contents = {
636
+ const contents = map({
763
637
  $metadata: deserializeMetadata(output),
764
- };
638
+ });
765
639
  await collectBody(output.body, context);
766
- return Promise.resolve(contents);
640
+ return contents;
767
641
  };
768
642
  exports.deserializeAws_restJson1AssociateCertificateCommand = deserializeAws_restJson1AssociateCertificateCommand;
769
643
  const deserializeAws_restJson1AssociateCertificateCommandError = async (output, context) => {
@@ -771,7 +645,6 @@ const deserializeAws_restJson1AssociateCertificateCommandError = async (output,
771
645
  ...output,
772
646
  body: await parseBody(output.body, context),
773
647
  };
774
- let response;
775
648
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
776
649
  switch (errorCode) {
777
650
  case "BadRequestException":
@@ -794,25 +667,23 @@ const deserializeAws_restJson1AssociateCertificateCommandError = async (output,
794
667
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
795
668
  default:
796
669
  const parsedBody = parsedOutput.body;
797
- const $metadata = deserializeMetadata(output);
798
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
799
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
800
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
801
- $fault: "client",
802
- $metadata,
670
+ (0, smithy_client_1.throwDefaultError)({
671
+ output,
672
+ parsedBody,
673
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
674
+ errorCode,
803
675
  });
804
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
805
676
  }
806
677
  };
807
678
  const deserializeAws_restJson1CancelJobCommand = async (output, context) => {
808
679
  if (output.statusCode !== 202 && output.statusCode >= 300) {
809
680
  return deserializeAws_restJson1CancelJobCommandError(output, context);
810
681
  }
811
- const contents = {
682
+ const contents = map({
812
683
  $metadata: deserializeMetadata(output),
813
- };
684
+ });
814
685
  await collectBody(output.body, context);
815
- return Promise.resolve(contents);
686
+ return contents;
816
687
  };
817
688
  exports.deserializeAws_restJson1CancelJobCommand = deserializeAws_restJson1CancelJobCommand;
818
689
  const deserializeAws_restJson1CancelJobCommandError = async (output, context) => {
@@ -820,7 +691,6 @@ const deserializeAws_restJson1CancelJobCommandError = async (output, context) =>
820
691
  ...output,
821
692
  body: await parseBody(output.body, context),
822
693
  };
823
- let response;
824
694
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
825
695
  switch (errorCode) {
826
696
  case "BadRequestException":
@@ -843,29 +713,26 @@ const deserializeAws_restJson1CancelJobCommandError = async (output, context) =>
843
713
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
844
714
  default:
845
715
  const parsedBody = parsedOutput.body;
846
- const $metadata = deserializeMetadata(output);
847
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
848
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
849
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
850
- $fault: "client",
851
- $metadata,
716
+ (0, smithy_client_1.throwDefaultError)({
717
+ output,
718
+ parsedBody,
719
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
720
+ errorCode,
852
721
  });
853
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
854
722
  }
855
723
  };
856
724
  const deserializeAws_restJson1CreateJobCommand = async (output, context) => {
857
725
  if (output.statusCode !== 201 && output.statusCode >= 300) {
858
726
  return deserializeAws_restJson1CreateJobCommandError(output, context);
859
727
  }
860
- const contents = {
728
+ const contents = map({
861
729
  $metadata: deserializeMetadata(output),
862
- Job: undefined,
863
- };
730
+ });
864
731
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
865
- if (data.job !== undefined && data.job !== null) {
732
+ if (data.job != null) {
866
733
  contents.Job = deserializeAws_restJson1Job(data.job, context);
867
734
  }
868
- return Promise.resolve(contents);
735
+ return contents;
869
736
  };
870
737
  exports.deserializeAws_restJson1CreateJobCommand = deserializeAws_restJson1CreateJobCommand;
871
738
  const deserializeAws_restJson1CreateJobCommandError = async (output, context) => {
@@ -873,7 +740,6 @@ const deserializeAws_restJson1CreateJobCommandError = async (output, context) =>
873
740
  ...output,
874
741
  body: await parseBody(output.body, context),
875
742
  };
876
- let response;
877
743
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
878
744
  switch (errorCode) {
879
745
  case "BadRequestException":
@@ -896,29 +762,26 @@ const deserializeAws_restJson1CreateJobCommandError = async (output, context) =>
896
762
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
897
763
  default:
898
764
  const parsedBody = parsedOutput.body;
899
- const $metadata = deserializeMetadata(output);
900
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
901
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
902
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
903
- $fault: "client",
904
- $metadata,
765
+ (0, smithy_client_1.throwDefaultError)({
766
+ output,
767
+ parsedBody,
768
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
769
+ errorCode,
905
770
  });
906
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
907
771
  }
908
772
  };
909
773
  const deserializeAws_restJson1CreateJobTemplateCommand = async (output, context) => {
910
774
  if (output.statusCode !== 201 && output.statusCode >= 300) {
911
775
  return deserializeAws_restJson1CreateJobTemplateCommandError(output, context);
912
776
  }
913
- const contents = {
777
+ const contents = map({
914
778
  $metadata: deserializeMetadata(output),
915
- JobTemplate: undefined,
916
- };
779
+ });
917
780
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
918
- if (data.jobTemplate !== undefined && data.jobTemplate !== null) {
781
+ if (data.jobTemplate != null) {
919
782
  contents.JobTemplate = deserializeAws_restJson1JobTemplate(data.jobTemplate, context);
920
783
  }
921
- return Promise.resolve(contents);
784
+ return contents;
922
785
  };
923
786
  exports.deserializeAws_restJson1CreateJobTemplateCommand = deserializeAws_restJson1CreateJobTemplateCommand;
924
787
  const deserializeAws_restJson1CreateJobTemplateCommandError = async (output, context) => {
@@ -926,7 +789,6 @@ const deserializeAws_restJson1CreateJobTemplateCommandError = async (output, con
926
789
  ...output,
927
790
  body: await parseBody(output.body, context),
928
791
  };
929
- let response;
930
792
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
931
793
  switch (errorCode) {
932
794
  case "BadRequestException":
@@ -949,29 +811,26 @@ const deserializeAws_restJson1CreateJobTemplateCommandError = async (output, con
949
811
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
950
812
  default:
951
813
  const parsedBody = parsedOutput.body;
952
- const $metadata = deserializeMetadata(output);
953
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
954
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
955
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
956
- $fault: "client",
957
- $metadata,
814
+ (0, smithy_client_1.throwDefaultError)({
815
+ output,
816
+ parsedBody,
817
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
818
+ errorCode,
958
819
  });
959
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
960
820
  }
961
821
  };
962
822
  const deserializeAws_restJson1CreatePresetCommand = async (output, context) => {
963
823
  if (output.statusCode !== 201 && output.statusCode >= 300) {
964
824
  return deserializeAws_restJson1CreatePresetCommandError(output, context);
965
825
  }
966
- const contents = {
826
+ const contents = map({
967
827
  $metadata: deserializeMetadata(output),
968
- Preset: undefined,
969
- };
828
+ });
970
829
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
971
- if (data.preset !== undefined && data.preset !== null) {
830
+ if (data.preset != null) {
972
831
  contents.Preset = deserializeAws_restJson1Preset(data.preset, context);
973
832
  }
974
- return Promise.resolve(contents);
833
+ return contents;
975
834
  };
976
835
  exports.deserializeAws_restJson1CreatePresetCommand = deserializeAws_restJson1CreatePresetCommand;
977
836
  const deserializeAws_restJson1CreatePresetCommandError = async (output, context) => {
@@ -979,7 +838,6 @@ const deserializeAws_restJson1CreatePresetCommandError = async (output, context)
979
838
  ...output,
980
839
  body: await parseBody(output.body, context),
981
840
  };
982
- let response;
983
841
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
984
842
  switch (errorCode) {
985
843
  case "BadRequestException":
@@ -1002,29 +860,26 @@ const deserializeAws_restJson1CreatePresetCommandError = async (output, context)
1002
860
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1003
861
  default:
1004
862
  const parsedBody = parsedOutput.body;
1005
- const $metadata = deserializeMetadata(output);
1006
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1007
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1008
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1009
- $fault: "client",
1010
- $metadata,
863
+ (0, smithy_client_1.throwDefaultError)({
864
+ output,
865
+ parsedBody,
866
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
867
+ errorCode,
1011
868
  });
1012
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1013
869
  }
1014
870
  };
1015
871
  const deserializeAws_restJson1CreateQueueCommand = async (output, context) => {
1016
872
  if (output.statusCode !== 201 && output.statusCode >= 300) {
1017
873
  return deserializeAws_restJson1CreateQueueCommandError(output, context);
1018
874
  }
1019
- const contents = {
875
+ const contents = map({
1020
876
  $metadata: deserializeMetadata(output),
1021
- Queue: undefined,
1022
- };
877
+ });
1023
878
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1024
- if (data.queue !== undefined && data.queue !== null) {
879
+ if (data.queue != null) {
1025
880
  contents.Queue = deserializeAws_restJson1Queue(data.queue, context);
1026
881
  }
1027
- return Promise.resolve(contents);
882
+ return contents;
1028
883
  };
1029
884
  exports.deserializeAws_restJson1CreateQueueCommand = deserializeAws_restJson1CreateQueueCommand;
1030
885
  const deserializeAws_restJson1CreateQueueCommandError = async (output, context) => {
@@ -1032,7 +887,6 @@ const deserializeAws_restJson1CreateQueueCommandError = async (output, context)
1032
887
  ...output,
1033
888
  body: await parseBody(output.body, context),
1034
889
  };
1035
- let response;
1036
890
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1037
891
  switch (errorCode) {
1038
892
  case "BadRequestException":
@@ -1055,25 +909,23 @@ const deserializeAws_restJson1CreateQueueCommandError = async (output, context)
1055
909
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1056
910
  default:
1057
911
  const parsedBody = parsedOutput.body;
1058
- const $metadata = deserializeMetadata(output);
1059
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1060
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1061
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1062
- $fault: "client",
1063
- $metadata,
912
+ (0, smithy_client_1.throwDefaultError)({
913
+ output,
914
+ parsedBody,
915
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
916
+ errorCode,
1064
917
  });
1065
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1066
918
  }
1067
919
  };
1068
920
  const deserializeAws_restJson1DeleteJobTemplateCommand = async (output, context) => {
1069
921
  if (output.statusCode !== 202 && output.statusCode >= 300) {
1070
922
  return deserializeAws_restJson1DeleteJobTemplateCommandError(output, context);
1071
923
  }
1072
- const contents = {
924
+ const contents = map({
1073
925
  $metadata: deserializeMetadata(output),
1074
- };
926
+ });
1075
927
  await collectBody(output.body, context);
1076
- return Promise.resolve(contents);
928
+ return contents;
1077
929
  };
1078
930
  exports.deserializeAws_restJson1DeleteJobTemplateCommand = deserializeAws_restJson1DeleteJobTemplateCommand;
1079
931
  const deserializeAws_restJson1DeleteJobTemplateCommandError = async (output, context) => {
@@ -1081,7 +933,6 @@ const deserializeAws_restJson1DeleteJobTemplateCommandError = async (output, con
1081
933
  ...output,
1082
934
  body: await parseBody(output.body, context),
1083
935
  };
1084
- let response;
1085
936
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1086
937
  switch (errorCode) {
1087
938
  case "BadRequestException":
@@ -1104,25 +955,23 @@ const deserializeAws_restJson1DeleteJobTemplateCommandError = async (output, con
1104
955
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1105
956
  default:
1106
957
  const parsedBody = parsedOutput.body;
1107
- const $metadata = deserializeMetadata(output);
1108
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1109
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1110
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1111
- $fault: "client",
1112
- $metadata,
958
+ (0, smithy_client_1.throwDefaultError)({
959
+ output,
960
+ parsedBody,
961
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
962
+ errorCode,
1113
963
  });
1114
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1115
964
  }
1116
965
  };
1117
966
  const deserializeAws_restJson1DeletePolicyCommand = async (output, context) => {
1118
967
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1119
968
  return deserializeAws_restJson1DeletePolicyCommandError(output, context);
1120
969
  }
1121
- const contents = {
970
+ const contents = map({
1122
971
  $metadata: deserializeMetadata(output),
1123
- };
972
+ });
1124
973
  await collectBody(output.body, context);
1125
- return Promise.resolve(contents);
974
+ return contents;
1126
975
  };
1127
976
  exports.deserializeAws_restJson1DeletePolicyCommand = deserializeAws_restJson1DeletePolicyCommand;
1128
977
  const deserializeAws_restJson1DeletePolicyCommandError = async (output, context) => {
@@ -1130,7 +979,6 @@ const deserializeAws_restJson1DeletePolicyCommandError = async (output, context)
1130
979
  ...output,
1131
980
  body: await parseBody(output.body, context),
1132
981
  };
1133
- let response;
1134
982
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1135
983
  switch (errorCode) {
1136
984
  case "BadRequestException":
@@ -1153,25 +1001,23 @@ const deserializeAws_restJson1DeletePolicyCommandError = async (output, context)
1153
1001
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1154
1002
  default:
1155
1003
  const parsedBody = parsedOutput.body;
1156
- const $metadata = deserializeMetadata(output);
1157
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1158
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1159
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1160
- $fault: "client",
1161
- $metadata,
1004
+ (0, smithy_client_1.throwDefaultError)({
1005
+ output,
1006
+ parsedBody,
1007
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1008
+ errorCode,
1162
1009
  });
1163
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1164
1010
  }
1165
1011
  };
1166
1012
  const deserializeAws_restJson1DeletePresetCommand = async (output, context) => {
1167
1013
  if (output.statusCode !== 202 && output.statusCode >= 300) {
1168
1014
  return deserializeAws_restJson1DeletePresetCommandError(output, context);
1169
1015
  }
1170
- const contents = {
1016
+ const contents = map({
1171
1017
  $metadata: deserializeMetadata(output),
1172
- };
1018
+ });
1173
1019
  await collectBody(output.body, context);
1174
- return Promise.resolve(contents);
1020
+ return contents;
1175
1021
  };
1176
1022
  exports.deserializeAws_restJson1DeletePresetCommand = deserializeAws_restJson1DeletePresetCommand;
1177
1023
  const deserializeAws_restJson1DeletePresetCommandError = async (output, context) => {
@@ -1179,7 +1025,6 @@ const deserializeAws_restJson1DeletePresetCommandError = async (output, context)
1179
1025
  ...output,
1180
1026
  body: await parseBody(output.body, context),
1181
1027
  };
1182
- let response;
1183
1028
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1184
1029
  switch (errorCode) {
1185
1030
  case "BadRequestException":
@@ -1202,25 +1047,23 @@ const deserializeAws_restJson1DeletePresetCommandError = async (output, context)
1202
1047
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1203
1048
  default:
1204
1049
  const parsedBody = parsedOutput.body;
1205
- const $metadata = deserializeMetadata(output);
1206
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1207
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1208
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1209
- $fault: "client",
1210
- $metadata,
1050
+ (0, smithy_client_1.throwDefaultError)({
1051
+ output,
1052
+ parsedBody,
1053
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1054
+ errorCode,
1211
1055
  });
1212
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1213
1056
  }
1214
1057
  };
1215
1058
  const deserializeAws_restJson1DeleteQueueCommand = async (output, context) => {
1216
1059
  if (output.statusCode !== 202 && output.statusCode >= 300) {
1217
1060
  return deserializeAws_restJson1DeleteQueueCommandError(output, context);
1218
1061
  }
1219
- const contents = {
1062
+ const contents = map({
1220
1063
  $metadata: deserializeMetadata(output),
1221
- };
1064
+ });
1222
1065
  await collectBody(output.body, context);
1223
- return Promise.resolve(contents);
1066
+ return contents;
1224
1067
  };
1225
1068
  exports.deserializeAws_restJson1DeleteQueueCommand = deserializeAws_restJson1DeleteQueueCommand;
1226
1069
  const deserializeAws_restJson1DeleteQueueCommandError = async (output, context) => {
@@ -1228,7 +1071,6 @@ const deserializeAws_restJson1DeleteQueueCommandError = async (output, context)
1228
1071
  ...output,
1229
1072
  body: await parseBody(output.body, context),
1230
1073
  };
1231
- let response;
1232
1074
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1233
1075
  switch (errorCode) {
1234
1076
  case "BadRequestException":
@@ -1251,33 +1093,29 @@ const deserializeAws_restJson1DeleteQueueCommandError = async (output, context)
1251
1093
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1252
1094
  default:
1253
1095
  const parsedBody = parsedOutput.body;
1254
- const $metadata = deserializeMetadata(output);
1255
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1256
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1257
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1258
- $fault: "client",
1259
- $metadata,
1096
+ (0, smithy_client_1.throwDefaultError)({
1097
+ output,
1098
+ parsedBody,
1099
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1100
+ errorCode,
1260
1101
  });
1261
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1262
1102
  }
1263
1103
  };
1264
1104
  const deserializeAws_restJson1DescribeEndpointsCommand = async (output, context) => {
1265
1105
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1266
1106
  return deserializeAws_restJson1DescribeEndpointsCommandError(output, context);
1267
1107
  }
1268
- const contents = {
1108
+ const contents = map({
1269
1109
  $metadata: deserializeMetadata(output),
1270
- Endpoints: undefined,
1271
- NextToken: undefined,
1272
- };
1110
+ });
1273
1111
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1274
- if (data.endpoints !== undefined && data.endpoints !== null) {
1112
+ if (data.endpoints != null) {
1275
1113
  contents.Endpoints = deserializeAws_restJson1__listOfEndpoint(data.endpoints, context);
1276
1114
  }
1277
- if (data.nextToken !== undefined && data.nextToken !== null) {
1115
+ if (data.nextToken != null) {
1278
1116
  contents.NextToken = (0, smithy_client_1.expectString)(data.nextToken);
1279
1117
  }
1280
- return Promise.resolve(contents);
1118
+ return contents;
1281
1119
  };
1282
1120
  exports.deserializeAws_restJson1DescribeEndpointsCommand = deserializeAws_restJson1DescribeEndpointsCommand;
1283
1121
  const deserializeAws_restJson1DescribeEndpointsCommandError = async (output, context) => {
@@ -1285,7 +1123,6 @@ const deserializeAws_restJson1DescribeEndpointsCommandError = async (output, con
1285
1123
  ...output,
1286
1124
  body: await parseBody(output.body, context),
1287
1125
  };
1288
- let response;
1289
1126
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1290
1127
  switch (errorCode) {
1291
1128
  case "BadRequestException":
@@ -1308,25 +1145,23 @@ const deserializeAws_restJson1DescribeEndpointsCommandError = async (output, con
1308
1145
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1309
1146
  default:
1310
1147
  const parsedBody = parsedOutput.body;
1311
- const $metadata = deserializeMetadata(output);
1312
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1313
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1314
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1315
- $fault: "client",
1316
- $metadata,
1148
+ (0, smithy_client_1.throwDefaultError)({
1149
+ output,
1150
+ parsedBody,
1151
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1152
+ errorCode,
1317
1153
  });
1318
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1319
1154
  }
1320
1155
  };
1321
1156
  const deserializeAws_restJson1DisassociateCertificateCommand = async (output, context) => {
1322
1157
  if (output.statusCode !== 202 && output.statusCode >= 300) {
1323
1158
  return deserializeAws_restJson1DisassociateCertificateCommandError(output, context);
1324
1159
  }
1325
- const contents = {
1160
+ const contents = map({
1326
1161
  $metadata: deserializeMetadata(output),
1327
- };
1162
+ });
1328
1163
  await collectBody(output.body, context);
1329
- return Promise.resolve(contents);
1164
+ return contents;
1330
1165
  };
1331
1166
  exports.deserializeAws_restJson1DisassociateCertificateCommand = deserializeAws_restJson1DisassociateCertificateCommand;
1332
1167
  const deserializeAws_restJson1DisassociateCertificateCommandError = async (output, context) => {
@@ -1334,7 +1169,6 @@ const deserializeAws_restJson1DisassociateCertificateCommandError = async (outpu
1334
1169
  ...output,
1335
1170
  body: await parseBody(output.body, context),
1336
1171
  };
1337
- let response;
1338
1172
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1339
1173
  switch (errorCode) {
1340
1174
  case "BadRequestException":
@@ -1357,29 +1191,26 @@ const deserializeAws_restJson1DisassociateCertificateCommandError = async (outpu
1357
1191
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1358
1192
  default:
1359
1193
  const parsedBody = parsedOutput.body;
1360
- const $metadata = deserializeMetadata(output);
1361
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1362
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1363
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1364
- $fault: "client",
1365
- $metadata,
1194
+ (0, smithy_client_1.throwDefaultError)({
1195
+ output,
1196
+ parsedBody,
1197
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1198
+ errorCode,
1366
1199
  });
1367
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1368
1200
  }
1369
1201
  };
1370
1202
  const deserializeAws_restJson1GetJobCommand = async (output, context) => {
1371
1203
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1372
1204
  return deserializeAws_restJson1GetJobCommandError(output, context);
1373
1205
  }
1374
- const contents = {
1206
+ const contents = map({
1375
1207
  $metadata: deserializeMetadata(output),
1376
- Job: undefined,
1377
- };
1208
+ });
1378
1209
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1379
- if (data.job !== undefined && data.job !== null) {
1210
+ if (data.job != null) {
1380
1211
  contents.Job = deserializeAws_restJson1Job(data.job, context);
1381
1212
  }
1382
- return Promise.resolve(contents);
1213
+ return contents;
1383
1214
  };
1384
1215
  exports.deserializeAws_restJson1GetJobCommand = deserializeAws_restJson1GetJobCommand;
1385
1216
  const deserializeAws_restJson1GetJobCommandError = async (output, context) => {
@@ -1387,7 +1218,6 @@ const deserializeAws_restJson1GetJobCommandError = async (output, context) => {
1387
1218
  ...output,
1388
1219
  body: await parseBody(output.body, context),
1389
1220
  };
1390
- let response;
1391
1221
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1392
1222
  switch (errorCode) {
1393
1223
  case "BadRequestException":
@@ -1410,29 +1240,26 @@ const deserializeAws_restJson1GetJobCommandError = async (output, context) => {
1410
1240
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1411
1241
  default:
1412
1242
  const parsedBody = parsedOutput.body;
1413
- const $metadata = deserializeMetadata(output);
1414
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1415
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1416
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1417
- $fault: "client",
1418
- $metadata,
1243
+ (0, smithy_client_1.throwDefaultError)({
1244
+ output,
1245
+ parsedBody,
1246
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1247
+ errorCode,
1419
1248
  });
1420
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1421
1249
  }
1422
1250
  };
1423
1251
  const deserializeAws_restJson1GetJobTemplateCommand = async (output, context) => {
1424
1252
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1425
1253
  return deserializeAws_restJson1GetJobTemplateCommandError(output, context);
1426
1254
  }
1427
- const contents = {
1255
+ const contents = map({
1428
1256
  $metadata: deserializeMetadata(output),
1429
- JobTemplate: undefined,
1430
- };
1257
+ });
1431
1258
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1432
- if (data.jobTemplate !== undefined && data.jobTemplate !== null) {
1259
+ if (data.jobTemplate != null) {
1433
1260
  contents.JobTemplate = deserializeAws_restJson1JobTemplate(data.jobTemplate, context);
1434
1261
  }
1435
- return Promise.resolve(contents);
1262
+ return contents;
1436
1263
  };
1437
1264
  exports.deserializeAws_restJson1GetJobTemplateCommand = deserializeAws_restJson1GetJobTemplateCommand;
1438
1265
  const deserializeAws_restJson1GetJobTemplateCommandError = async (output, context) => {
@@ -1440,7 +1267,6 @@ const deserializeAws_restJson1GetJobTemplateCommandError = async (output, contex
1440
1267
  ...output,
1441
1268
  body: await parseBody(output.body, context),
1442
1269
  };
1443
- let response;
1444
1270
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1445
1271
  switch (errorCode) {
1446
1272
  case "BadRequestException":
@@ -1463,29 +1289,26 @@ const deserializeAws_restJson1GetJobTemplateCommandError = async (output, contex
1463
1289
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1464
1290
  default:
1465
1291
  const parsedBody = parsedOutput.body;
1466
- const $metadata = deserializeMetadata(output);
1467
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1468
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1469
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1470
- $fault: "client",
1471
- $metadata,
1292
+ (0, smithy_client_1.throwDefaultError)({
1293
+ output,
1294
+ parsedBody,
1295
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1296
+ errorCode,
1472
1297
  });
1473
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1474
1298
  }
1475
1299
  };
1476
1300
  const deserializeAws_restJson1GetPolicyCommand = async (output, context) => {
1477
1301
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1478
1302
  return deserializeAws_restJson1GetPolicyCommandError(output, context);
1479
1303
  }
1480
- const contents = {
1304
+ const contents = map({
1481
1305
  $metadata: deserializeMetadata(output),
1482
- Policy: undefined,
1483
- };
1306
+ });
1484
1307
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1485
- if (data.policy !== undefined && data.policy !== null) {
1308
+ if (data.policy != null) {
1486
1309
  contents.Policy = deserializeAws_restJson1Policy(data.policy, context);
1487
1310
  }
1488
- return Promise.resolve(contents);
1311
+ return contents;
1489
1312
  };
1490
1313
  exports.deserializeAws_restJson1GetPolicyCommand = deserializeAws_restJson1GetPolicyCommand;
1491
1314
  const deserializeAws_restJson1GetPolicyCommandError = async (output, context) => {
@@ -1493,7 +1316,6 @@ const deserializeAws_restJson1GetPolicyCommandError = async (output, context) =>
1493
1316
  ...output,
1494
1317
  body: await parseBody(output.body, context),
1495
1318
  };
1496
- let response;
1497
1319
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1498
1320
  switch (errorCode) {
1499
1321
  case "BadRequestException":
@@ -1516,29 +1338,26 @@ const deserializeAws_restJson1GetPolicyCommandError = async (output, context) =>
1516
1338
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1517
1339
  default:
1518
1340
  const parsedBody = parsedOutput.body;
1519
- const $metadata = deserializeMetadata(output);
1520
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1521
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1522
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1523
- $fault: "client",
1524
- $metadata,
1341
+ (0, smithy_client_1.throwDefaultError)({
1342
+ output,
1343
+ parsedBody,
1344
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1345
+ errorCode,
1525
1346
  });
1526
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1527
1347
  }
1528
1348
  };
1529
1349
  const deserializeAws_restJson1GetPresetCommand = async (output, context) => {
1530
1350
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1531
1351
  return deserializeAws_restJson1GetPresetCommandError(output, context);
1532
1352
  }
1533
- const contents = {
1353
+ const contents = map({
1534
1354
  $metadata: deserializeMetadata(output),
1535
- Preset: undefined,
1536
- };
1355
+ });
1537
1356
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1538
- if (data.preset !== undefined && data.preset !== null) {
1357
+ if (data.preset != null) {
1539
1358
  contents.Preset = deserializeAws_restJson1Preset(data.preset, context);
1540
1359
  }
1541
- return Promise.resolve(contents);
1360
+ return contents;
1542
1361
  };
1543
1362
  exports.deserializeAws_restJson1GetPresetCommand = deserializeAws_restJson1GetPresetCommand;
1544
1363
  const deserializeAws_restJson1GetPresetCommandError = async (output, context) => {
@@ -1546,7 +1365,6 @@ const deserializeAws_restJson1GetPresetCommandError = async (output, context) =>
1546
1365
  ...output,
1547
1366
  body: await parseBody(output.body, context),
1548
1367
  };
1549
- let response;
1550
1368
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1551
1369
  switch (errorCode) {
1552
1370
  case "BadRequestException":
@@ -1569,29 +1387,26 @@ const deserializeAws_restJson1GetPresetCommandError = async (output, context) =>
1569
1387
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1570
1388
  default:
1571
1389
  const parsedBody = parsedOutput.body;
1572
- const $metadata = deserializeMetadata(output);
1573
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1574
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1575
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1576
- $fault: "client",
1577
- $metadata,
1390
+ (0, smithy_client_1.throwDefaultError)({
1391
+ output,
1392
+ parsedBody,
1393
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1394
+ errorCode,
1578
1395
  });
1579
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1580
1396
  }
1581
1397
  };
1582
1398
  const deserializeAws_restJson1GetQueueCommand = async (output, context) => {
1583
1399
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1584
1400
  return deserializeAws_restJson1GetQueueCommandError(output, context);
1585
1401
  }
1586
- const contents = {
1402
+ const contents = map({
1587
1403
  $metadata: deserializeMetadata(output),
1588
- Queue: undefined,
1589
- };
1404
+ });
1590
1405
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1591
- if (data.queue !== undefined && data.queue !== null) {
1406
+ if (data.queue != null) {
1592
1407
  contents.Queue = deserializeAws_restJson1Queue(data.queue, context);
1593
1408
  }
1594
- return Promise.resolve(contents);
1409
+ return contents;
1595
1410
  };
1596
1411
  exports.deserializeAws_restJson1GetQueueCommand = deserializeAws_restJson1GetQueueCommand;
1597
1412
  const deserializeAws_restJson1GetQueueCommandError = async (output, context) => {
@@ -1599,7 +1414,6 @@ const deserializeAws_restJson1GetQueueCommandError = async (output, context) =>
1599
1414
  ...output,
1600
1415
  body: await parseBody(output.body, context),
1601
1416
  };
1602
- let response;
1603
1417
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1604
1418
  switch (errorCode) {
1605
1419
  case "BadRequestException":
@@ -1622,33 +1436,29 @@ const deserializeAws_restJson1GetQueueCommandError = async (output, context) =>
1622
1436
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1623
1437
  default:
1624
1438
  const parsedBody = parsedOutput.body;
1625
- const $metadata = deserializeMetadata(output);
1626
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1627
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1628
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1629
- $fault: "client",
1630
- $metadata,
1439
+ (0, smithy_client_1.throwDefaultError)({
1440
+ output,
1441
+ parsedBody,
1442
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1443
+ errorCode,
1631
1444
  });
1632
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1633
1445
  }
1634
1446
  };
1635
1447
  const deserializeAws_restJson1ListJobsCommand = async (output, context) => {
1636
1448
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1637
1449
  return deserializeAws_restJson1ListJobsCommandError(output, context);
1638
1450
  }
1639
- const contents = {
1451
+ const contents = map({
1640
1452
  $metadata: deserializeMetadata(output),
1641
- Jobs: undefined,
1642
- NextToken: undefined,
1643
- };
1453
+ });
1644
1454
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1645
- if (data.jobs !== undefined && data.jobs !== null) {
1455
+ if (data.jobs != null) {
1646
1456
  contents.Jobs = deserializeAws_restJson1__listOfJob(data.jobs, context);
1647
1457
  }
1648
- if (data.nextToken !== undefined && data.nextToken !== null) {
1458
+ if (data.nextToken != null) {
1649
1459
  contents.NextToken = (0, smithy_client_1.expectString)(data.nextToken);
1650
1460
  }
1651
- return Promise.resolve(contents);
1461
+ return contents;
1652
1462
  };
1653
1463
  exports.deserializeAws_restJson1ListJobsCommand = deserializeAws_restJson1ListJobsCommand;
1654
1464
  const deserializeAws_restJson1ListJobsCommandError = async (output, context) => {
@@ -1656,7 +1466,6 @@ const deserializeAws_restJson1ListJobsCommandError = async (output, context) =>
1656
1466
  ...output,
1657
1467
  body: await parseBody(output.body, context),
1658
1468
  };
1659
- let response;
1660
1469
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1661
1470
  switch (errorCode) {
1662
1471
  case "BadRequestException":
@@ -1679,33 +1488,29 @@ const deserializeAws_restJson1ListJobsCommandError = async (output, context) =>
1679
1488
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1680
1489
  default:
1681
1490
  const parsedBody = parsedOutput.body;
1682
- const $metadata = deserializeMetadata(output);
1683
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1684
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1685
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1686
- $fault: "client",
1687
- $metadata,
1491
+ (0, smithy_client_1.throwDefaultError)({
1492
+ output,
1493
+ parsedBody,
1494
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1495
+ errorCode,
1688
1496
  });
1689
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1690
1497
  }
1691
1498
  };
1692
1499
  const deserializeAws_restJson1ListJobTemplatesCommand = async (output, context) => {
1693
1500
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1694
1501
  return deserializeAws_restJson1ListJobTemplatesCommandError(output, context);
1695
1502
  }
1696
- const contents = {
1503
+ const contents = map({
1697
1504
  $metadata: deserializeMetadata(output),
1698
- JobTemplates: undefined,
1699
- NextToken: undefined,
1700
- };
1505
+ });
1701
1506
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1702
- if (data.jobTemplates !== undefined && data.jobTemplates !== null) {
1507
+ if (data.jobTemplates != null) {
1703
1508
  contents.JobTemplates = deserializeAws_restJson1__listOfJobTemplate(data.jobTemplates, context);
1704
1509
  }
1705
- if (data.nextToken !== undefined && data.nextToken !== null) {
1510
+ if (data.nextToken != null) {
1706
1511
  contents.NextToken = (0, smithy_client_1.expectString)(data.nextToken);
1707
1512
  }
1708
- return Promise.resolve(contents);
1513
+ return contents;
1709
1514
  };
1710
1515
  exports.deserializeAws_restJson1ListJobTemplatesCommand = deserializeAws_restJson1ListJobTemplatesCommand;
1711
1516
  const deserializeAws_restJson1ListJobTemplatesCommandError = async (output, context) => {
@@ -1713,7 +1518,6 @@ const deserializeAws_restJson1ListJobTemplatesCommandError = async (output, cont
1713
1518
  ...output,
1714
1519
  body: await parseBody(output.body, context),
1715
1520
  };
1716
- let response;
1717
1521
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1718
1522
  switch (errorCode) {
1719
1523
  case "BadRequestException":
@@ -1736,33 +1540,29 @@ const deserializeAws_restJson1ListJobTemplatesCommandError = async (output, cont
1736
1540
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1737
1541
  default:
1738
1542
  const parsedBody = parsedOutput.body;
1739
- const $metadata = deserializeMetadata(output);
1740
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1741
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1742
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1743
- $fault: "client",
1744
- $metadata,
1543
+ (0, smithy_client_1.throwDefaultError)({
1544
+ output,
1545
+ parsedBody,
1546
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1547
+ errorCode,
1745
1548
  });
1746
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1747
1549
  }
1748
1550
  };
1749
1551
  const deserializeAws_restJson1ListPresetsCommand = async (output, context) => {
1750
1552
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1751
1553
  return deserializeAws_restJson1ListPresetsCommandError(output, context);
1752
1554
  }
1753
- const contents = {
1555
+ const contents = map({
1754
1556
  $metadata: deserializeMetadata(output),
1755
- NextToken: undefined,
1756
- Presets: undefined,
1757
- };
1557
+ });
1758
1558
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1759
- if (data.nextToken !== undefined && data.nextToken !== null) {
1559
+ if (data.nextToken != null) {
1760
1560
  contents.NextToken = (0, smithy_client_1.expectString)(data.nextToken);
1761
1561
  }
1762
- if (data.presets !== undefined && data.presets !== null) {
1562
+ if (data.presets != null) {
1763
1563
  contents.Presets = deserializeAws_restJson1__listOfPreset(data.presets, context);
1764
1564
  }
1765
- return Promise.resolve(contents);
1565
+ return contents;
1766
1566
  };
1767
1567
  exports.deserializeAws_restJson1ListPresetsCommand = deserializeAws_restJson1ListPresetsCommand;
1768
1568
  const deserializeAws_restJson1ListPresetsCommandError = async (output, context) => {
@@ -1770,7 +1570,6 @@ const deserializeAws_restJson1ListPresetsCommandError = async (output, context)
1770
1570
  ...output,
1771
1571
  body: await parseBody(output.body, context),
1772
1572
  };
1773
- let response;
1774
1573
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1775
1574
  switch (errorCode) {
1776
1575
  case "BadRequestException":
@@ -1793,33 +1592,29 @@ const deserializeAws_restJson1ListPresetsCommandError = async (output, context)
1793
1592
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1794
1593
  default:
1795
1594
  const parsedBody = parsedOutput.body;
1796
- const $metadata = deserializeMetadata(output);
1797
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1798
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1799
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1800
- $fault: "client",
1801
- $metadata,
1595
+ (0, smithy_client_1.throwDefaultError)({
1596
+ output,
1597
+ parsedBody,
1598
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1599
+ errorCode,
1802
1600
  });
1803
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1804
1601
  }
1805
1602
  };
1806
1603
  const deserializeAws_restJson1ListQueuesCommand = async (output, context) => {
1807
1604
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1808
1605
  return deserializeAws_restJson1ListQueuesCommandError(output, context);
1809
1606
  }
1810
- const contents = {
1607
+ const contents = map({
1811
1608
  $metadata: deserializeMetadata(output),
1812
- NextToken: undefined,
1813
- Queues: undefined,
1814
- };
1609
+ });
1815
1610
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1816
- if (data.nextToken !== undefined && data.nextToken !== null) {
1611
+ if (data.nextToken != null) {
1817
1612
  contents.NextToken = (0, smithy_client_1.expectString)(data.nextToken);
1818
1613
  }
1819
- if (data.queues !== undefined && data.queues !== null) {
1614
+ if (data.queues != null) {
1820
1615
  contents.Queues = deserializeAws_restJson1__listOfQueue(data.queues, context);
1821
1616
  }
1822
- return Promise.resolve(contents);
1617
+ return contents;
1823
1618
  };
1824
1619
  exports.deserializeAws_restJson1ListQueuesCommand = deserializeAws_restJson1ListQueuesCommand;
1825
1620
  const deserializeAws_restJson1ListQueuesCommandError = async (output, context) => {
@@ -1827,7 +1622,6 @@ const deserializeAws_restJson1ListQueuesCommandError = async (output, context) =
1827
1622
  ...output,
1828
1623
  body: await parseBody(output.body, context),
1829
1624
  };
1830
- let response;
1831
1625
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1832
1626
  switch (errorCode) {
1833
1627
  case "BadRequestException":
@@ -1850,29 +1644,26 @@ const deserializeAws_restJson1ListQueuesCommandError = async (output, context) =
1850
1644
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1851
1645
  default:
1852
1646
  const parsedBody = parsedOutput.body;
1853
- const $metadata = deserializeMetadata(output);
1854
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1855
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1856
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1857
- $fault: "client",
1858
- $metadata,
1647
+ (0, smithy_client_1.throwDefaultError)({
1648
+ output,
1649
+ parsedBody,
1650
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1651
+ errorCode,
1859
1652
  });
1860
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1861
1653
  }
1862
1654
  };
1863
1655
  const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
1864
1656
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1865
1657
  return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
1866
1658
  }
1867
- const contents = {
1659
+ const contents = map({
1868
1660
  $metadata: deserializeMetadata(output),
1869
- ResourceTags: undefined,
1870
- };
1661
+ });
1871
1662
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1872
- if (data.resourceTags !== undefined && data.resourceTags !== null) {
1663
+ if (data.resourceTags != null) {
1873
1664
  contents.ResourceTags = deserializeAws_restJson1ResourceTags(data.resourceTags, context);
1874
1665
  }
1875
- return Promise.resolve(contents);
1666
+ return contents;
1876
1667
  };
1877
1668
  exports.deserializeAws_restJson1ListTagsForResourceCommand = deserializeAws_restJson1ListTagsForResourceCommand;
1878
1669
  const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
@@ -1880,7 +1671,6 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
1880
1671
  ...output,
1881
1672
  body: await parseBody(output.body, context),
1882
1673
  };
1883
- let response;
1884
1674
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1885
1675
  switch (errorCode) {
1886
1676
  case "BadRequestException":
@@ -1903,29 +1693,26 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
1903
1693
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1904
1694
  default:
1905
1695
  const parsedBody = parsedOutput.body;
1906
- const $metadata = deserializeMetadata(output);
1907
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1908
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1909
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1910
- $fault: "client",
1911
- $metadata,
1696
+ (0, smithy_client_1.throwDefaultError)({
1697
+ output,
1698
+ parsedBody,
1699
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1700
+ errorCode,
1912
1701
  });
1913
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1914
1702
  }
1915
1703
  };
1916
1704
  const deserializeAws_restJson1PutPolicyCommand = async (output, context) => {
1917
1705
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1918
1706
  return deserializeAws_restJson1PutPolicyCommandError(output, context);
1919
1707
  }
1920
- const contents = {
1708
+ const contents = map({
1921
1709
  $metadata: deserializeMetadata(output),
1922
- Policy: undefined,
1923
- };
1710
+ });
1924
1711
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
1925
- if (data.policy !== undefined && data.policy !== null) {
1712
+ if (data.policy != null) {
1926
1713
  contents.Policy = deserializeAws_restJson1Policy(data.policy, context);
1927
1714
  }
1928
- return Promise.resolve(contents);
1715
+ return contents;
1929
1716
  };
1930
1717
  exports.deserializeAws_restJson1PutPolicyCommand = deserializeAws_restJson1PutPolicyCommand;
1931
1718
  const deserializeAws_restJson1PutPolicyCommandError = async (output, context) => {
@@ -1933,7 +1720,6 @@ const deserializeAws_restJson1PutPolicyCommandError = async (output, context) =>
1933
1720
  ...output,
1934
1721
  body: await parseBody(output.body, context),
1935
1722
  };
1936
- let response;
1937
1723
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1938
1724
  switch (errorCode) {
1939
1725
  case "BadRequestException":
@@ -1956,25 +1742,23 @@ const deserializeAws_restJson1PutPolicyCommandError = async (output, context) =>
1956
1742
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1957
1743
  default:
1958
1744
  const parsedBody = parsedOutput.body;
1959
- const $metadata = deserializeMetadata(output);
1960
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1961
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
1962
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1963
- $fault: "client",
1964
- $metadata,
1745
+ (0, smithy_client_1.throwDefaultError)({
1746
+ output,
1747
+ parsedBody,
1748
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1749
+ errorCode,
1965
1750
  });
1966
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1967
1751
  }
1968
1752
  };
1969
1753
  const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
1970
1754
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1971
1755
  return deserializeAws_restJson1TagResourceCommandError(output, context);
1972
1756
  }
1973
- const contents = {
1757
+ const contents = map({
1974
1758
  $metadata: deserializeMetadata(output),
1975
- };
1759
+ });
1976
1760
  await collectBody(output.body, context);
1977
- return Promise.resolve(contents);
1761
+ return contents;
1978
1762
  };
1979
1763
  exports.deserializeAws_restJson1TagResourceCommand = deserializeAws_restJson1TagResourceCommand;
1980
1764
  const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
@@ -1982,7 +1766,6 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
1982
1766
  ...output,
1983
1767
  body: await parseBody(output.body, context),
1984
1768
  };
1985
- let response;
1986
1769
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1987
1770
  switch (errorCode) {
1988
1771
  case "BadRequestException":
@@ -2005,25 +1788,23 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
2005
1788
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2006
1789
  default:
2007
1790
  const parsedBody = parsedOutput.body;
2008
- const $metadata = deserializeMetadata(output);
2009
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2010
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
2011
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2012
- $fault: "client",
2013
- $metadata,
1791
+ (0, smithy_client_1.throwDefaultError)({
1792
+ output,
1793
+ parsedBody,
1794
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1795
+ errorCode,
2014
1796
  });
2015
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2016
1797
  }
2017
1798
  };
2018
1799
  const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
2019
1800
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2020
1801
  return deserializeAws_restJson1UntagResourceCommandError(output, context);
2021
1802
  }
2022
- const contents = {
1803
+ const contents = map({
2023
1804
  $metadata: deserializeMetadata(output),
2024
- };
1805
+ });
2025
1806
  await collectBody(output.body, context);
2026
- return Promise.resolve(contents);
1807
+ return contents;
2027
1808
  };
2028
1809
  exports.deserializeAws_restJson1UntagResourceCommand = deserializeAws_restJson1UntagResourceCommand;
2029
1810
  const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
@@ -2031,7 +1812,6 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
2031
1812
  ...output,
2032
1813
  body: await parseBody(output.body, context),
2033
1814
  };
2034
- let response;
2035
1815
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2036
1816
  switch (errorCode) {
2037
1817
  case "BadRequestException":
@@ -2054,29 +1834,26 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
2054
1834
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2055
1835
  default:
2056
1836
  const parsedBody = parsedOutput.body;
2057
- const $metadata = deserializeMetadata(output);
2058
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2059
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
2060
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2061
- $fault: "client",
2062
- $metadata,
1837
+ (0, smithy_client_1.throwDefaultError)({
1838
+ output,
1839
+ parsedBody,
1840
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1841
+ errorCode,
2063
1842
  });
2064
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2065
1843
  }
2066
1844
  };
2067
1845
  const deserializeAws_restJson1UpdateJobTemplateCommand = async (output, context) => {
2068
1846
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2069
1847
  return deserializeAws_restJson1UpdateJobTemplateCommandError(output, context);
2070
1848
  }
2071
- const contents = {
1849
+ const contents = map({
2072
1850
  $metadata: deserializeMetadata(output),
2073
- JobTemplate: undefined,
2074
- };
1851
+ });
2075
1852
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
2076
- if (data.jobTemplate !== undefined && data.jobTemplate !== null) {
1853
+ if (data.jobTemplate != null) {
2077
1854
  contents.JobTemplate = deserializeAws_restJson1JobTemplate(data.jobTemplate, context);
2078
1855
  }
2079
- return Promise.resolve(contents);
1856
+ return contents;
2080
1857
  };
2081
1858
  exports.deserializeAws_restJson1UpdateJobTemplateCommand = deserializeAws_restJson1UpdateJobTemplateCommand;
2082
1859
  const deserializeAws_restJson1UpdateJobTemplateCommandError = async (output, context) => {
@@ -2084,7 +1861,6 @@ const deserializeAws_restJson1UpdateJobTemplateCommandError = async (output, con
2084
1861
  ...output,
2085
1862
  body: await parseBody(output.body, context),
2086
1863
  };
2087
- let response;
2088
1864
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2089
1865
  switch (errorCode) {
2090
1866
  case "BadRequestException":
@@ -2107,29 +1883,26 @@ const deserializeAws_restJson1UpdateJobTemplateCommandError = async (output, con
2107
1883
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2108
1884
  default:
2109
1885
  const parsedBody = parsedOutput.body;
2110
- const $metadata = deserializeMetadata(output);
2111
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2112
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
2113
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2114
- $fault: "client",
2115
- $metadata,
1886
+ (0, smithy_client_1.throwDefaultError)({
1887
+ output,
1888
+ parsedBody,
1889
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1890
+ errorCode,
2116
1891
  });
2117
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2118
1892
  }
2119
1893
  };
2120
1894
  const deserializeAws_restJson1UpdatePresetCommand = async (output, context) => {
2121
1895
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2122
1896
  return deserializeAws_restJson1UpdatePresetCommandError(output, context);
2123
1897
  }
2124
- const contents = {
1898
+ const contents = map({
2125
1899
  $metadata: deserializeMetadata(output),
2126
- Preset: undefined,
2127
- };
1900
+ });
2128
1901
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
2129
- if (data.preset !== undefined && data.preset !== null) {
1902
+ if (data.preset != null) {
2130
1903
  contents.Preset = deserializeAws_restJson1Preset(data.preset, context);
2131
1904
  }
2132
- return Promise.resolve(contents);
1905
+ return contents;
2133
1906
  };
2134
1907
  exports.deserializeAws_restJson1UpdatePresetCommand = deserializeAws_restJson1UpdatePresetCommand;
2135
1908
  const deserializeAws_restJson1UpdatePresetCommandError = async (output, context) => {
@@ -2137,7 +1910,6 @@ const deserializeAws_restJson1UpdatePresetCommandError = async (output, context)
2137
1910
  ...output,
2138
1911
  body: await parseBody(output.body, context),
2139
1912
  };
2140
- let response;
2141
1913
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2142
1914
  switch (errorCode) {
2143
1915
  case "BadRequestException":
@@ -2160,29 +1932,26 @@ const deserializeAws_restJson1UpdatePresetCommandError = async (output, context)
2160
1932
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2161
1933
  default:
2162
1934
  const parsedBody = parsedOutput.body;
2163
- const $metadata = deserializeMetadata(output);
2164
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2165
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
2166
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2167
- $fault: "client",
2168
- $metadata,
1935
+ (0, smithy_client_1.throwDefaultError)({
1936
+ output,
1937
+ parsedBody,
1938
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1939
+ errorCode,
2169
1940
  });
2170
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2171
1941
  }
2172
1942
  };
2173
1943
  const deserializeAws_restJson1UpdateQueueCommand = async (output, context) => {
2174
1944
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2175
1945
  return deserializeAws_restJson1UpdateQueueCommandError(output, context);
2176
1946
  }
2177
- const contents = {
1947
+ const contents = map({
2178
1948
  $metadata: deserializeMetadata(output),
2179
- Queue: undefined,
2180
- };
1949
+ });
2181
1950
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
2182
- if (data.queue !== undefined && data.queue !== null) {
1951
+ if (data.queue != null) {
2183
1952
  contents.Queue = deserializeAws_restJson1Queue(data.queue, context);
2184
1953
  }
2185
- return Promise.resolve(contents);
1954
+ return contents;
2186
1955
  };
2187
1956
  exports.deserializeAws_restJson1UpdateQueueCommand = deserializeAws_restJson1UpdateQueueCommand;
2188
1957
  const deserializeAws_restJson1UpdateQueueCommandError = async (output, context) => {
@@ -2190,7 +1959,6 @@ const deserializeAws_restJson1UpdateQueueCommandError = async (output, context)
2190
1959
  ...output,
2191
1960
  body: await parseBody(output.body, context),
2192
1961
  };
2193
- let response;
2194
1962
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2195
1963
  switch (errorCode) {
2196
1964
  case "BadRequestException":
@@ -2213,20 +1981,19 @@ const deserializeAws_restJson1UpdateQueueCommandError = async (output, context)
2213
1981
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2214
1982
  default:
2215
1983
  const parsedBody = parsedOutput.body;
2216
- const $metadata = deserializeMetadata(output);
2217
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2218
- response = new MediaConvertServiceException_1.MediaConvertServiceException({
2219
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2220
- $fault: "client",
2221
- $metadata,
1984
+ (0, smithy_client_1.throwDefaultError)({
1985
+ output,
1986
+ parsedBody,
1987
+ exceptionCtor: MediaConvertServiceException_1.MediaConvertServiceException,
1988
+ errorCode,
2222
1989
  });
2223
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2224
1990
  }
2225
1991
  };
1992
+ const map = smithy_client_1.map;
2226
1993
  const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
2227
- const contents = {};
1994
+ const contents = map({});
2228
1995
  const data = parsedOutput.body;
2229
- if (data.message !== undefined && data.message !== null) {
1996
+ if (data.message != null) {
2230
1997
  contents.Message = (0, smithy_client_1.expectString)(data.message);
2231
1998
  }
2232
1999
  const exception = new models_1_1.BadRequestException({
@@ -2236,9 +2003,9 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
2236
2003
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
2237
2004
  };
2238
2005
  const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
2239
- const contents = {};
2006
+ const contents = map({});
2240
2007
  const data = parsedOutput.body;
2241
- if (data.message !== undefined && data.message !== null) {
2008
+ if (data.message != null) {
2242
2009
  contents.Message = (0, smithy_client_1.expectString)(data.message);
2243
2010
  }
2244
2011
  const exception = new models_1_1.ConflictException({
@@ -2248,9 +2015,9 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
2248
2015
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
2249
2016
  };
2250
2017
  const deserializeAws_restJson1ForbiddenExceptionResponse = async (parsedOutput, context) => {
2251
- const contents = {};
2018
+ const contents = map({});
2252
2019
  const data = parsedOutput.body;
2253
- if (data.message !== undefined && data.message !== null) {
2020
+ if (data.message != null) {
2254
2021
  contents.Message = (0, smithy_client_1.expectString)(data.message);
2255
2022
  }
2256
2023
  const exception = new models_1_1.ForbiddenException({
@@ -2260,9 +2027,9 @@ const deserializeAws_restJson1ForbiddenExceptionResponse = async (parsedOutput,
2260
2027
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
2261
2028
  };
2262
2029
  const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (parsedOutput, context) => {
2263
- const contents = {};
2030
+ const contents = map({});
2264
2031
  const data = parsedOutput.body;
2265
- if (data.message !== undefined && data.message !== null) {
2032
+ if (data.message != null) {
2266
2033
  contents.Message = (0, smithy_client_1.expectString)(data.message);
2267
2034
  }
2268
2035
  const exception = new models_1_1.InternalServerErrorException({
@@ -2272,9 +2039,9 @@ const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (pars
2272
2039
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
2273
2040
  };
2274
2041
  const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, context) => {
2275
- const contents = {};
2042
+ const contents = map({});
2276
2043
  const data = parsedOutput.body;
2277
- if (data.message !== undefined && data.message !== null) {
2044
+ if (data.message != null) {
2278
2045
  contents.Message = (0, smithy_client_1.expectString)(data.message);
2279
2046
  }
2280
2047
  const exception = new models_1_1.NotFoundException({
@@ -2284,9 +2051,9 @@ const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, c
2284
2051
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
2285
2052
  };
2286
2053
  const deserializeAws_restJson1TooManyRequestsExceptionResponse = async (parsedOutput, context) => {
2287
- const contents = {};
2054
+ const contents = map({});
2288
2055
  const data = parsedOutput.body;
2289
- if (data.message !== undefined && data.message !== null) {
2056
+ if (data.message != null) {
2290
2057
  contents.Message = (0, smithy_client_1.expectString)(data.message);
2291
2058
  }
2292
2059
  const exception = new models_1_1.TooManyRequestsException({
@@ -2299,9 +2066,6 @@ const serializeAws_restJson1__listOf__doubleMinNegative60Max6 = (input, context)
2299
2066
  return input
2300
2067
  .filter((e) => e != null)
2301
2068
  .map((entry) => {
2302
- if (entry === null) {
2303
- return null;
2304
- }
2305
2069
  return (0, smithy_client_1.serializeFloat)(entry);
2306
2070
  });
2307
2071
  };
@@ -2309,9 +2073,6 @@ const serializeAws_restJson1__listOf__integerMin1Max2147483647 = (input, context
2309
2073
  return input
2310
2074
  .filter((e) => e != null)
2311
2075
  .map((entry) => {
2312
- if (entry === null) {
2313
- return null;
2314
- }
2315
2076
  return entry;
2316
2077
  });
2317
2078
  };
@@ -2319,9 +2080,6 @@ const serializeAws_restJson1__listOf__integerMin32Max8182 = (input, context) =>
2319
2080
  return input
2320
2081
  .filter((e) => e != null)
2321
2082
  .map((entry) => {
2322
- if (entry === null) {
2323
- return null;
2324
- }
2325
2083
  return entry;
2326
2084
  });
2327
2085
  };
@@ -2329,9 +2087,6 @@ const serializeAws_restJson1__listOf__integerMinNegative60Max6 = (input, context
2329
2087
  return input
2330
2088
  .filter((e) => e != null)
2331
2089
  .map((entry) => {
2332
- if (entry === null) {
2333
- return null;
2334
- }
2335
2090
  return entry;
2336
2091
  });
2337
2092
  };
@@ -2339,9 +2094,6 @@ const serializeAws_restJson1__listOf__string = (input, context) => {
2339
2094
  return input
2340
2095
  .filter((e) => e != null)
2341
2096
  .map((entry) => {
2342
- if (entry === null) {
2343
- return null;
2344
- }
2345
2097
  return entry;
2346
2098
  });
2347
2099
  };
@@ -2349,9 +2101,6 @@ const serializeAws_restJson1__listOf__stringMin1 = (input, context) => {
2349
2101
  return input
2350
2102
  .filter((e) => e != null)
2351
2103
  .map((entry) => {
2352
- if (entry === null) {
2353
- return null;
2354
- }
2355
2104
  return entry;
2356
2105
  });
2357
2106
  };
@@ -2359,9 +2108,6 @@ const serializeAws_restJson1__listOf__stringMin36Max36Pattern09aFAF809aFAF409aFA
2359
2108
  return input
2360
2109
  .filter((e) => e != null)
2361
2110
  .map((entry) => {
2362
- if (entry === null) {
2363
- return null;
2364
- }
2365
2111
  return entry;
2366
2112
  });
2367
2113
  };
@@ -2369,9 +2115,6 @@ const serializeAws_restJson1__listOf__stringPattern09aFAF809aFAF409aFAF409aFAF40
2369
2115
  return input
2370
2116
  .filter((e) => e != null)
2371
2117
  .map((entry) => {
2372
- if (entry === null) {
2373
- return null;
2374
- }
2375
2118
  return entry;
2376
2119
  });
2377
2120
  };
@@ -2379,9 +2122,6 @@ const serializeAws_restJson1__listOf__stringPatternS3ASSETMAPXml = (input, conte
2379
2122
  return input
2380
2123
  .filter((e) => e != null)
2381
2124
  .map((entry) => {
2382
- if (entry === null) {
2383
- return null;
2384
- }
2385
2125
  return entry;
2386
2126
  });
2387
2127
  };
@@ -2389,9 +2129,6 @@ const serializeAws_restJson1__listOfAllowedRenditionSize = (input, context) => {
2389
2129
  return input
2390
2130
  .filter((e) => e != null)
2391
2131
  .map((entry) => {
2392
- if (entry === null) {
2393
- return null;
2394
- }
2395
2132
  return serializeAws_restJson1AllowedRenditionSize(entry, context);
2396
2133
  });
2397
2134
  };
@@ -2399,9 +2136,6 @@ const serializeAws_restJson1__listOfAudioDescription = (input, context) => {
2399
2136
  return input
2400
2137
  .filter((e) => e != null)
2401
2138
  .map((entry) => {
2402
- if (entry === null) {
2403
- return null;
2404
- }
2405
2139
  return serializeAws_restJson1AudioDescription(entry, context);
2406
2140
  });
2407
2141
  };
@@ -2409,9 +2143,6 @@ const serializeAws_restJson1__listOfAutomatedAbrRule = (input, context) => {
2409
2143
  return input
2410
2144
  .filter((e) => e != null)
2411
2145
  .map((entry) => {
2412
- if (entry === null) {
2413
- return null;
2414
- }
2415
2146
  return serializeAws_restJson1AutomatedAbrRule(entry, context);
2416
2147
  });
2417
2148
  };
@@ -2419,9 +2150,6 @@ const serializeAws_restJson1__listOfCaptionDescription = (input, context) => {
2419
2150
  return input
2420
2151
  .filter((e) => e != null)
2421
2152
  .map((entry) => {
2422
- if (entry === null) {
2423
- return null;
2424
- }
2425
2153
  return serializeAws_restJson1CaptionDescription(entry, context);
2426
2154
  });
2427
2155
  };
@@ -2429,9 +2157,6 @@ const serializeAws_restJson1__listOfCaptionDescriptionPreset = (input, context)
2429
2157
  return input
2430
2158
  .filter((e) => e != null)
2431
2159
  .map((entry) => {
2432
- if (entry === null) {
2433
- return null;
2434
- }
2435
2160
  return serializeAws_restJson1CaptionDescriptionPreset(entry, context);
2436
2161
  });
2437
2162
  };
@@ -2439,9 +2164,6 @@ const serializeAws_restJson1__listOfCmafAdditionalManifest = (input, context) =>
2439
2164
  return input
2440
2165
  .filter((e) => e != null)
2441
2166
  .map((entry) => {
2442
- if (entry === null) {
2443
- return null;
2444
- }
2445
2167
  return serializeAws_restJson1CmafAdditionalManifest(entry, context);
2446
2168
  });
2447
2169
  };
@@ -2449,9 +2171,6 @@ const serializeAws_restJson1__listOfDashAdditionalManifest = (input, context) =>
2449
2171
  return input
2450
2172
  .filter((e) => e != null)
2451
2173
  .map((entry) => {
2452
- if (entry === null) {
2453
- return null;
2454
- }
2455
2174
  return serializeAws_restJson1DashAdditionalManifest(entry, context);
2456
2175
  });
2457
2176
  };
@@ -2459,9 +2178,6 @@ const serializeAws_restJson1__listOfForceIncludeRenditionSize = (input, context)
2459
2178
  return input
2460
2179
  .filter((e) => e != null)
2461
2180
  .map((entry) => {
2462
- if (entry === null) {
2463
- return null;
2464
- }
2465
2181
  return serializeAws_restJson1ForceIncludeRenditionSize(entry, context);
2466
2182
  });
2467
2183
  };
@@ -2469,9 +2185,6 @@ const serializeAws_restJson1__listOfHlsAdditionalManifest = (input, context) =>
2469
2185
  return input
2470
2186
  .filter((e) => e != null)
2471
2187
  .map((entry) => {
2472
- if (entry === null) {
2473
- return null;
2474
- }
2475
2188
  return serializeAws_restJson1HlsAdditionalManifest(entry, context);
2476
2189
  });
2477
2190
  };
@@ -2479,9 +2192,6 @@ const serializeAws_restJson1__listOfHlsAdMarkers = (input, context) => {
2479
2192
  return input
2480
2193
  .filter((e) => e != null)
2481
2194
  .map((entry) => {
2482
- if (entry === null) {
2483
- return null;
2484
- }
2485
2195
  return entry;
2486
2196
  });
2487
2197
  };
@@ -2489,9 +2199,6 @@ const serializeAws_restJson1__listOfHlsCaptionLanguageMapping = (input, context)
2489
2199
  return input
2490
2200
  .filter((e) => e != null)
2491
2201
  .map((entry) => {
2492
- if (entry === null) {
2493
- return null;
2494
- }
2495
2202
  return serializeAws_restJson1HlsCaptionLanguageMapping(entry, context);
2496
2203
  });
2497
2204
  };
@@ -2499,9 +2206,6 @@ const serializeAws_restJson1__listOfHopDestination = (input, context) => {
2499
2206
  return input
2500
2207
  .filter((e) => e != null)
2501
2208
  .map((entry) => {
2502
- if (entry === null) {
2503
- return null;
2504
- }
2505
2209
  return serializeAws_restJson1HopDestination(entry, context);
2506
2210
  });
2507
2211
  };
@@ -2509,9 +2213,6 @@ const serializeAws_restJson1__listOfId3Insertion = (input, context) => {
2509
2213
  return input
2510
2214
  .filter((e) => e != null)
2511
2215
  .map((entry) => {
2512
- if (entry === null) {
2513
- return null;
2514
- }
2515
2216
  return serializeAws_restJson1Id3Insertion(entry, context);
2516
2217
  });
2517
2218
  };
@@ -2519,9 +2220,6 @@ const serializeAws_restJson1__listOfInput = (input, context) => {
2519
2220
  return input
2520
2221
  .filter((e) => e != null)
2521
2222
  .map((entry) => {
2522
- if (entry === null) {
2523
- return null;
2524
- }
2525
2223
  return serializeAws_restJson1Input(entry, context);
2526
2224
  });
2527
2225
  };
@@ -2529,9 +2227,6 @@ const serializeAws_restJson1__listOfInputClipping = (input, context) => {
2529
2227
  return input
2530
2228
  .filter((e) => e != null)
2531
2229
  .map((entry) => {
2532
- if (entry === null) {
2533
- return null;
2534
- }
2535
2230
  return serializeAws_restJson1InputClipping(entry, context);
2536
2231
  });
2537
2232
  };
@@ -2539,9 +2234,6 @@ const serializeAws_restJson1__listOfInputTemplate = (input, context) => {
2539
2234
  return input
2540
2235
  .filter((e) => e != null)
2541
2236
  .map((entry) => {
2542
- if (entry === null) {
2543
- return null;
2544
- }
2545
2237
  return serializeAws_restJson1InputTemplate(entry, context);
2546
2238
  });
2547
2239
  };
@@ -2549,9 +2241,6 @@ const serializeAws_restJson1__listOfInsertableImage = (input, context) => {
2549
2241
  return input
2550
2242
  .filter((e) => e != null)
2551
2243
  .map((entry) => {
2552
- if (entry === null) {
2553
- return null;
2554
- }
2555
2244
  return serializeAws_restJson1InsertableImage(entry, context);
2556
2245
  });
2557
2246
  };
@@ -2559,9 +2248,6 @@ const serializeAws_restJson1__listOfMsSmoothAdditionalManifest = (input, context
2559
2248
  return input
2560
2249
  .filter((e) => e != null)
2561
2250
  .map((entry) => {
2562
- if (entry === null) {
2563
- return null;
2564
- }
2565
2251
  return serializeAws_restJson1MsSmoothAdditionalManifest(entry, context);
2566
2252
  });
2567
2253
  };
@@ -2569,9 +2255,6 @@ const serializeAws_restJson1__listOfOutput = (input, context) => {
2569
2255
  return input
2570
2256
  .filter((e) => e != null)
2571
2257
  .map((entry) => {
2572
- if (entry === null) {
2573
- return null;
2574
- }
2575
2258
  return serializeAws_restJson1Output(entry, context);
2576
2259
  });
2577
2260
  };
@@ -2579,9 +2262,6 @@ const serializeAws_restJson1__listOfOutputChannelMapping = (input, context) => {
2579
2262
  return input
2580
2263
  .filter((e) => e != null)
2581
2264
  .map((entry) => {
2582
- if (entry === null) {
2583
- return null;
2584
- }
2585
2265
  return serializeAws_restJson1OutputChannelMapping(entry, context);
2586
2266
  });
2587
2267
  };
@@ -2589,9 +2269,6 @@ const serializeAws_restJson1__listOfOutputGroup = (input, context) => {
2589
2269
  return input
2590
2270
  .filter((e) => e != null)
2591
2271
  .map((entry) => {
2592
- if (entry === null) {
2593
- return null;
2594
- }
2595
2272
  return serializeAws_restJson1OutputGroup(entry, context);
2596
2273
  });
2597
2274
  };
@@ -2599,9 +2276,6 @@ const serializeAws_restJson1__listOfTeletextPageType = (input, context) => {
2599
2276
  return input
2600
2277
  .filter((e) => e != null)
2601
2278
  .map((entry) => {
2602
- if (entry === null) {
2603
- return null;
2604
- }
2605
2279
  return entry;
2606
2280
  });
2607
2281
  };