@aws-sdk/client-transcribe 3.52.0 → 3.53.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 (16) hide show
  1. package/CHANGELOG.md +11 -0
  2. package/dist-cjs/index.js +3 -0
  3. package/dist-cjs/models/TranscribeServiceException.js +11 -0
  4. package/dist-cjs/models/models_0.js +74 -3
  5. package/dist-cjs/protocols/Aws_json1_1.js +353 -1325
  6. package/dist-es/index.js +1 -0
  7. package/dist-es/models/TranscribeServiceException.js +12 -0
  8. package/dist-es/models/models_0.js +67 -1
  9. package/dist-es/protocols/Aws_json1_1.js +816 -1473
  10. package/dist-types/index.d.ts +1 -0
  11. package/dist-types/models/TranscribeServiceException.d.ts +10 -0
  12. package/dist-types/models/models_0.d.ts +37 -16
  13. package/dist-types/ts3.4/index.d.ts +1 -0
  14. package/dist-types/ts3.4/models/TranscribeServiceException.d.ts +6 -0
  15. package/dist-types/ts3.4/models/models_0.d.ts +27 -16
  16. package/package.json +25 -25
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -1,7 +1,8 @@
1
1
  import { __assign, __awaiter, __generator, __read } from "tslib";
2
2
  import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
3
- import { expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, expectUnion as __expectUnion, limitedParseFloat32 as __limitedParseFloat32, parseEpochTimestamp as __parseEpochTimestamp, } from "@aws-sdk/smithy-client";
4
- import { Rule, } from "../models/models_0";
3
+ import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, expectUnion as __expectUnion, limitedParseFloat32 as __limitedParseFloat32, parseEpochTimestamp as __parseEpochTimestamp, } from "@aws-sdk/smithy-client";
4
+ import { BadRequestException, ConflictException, InternalFailureException, LimitExceededException, NotFoundException, Rule, } from "../models/models_0";
5
+ import { TranscribeServiceException as __BaseException } from "../models/TranscribeServiceException";
5
6
  export var serializeAws_json1_1CreateCallAnalyticsCategoryCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
6
7
  var headers, body;
7
8
  return __generator(this, function (_a) {
@@ -450,16 +451,16 @@ export var deserializeAws_json1_1CreateCallAnalyticsCategoryCommand = function (
450
451
  });
451
452
  }); };
452
453
  var deserializeAws_json1_1CreateCallAnalyticsCategoryCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
453
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
454
- var _g;
455
- return __generator(this, function (_h) {
456
- switch (_h.label) {
454
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
455
+ var _c;
456
+ return __generator(this, function (_d) {
457
+ switch (_d.label) {
457
458
  case 0:
458
459
  _a = [__assign({}, output)];
459
- _g = {};
460
+ _c = {};
460
461
  return [4, parseBody(output.body, context)];
461
462
  case 1:
462
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
463
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
463
464
  errorCode = "UnknownError";
464
465
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
465
466
  _b = errorCode;
@@ -474,40 +475,22 @@ var deserializeAws_json1_1CreateCallAnalyticsCategoryCommandError = function (ou
474
475
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 8];
475
476
  }
476
477
  return [3, 10];
477
- case 2:
478
- _c = [{}];
479
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
480
- case 3:
481
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
482
- return [3, 11];
483
- case 4:
484
- _d = [{}];
485
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
486
- case 5:
487
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
488
- return [3, 11];
489
- case 6:
490
- _e = [{}];
491
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
492
- case 7:
493
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
494
- return [3, 11];
495
- case 8:
496
- _f = [{}];
497
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
498
- case 9:
499
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
500
- return [3, 11];
478
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
479
+ case 3: throw _d.sent();
480
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
481
+ case 5: throw _d.sent();
482
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
483
+ case 7: throw _d.sent();
484
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
485
+ case 9: throw _d.sent();
501
486
  case 10:
502
487
  parsedBody = parsedOutput.body;
503
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
504
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
505
- _h.label = 11;
506
- case 11:
507
- message = response.message || response.Message || errorCode;
508
- response.message = message;
509
- delete response.Message;
510
- return [2, Promise.reject(Object.assign(new Error(message), response))];
488
+ response = new __BaseException({
489
+ name: parsedBody.code || parsedBody.Code || errorCode,
490
+ $fault: "client",
491
+ $metadata: deserializeMetadata(output),
492
+ });
493
+ throw __decorateServiceException(response, parsedBody);
511
494
  }
512
495
  });
513
496
  }); };
@@ -530,16 +513,16 @@ export var deserializeAws_json1_1CreateLanguageModelCommand = function (output,
530
513
  });
531
514
  }); };
532
515
  var deserializeAws_json1_1CreateLanguageModelCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
533
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
534
- var _g;
535
- return __generator(this, function (_h) {
536
- switch (_h.label) {
516
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
517
+ var _c;
518
+ return __generator(this, function (_d) {
519
+ switch (_d.label) {
537
520
  case 0:
538
521
  _a = [__assign({}, output)];
539
- _g = {};
522
+ _c = {};
540
523
  return [4, parseBody(output.body, context)];
541
524
  case 1:
542
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
525
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
543
526
  errorCode = "UnknownError";
544
527
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
545
528
  _b = errorCode;
@@ -554,40 +537,22 @@ var deserializeAws_json1_1CreateLanguageModelCommandError = function (output, co
554
537
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 8];
555
538
  }
556
539
  return [3, 10];
557
- case 2:
558
- _c = [{}];
559
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
560
- case 3:
561
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
562
- return [3, 11];
563
- case 4:
564
- _d = [{}];
565
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
566
- case 5:
567
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
568
- return [3, 11];
569
- case 6:
570
- _e = [{}];
571
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
572
- case 7:
573
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
574
- return [3, 11];
575
- case 8:
576
- _f = [{}];
577
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
578
- case 9:
579
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
580
- return [3, 11];
540
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
541
+ case 3: throw _d.sent();
542
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
543
+ case 5: throw _d.sent();
544
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
545
+ case 7: throw _d.sent();
546
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
547
+ case 9: throw _d.sent();
581
548
  case 10:
582
549
  parsedBody = parsedOutput.body;
583
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
584
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
585
- _h.label = 11;
586
- case 11:
587
- message = response.message || response.Message || errorCode;
588
- response.message = message;
589
- delete response.Message;
590
- return [2, Promise.reject(Object.assign(new Error(message), response))];
550
+ response = new __BaseException({
551
+ name: parsedBody.code || parsedBody.Code || errorCode,
552
+ $fault: "client",
553
+ $metadata: deserializeMetadata(output),
554
+ });
555
+ throw __decorateServiceException(response, parsedBody);
591
556
  }
592
557
  });
593
558
  }); };
@@ -610,16 +575,16 @@ export var deserializeAws_json1_1CreateMedicalVocabularyCommand = function (outp
610
575
  });
611
576
  }); };
612
577
  var deserializeAws_json1_1CreateMedicalVocabularyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
613
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
614
- var _g;
615
- return __generator(this, function (_h) {
616
- switch (_h.label) {
578
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
579
+ var _c;
580
+ return __generator(this, function (_d) {
581
+ switch (_d.label) {
617
582
  case 0:
618
583
  _a = [__assign({}, output)];
619
- _g = {};
584
+ _c = {};
620
585
  return [4, parseBody(output.body, context)];
621
586
  case 1:
622
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
587
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
623
588
  errorCode = "UnknownError";
624
589
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
625
590
  _b = errorCode;
@@ -634,40 +599,22 @@ var deserializeAws_json1_1CreateMedicalVocabularyCommandError = function (output
634
599
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 8];
635
600
  }
636
601
  return [3, 10];
637
- case 2:
638
- _c = [{}];
639
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
640
- case 3:
641
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
642
- return [3, 11];
643
- case 4:
644
- _d = [{}];
645
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
646
- case 5:
647
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
648
- return [3, 11];
649
- case 6:
650
- _e = [{}];
651
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
652
- case 7:
653
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
654
- return [3, 11];
655
- case 8:
656
- _f = [{}];
657
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
658
- case 9:
659
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
660
- return [3, 11];
602
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
603
+ case 3: throw _d.sent();
604
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
605
+ case 5: throw _d.sent();
606
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
607
+ case 7: throw _d.sent();
608
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
609
+ case 9: throw _d.sent();
661
610
  case 10:
662
611
  parsedBody = parsedOutput.body;
663
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
664
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
665
- _h.label = 11;
666
- case 11:
667
- message = response.message || response.Message || errorCode;
668
- response.message = message;
669
- delete response.Message;
670
- return [2, Promise.reject(Object.assign(new Error(message), response))];
612
+ response = new __BaseException({
613
+ name: parsedBody.code || parsedBody.Code || errorCode,
614
+ $fault: "client",
615
+ $metadata: deserializeMetadata(output),
616
+ });
617
+ throw __decorateServiceException(response, parsedBody);
671
618
  }
672
619
  });
673
620
  }); };
@@ -690,16 +637,16 @@ export var deserializeAws_json1_1CreateVocabularyCommand = function (output, con
690
637
  });
691
638
  }); };
692
639
  var deserializeAws_json1_1CreateVocabularyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
693
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
694
- var _g;
695
- return __generator(this, function (_h) {
696
- switch (_h.label) {
640
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
641
+ var _c;
642
+ return __generator(this, function (_d) {
643
+ switch (_d.label) {
697
644
  case 0:
698
645
  _a = [__assign({}, output)];
699
- _g = {};
646
+ _c = {};
700
647
  return [4, parseBody(output.body, context)];
701
648
  case 1:
702
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
649
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
703
650
  errorCode = "UnknownError";
704
651
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
705
652
  _b = errorCode;
@@ -714,40 +661,22 @@ var deserializeAws_json1_1CreateVocabularyCommandError = function (output, conte
714
661
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 8];
715
662
  }
716
663
  return [3, 10];
717
- case 2:
718
- _c = [{}];
719
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
720
- case 3:
721
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
722
- return [3, 11];
723
- case 4:
724
- _d = [{}];
725
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
726
- case 5:
727
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
728
- return [3, 11];
729
- case 6:
730
- _e = [{}];
731
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
732
- case 7:
733
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
734
- return [3, 11];
735
- case 8:
736
- _f = [{}];
737
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
738
- case 9:
739
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
740
- return [3, 11];
664
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
665
+ case 3: throw _d.sent();
666
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
667
+ case 5: throw _d.sent();
668
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
669
+ case 7: throw _d.sent();
670
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
671
+ case 9: throw _d.sent();
741
672
  case 10:
742
673
  parsedBody = parsedOutput.body;
743
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
744
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
745
- _h.label = 11;
746
- case 11:
747
- message = response.message || response.Message || errorCode;
748
- response.message = message;
749
- delete response.Message;
750
- return [2, Promise.reject(Object.assign(new Error(message), response))];
674
+ response = new __BaseException({
675
+ name: parsedBody.code || parsedBody.Code || errorCode,
676
+ $fault: "client",
677
+ $metadata: deserializeMetadata(output),
678
+ });
679
+ throw __decorateServiceException(response, parsedBody);
751
680
  }
752
681
  });
753
682
  }); };
@@ -770,16 +699,16 @@ export var deserializeAws_json1_1CreateVocabularyFilterCommand = function (outpu
770
699
  });
771
700
  }); };
772
701
  var deserializeAws_json1_1CreateVocabularyFilterCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
773
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
774
- var _g;
775
- return __generator(this, function (_h) {
776
- switch (_h.label) {
702
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
703
+ var _c;
704
+ return __generator(this, function (_d) {
705
+ switch (_d.label) {
777
706
  case 0:
778
707
  _a = [__assign({}, output)];
779
- _g = {};
708
+ _c = {};
780
709
  return [4, parseBody(output.body, context)];
781
710
  case 1:
782
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
711
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
783
712
  errorCode = "UnknownError";
784
713
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
785
714
  _b = errorCode;
@@ -794,40 +723,22 @@ var deserializeAws_json1_1CreateVocabularyFilterCommandError = function (output,
794
723
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 8];
795
724
  }
796
725
  return [3, 10];
797
- case 2:
798
- _c = [{}];
799
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
800
- case 3:
801
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
802
- return [3, 11];
803
- case 4:
804
- _d = [{}];
805
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
806
- case 5:
807
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
808
- return [3, 11];
809
- case 6:
810
- _e = [{}];
811
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
812
- case 7:
813
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
814
- return [3, 11];
815
- case 8:
816
- _f = [{}];
817
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
818
- case 9:
819
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
820
- return [3, 11];
726
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
727
+ case 3: throw _d.sent();
728
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
729
+ case 5: throw _d.sent();
730
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
731
+ case 7: throw _d.sent();
732
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
733
+ case 9: throw _d.sent();
821
734
  case 10:
822
735
  parsedBody = parsedOutput.body;
823
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
824
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
825
- _h.label = 11;
826
- case 11:
827
- message = response.message || response.Message || errorCode;
828
- response.message = message;
829
- delete response.Message;
830
- return [2, Promise.reject(Object.assign(new Error(message), response))];
736
+ response = new __BaseException({
737
+ name: parsedBody.code || parsedBody.Code || errorCode,
738
+ $fault: "client",
739
+ $metadata: deserializeMetadata(output),
740
+ });
741
+ throw __decorateServiceException(response, parsedBody);
831
742
  }
832
743
  });
833
744
  }); };
@@ -850,16 +761,16 @@ export var deserializeAws_json1_1DeleteCallAnalyticsCategoryCommand = function (
850
761
  });
851
762
  }); };
852
763
  var deserializeAws_json1_1DeleteCallAnalyticsCategoryCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
853
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
854
- var _g;
855
- return __generator(this, function (_h) {
856
- switch (_h.label) {
764
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
765
+ var _c;
766
+ return __generator(this, function (_d) {
767
+ switch (_d.label) {
857
768
  case 0:
858
769
  _a = [__assign({}, output)];
859
- _g = {};
770
+ _c = {};
860
771
  return [4, parseBody(output.body, context)];
861
772
  case 1:
862
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
773
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
863
774
  errorCode = "UnknownError";
864
775
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
865
776
  _b = errorCode;
@@ -874,40 +785,22 @@ var deserializeAws_json1_1DeleteCallAnalyticsCategoryCommandError = function (ou
874
785
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
875
786
  }
876
787
  return [3, 10];
877
- case 2:
878
- _c = [{}];
879
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
880
- case 3:
881
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
882
- return [3, 11];
883
- case 4:
884
- _d = [{}];
885
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
886
- case 5:
887
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
888
- return [3, 11];
889
- case 6:
890
- _e = [{}];
891
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
892
- case 7:
893
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
894
- return [3, 11];
895
- case 8:
896
- _f = [{}];
897
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
898
- case 9:
899
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
900
- return [3, 11];
788
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
789
+ case 3: throw _d.sent();
790
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
791
+ case 5: throw _d.sent();
792
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
793
+ case 7: throw _d.sent();
794
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
795
+ case 9: throw _d.sent();
901
796
  case 10:
902
797
  parsedBody = parsedOutput.body;
903
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
904
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
905
- _h.label = 11;
906
- case 11:
907
- message = response.message || response.Message || errorCode;
908
- response.message = message;
909
- delete response.Message;
910
- return [2, Promise.reject(Object.assign(new Error(message), response))];
798
+ response = new __BaseException({
799
+ name: parsedBody.code || parsedBody.Code || errorCode,
800
+ $fault: "client",
801
+ $metadata: deserializeMetadata(output),
802
+ });
803
+ throw __decorateServiceException(response, parsedBody);
911
804
  }
912
805
  });
913
806
  }); };
@@ -930,16 +823,16 @@ export var deserializeAws_json1_1DeleteCallAnalyticsJobCommand = function (outpu
930
823
  });
931
824
  }); };
932
825
  var deserializeAws_json1_1DeleteCallAnalyticsJobCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
933
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
934
- var _f;
935
- return __generator(this, function (_g) {
936
- switch (_g.label) {
826
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
827
+ var _c;
828
+ return __generator(this, function (_d) {
829
+ switch (_d.label) {
937
830
  case 0:
938
831
  _a = [__assign({}, output)];
939
- _f = {};
832
+ _c = {};
940
833
  return [4, parseBody(output.body, context)];
941
834
  case 1:
942
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
835
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
943
836
  errorCode = "UnknownError";
944
837
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
945
838
  _b = errorCode;
@@ -952,34 +845,20 @@ var deserializeAws_json1_1DeleteCallAnalyticsJobCommandError = function (output,
952
845
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
953
846
  }
954
847
  return [3, 8];
955
- case 2:
956
- _c = [{}];
957
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
958
- case 3:
959
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
960
- return [3, 9];
961
- case 4:
962
- _d = [{}];
963
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
964
- case 5:
965
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
966
- return [3, 9];
967
- case 6:
968
- _e = [{}];
969
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
970
- case 7:
971
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
972
- return [3, 9];
848
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
849
+ case 3: throw _d.sent();
850
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
851
+ case 5: throw _d.sent();
852
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
853
+ case 7: throw _d.sent();
973
854
  case 8:
974
855
  parsedBody = parsedOutput.body;
975
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
976
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
977
- _g.label = 9;
978
- case 9:
979
- message = response.message || response.Message || errorCode;
980
- response.message = message;
981
- delete response.Message;
982
- return [2, Promise.reject(Object.assign(new Error(message), response))];
856
+ response = new __BaseException({
857
+ name: parsedBody.code || parsedBody.Code || errorCode,
858
+ $fault: "client",
859
+ $metadata: deserializeMetadata(output),
860
+ });
861
+ throw __decorateServiceException(response, parsedBody);
983
862
  }
984
863
  });
985
864
  }); };
@@ -1002,16 +881,16 @@ export var deserializeAws_json1_1DeleteLanguageModelCommand = function (output,
1002
881
  });
1003
882
  }); };
1004
883
  var deserializeAws_json1_1DeleteLanguageModelCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1005
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
1006
- var _f;
1007
- return __generator(this, function (_g) {
1008
- switch (_g.label) {
884
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
885
+ var _c;
886
+ return __generator(this, function (_d) {
887
+ switch (_d.label) {
1009
888
  case 0:
1010
889
  _a = [__assign({}, output)];
1011
- _f = {};
890
+ _c = {};
1012
891
  return [4, parseBody(output.body, context)];
1013
892
  case 1:
1014
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
893
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1015
894
  errorCode = "UnknownError";
1016
895
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1017
896
  _b = errorCode;
@@ -1024,34 +903,20 @@ var deserializeAws_json1_1DeleteLanguageModelCommandError = function (output, co
1024
903
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
1025
904
  }
1026
905
  return [3, 8];
1027
- case 2:
1028
- _c = [{}];
1029
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1030
- case 3:
1031
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1032
- return [3, 9];
1033
- case 4:
1034
- _d = [{}];
1035
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1036
- case 5:
1037
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1038
- return [3, 9];
1039
- case 6:
1040
- _e = [{}];
1041
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1042
- case 7:
1043
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1044
- return [3, 9];
906
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
907
+ case 3: throw _d.sent();
908
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
909
+ case 5: throw _d.sent();
910
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
911
+ case 7: throw _d.sent();
1045
912
  case 8:
1046
913
  parsedBody = parsedOutput.body;
1047
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1048
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1049
- _g.label = 9;
1050
- case 9:
1051
- message = response.message || response.Message || errorCode;
1052
- response.message = message;
1053
- delete response.Message;
1054
- return [2, Promise.reject(Object.assign(new Error(message), response))];
914
+ response = new __BaseException({
915
+ name: parsedBody.code || parsedBody.Code || errorCode,
916
+ $fault: "client",
917
+ $metadata: deserializeMetadata(output),
918
+ });
919
+ throw __decorateServiceException(response, parsedBody);
1055
920
  }
1056
921
  });
1057
922
  }); };
@@ -1074,16 +939,16 @@ export var deserializeAws_json1_1DeleteMedicalTranscriptionJobCommand = function
1074
939
  });
1075
940
  }); };
1076
941
  var deserializeAws_json1_1DeleteMedicalTranscriptionJobCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1077
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
1078
- var _f;
1079
- return __generator(this, function (_g) {
1080
- switch (_g.label) {
942
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
943
+ var _c;
944
+ return __generator(this, function (_d) {
945
+ switch (_d.label) {
1081
946
  case 0:
1082
947
  _a = [__assign({}, output)];
1083
- _f = {};
948
+ _c = {};
1084
949
  return [4, parseBody(output.body, context)];
1085
950
  case 1:
1086
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
951
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1087
952
  errorCode = "UnknownError";
1088
953
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1089
954
  _b = errorCode;
@@ -1096,34 +961,20 @@ var deserializeAws_json1_1DeleteMedicalTranscriptionJobCommandError = function (
1096
961
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
1097
962
  }
1098
963
  return [3, 8];
1099
- case 2:
1100
- _c = [{}];
1101
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1102
- case 3:
1103
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1104
- return [3, 9];
1105
- case 4:
1106
- _d = [{}];
1107
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1108
- case 5:
1109
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1110
- return [3, 9];
1111
- case 6:
1112
- _e = [{}];
1113
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1114
- case 7:
1115
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1116
- return [3, 9];
964
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
965
+ case 3: throw _d.sent();
966
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
967
+ case 5: throw _d.sent();
968
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
969
+ case 7: throw _d.sent();
1117
970
  case 8:
1118
971
  parsedBody = parsedOutput.body;
1119
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1120
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1121
- _g.label = 9;
1122
- case 9:
1123
- message = response.message || response.Message || errorCode;
1124
- response.message = message;
1125
- delete response.Message;
1126
- return [2, Promise.reject(Object.assign(new Error(message), response))];
972
+ response = new __BaseException({
973
+ name: parsedBody.code || parsedBody.Code || errorCode,
974
+ $fault: "client",
975
+ $metadata: deserializeMetadata(output),
976
+ });
977
+ throw __decorateServiceException(response, parsedBody);
1127
978
  }
1128
979
  });
1129
980
  }); };
@@ -1146,16 +997,16 @@ export var deserializeAws_json1_1DeleteMedicalVocabularyCommand = function (outp
1146
997
  });
1147
998
  }); };
1148
999
  var deserializeAws_json1_1DeleteMedicalVocabularyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1149
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
1150
- var _g;
1151
- return __generator(this, function (_h) {
1152
- switch (_h.label) {
1000
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1001
+ var _c;
1002
+ return __generator(this, function (_d) {
1003
+ switch (_d.label) {
1153
1004
  case 0:
1154
1005
  _a = [__assign({}, output)];
1155
- _g = {};
1006
+ _c = {};
1156
1007
  return [4, parseBody(output.body, context)];
1157
1008
  case 1:
1158
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1009
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1159
1010
  errorCode = "UnknownError";
1160
1011
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1161
1012
  _b = errorCode;
@@ -1170,40 +1021,22 @@ var deserializeAws_json1_1DeleteMedicalVocabularyCommandError = function (output
1170
1021
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
1171
1022
  }
1172
1023
  return [3, 10];
1173
- case 2:
1174
- _c = [{}];
1175
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1176
- case 3:
1177
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1178
- return [3, 11];
1179
- case 4:
1180
- _d = [{}];
1181
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1182
- case 5:
1183
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1184
- return [3, 11];
1185
- case 6:
1186
- _e = [{}];
1187
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1188
- case 7:
1189
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1190
- return [3, 11];
1191
- case 8:
1192
- _f = [{}];
1193
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1194
- case 9:
1195
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1196
- return [3, 11];
1024
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1025
+ case 3: throw _d.sent();
1026
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1027
+ case 5: throw _d.sent();
1028
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1029
+ case 7: throw _d.sent();
1030
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1031
+ case 9: throw _d.sent();
1197
1032
  case 10:
1198
1033
  parsedBody = parsedOutput.body;
1199
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1200
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1201
- _h.label = 11;
1202
- case 11:
1203
- message = response.message || response.Message || errorCode;
1204
- response.message = message;
1205
- delete response.Message;
1206
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1034
+ response = new __BaseException({
1035
+ name: parsedBody.code || parsedBody.Code || errorCode,
1036
+ $fault: "client",
1037
+ $metadata: deserializeMetadata(output),
1038
+ });
1039
+ throw __decorateServiceException(response, parsedBody);
1207
1040
  }
1208
1041
  });
1209
1042
  }); };
@@ -1226,16 +1059,16 @@ export var deserializeAws_json1_1DeleteTranscriptionJobCommand = function (outpu
1226
1059
  });
1227
1060
  }); };
1228
1061
  var deserializeAws_json1_1DeleteTranscriptionJobCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1229
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
1230
- var _f;
1231
- return __generator(this, function (_g) {
1232
- switch (_g.label) {
1062
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1063
+ var _c;
1064
+ return __generator(this, function (_d) {
1065
+ switch (_d.label) {
1233
1066
  case 0:
1234
1067
  _a = [__assign({}, output)];
1235
- _f = {};
1068
+ _c = {};
1236
1069
  return [4, parseBody(output.body, context)];
1237
1070
  case 1:
1238
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
1071
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1239
1072
  errorCode = "UnknownError";
1240
1073
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1241
1074
  _b = errorCode;
@@ -1248,34 +1081,20 @@ var deserializeAws_json1_1DeleteTranscriptionJobCommandError = function (output,
1248
1081
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
1249
1082
  }
1250
1083
  return [3, 8];
1251
- case 2:
1252
- _c = [{}];
1253
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1254
- case 3:
1255
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1256
- return [3, 9];
1257
- case 4:
1258
- _d = [{}];
1259
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1260
- case 5:
1261
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1262
- return [3, 9];
1263
- case 6:
1264
- _e = [{}];
1265
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1266
- case 7:
1267
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1268
- return [3, 9];
1084
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1085
+ case 3: throw _d.sent();
1086
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1087
+ case 5: throw _d.sent();
1088
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1089
+ case 7: throw _d.sent();
1269
1090
  case 8:
1270
1091
  parsedBody = parsedOutput.body;
1271
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1272
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1273
- _g.label = 9;
1274
- case 9:
1275
- message = response.message || response.Message || errorCode;
1276
- response.message = message;
1277
- delete response.Message;
1278
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1092
+ response = new __BaseException({
1093
+ name: parsedBody.code || parsedBody.Code || errorCode,
1094
+ $fault: "client",
1095
+ $metadata: deserializeMetadata(output),
1096
+ });
1097
+ throw __decorateServiceException(response, parsedBody);
1279
1098
  }
1280
1099
  });
1281
1100
  }); };
@@ -1298,16 +1117,16 @@ export var deserializeAws_json1_1DeleteVocabularyCommand = function (output, con
1298
1117
  });
1299
1118
  }); };
1300
1119
  var deserializeAws_json1_1DeleteVocabularyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1301
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
1302
- var _g;
1303
- return __generator(this, function (_h) {
1304
- switch (_h.label) {
1120
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1121
+ var _c;
1122
+ return __generator(this, function (_d) {
1123
+ switch (_d.label) {
1305
1124
  case 0:
1306
1125
  _a = [__assign({}, output)];
1307
- _g = {};
1126
+ _c = {};
1308
1127
  return [4, parseBody(output.body, context)];
1309
1128
  case 1:
1310
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1129
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1311
1130
  errorCode = "UnknownError";
1312
1131
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1313
1132
  _b = errorCode;
@@ -1322,40 +1141,22 @@ var deserializeAws_json1_1DeleteVocabularyCommandError = function (output, conte
1322
1141
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
1323
1142
  }
1324
1143
  return [3, 10];
1325
- case 2:
1326
- _c = [{}];
1327
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1328
- case 3:
1329
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1330
- return [3, 11];
1331
- case 4:
1332
- _d = [{}];
1333
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1334
- case 5:
1335
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1336
- return [3, 11];
1337
- case 6:
1338
- _e = [{}];
1339
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1340
- case 7:
1341
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1342
- return [3, 11];
1343
- case 8:
1344
- _f = [{}];
1345
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1346
- case 9:
1347
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1348
- return [3, 11];
1144
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1145
+ case 3: throw _d.sent();
1146
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1147
+ case 5: throw _d.sent();
1148
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1149
+ case 7: throw _d.sent();
1150
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1151
+ case 9: throw _d.sent();
1349
1152
  case 10:
1350
1153
  parsedBody = parsedOutput.body;
1351
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1352
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1353
- _h.label = 11;
1354
- case 11:
1355
- message = response.message || response.Message || errorCode;
1356
- response.message = message;
1357
- delete response.Message;
1358
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1154
+ response = new __BaseException({
1155
+ name: parsedBody.code || parsedBody.Code || errorCode,
1156
+ $fault: "client",
1157
+ $metadata: deserializeMetadata(output),
1158
+ });
1159
+ throw __decorateServiceException(response, parsedBody);
1359
1160
  }
1360
1161
  });
1361
1162
  }); };
@@ -1378,16 +1179,16 @@ export var deserializeAws_json1_1DeleteVocabularyFilterCommand = function (outpu
1378
1179
  });
1379
1180
  }); };
1380
1181
  var deserializeAws_json1_1DeleteVocabularyFilterCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1381
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
1382
- var _g;
1383
- return __generator(this, function (_h) {
1384
- switch (_h.label) {
1182
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1183
+ var _c;
1184
+ return __generator(this, function (_d) {
1185
+ switch (_d.label) {
1385
1186
  case 0:
1386
1187
  _a = [__assign({}, output)];
1387
- _g = {};
1188
+ _c = {};
1388
1189
  return [4, parseBody(output.body, context)];
1389
1190
  case 1:
1390
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1191
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1391
1192
  errorCode = "UnknownError";
1392
1193
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1393
1194
  _b = errorCode;
@@ -1402,40 +1203,22 @@ var deserializeAws_json1_1DeleteVocabularyFilterCommandError = function (output,
1402
1203
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
1403
1204
  }
1404
1205
  return [3, 10];
1405
- case 2:
1406
- _c = [{}];
1407
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1408
- case 3:
1409
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1410
- return [3, 11];
1411
- case 4:
1412
- _d = [{}];
1413
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1414
- case 5:
1415
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1416
- return [3, 11];
1417
- case 6:
1418
- _e = [{}];
1419
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1420
- case 7:
1421
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1422
- return [3, 11];
1423
- case 8:
1424
- _f = [{}];
1425
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1426
- case 9:
1427
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1428
- return [3, 11];
1206
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1207
+ case 3: throw _d.sent();
1208
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1209
+ case 5: throw _d.sent();
1210
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1211
+ case 7: throw _d.sent();
1212
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1213
+ case 9: throw _d.sent();
1429
1214
  case 10:
1430
1215
  parsedBody = parsedOutput.body;
1431
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1432
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1433
- _h.label = 11;
1434
- case 11:
1435
- message = response.message || response.Message || errorCode;
1436
- response.message = message;
1437
- delete response.Message;
1438
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1216
+ response = new __BaseException({
1217
+ name: parsedBody.code || parsedBody.Code || errorCode,
1218
+ $fault: "client",
1219
+ $metadata: deserializeMetadata(output),
1220
+ });
1221
+ throw __decorateServiceException(response, parsedBody);
1439
1222
  }
1440
1223
  });
1441
1224
  }); };
@@ -1458,16 +1241,16 @@ export var deserializeAws_json1_1DescribeLanguageModelCommand = function (output
1458
1241
  });
1459
1242
  }); };
1460
1243
  var deserializeAws_json1_1DescribeLanguageModelCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1461
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
1462
- var _g;
1463
- return __generator(this, function (_h) {
1464
- switch (_h.label) {
1244
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1245
+ var _c;
1246
+ return __generator(this, function (_d) {
1247
+ switch (_d.label) {
1465
1248
  case 0:
1466
1249
  _a = [__assign({}, output)];
1467
- _g = {};
1250
+ _c = {};
1468
1251
  return [4, parseBody(output.body, context)];
1469
1252
  case 1:
1470
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1253
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1471
1254
  errorCode = "UnknownError";
1472
1255
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1473
1256
  _b = errorCode;
@@ -1482,40 +1265,22 @@ var deserializeAws_json1_1DescribeLanguageModelCommandError = function (output,
1482
1265
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
1483
1266
  }
1484
1267
  return [3, 10];
1485
- case 2:
1486
- _c = [{}];
1487
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1488
- case 3:
1489
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1490
- return [3, 11];
1491
- case 4:
1492
- _d = [{}];
1493
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1494
- case 5:
1495
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1496
- return [3, 11];
1497
- case 6:
1498
- _e = [{}];
1499
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1500
- case 7:
1501
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1502
- return [3, 11];
1503
- case 8:
1504
- _f = [{}];
1505
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1506
- case 9:
1507
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1508
- return [3, 11];
1268
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1269
+ case 3: throw _d.sent();
1270
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1271
+ case 5: throw _d.sent();
1272
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1273
+ case 7: throw _d.sent();
1274
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1275
+ case 9: throw _d.sent();
1509
1276
  case 10:
1510
1277
  parsedBody = parsedOutput.body;
1511
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1512
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1513
- _h.label = 11;
1514
- case 11:
1515
- message = response.message || response.Message || errorCode;
1516
- response.message = message;
1517
- delete response.Message;
1518
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1278
+ response = new __BaseException({
1279
+ name: parsedBody.code || parsedBody.Code || errorCode,
1280
+ $fault: "client",
1281
+ $metadata: deserializeMetadata(output),
1282
+ });
1283
+ throw __decorateServiceException(response, parsedBody);
1519
1284
  }
1520
1285
  });
1521
1286
  }); };
@@ -1538,16 +1303,16 @@ export var deserializeAws_json1_1GetCallAnalyticsCategoryCommand = function (out
1538
1303
  });
1539
1304
  }); };
1540
1305
  var deserializeAws_json1_1GetCallAnalyticsCategoryCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1541
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
1542
- var _g;
1543
- return __generator(this, function (_h) {
1544
- switch (_h.label) {
1306
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1307
+ var _c;
1308
+ return __generator(this, function (_d) {
1309
+ switch (_d.label) {
1545
1310
  case 0:
1546
1311
  _a = [__assign({}, output)];
1547
- _g = {};
1312
+ _c = {};
1548
1313
  return [4, parseBody(output.body, context)];
1549
1314
  case 1:
1550
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1315
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1551
1316
  errorCode = "UnknownError";
1552
1317
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1553
1318
  _b = errorCode;
@@ -1562,40 +1327,22 @@ var deserializeAws_json1_1GetCallAnalyticsCategoryCommandError = function (outpu
1562
1327
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
1563
1328
  }
1564
1329
  return [3, 10];
1565
- case 2:
1566
- _c = [{}];
1567
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1568
- case 3:
1569
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1570
- return [3, 11];
1571
- case 4:
1572
- _d = [{}];
1573
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1574
- case 5:
1575
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1576
- return [3, 11];
1577
- case 6:
1578
- _e = [{}];
1579
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1580
- case 7:
1581
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1582
- return [3, 11];
1583
- case 8:
1584
- _f = [{}];
1585
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1586
- case 9:
1587
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1588
- return [3, 11];
1330
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1331
+ case 3: throw _d.sent();
1332
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1333
+ case 5: throw _d.sent();
1334
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1335
+ case 7: throw _d.sent();
1336
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1337
+ case 9: throw _d.sent();
1589
1338
  case 10:
1590
1339
  parsedBody = parsedOutput.body;
1591
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1592
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1593
- _h.label = 11;
1594
- case 11:
1595
- message = response.message || response.Message || errorCode;
1596
- response.message = message;
1597
- delete response.Message;
1598
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1340
+ response = new __BaseException({
1341
+ name: parsedBody.code || parsedBody.Code || errorCode,
1342
+ $fault: "client",
1343
+ $metadata: deserializeMetadata(output),
1344
+ });
1345
+ throw __decorateServiceException(response, parsedBody);
1599
1346
  }
1600
1347
  });
1601
1348
  }); };
@@ -1618,16 +1365,16 @@ export var deserializeAws_json1_1GetCallAnalyticsJobCommand = function (output,
1618
1365
  });
1619
1366
  }); };
1620
1367
  var deserializeAws_json1_1GetCallAnalyticsJobCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1621
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
1622
- var _g;
1623
- return __generator(this, function (_h) {
1624
- switch (_h.label) {
1368
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1369
+ var _c;
1370
+ return __generator(this, function (_d) {
1371
+ switch (_d.label) {
1625
1372
  case 0:
1626
1373
  _a = [__assign({}, output)];
1627
- _g = {};
1374
+ _c = {};
1628
1375
  return [4, parseBody(output.body, context)];
1629
1376
  case 1:
1630
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1377
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1631
1378
  errorCode = "UnknownError";
1632
1379
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1633
1380
  _b = errorCode;
@@ -1642,40 +1389,22 @@ var deserializeAws_json1_1GetCallAnalyticsJobCommandError = function (output, co
1642
1389
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
1643
1390
  }
1644
1391
  return [3, 10];
1645
- case 2:
1646
- _c = [{}];
1647
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1648
- case 3:
1649
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1650
- return [3, 11];
1651
- case 4:
1652
- _d = [{}];
1653
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1654
- case 5:
1655
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1656
- return [3, 11];
1657
- case 6:
1658
- _e = [{}];
1659
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1660
- case 7:
1661
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1662
- return [3, 11];
1663
- case 8:
1664
- _f = [{}];
1665
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1666
- case 9:
1667
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1668
- return [3, 11];
1392
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1393
+ case 3: throw _d.sent();
1394
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1395
+ case 5: throw _d.sent();
1396
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1397
+ case 7: throw _d.sent();
1398
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1399
+ case 9: throw _d.sent();
1669
1400
  case 10:
1670
1401
  parsedBody = parsedOutput.body;
1671
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1672
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1673
- _h.label = 11;
1674
- case 11:
1675
- message = response.message || response.Message || errorCode;
1676
- response.message = message;
1677
- delete response.Message;
1678
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1402
+ response = new __BaseException({
1403
+ name: parsedBody.code || parsedBody.Code || errorCode,
1404
+ $fault: "client",
1405
+ $metadata: deserializeMetadata(output),
1406
+ });
1407
+ throw __decorateServiceException(response, parsedBody);
1679
1408
  }
1680
1409
  });
1681
1410
  }); };
@@ -1698,16 +1427,16 @@ export var deserializeAws_json1_1GetMedicalTranscriptionJobCommand = function (o
1698
1427
  });
1699
1428
  }); };
1700
1429
  var deserializeAws_json1_1GetMedicalTranscriptionJobCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1701
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
1702
- var _g;
1703
- return __generator(this, function (_h) {
1704
- switch (_h.label) {
1430
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1431
+ var _c;
1432
+ return __generator(this, function (_d) {
1433
+ switch (_d.label) {
1705
1434
  case 0:
1706
1435
  _a = [__assign({}, output)];
1707
- _g = {};
1436
+ _c = {};
1708
1437
  return [4, parseBody(output.body, context)];
1709
1438
  case 1:
1710
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1439
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1711
1440
  errorCode = "UnknownError";
1712
1441
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1713
1442
  _b = errorCode;
@@ -1722,40 +1451,22 @@ var deserializeAws_json1_1GetMedicalTranscriptionJobCommandError = function (out
1722
1451
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
1723
1452
  }
1724
1453
  return [3, 10];
1725
- case 2:
1726
- _c = [{}];
1727
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1728
- case 3:
1729
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1730
- return [3, 11];
1731
- case 4:
1732
- _d = [{}];
1733
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1734
- case 5:
1735
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1736
- return [3, 11];
1737
- case 6:
1738
- _e = [{}];
1739
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1740
- case 7:
1741
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1742
- return [3, 11];
1743
- case 8:
1744
- _f = [{}];
1745
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1746
- case 9:
1747
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1748
- return [3, 11];
1454
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1455
+ case 3: throw _d.sent();
1456
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1457
+ case 5: throw _d.sent();
1458
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1459
+ case 7: throw _d.sent();
1460
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1461
+ case 9: throw _d.sent();
1749
1462
  case 10:
1750
1463
  parsedBody = parsedOutput.body;
1751
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1752
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1753
- _h.label = 11;
1754
- case 11:
1755
- message = response.message || response.Message || errorCode;
1756
- response.message = message;
1757
- delete response.Message;
1758
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1464
+ response = new __BaseException({
1465
+ name: parsedBody.code || parsedBody.Code || errorCode,
1466
+ $fault: "client",
1467
+ $metadata: deserializeMetadata(output),
1468
+ });
1469
+ throw __decorateServiceException(response, parsedBody);
1759
1470
  }
1760
1471
  });
1761
1472
  }); };
@@ -1778,16 +1489,16 @@ export var deserializeAws_json1_1GetMedicalVocabularyCommand = function (output,
1778
1489
  });
1779
1490
  }); };
1780
1491
  var deserializeAws_json1_1GetMedicalVocabularyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1781
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
1782
- var _g;
1783
- return __generator(this, function (_h) {
1784
- switch (_h.label) {
1492
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1493
+ var _c;
1494
+ return __generator(this, function (_d) {
1495
+ switch (_d.label) {
1785
1496
  case 0:
1786
1497
  _a = [__assign({}, output)];
1787
- _g = {};
1498
+ _c = {};
1788
1499
  return [4, parseBody(output.body, context)];
1789
1500
  case 1:
1790
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1501
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1791
1502
  errorCode = "UnknownError";
1792
1503
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1793
1504
  _b = errorCode;
@@ -1802,40 +1513,22 @@ var deserializeAws_json1_1GetMedicalVocabularyCommandError = function (output, c
1802
1513
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
1803
1514
  }
1804
1515
  return [3, 10];
1805
- case 2:
1806
- _c = [{}];
1807
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1808
- case 3:
1809
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1810
- return [3, 11];
1811
- case 4:
1812
- _d = [{}];
1813
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1814
- case 5:
1815
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1816
- return [3, 11];
1817
- case 6:
1818
- _e = [{}];
1819
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1820
- case 7:
1821
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1822
- return [3, 11];
1823
- case 8:
1824
- _f = [{}];
1825
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1826
- case 9:
1827
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1828
- return [3, 11];
1516
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1517
+ case 3: throw _d.sent();
1518
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1519
+ case 5: throw _d.sent();
1520
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1521
+ case 7: throw _d.sent();
1522
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1523
+ case 9: throw _d.sent();
1829
1524
  case 10:
1830
1525
  parsedBody = parsedOutput.body;
1831
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1832
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1833
- _h.label = 11;
1834
- case 11:
1835
- message = response.message || response.Message || errorCode;
1836
- response.message = message;
1837
- delete response.Message;
1838
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1526
+ response = new __BaseException({
1527
+ name: parsedBody.code || parsedBody.Code || errorCode,
1528
+ $fault: "client",
1529
+ $metadata: deserializeMetadata(output),
1530
+ });
1531
+ throw __decorateServiceException(response, parsedBody);
1839
1532
  }
1840
1533
  });
1841
1534
  }); };
@@ -1858,16 +1551,16 @@ export var deserializeAws_json1_1GetTranscriptionJobCommand = function (output,
1858
1551
  });
1859
1552
  }); };
1860
1553
  var deserializeAws_json1_1GetTranscriptionJobCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1861
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
1862
- var _g;
1863
- return __generator(this, function (_h) {
1864
- switch (_h.label) {
1554
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1555
+ var _c;
1556
+ return __generator(this, function (_d) {
1557
+ switch (_d.label) {
1865
1558
  case 0:
1866
1559
  _a = [__assign({}, output)];
1867
- _g = {};
1560
+ _c = {};
1868
1561
  return [4, parseBody(output.body, context)];
1869
1562
  case 1:
1870
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1563
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1871
1564
  errorCode = "UnknownError";
1872
1565
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1873
1566
  _b = errorCode;
@@ -1882,40 +1575,22 @@ var deserializeAws_json1_1GetTranscriptionJobCommandError = function (output, co
1882
1575
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
1883
1576
  }
1884
1577
  return [3, 10];
1885
- case 2:
1886
- _c = [{}];
1887
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1888
- case 3:
1889
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1890
- return [3, 11];
1891
- case 4:
1892
- _d = [{}];
1893
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1894
- case 5:
1895
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1896
- return [3, 11];
1897
- case 6:
1898
- _e = [{}];
1899
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1900
- case 7:
1901
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1902
- return [3, 11];
1903
- case 8:
1904
- _f = [{}];
1905
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1906
- case 9:
1907
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1908
- return [3, 11];
1578
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1579
+ case 3: throw _d.sent();
1580
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1581
+ case 5: throw _d.sent();
1582
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1583
+ case 7: throw _d.sent();
1584
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1585
+ case 9: throw _d.sent();
1909
1586
  case 10:
1910
1587
  parsedBody = parsedOutput.body;
1911
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1912
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1913
- _h.label = 11;
1914
- case 11:
1915
- message = response.message || response.Message || errorCode;
1916
- response.message = message;
1917
- delete response.Message;
1918
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1588
+ response = new __BaseException({
1589
+ name: parsedBody.code || parsedBody.Code || errorCode,
1590
+ $fault: "client",
1591
+ $metadata: deserializeMetadata(output),
1592
+ });
1593
+ throw __decorateServiceException(response, parsedBody);
1919
1594
  }
1920
1595
  });
1921
1596
  }); };
@@ -1938,16 +1613,16 @@ export var deserializeAws_json1_1GetVocabularyCommand = function (output, contex
1938
1613
  });
1939
1614
  }); };
1940
1615
  var deserializeAws_json1_1GetVocabularyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1941
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
1942
- var _g;
1943
- return __generator(this, function (_h) {
1944
- switch (_h.label) {
1616
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1617
+ var _c;
1618
+ return __generator(this, function (_d) {
1619
+ switch (_d.label) {
1945
1620
  case 0:
1946
1621
  _a = [__assign({}, output)];
1947
- _g = {};
1622
+ _c = {};
1948
1623
  return [4, parseBody(output.body, context)];
1949
1624
  case 1:
1950
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1625
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1951
1626
  errorCode = "UnknownError";
1952
1627
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1953
1628
  _b = errorCode;
@@ -1962,40 +1637,22 @@ var deserializeAws_json1_1GetVocabularyCommandError = function (output, context)
1962
1637
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
1963
1638
  }
1964
1639
  return [3, 10];
1965
- case 2:
1966
- _c = [{}];
1967
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1968
- case 3:
1969
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1970
- return [3, 11];
1971
- case 4:
1972
- _d = [{}];
1973
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1974
- case 5:
1975
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1976
- return [3, 11];
1977
- case 6:
1978
- _e = [{}];
1979
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1980
- case 7:
1981
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1982
- return [3, 11];
1983
- case 8:
1984
- _f = [{}];
1985
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1986
- case 9:
1987
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1988
- return [3, 11];
1640
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1641
+ case 3: throw _d.sent();
1642
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1643
+ case 5: throw _d.sent();
1644
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1645
+ case 7: throw _d.sent();
1646
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1647
+ case 9: throw _d.sent();
1989
1648
  case 10:
1990
1649
  parsedBody = parsedOutput.body;
1991
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1992
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1993
- _h.label = 11;
1994
- case 11:
1995
- message = response.message || response.Message || errorCode;
1996
- response.message = message;
1997
- delete response.Message;
1998
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1650
+ response = new __BaseException({
1651
+ name: parsedBody.code || parsedBody.Code || errorCode,
1652
+ $fault: "client",
1653
+ $metadata: deserializeMetadata(output),
1654
+ });
1655
+ throw __decorateServiceException(response, parsedBody);
1999
1656
  }
2000
1657
  });
2001
1658
  }); };
@@ -2018,16 +1675,16 @@ export var deserializeAws_json1_1GetVocabularyFilterCommand = function (output,
2018
1675
  });
2019
1676
  }); };
2020
1677
  var deserializeAws_json1_1GetVocabularyFilterCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2021
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
2022
- var _g;
2023
- return __generator(this, function (_h) {
2024
- switch (_h.label) {
1678
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1679
+ var _c;
1680
+ return __generator(this, function (_d) {
1681
+ switch (_d.label) {
2025
1682
  case 0:
2026
1683
  _a = [__assign({}, output)];
2027
- _g = {};
1684
+ _c = {};
2028
1685
  return [4, parseBody(output.body, context)];
2029
1686
  case 1:
2030
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
1687
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2031
1688
  errorCode = "UnknownError";
2032
1689
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2033
1690
  _b = errorCode;
@@ -2042,40 +1699,22 @@ var deserializeAws_json1_1GetVocabularyFilterCommandError = function (output, co
2042
1699
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
2043
1700
  }
2044
1701
  return [3, 10];
2045
- case 2:
2046
- _c = [{}];
2047
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2048
- case 3:
2049
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2050
- return [3, 11];
2051
- case 4:
2052
- _d = [{}];
2053
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2054
- case 5:
2055
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2056
- return [3, 11];
2057
- case 6:
2058
- _e = [{}];
2059
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2060
- case 7:
2061
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2062
- return [3, 11];
2063
- case 8:
2064
- _f = [{}];
2065
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
2066
- case 9:
2067
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2068
- return [3, 11];
1702
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1703
+ case 3: throw _d.sent();
1704
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1705
+ case 5: throw _d.sent();
1706
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1707
+ case 7: throw _d.sent();
1708
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
1709
+ case 9: throw _d.sent();
2069
1710
  case 10:
2070
1711
  parsedBody = parsedOutput.body;
2071
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2072
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2073
- _h.label = 11;
2074
- case 11:
2075
- message = response.message || response.Message || errorCode;
2076
- response.message = message;
2077
- delete response.Message;
2078
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1712
+ response = new __BaseException({
1713
+ name: parsedBody.code || parsedBody.Code || errorCode,
1714
+ $fault: "client",
1715
+ $metadata: deserializeMetadata(output),
1716
+ });
1717
+ throw __decorateServiceException(response, parsedBody);
2079
1718
  }
2080
1719
  });
2081
1720
  }); };
@@ -2098,16 +1737,16 @@ export var deserializeAws_json1_1ListCallAnalyticsCategoriesCommand = function (
2098
1737
  });
2099
1738
  }); };
2100
1739
  var deserializeAws_json1_1ListCallAnalyticsCategoriesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2101
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
2102
- var _f;
2103
- return __generator(this, function (_g) {
2104
- switch (_g.label) {
1740
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1741
+ var _c;
1742
+ return __generator(this, function (_d) {
1743
+ switch (_d.label) {
2105
1744
  case 0:
2106
1745
  _a = [__assign({}, output)];
2107
- _f = {};
1746
+ _c = {};
2108
1747
  return [4, parseBody(output.body, context)];
2109
1748
  case 1:
2110
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
1749
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2111
1750
  errorCode = "UnknownError";
2112
1751
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2113
1752
  _b = errorCode;
@@ -2120,34 +1759,20 @@ var deserializeAws_json1_1ListCallAnalyticsCategoriesCommandError = function (ou
2120
1759
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
2121
1760
  }
2122
1761
  return [3, 8];
2123
- case 2:
2124
- _c = [{}];
2125
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2126
- case 3:
2127
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2128
- return [3, 9];
2129
- case 4:
2130
- _d = [{}];
2131
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2132
- case 5:
2133
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2134
- return [3, 9];
2135
- case 6:
2136
- _e = [{}];
2137
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2138
- case 7:
2139
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2140
- return [3, 9];
1762
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1763
+ case 3: throw _d.sent();
1764
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1765
+ case 5: throw _d.sent();
1766
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1767
+ case 7: throw _d.sent();
2141
1768
  case 8:
2142
1769
  parsedBody = parsedOutput.body;
2143
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2144
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2145
- _g.label = 9;
2146
- case 9:
2147
- message = response.message || response.Message || errorCode;
2148
- response.message = message;
2149
- delete response.Message;
2150
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1770
+ response = new __BaseException({
1771
+ name: parsedBody.code || parsedBody.Code || errorCode,
1772
+ $fault: "client",
1773
+ $metadata: deserializeMetadata(output),
1774
+ });
1775
+ throw __decorateServiceException(response, parsedBody);
2151
1776
  }
2152
1777
  });
2153
1778
  }); };
@@ -2170,16 +1795,16 @@ export var deserializeAws_json1_1ListCallAnalyticsJobsCommand = function (output
2170
1795
  });
2171
1796
  }); };
2172
1797
  var deserializeAws_json1_1ListCallAnalyticsJobsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2173
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
2174
- var _f;
2175
- return __generator(this, function (_g) {
2176
- switch (_g.label) {
1798
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1799
+ var _c;
1800
+ return __generator(this, function (_d) {
1801
+ switch (_d.label) {
2177
1802
  case 0:
2178
1803
  _a = [__assign({}, output)];
2179
- _f = {};
1804
+ _c = {};
2180
1805
  return [4, parseBody(output.body, context)];
2181
1806
  case 1:
2182
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
1807
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2183
1808
  errorCode = "UnknownError";
2184
1809
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2185
1810
  _b = errorCode;
@@ -2192,34 +1817,20 @@ var deserializeAws_json1_1ListCallAnalyticsJobsCommandError = function (output,
2192
1817
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
2193
1818
  }
2194
1819
  return [3, 8];
2195
- case 2:
2196
- _c = [{}];
2197
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2198
- case 3:
2199
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2200
- return [3, 9];
2201
- case 4:
2202
- _d = [{}];
2203
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2204
- case 5:
2205
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2206
- return [3, 9];
2207
- case 6:
2208
- _e = [{}];
2209
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2210
- case 7:
2211
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2212
- return [3, 9];
1820
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1821
+ case 3: throw _d.sent();
1822
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1823
+ case 5: throw _d.sent();
1824
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1825
+ case 7: throw _d.sent();
2213
1826
  case 8:
2214
1827
  parsedBody = parsedOutput.body;
2215
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2216
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2217
- _g.label = 9;
2218
- case 9:
2219
- message = response.message || response.Message || errorCode;
2220
- response.message = message;
2221
- delete response.Message;
2222
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1828
+ response = new __BaseException({
1829
+ name: parsedBody.code || parsedBody.Code || errorCode,
1830
+ $fault: "client",
1831
+ $metadata: deserializeMetadata(output),
1832
+ });
1833
+ throw __decorateServiceException(response, parsedBody);
2223
1834
  }
2224
1835
  });
2225
1836
  }); };
@@ -2242,16 +1853,16 @@ export var deserializeAws_json1_1ListLanguageModelsCommand = function (output, c
2242
1853
  });
2243
1854
  }); };
2244
1855
  var deserializeAws_json1_1ListLanguageModelsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2245
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
2246
- var _f;
2247
- return __generator(this, function (_g) {
2248
- switch (_g.label) {
1856
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1857
+ var _c;
1858
+ return __generator(this, function (_d) {
1859
+ switch (_d.label) {
2249
1860
  case 0:
2250
1861
  _a = [__assign({}, output)];
2251
- _f = {};
1862
+ _c = {};
2252
1863
  return [4, parseBody(output.body, context)];
2253
1864
  case 1:
2254
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
1865
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2255
1866
  errorCode = "UnknownError";
2256
1867
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2257
1868
  _b = errorCode;
@@ -2264,34 +1875,20 @@ var deserializeAws_json1_1ListLanguageModelsCommandError = function (output, con
2264
1875
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
2265
1876
  }
2266
1877
  return [3, 8];
2267
- case 2:
2268
- _c = [{}];
2269
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2270
- case 3:
2271
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2272
- return [3, 9];
2273
- case 4:
2274
- _d = [{}];
2275
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2276
- case 5:
2277
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2278
- return [3, 9];
2279
- case 6:
2280
- _e = [{}];
2281
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2282
- case 7:
2283
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2284
- return [3, 9];
1878
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1879
+ case 3: throw _d.sent();
1880
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1881
+ case 5: throw _d.sent();
1882
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1883
+ case 7: throw _d.sent();
2285
1884
  case 8:
2286
1885
  parsedBody = parsedOutput.body;
2287
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2288
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2289
- _g.label = 9;
2290
- case 9:
2291
- message = response.message || response.Message || errorCode;
2292
- response.message = message;
2293
- delete response.Message;
2294
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1886
+ response = new __BaseException({
1887
+ name: parsedBody.code || parsedBody.Code || errorCode,
1888
+ $fault: "client",
1889
+ $metadata: deserializeMetadata(output),
1890
+ });
1891
+ throw __decorateServiceException(response, parsedBody);
2295
1892
  }
2296
1893
  });
2297
1894
  }); };
@@ -2314,16 +1911,16 @@ export var deserializeAws_json1_1ListMedicalTranscriptionJobsCommand = function
2314
1911
  });
2315
1912
  }); };
2316
1913
  var deserializeAws_json1_1ListMedicalTranscriptionJobsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2317
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
2318
- var _f;
2319
- return __generator(this, function (_g) {
2320
- switch (_g.label) {
1914
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1915
+ var _c;
1916
+ return __generator(this, function (_d) {
1917
+ switch (_d.label) {
2321
1918
  case 0:
2322
1919
  _a = [__assign({}, output)];
2323
- _f = {};
1920
+ _c = {};
2324
1921
  return [4, parseBody(output.body, context)];
2325
1922
  case 1:
2326
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
1923
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2327
1924
  errorCode = "UnknownError";
2328
1925
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2329
1926
  _b = errorCode;
@@ -2336,34 +1933,20 @@ var deserializeAws_json1_1ListMedicalTranscriptionJobsCommandError = function (o
2336
1933
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
2337
1934
  }
2338
1935
  return [3, 8];
2339
- case 2:
2340
- _c = [{}];
2341
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2342
- case 3:
2343
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2344
- return [3, 9];
2345
- case 4:
2346
- _d = [{}];
2347
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2348
- case 5:
2349
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2350
- return [3, 9];
2351
- case 6:
2352
- _e = [{}];
2353
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2354
- case 7:
2355
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2356
- return [3, 9];
1936
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1937
+ case 3: throw _d.sent();
1938
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1939
+ case 5: throw _d.sent();
1940
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1941
+ case 7: throw _d.sent();
2357
1942
  case 8:
2358
1943
  parsedBody = parsedOutput.body;
2359
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2360
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2361
- _g.label = 9;
2362
- case 9:
2363
- message = response.message || response.Message || errorCode;
2364
- response.message = message;
2365
- delete response.Message;
2366
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1944
+ response = new __BaseException({
1945
+ name: parsedBody.code || parsedBody.Code || errorCode,
1946
+ $fault: "client",
1947
+ $metadata: deserializeMetadata(output),
1948
+ });
1949
+ throw __decorateServiceException(response, parsedBody);
2367
1950
  }
2368
1951
  });
2369
1952
  }); };
@@ -2386,16 +1969,16 @@ export var deserializeAws_json1_1ListMedicalVocabulariesCommand = function (outp
2386
1969
  });
2387
1970
  }); };
2388
1971
  var deserializeAws_json1_1ListMedicalVocabulariesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2389
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
2390
- var _f;
2391
- return __generator(this, function (_g) {
2392
- switch (_g.label) {
1972
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1973
+ var _c;
1974
+ return __generator(this, function (_d) {
1975
+ switch (_d.label) {
2393
1976
  case 0:
2394
1977
  _a = [__assign({}, output)];
2395
- _f = {};
1978
+ _c = {};
2396
1979
  return [4, parseBody(output.body, context)];
2397
1980
  case 1:
2398
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
1981
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2399
1982
  errorCode = "UnknownError";
2400
1983
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2401
1984
  _b = errorCode;
@@ -2408,34 +1991,20 @@ var deserializeAws_json1_1ListMedicalVocabulariesCommandError = function (output
2408
1991
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
2409
1992
  }
2410
1993
  return [3, 8];
2411
- case 2:
2412
- _c = [{}];
2413
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2414
- case 3:
2415
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2416
- return [3, 9];
2417
- case 4:
2418
- _d = [{}];
2419
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2420
- case 5:
2421
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2422
- return [3, 9];
2423
- case 6:
2424
- _e = [{}];
2425
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2426
- case 7:
2427
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2428
- return [3, 9];
1994
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
1995
+ case 3: throw _d.sent();
1996
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
1997
+ case 5: throw _d.sent();
1998
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1999
+ case 7: throw _d.sent();
2429
2000
  case 8:
2430
2001
  parsedBody = parsedOutput.body;
2431
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2432
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2433
- _g.label = 9;
2434
- case 9:
2435
- message = response.message || response.Message || errorCode;
2436
- response.message = message;
2437
- delete response.Message;
2438
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2002
+ response = new __BaseException({
2003
+ name: parsedBody.code || parsedBody.Code || errorCode,
2004
+ $fault: "client",
2005
+ $metadata: deserializeMetadata(output),
2006
+ });
2007
+ throw __decorateServiceException(response, parsedBody);
2439
2008
  }
2440
2009
  });
2441
2010
  }); };
@@ -2458,16 +2027,16 @@ export var deserializeAws_json1_1ListTagsForResourceCommand = function (output,
2458
2027
  });
2459
2028
  }); };
2460
2029
  var deserializeAws_json1_1ListTagsForResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2461
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
2462
- var _g;
2463
- return __generator(this, function (_h) {
2464
- switch (_h.label) {
2030
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2031
+ var _c;
2032
+ return __generator(this, function (_d) {
2033
+ switch (_d.label) {
2465
2034
  case 0:
2466
2035
  _a = [__assign({}, output)];
2467
- _g = {};
2036
+ _c = {};
2468
2037
  return [4, parseBody(output.body, context)];
2469
2038
  case 1:
2470
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
2039
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2471
2040
  errorCode = "UnknownError";
2472
2041
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2473
2042
  _b = errorCode;
@@ -2482,40 +2051,22 @@ var deserializeAws_json1_1ListTagsForResourceCommandError = function (output, co
2482
2051
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
2483
2052
  }
2484
2053
  return [3, 10];
2485
- case 2:
2486
- _c = [{}];
2487
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2488
- case 3:
2489
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2490
- return [3, 11];
2491
- case 4:
2492
- _d = [{}];
2493
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2494
- case 5:
2495
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2496
- return [3, 11];
2497
- case 6:
2498
- _e = [{}];
2499
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2500
- case 7:
2501
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2502
- return [3, 11];
2503
- case 8:
2504
- _f = [{}];
2505
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
2506
- case 9:
2507
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2508
- return [3, 11];
2054
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2055
+ case 3: throw _d.sent();
2056
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2057
+ case 5: throw _d.sent();
2058
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2059
+ case 7: throw _d.sent();
2060
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
2061
+ case 9: throw _d.sent();
2509
2062
  case 10:
2510
2063
  parsedBody = parsedOutput.body;
2511
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2512
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2513
- _h.label = 11;
2514
- case 11:
2515
- message = response.message || response.Message || errorCode;
2516
- response.message = message;
2517
- delete response.Message;
2518
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2064
+ response = new __BaseException({
2065
+ name: parsedBody.code || parsedBody.Code || errorCode,
2066
+ $fault: "client",
2067
+ $metadata: deserializeMetadata(output),
2068
+ });
2069
+ throw __decorateServiceException(response, parsedBody);
2519
2070
  }
2520
2071
  });
2521
2072
  }); };
@@ -2538,16 +2089,16 @@ export var deserializeAws_json1_1ListTranscriptionJobsCommand = function (output
2538
2089
  });
2539
2090
  }); };
2540
2091
  var deserializeAws_json1_1ListTranscriptionJobsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2541
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
2542
- var _f;
2543
- return __generator(this, function (_g) {
2544
- switch (_g.label) {
2092
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2093
+ var _c;
2094
+ return __generator(this, function (_d) {
2095
+ switch (_d.label) {
2545
2096
  case 0:
2546
2097
  _a = [__assign({}, output)];
2547
- _f = {};
2098
+ _c = {};
2548
2099
  return [4, parseBody(output.body, context)];
2549
2100
  case 1:
2550
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
2101
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2551
2102
  errorCode = "UnknownError";
2552
2103
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2553
2104
  _b = errorCode;
@@ -2560,34 +2111,20 @@ var deserializeAws_json1_1ListTranscriptionJobsCommandError = function (output,
2560
2111
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
2561
2112
  }
2562
2113
  return [3, 8];
2563
- case 2:
2564
- _c = [{}];
2565
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2566
- case 3:
2567
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2568
- return [3, 9];
2569
- case 4:
2570
- _d = [{}];
2571
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2572
- case 5:
2573
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2574
- return [3, 9];
2575
- case 6:
2576
- _e = [{}];
2577
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2578
- case 7:
2579
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2580
- return [3, 9];
2114
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2115
+ case 3: throw _d.sent();
2116
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2117
+ case 5: throw _d.sent();
2118
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2119
+ case 7: throw _d.sent();
2581
2120
  case 8:
2582
2121
  parsedBody = parsedOutput.body;
2583
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2584
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2585
- _g.label = 9;
2586
- case 9:
2587
- message = response.message || response.Message || errorCode;
2588
- response.message = message;
2589
- delete response.Message;
2590
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2122
+ response = new __BaseException({
2123
+ name: parsedBody.code || parsedBody.Code || errorCode,
2124
+ $fault: "client",
2125
+ $metadata: deserializeMetadata(output),
2126
+ });
2127
+ throw __decorateServiceException(response, parsedBody);
2591
2128
  }
2592
2129
  });
2593
2130
  }); };
@@ -2610,16 +2147,16 @@ export var deserializeAws_json1_1ListVocabulariesCommand = function (output, con
2610
2147
  });
2611
2148
  }); };
2612
2149
  var deserializeAws_json1_1ListVocabulariesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2613
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
2614
- var _f;
2615
- return __generator(this, function (_g) {
2616
- switch (_g.label) {
2150
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2151
+ var _c;
2152
+ return __generator(this, function (_d) {
2153
+ switch (_d.label) {
2617
2154
  case 0:
2618
2155
  _a = [__assign({}, output)];
2619
- _f = {};
2156
+ _c = {};
2620
2157
  return [4, parseBody(output.body, context)];
2621
2158
  case 1:
2622
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
2159
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2623
2160
  errorCode = "UnknownError";
2624
2161
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2625
2162
  _b = errorCode;
@@ -2632,34 +2169,20 @@ var deserializeAws_json1_1ListVocabulariesCommandError = function (output, conte
2632
2169
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
2633
2170
  }
2634
2171
  return [3, 8];
2635
- case 2:
2636
- _c = [{}];
2637
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2638
- case 3:
2639
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2640
- return [3, 9];
2641
- case 4:
2642
- _d = [{}];
2643
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2644
- case 5:
2645
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2646
- return [3, 9];
2647
- case 6:
2648
- _e = [{}];
2649
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2650
- case 7:
2651
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2652
- return [3, 9];
2172
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2173
+ case 3: throw _d.sent();
2174
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2175
+ case 5: throw _d.sent();
2176
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2177
+ case 7: throw _d.sent();
2653
2178
  case 8:
2654
2179
  parsedBody = parsedOutput.body;
2655
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2656
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2657
- _g.label = 9;
2658
- case 9:
2659
- message = response.message || response.Message || errorCode;
2660
- response.message = message;
2661
- delete response.Message;
2662
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2180
+ response = new __BaseException({
2181
+ name: parsedBody.code || parsedBody.Code || errorCode,
2182
+ $fault: "client",
2183
+ $metadata: deserializeMetadata(output),
2184
+ });
2185
+ throw __decorateServiceException(response, parsedBody);
2663
2186
  }
2664
2187
  });
2665
2188
  }); };
@@ -2682,16 +2205,16 @@ export var deserializeAws_json1_1ListVocabularyFiltersCommand = function (output
2682
2205
  });
2683
2206
  }); };
2684
2207
  var deserializeAws_json1_1ListVocabularyFiltersCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2685
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
2686
- var _f;
2687
- return __generator(this, function (_g) {
2688
- switch (_g.label) {
2208
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2209
+ var _c;
2210
+ return __generator(this, function (_d) {
2211
+ switch (_d.label) {
2689
2212
  case 0:
2690
2213
  _a = [__assign({}, output)];
2691
- _f = {};
2214
+ _c = {};
2692
2215
  return [4, parseBody(output.body, context)];
2693
2216
  case 1:
2694
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
2217
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2695
2218
  errorCode = "UnknownError";
2696
2219
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2697
2220
  _b = errorCode;
@@ -2704,34 +2227,20 @@ var deserializeAws_json1_1ListVocabularyFiltersCommandError = function (output,
2704
2227
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 6];
2705
2228
  }
2706
2229
  return [3, 8];
2707
- case 2:
2708
- _c = [{}];
2709
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2710
- case 3:
2711
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2712
- return [3, 9];
2713
- case 4:
2714
- _d = [{}];
2715
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2716
- case 5:
2717
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2718
- return [3, 9];
2719
- case 6:
2720
- _e = [{}];
2721
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2722
- case 7:
2723
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2724
- return [3, 9];
2230
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2231
+ case 3: throw _d.sent();
2232
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2233
+ case 5: throw _d.sent();
2234
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2235
+ case 7: throw _d.sent();
2725
2236
  case 8:
2726
2237
  parsedBody = parsedOutput.body;
2727
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2728
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2729
- _g.label = 9;
2730
- case 9:
2731
- message = response.message || response.Message || errorCode;
2732
- response.message = message;
2733
- delete response.Message;
2734
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2238
+ response = new __BaseException({
2239
+ name: parsedBody.code || parsedBody.Code || errorCode,
2240
+ $fault: "client",
2241
+ $metadata: deserializeMetadata(output),
2242
+ });
2243
+ throw __decorateServiceException(response, parsedBody);
2735
2244
  }
2736
2245
  });
2737
2246
  }); };
@@ -2754,16 +2263,16 @@ export var deserializeAws_json1_1StartCallAnalyticsJobCommand = function (output
2754
2263
  });
2755
2264
  }); };
2756
2265
  var deserializeAws_json1_1StartCallAnalyticsJobCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2757
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
2758
- var _g;
2759
- return __generator(this, function (_h) {
2760
- switch (_h.label) {
2266
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2267
+ var _c;
2268
+ return __generator(this, function (_d) {
2269
+ switch (_d.label) {
2761
2270
  case 0:
2762
2271
  _a = [__assign({}, output)];
2763
- _g = {};
2272
+ _c = {};
2764
2273
  return [4, parseBody(output.body, context)];
2765
2274
  case 1:
2766
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
2275
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2767
2276
  errorCode = "UnknownError";
2768
2277
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2769
2278
  _b = errorCode;
@@ -2778,40 +2287,22 @@ var deserializeAws_json1_1StartCallAnalyticsJobCommandError = function (output,
2778
2287
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 8];
2779
2288
  }
2780
2289
  return [3, 10];
2781
- case 2:
2782
- _c = [{}];
2783
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2784
- case 3:
2785
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2786
- return [3, 11];
2787
- case 4:
2788
- _d = [{}];
2789
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2790
- case 5:
2791
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2792
- return [3, 11];
2793
- case 6:
2794
- _e = [{}];
2795
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2796
- case 7:
2797
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2798
- return [3, 11];
2799
- case 8:
2800
- _f = [{}];
2801
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2802
- case 9:
2803
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2804
- return [3, 11];
2290
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2291
+ case 3: throw _d.sent();
2292
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2293
+ case 5: throw _d.sent();
2294
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2295
+ case 7: throw _d.sent();
2296
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2297
+ case 9: throw _d.sent();
2805
2298
  case 10:
2806
2299
  parsedBody = parsedOutput.body;
2807
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2808
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2809
- _h.label = 11;
2810
- case 11:
2811
- message = response.message || response.Message || errorCode;
2812
- response.message = message;
2813
- delete response.Message;
2814
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2300
+ response = new __BaseException({
2301
+ name: parsedBody.code || parsedBody.Code || errorCode,
2302
+ $fault: "client",
2303
+ $metadata: deserializeMetadata(output),
2304
+ });
2305
+ throw __decorateServiceException(response, parsedBody);
2815
2306
  }
2816
2307
  });
2817
2308
  }); };
@@ -2834,16 +2325,16 @@ export var deserializeAws_json1_1StartMedicalTranscriptionJobCommand = function
2834
2325
  });
2835
2326
  }); };
2836
2327
  var deserializeAws_json1_1StartMedicalTranscriptionJobCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2837
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
2838
- var _g;
2839
- return __generator(this, function (_h) {
2840
- switch (_h.label) {
2328
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2329
+ var _c;
2330
+ return __generator(this, function (_d) {
2331
+ switch (_d.label) {
2841
2332
  case 0:
2842
2333
  _a = [__assign({}, output)];
2843
- _g = {};
2334
+ _c = {};
2844
2335
  return [4, parseBody(output.body, context)];
2845
2336
  case 1:
2846
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
2337
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2847
2338
  errorCode = "UnknownError";
2848
2339
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2849
2340
  _b = errorCode;
@@ -2858,40 +2349,22 @@ var deserializeAws_json1_1StartMedicalTranscriptionJobCommandError = function (o
2858
2349
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 8];
2859
2350
  }
2860
2351
  return [3, 10];
2861
- case 2:
2862
- _c = [{}];
2863
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2864
- case 3:
2865
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2866
- return [3, 11];
2867
- case 4:
2868
- _d = [{}];
2869
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2870
- case 5:
2871
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2872
- return [3, 11];
2873
- case 6:
2874
- _e = [{}];
2875
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2876
- case 7:
2877
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2878
- return [3, 11];
2879
- case 8:
2880
- _f = [{}];
2881
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2882
- case 9:
2883
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2884
- return [3, 11];
2352
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2353
+ case 3: throw _d.sent();
2354
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2355
+ case 5: throw _d.sent();
2356
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2357
+ case 7: throw _d.sent();
2358
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2359
+ case 9: throw _d.sent();
2885
2360
  case 10:
2886
2361
  parsedBody = parsedOutput.body;
2887
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2888
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2889
- _h.label = 11;
2890
- case 11:
2891
- message = response.message || response.Message || errorCode;
2892
- response.message = message;
2893
- delete response.Message;
2894
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2362
+ response = new __BaseException({
2363
+ name: parsedBody.code || parsedBody.Code || errorCode,
2364
+ $fault: "client",
2365
+ $metadata: deserializeMetadata(output),
2366
+ });
2367
+ throw __decorateServiceException(response, parsedBody);
2895
2368
  }
2896
2369
  });
2897
2370
  }); };
@@ -2914,16 +2387,16 @@ export var deserializeAws_json1_1StartTranscriptionJobCommand = function (output
2914
2387
  });
2915
2388
  }); };
2916
2389
  var deserializeAws_json1_1StartTranscriptionJobCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2917
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
2918
- var _g;
2919
- return __generator(this, function (_h) {
2920
- switch (_h.label) {
2390
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2391
+ var _c;
2392
+ return __generator(this, function (_d) {
2393
+ switch (_d.label) {
2921
2394
  case 0:
2922
2395
  _a = [__assign({}, output)];
2923
- _g = {};
2396
+ _c = {};
2924
2397
  return [4, parseBody(output.body, context)];
2925
2398
  case 1:
2926
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
2399
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2927
2400
  errorCode = "UnknownError";
2928
2401
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2929
2402
  _b = errorCode;
@@ -2938,40 +2411,22 @@ var deserializeAws_json1_1StartTranscriptionJobCommandError = function (output,
2938
2411
  case "com.amazonaws.transcribe#LimitExceededException": return [3, 8];
2939
2412
  }
2940
2413
  return [3, 10];
2941
- case 2:
2942
- _c = [{}];
2943
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2944
- case 3:
2945
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2946
- return [3, 11];
2947
- case 4:
2948
- _d = [{}];
2949
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2950
- case 5:
2951
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2952
- return [3, 11];
2953
- case 6:
2954
- _e = [{}];
2955
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2956
- case 7:
2957
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2958
- return [3, 11];
2959
- case 8:
2960
- _f = [{}];
2961
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2962
- case 9:
2963
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2964
- return [3, 11];
2414
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2415
+ case 3: throw _d.sent();
2416
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2417
+ case 5: throw _d.sent();
2418
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2419
+ case 7: throw _d.sent();
2420
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2421
+ case 9: throw _d.sent();
2965
2422
  case 10:
2966
2423
  parsedBody = parsedOutput.body;
2967
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2968
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2969
- _h.label = 11;
2970
- case 11:
2971
- message = response.message || response.Message || errorCode;
2972
- response.message = message;
2973
- delete response.Message;
2974
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2424
+ response = new __BaseException({
2425
+ name: parsedBody.code || parsedBody.Code || errorCode,
2426
+ $fault: "client",
2427
+ $metadata: deserializeMetadata(output),
2428
+ });
2429
+ throw __decorateServiceException(response, parsedBody);
2975
2430
  }
2976
2431
  });
2977
2432
  }); };
@@ -2994,16 +2449,16 @@ export var deserializeAws_json1_1TagResourceCommand = function (output, context)
2994
2449
  });
2995
2450
  }); };
2996
2451
  var deserializeAws_json1_1TagResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2997
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, parsedBody, message;
2998
- var _h;
2999
- return __generator(this, function (_j) {
3000
- switch (_j.label) {
2452
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2453
+ var _c;
2454
+ return __generator(this, function (_d) {
2455
+ switch (_d.label) {
3001
2456
  case 0:
3002
2457
  _a = [__assign({}, output)];
3003
- _h = {};
2458
+ _c = {};
3004
2459
  return [4, parseBody(output.body, context)];
3005
2460
  case 1:
3006
- parsedOutput = __assign.apply(void 0, _a.concat([(_h.body = _j.sent(), _h)]));
2461
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3007
2462
  errorCode = "UnknownError";
3008
2463
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3009
2464
  _b = errorCode;
@@ -3020,46 +2475,24 @@ var deserializeAws_json1_1TagResourceCommandError = function (output, context) {
3020
2475
  case "com.amazonaws.transcribe#NotFoundException": return [3, 10];
3021
2476
  }
3022
2477
  return [3, 12];
3023
- case 2:
3024
- _c = [{}];
3025
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
3026
- case 3:
3027
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3028
- return [3, 13];
3029
- case 4:
3030
- _d = [{}];
3031
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
3032
- case 5:
3033
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3034
- return [3, 13];
3035
- case 6:
3036
- _e = [{}];
3037
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
3038
- case 7:
3039
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3040
- return [3, 13];
3041
- case 8:
3042
- _f = [{}];
3043
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
3044
- case 9:
3045
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3046
- return [3, 13];
3047
- case 10:
3048
- _g = [{}];
3049
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
3050
- case 11:
3051
- response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3052
- return [3, 13];
2478
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2479
+ case 3: throw _d.sent();
2480
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2481
+ case 5: throw _d.sent();
2482
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2483
+ case 7: throw _d.sent();
2484
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2485
+ case 9: throw _d.sent();
2486
+ case 10: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
2487
+ case 11: throw _d.sent();
3053
2488
  case 12:
3054
2489
  parsedBody = parsedOutput.body;
3055
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3056
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3057
- _j.label = 13;
3058
- case 13:
3059
- message = response.message || response.Message || errorCode;
3060
- response.message = message;
3061
- delete response.Message;
3062
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2490
+ response = new __BaseException({
2491
+ name: parsedBody.code || parsedBody.Code || errorCode,
2492
+ $fault: "client",
2493
+ $metadata: deserializeMetadata(output),
2494
+ });
2495
+ throw __decorateServiceException(response, parsedBody);
3063
2496
  }
3064
2497
  });
3065
2498
  }); };
@@ -3082,16 +2515,16 @@ export var deserializeAws_json1_1UntagResourceCommand = function (output, contex
3082
2515
  });
3083
2516
  }); };
3084
2517
  var deserializeAws_json1_1UntagResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3085
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, parsedBody, message;
3086
- var _h;
3087
- return __generator(this, function (_j) {
3088
- switch (_j.label) {
2518
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2519
+ var _c;
2520
+ return __generator(this, function (_d) {
2521
+ switch (_d.label) {
3089
2522
  case 0:
3090
2523
  _a = [__assign({}, output)];
3091
- _h = {};
2524
+ _c = {};
3092
2525
  return [4, parseBody(output.body, context)];
3093
2526
  case 1:
3094
- parsedOutput = __assign.apply(void 0, _a.concat([(_h.body = _j.sent(), _h)]));
2527
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3095
2528
  errorCode = "UnknownError";
3096
2529
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3097
2530
  _b = errorCode;
@@ -3108,46 +2541,24 @@ var deserializeAws_json1_1UntagResourceCommandError = function (output, context)
3108
2541
  case "com.amazonaws.transcribe#NotFoundException": return [3, 10];
3109
2542
  }
3110
2543
  return [3, 12];
3111
- case 2:
3112
- _c = [{}];
3113
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
3114
- case 3:
3115
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3116
- return [3, 13];
3117
- case 4:
3118
- _d = [{}];
3119
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
3120
- case 5:
3121
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3122
- return [3, 13];
3123
- case 6:
3124
- _e = [{}];
3125
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
3126
- case 7:
3127
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3128
- return [3, 13];
3129
- case 8:
3130
- _f = [{}];
3131
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
3132
- case 9:
3133
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3134
- return [3, 13];
3135
- case 10:
3136
- _g = [{}];
3137
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
3138
- case 11:
3139
- response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3140
- return [3, 13];
2544
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2545
+ case 3: throw _d.sent();
2546
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2547
+ case 5: throw _d.sent();
2548
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2549
+ case 7: throw _d.sent();
2550
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2551
+ case 9: throw _d.sent();
2552
+ case 10: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
2553
+ case 11: throw _d.sent();
3141
2554
  case 12:
3142
2555
  parsedBody = parsedOutput.body;
3143
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3144
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3145
- _j.label = 13;
3146
- case 13:
3147
- message = response.message || response.Message || errorCode;
3148
- response.message = message;
3149
- delete response.Message;
3150
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2556
+ response = new __BaseException({
2557
+ name: parsedBody.code || parsedBody.Code || errorCode,
2558
+ $fault: "client",
2559
+ $metadata: deserializeMetadata(output),
2560
+ });
2561
+ throw __decorateServiceException(response, parsedBody);
3151
2562
  }
3152
2563
  });
3153
2564
  }); };
@@ -3170,16 +2581,16 @@ export var deserializeAws_json1_1UpdateCallAnalyticsCategoryCommand = function (
3170
2581
  });
3171
2582
  }); };
3172
2583
  var deserializeAws_json1_1UpdateCallAnalyticsCategoryCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3173
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, parsedBody, message;
3174
- var _h;
3175
- return __generator(this, function (_j) {
3176
- switch (_j.label) {
2584
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2585
+ var _c;
2586
+ return __generator(this, function (_d) {
2587
+ switch (_d.label) {
3177
2588
  case 0:
3178
2589
  _a = [__assign({}, output)];
3179
- _h = {};
2590
+ _c = {};
3180
2591
  return [4, parseBody(output.body, context)];
3181
2592
  case 1:
3182
- parsedOutput = __assign.apply(void 0, _a.concat([(_h.body = _j.sent(), _h)]));
2593
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3183
2594
  errorCode = "UnknownError";
3184
2595
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3185
2596
  _b = errorCode;
@@ -3196,46 +2607,24 @@ var deserializeAws_json1_1UpdateCallAnalyticsCategoryCommandError = function (ou
3196
2607
  case "com.amazonaws.transcribe#NotFoundException": return [3, 10];
3197
2608
  }
3198
2609
  return [3, 12];
3199
- case 2:
3200
- _c = [{}];
3201
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
3202
- case 3:
3203
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3204
- return [3, 13];
3205
- case 4:
3206
- _d = [{}];
3207
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
3208
- case 5:
3209
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3210
- return [3, 13];
3211
- case 6:
3212
- _e = [{}];
3213
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
3214
- case 7:
3215
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3216
- return [3, 13];
3217
- case 8:
3218
- _f = [{}];
3219
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
3220
- case 9:
3221
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3222
- return [3, 13];
3223
- case 10:
3224
- _g = [{}];
3225
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
3226
- case 11:
3227
- response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3228
- return [3, 13];
2610
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2611
+ case 3: throw _d.sent();
2612
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2613
+ case 5: throw _d.sent();
2614
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2615
+ case 7: throw _d.sent();
2616
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2617
+ case 9: throw _d.sent();
2618
+ case 10: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
2619
+ case 11: throw _d.sent();
3229
2620
  case 12:
3230
2621
  parsedBody = parsedOutput.body;
3231
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3232
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3233
- _j.label = 13;
3234
- case 13:
3235
- message = response.message || response.Message || errorCode;
3236
- response.message = message;
3237
- delete response.Message;
3238
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2622
+ response = new __BaseException({
2623
+ name: parsedBody.code || parsedBody.Code || errorCode,
2624
+ $fault: "client",
2625
+ $metadata: deserializeMetadata(output),
2626
+ });
2627
+ throw __decorateServiceException(response, parsedBody);
3239
2628
  }
3240
2629
  });
3241
2630
  }); };
@@ -3258,16 +2647,16 @@ export var deserializeAws_json1_1UpdateMedicalVocabularyCommand = function (outp
3258
2647
  });
3259
2648
  }); };
3260
2649
  var deserializeAws_json1_1UpdateMedicalVocabularyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3261
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, parsedBody, message;
3262
- var _h;
3263
- return __generator(this, function (_j) {
3264
- switch (_j.label) {
2650
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2651
+ var _c;
2652
+ return __generator(this, function (_d) {
2653
+ switch (_d.label) {
3265
2654
  case 0:
3266
2655
  _a = [__assign({}, output)];
3267
- _h = {};
2656
+ _c = {};
3268
2657
  return [4, parseBody(output.body, context)];
3269
2658
  case 1:
3270
- parsedOutput = __assign.apply(void 0, _a.concat([(_h.body = _j.sent(), _h)]));
2659
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3271
2660
  errorCode = "UnknownError";
3272
2661
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3273
2662
  _b = errorCode;
@@ -3284,46 +2673,24 @@ var deserializeAws_json1_1UpdateMedicalVocabularyCommandError = function (output
3284
2673
  case "com.amazonaws.transcribe#NotFoundException": return [3, 10];
3285
2674
  }
3286
2675
  return [3, 12];
3287
- case 2:
3288
- _c = [{}];
3289
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
3290
- case 3:
3291
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3292
- return [3, 13];
3293
- case 4:
3294
- _d = [{}];
3295
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
3296
- case 5:
3297
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3298
- return [3, 13];
3299
- case 6:
3300
- _e = [{}];
3301
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
3302
- case 7:
3303
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3304
- return [3, 13];
3305
- case 8:
3306
- _f = [{}];
3307
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
3308
- case 9:
3309
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3310
- return [3, 13];
3311
- case 10:
3312
- _g = [{}];
3313
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
3314
- case 11:
3315
- response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3316
- return [3, 13];
2676
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2677
+ case 3: throw _d.sent();
2678
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2679
+ case 5: throw _d.sent();
2680
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2681
+ case 7: throw _d.sent();
2682
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2683
+ case 9: throw _d.sent();
2684
+ case 10: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
2685
+ case 11: throw _d.sent();
3317
2686
  case 12:
3318
2687
  parsedBody = parsedOutput.body;
3319
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3320
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3321
- _j.label = 13;
3322
- case 13:
3323
- message = response.message || response.Message || errorCode;
3324
- response.message = message;
3325
- delete response.Message;
3326
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2688
+ response = new __BaseException({
2689
+ name: parsedBody.code || parsedBody.Code || errorCode,
2690
+ $fault: "client",
2691
+ $metadata: deserializeMetadata(output),
2692
+ });
2693
+ throw __decorateServiceException(response, parsedBody);
3327
2694
  }
3328
2695
  });
3329
2696
  }); };
@@ -3346,16 +2713,16 @@ export var deserializeAws_json1_1UpdateVocabularyCommand = function (output, con
3346
2713
  });
3347
2714
  }); };
3348
2715
  var deserializeAws_json1_1UpdateVocabularyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3349
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, parsedBody, message;
3350
- var _h;
3351
- return __generator(this, function (_j) {
3352
- switch (_j.label) {
2716
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2717
+ var _c;
2718
+ return __generator(this, function (_d) {
2719
+ switch (_d.label) {
3353
2720
  case 0:
3354
2721
  _a = [__assign({}, output)];
3355
- _h = {};
2722
+ _c = {};
3356
2723
  return [4, parseBody(output.body, context)];
3357
2724
  case 1:
3358
- parsedOutput = __assign.apply(void 0, _a.concat([(_h.body = _j.sent(), _h)]));
2725
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3359
2726
  errorCode = "UnknownError";
3360
2727
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3361
2728
  _b = errorCode;
@@ -3372,46 +2739,24 @@ var deserializeAws_json1_1UpdateVocabularyCommandError = function (output, conte
3372
2739
  case "com.amazonaws.transcribe#NotFoundException": return [3, 10];
3373
2740
  }
3374
2741
  return [3, 12];
3375
- case 2:
3376
- _c = [{}];
3377
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
3378
- case 3:
3379
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3380
- return [3, 13];
3381
- case 4:
3382
- _d = [{}];
3383
- return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
3384
- case 5:
3385
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3386
- return [3, 13];
3387
- case 6:
3388
- _e = [{}];
3389
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
3390
- case 7:
3391
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3392
- return [3, 13];
3393
- case 8:
3394
- _f = [{}];
3395
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
3396
- case 9:
3397
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3398
- return [3, 13];
3399
- case 10:
3400
- _g = [{}];
3401
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
3402
- case 11:
3403
- response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3404
- return [3, 13];
2742
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2743
+ case 3: throw _d.sent();
2744
+ case 4: return [4, deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context)];
2745
+ case 5: throw _d.sent();
2746
+ case 6: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2747
+ case 7: throw _d.sent();
2748
+ case 8: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2749
+ case 9: throw _d.sent();
2750
+ case 10: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
2751
+ case 11: throw _d.sent();
3405
2752
  case 12:
3406
2753
  parsedBody = parsedOutput.body;
3407
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3408
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3409
- _j.label = 13;
3410
- case 13:
3411
- message = response.message || response.Message || errorCode;
3412
- response.message = message;
3413
- delete response.Message;
3414
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2754
+ response = new __BaseException({
2755
+ name: parsedBody.code || parsedBody.Code || errorCode,
2756
+ $fault: "client",
2757
+ $metadata: deserializeMetadata(output),
2758
+ });
2759
+ throw __decorateServiceException(response, parsedBody);
3415
2760
  }
3416
2761
  });
3417
2762
  }); };
@@ -3434,16 +2779,16 @@ export var deserializeAws_json1_1UpdateVocabularyFilterCommand = function (outpu
3434
2779
  });
3435
2780
  }); };
3436
2781
  var deserializeAws_json1_1UpdateVocabularyFilterCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3437
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
3438
- var _g;
3439
- return __generator(this, function (_h) {
3440
- switch (_h.label) {
2782
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2783
+ var _c;
2784
+ return __generator(this, function (_d) {
2785
+ switch (_d.label) {
3441
2786
  case 0:
3442
2787
  _a = [__assign({}, output)];
3443
- _g = {};
2788
+ _c = {};
3444
2789
  return [4, parseBody(output.body, context)];
3445
2790
  case 1:
3446
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
2791
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3447
2792
  errorCode = "UnknownError";
3448
2793
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3449
2794
  _b = errorCode;
@@ -3458,86 +2803,68 @@ var deserializeAws_json1_1UpdateVocabularyFilterCommandError = function (output,
3458
2803
  case "com.amazonaws.transcribe#NotFoundException": return [3, 8];
3459
2804
  }
3460
2805
  return [3, 10];
3461
- case 2:
3462
- _c = [{}];
3463
- return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
3464
- case 3:
3465
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3466
- return [3, 11];
3467
- case 4:
3468
- _d = [{}];
3469
- return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
3470
- case 5:
3471
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3472
- return [3, 11];
3473
- case 6:
3474
- _e = [{}];
3475
- return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
3476
- case 7:
3477
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3478
- return [3, 11];
3479
- case 8:
3480
- _f = [{}];
3481
- return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
3482
- case 9:
3483
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3484
- return [3, 11];
2806
+ case 2: return [4, deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context)];
2807
+ case 3: throw _d.sent();
2808
+ case 4: return [4, deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context)];
2809
+ case 5: throw _d.sent();
2810
+ case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
2811
+ case 7: throw _d.sent();
2812
+ case 8: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
2813
+ case 9: throw _d.sent();
3485
2814
  case 10:
3486
2815
  parsedBody = parsedOutput.body;
3487
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3488
- response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3489
- _h.label = 11;
3490
- case 11:
3491
- message = response.message || response.Message || errorCode;
3492
- response.message = message;
3493
- delete response.Message;
3494
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2816
+ response = new __BaseException({
2817
+ name: parsedBody.code || parsedBody.Code || errorCode,
2818
+ $fault: "client",
2819
+ $metadata: deserializeMetadata(output),
2820
+ });
2821
+ throw __decorateServiceException(response, parsedBody);
3495
2822
  }
3496
2823
  });
3497
2824
  }); };
3498
2825
  var deserializeAws_json1_1BadRequestExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
3499
- var body, deserialized, contents;
2826
+ var body, deserialized, exception;
3500
2827
  return __generator(this, function (_a) {
3501
2828
  body = parsedOutput.body;
3502
2829
  deserialized = deserializeAws_json1_1BadRequestException(body, context);
3503
- contents = __assign({ name: "BadRequestException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
3504
- return [2, contents];
2830
+ exception = new BadRequestException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
2831
+ return [2, __decorateServiceException(exception, body)];
3505
2832
  });
3506
2833
  }); };
3507
2834
  var deserializeAws_json1_1ConflictExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
3508
- var body, deserialized, contents;
2835
+ var body, deserialized, exception;
3509
2836
  return __generator(this, function (_a) {
3510
2837
  body = parsedOutput.body;
3511
2838
  deserialized = deserializeAws_json1_1ConflictException(body, context);
3512
- contents = __assign({ name: "ConflictException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
3513
- return [2, contents];
2839
+ exception = new ConflictException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
2840
+ return [2, __decorateServiceException(exception, body)];
3514
2841
  });
3515
2842
  }); };
3516
2843
  var deserializeAws_json1_1InternalFailureExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
3517
- var body, deserialized, contents;
2844
+ var body, deserialized, exception;
3518
2845
  return __generator(this, function (_a) {
3519
2846
  body = parsedOutput.body;
3520
2847
  deserialized = deserializeAws_json1_1InternalFailureException(body, context);
3521
- contents = __assign({ name: "InternalFailureException", $fault: "server", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
3522
- return [2, contents];
2848
+ exception = new InternalFailureException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
2849
+ return [2, __decorateServiceException(exception, body)];
3523
2850
  });
3524
2851
  }); };
3525
2852
  var deserializeAws_json1_1LimitExceededExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
3526
- var body, deserialized, contents;
2853
+ var body, deserialized, exception;
3527
2854
  return __generator(this, function (_a) {
3528
2855
  body = parsedOutput.body;
3529
2856
  deserialized = deserializeAws_json1_1LimitExceededException(body, context);
3530
- contents = __assign({ name: "LimitExceededException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
3531
- return [2, contents];
2857
+ exception = new LimitExceededException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
2858
+ return [2, __decorateServiceException(exception, body)];
3532
2859
  });
3533
2860
  }); };
3534
2861
  var deserializeAws_json1_1NotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
3535
- var body, deserialized, contents;
2862
+ var body, deserialized, exception;
3536
2863
  return __generator(this, function (_a) {
3537
2864
  body = parsedOutput.body;
3538
2865
  deserialized = deserializeAws_json1_1NotFoundException(body, context);
3539
- contents = __assign({ name: "NotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
3540
- return [2, contents];
2866
+ exception = new NotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
2867
+ return [2, __decorateServiceException(exception, body)];
3541
2868
  });
3542
2869
  }); };
3543
2870
  var serializeAws_json1_1AbsoluteTimeRange = function (input, context) {
@@ -4071,7 +3398,7 @@ var deserializeAws_json1_1CallAnalyticsJobSettings = function (output, context)
4071
3398
  };
4072
3399
  };
4073
3400
  var deserializeAws_json1_1CallAnalyticsJobSummaries = function (output, context) {
4074
- return (output || [])
3401
+ var retVal = (output || [])
4075
3402
  .filter(function (e) { return e != null; })
4076
3403
  .map(function (entry) {
4077
3404
  if (entry === null) {
@@ -4079,6 +3406,7 @@ var deserializeAws_json1_1CallAnalyticsJobSummaries = function (output, context)
4079
3406
  }
4080
3407
  return deserializeAws_json1_1CallAnalyticsJobSummary(entry, context);
4081
3408
  });
3409
+ return retVal;
4082
3410
  };
4083
3411
  var deserializeAws_json1_1CallAnalyticsJobSummary = function (output, context) {
4084
3412
  return {
@@ -4112,7 +3440,7 @@ var deserializeAws_json1_1CategoryProperties = function (output, context) {
4112
3440
  };
4113
3441
  };
4114
3442
  var deserializeAws_json1_1CategoryPropertiesList = function (output, context) {
4115
- return (output || [])
3443
+ var retVal = (output || [])
4116
3444
  .filter(function (e) { return e != null; })
4117
3445
  .map(function (entry) {
4118
3446
  if (entry === null) {
@@ -4120,6 +3448,7 @@ var deserializeAws_json1_1CategoryPropertiesList = function (output, context) {
4120
3448
  }
4121
3449
  return deserializeAws_json1_1CategoryProperties(entry, context);
4122
3450
  });
3451
+ return retVal;
4123
3452
  };
4124
3453
  var deserializeAws_json1_1ChannelDefinition = function (output, context) {
4125
3454
  return {
@@ -4128,7 +3457,7 @@ var deserializeAws_json1_1ChannelDefinition = function (output, context) {
4128
3457
  };
4129
3458
  };
4130
3459
  var deserializeAws_json1_1ChannelDefinitions = function (output, context) {
4131
- return (output || [])
3460
+ var retVal = (output || [])
4132
3461
  .filter(function (e) { return e != null; })
4133
3462
  .map(function (entry) {
4134
3463
  if (entry === null) {
@@ -4136,6 +3465,7 @@ var deserializeAws_json1_1ChannelDefinitions = function (output, context) {
4136
3465
  }
4137
3466
  return deserializeAws_json1_1ChannelDefinition(entry, context);
4138
3467
  });
3468
+ return retVal;
4139
3469
  };
4140
3470
  var deserializeAws_json1_1ConflictException = function (output, context) {
4141
3471
  return {
@@ -4343,7 +3673,7 @@ var deserializeAws_json1_1LanguageModel = function (output, context) {
4343
3673
  };
4344
3674
  };
4345
3675
  var deserializeAws_json1_1LanguageOptions = function (output, context) {
4346
- return (output || [])
3676
+ var retVal = (output || [])
4347
3677
  .filter(function (e) { return e != null; })
4348
3678
  .map(function (entry) {
4349
3679
  if (entry === null) {
@@ -4351,6 +3681,7 @@ var deserializeAws_json1_1LanguageOptions = function (output, context) {
4351
3681
  }
4352
3682
  return __expectString(entry);
4353
3683
  });
3684
+ return retVal;
4354
3685
  };
4355
3686
  var deserializeAws_json1_1LimitExceededException = function (output, context) {
4356
3687
  return {
@@ -4480,7 +3811,7 @@ var deserializeAws_json1_1MedicalTranscriptionJob = function (output, context) {
4480
3811
  };
4481
3812
  };
4482
3813
  var deserializeAws_json1_1MedicalTranscriptionJobSummaries = function (output, context) {
4483
- return (output || [])
3814
+ var retVal = (output || [])
4484
3815
  .filter(function (e) { return e != null; })
4485
3816
  .map(function (entry) {
4486
3817
  if (entry === null) {
@@ -4488,6 +3819,7 @@ var deserializeAws_json1_1MedicalTranscriptionJobSummaries = function (output, c
4488
3819
  }
4489
3820
  return deserializeAws_json1_1MedicalTranscriptionJobSummary(entry, context);
4490
3821
  });
3822
+ return retVal;
4491
3823
  };
4492
3824
  var deserializeAws_json1_1MedicalTranscriptionJobSummary = function (output, context) {
4493
3825
  return {
@@ -4521,7 +3853,7 @@ var deserializeAws_json1_1MedicalTranscriptionSetting = function (output, contex
4521
3853
  };
4522
3854
  };
4523
3855
  var deserializeAws_json1_1Models = function (output, context) {
4524
- return (output || [])
3856
+ var retVal = (output || [])
4525
3857
  .filter(function (e) { return e != null; })
4526
3858
  .map(function (entry) {
4527
3859
  if (entry === null) {
@@ -4529,6 +3861,7 @@ var deserializeAws_json1_1Models = function (output, context) {
4529
3861
  }
4530
3862
  return deserializeAws_json1_1LanguageModel(entry, context);
4531
3863
  });
3864
+ return retVal;
4532
3865
  };
4533
3866
  var deserializeAws_json1_1ModelSettings = function (output, context) {
4534
3867
  return {
@@ -4553,7 +3886,7 @@ var deserializeAws_json1_1NotFoundException = function (output, context) {
4553
3886
  };
4554
3887
  };
4555
3888
  var deserializeAws_json1_1PiiEntityTypes = function (output, context) {
4556
- return (output || [])
3889
+ var retVal = (output || [])
4557
3890
  .filter(function (e) { return e != null; })
4558
3891
  .map(function (entry) {
4559
3892
  if (entry === null) {
@@ -4561,6 +3894,7 @@ var deserializeAws_json1_1PiiEntityTypes = function (output, context) {
4561
3894
  }
4562
3895
  return __expectString(entry);
4563
3896
  });
3897
+ return retVal;
4564
3898
  };
4565
3899
  var deserializeAws_json1_1RelativeTimeRange = function (output, context) {
4566
3900
  return {
@@ -4594,7 +3928,7 @@ var deserializeAws_json1_1Rule = function (output, context) {
4594
3928
  return { $unknown: Object.entries(output)[0] };
4595
3929
  };
4596
3930
  var deserializeAws_json1_1RuleList = function (output, context) {
4597
- return (output || [])
3931
+ var retVal = (output || [])
4598
3932
  .filter(function (e) { return e != null; })
4599
3933
  .map(function (entry) {
4600
3934
  if (entry === null) {
@@ -4602,6 +3936,7 @@ var deserializeAws_json1_1RuleList = function (output, context) {
4602
3936
  }
4603
3937
  return deserializeAws_json1_1Rule(__expectUnion(entry), context);
4604
3938
  });
3939
+ return retVal;
4605
3940
  };
4606
3941
  var deserializeAws_json1_1SentimentFilter = function (output, context) {
4607
3942
  return {
@@ -4619,7 +3954,7 @@ var deserializeAws_json1_1SentimentFilter = function (output, context) {
4619
3954
  };
4620
3955
  };
4621
3956
  var deserializeAws_json1_1SentimentValueList = function (output, context) {
4622
- return (output || [])
3957
+ var retVal = (output || [])
4623
3958
  .filter(function (e) { return e != null; })
4624
3959
  .map(function (entry) {
4625
3960
  if (entry === null) {
@@ -4627,6 +3962,7 @@ var deserializeAws_json1_1SentimentValueList = function (output, context) {
4627
3962
  }
4628
3963
  return __expectString(entry);
4629
3964
  });
3965
+ return retVal;
4630
3966
  };
4631
3967
  var deserializeAws_json1_1Settings = function (output, context) {
4632
3968
  return {
@@ -4662,7 +3998,7 @@ var deserializeAws_json1_1StartTranscriptionJobResponse = function (output, cont
4662
3998
  };
4663
3999
  };
4664
4000
  var deserializeAws_json1_1StringTargetList = function (output, context) {
4665
- return (output || [])
4001
+ var retVal = (output || [])
4666
4002
  .filter(function (e) { return e != null; })
4667
4003
  .map(function (entry) {
4668
4004
  if (entry === null) {
@@ -4670,9 +4006,10 @@ var deserializeAws_json1_1StringTargetList = function (output, context) {
4670
4006
  }
4671
4007
  return __expectString(entry);
4672
4008
  });
4009
+ return retVal;
4673
4010
  };
4674
4011
  var deserializeAws_json1_1SubtitleFileUris = function (output, context) {
4675
- return (output || [])
4012
+ var retVal = (output || [])
4676
4013
  .filter(function (e) { return e != null; })
4677
4014
  .map(function (entry) {
4678
4015
  if (entry === null) {
@@ -4680,9 +4017,10 @@ var deserializeAws_json1_1SubtitleFileUris = function (output, context) {
4680
4017
  }
4681
4018
  return __expectString(entry);
4682
4019
  });
4020
+ return retVal;
4683
4021
  };
4684
4022
  var deserializeAws_json1_1SubtitleFormats = function (output, context) {
4685
- return (output || [])
4023
+ var retVal = (output || [])
4686
4024
  .filter(function (e) { return e != null; })
4687
4025
  .map(function (entry) {
4688
4026
  if (entry === null) {
@@ -4690,6 +4028,7 @@ var deserializeAws_json1_1SubtitleFormats = function (output, context) {
4690
4028
  }
4691
4029
  return __expectString(entry);
4692
4030
  });
4031
+ return retVal;
4693
4032
  };
4694
4033
  var deserializeAws_json1_1SubtitlesOutput = function (output, context) {
4695
4034
  return {
@@ -4708,7 +4047,7 @@ var deserializeAws_json1_1Tag = function (output, context) {
4708
4047
  };
4709
4048
  };
4710
4049
  var deserializeAws_json1_1TagList = function (output, context) {
4711
- return (output || [])
4050
+ var retVal = (output || [])
4712
4051
  .filter(function (e) { return e != null; })
4713
4052
  .map(function (entry) {
4714
4053
  if (entry === null) {
@@ -4716,6 +4055,7 @@ var deserializeAws_json1_1TagList = function (output, context) {
4716
4055
  }
4717
4056
  return deserializeAws_json1_1Tag(entry, context);
4718
4057
  });
4058
+ return retVal;
4719
4059
  };
4720
4060
  var deserializeAws_json1_1TagResourceResponse = function (output, context) {
4721
4061
  return {};
@@ -4794,7 +4134,7 @@ var deserializeAws_json1_1TranscriptionJob = function (output, context) {
4794
4134
  };
4795
4135
  };
4796
4136
  var deserializeAws_json1_1TranscriptionJobSummaries = function (output, context) {
4797
- return (output || [])
4137
+ var retVal = (output || [])
4798
4138
  .filter(function (e) { return e != null; })
4799
4139
  .map(function (entry) {
4800
4140
  if (entry === null) {
@@ -4802,6 +4142,7 @@ var deserializeAws_json1_1TranscriptionJobSummaries = function (output, context)
4802
4142
  }
4803
4143
  return deserializeAws_json1_1TranscriptionJobSummary(entry, context);
4804
4144
  });
4145
+ return retVal;
4805
4146
  };
4806
4147
  var deserializeAws_json1_1TranscriptionJobSummary = function (output, context) {
4807
4148
  return {
@@ -4869,7 +4210,7 @@ var deserializeAws_json1_1UpdateVocabularyResponse = function (output, context)
4869
4210
  };
4870
4211
  };
4871
4212
  var deserializeAws_json1_1Vocabularies = function (output, context) {
4872
- return (output || [])
4213
+ var retVal = (output || [])
4873
4214
  .filter(function (e) { return e != null; })
4874
4215
  .map(function (entry) {
4875
4216
  if (entry === null) {
@@ -4877,6 +4218,7 @@ var deserializeAws_json1_1Vocabularies = function (output, context) {
4877
4218
  }
4878
4219
  return deserializeAws_json1_1VocabularyInfo(entry, context);
4879
4220
  });
4221
+ return retVal;
4880
4222
  };
4881
4223
  var deserializeAws_json1_1VocabularyFilterInfo = function (output, context) {
4882
4224
  return {
@@ -4888,7 +4230,7 @@ var deserializeAws_json1_1VocabularyFilterInfo = function (output, context) {
4888
4230
  };
4889
4231
  };
4890
4232
  var deserializeAws_json1_1VocabularyFilters = function (output, context) {
4891
- return (output || [])
4233
+ var retVal = (output || [])
4892
4234
  .filter(function (e) { return e != null; })
4893
4235
  .map(function (entry) {
4894
4236
  if (entry === null) {
@@ -4896,6 +4238,7 @@ var deserializeAws_json1_1VocabularyFilters = function (output, context) {
4896
4238
  }
4897
4239
  return deserializeAws_json1_1VocabularyFilterInfo(entry, context);
4898
4240
  });
4241
+ return retVal;
4899
4242
  };
4900
4243
  var deserializeAws_json1_1VocabularyInfo = function (output, context) {
4901
4244
  return {