@aws-sdk/client-amplifybackend 3.504.0 → 3.507.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 (3) hide show
  1. package/dist-cjs/index.js +33 -873
  2. package/dist-es/protocols/Aws_restJson1.js +32 -872
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -453,7 +453,7 @@ export const se_UpdateBackendStorageCommand = async (input, context) => {
453
453
  };
454
454
  export const de_CloneBackendCommand = async (output, context) => {
455
455
  if (output.statusCode !== 200 && output.statusCode >= 300) {
456
- return de_CloneBackendCommandError(output, context);
456
+ return de_CommandError(output, context);
457
457
  }
458
458
  const contents = map({
459
459
  $metadata: deserializeMetadata(output),
@@ -470,37 +470,9 @@ export const de_CloneBackendCommand = async (output, context) => {
470
470
  Object.assign(contents, doc);
471
471
  return contents;
472
472
  };
473
- const de_CloneBackendCommandError = async (output, context) => {
474
- const parsedOutput = {
475
- ...output,
476
- body: await parseErrorBody(output.body, context),
477
- };
478
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
479
- switch (errorCode) {
480
- case "BadRequestException":
481
- case "com.amazonaws.amplifybackend#BadRequestException":
482
- throw await de_BadRequestExceptionRes(parsedOutput, context);
483
- case "GatewayTimeoutException":
484
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
485
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
486
- case "NotFoundException":
487
- case "com.amazonaws.amplifybackend#NotFoundException":
488
- throw await de_NotFoundExceptionRes(parsedOutput, context);
489
- case "TooManyRequestsException":
490
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
491
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
492
- default:
493
- const parsedBody = parsedOutput.body;
494
- return throwDefaultError({
495
- output,
496
- parsedBody,
497
- errorCode,
498
- });
499
- }
500
- };
501
473
  export const de_CreateBackendCommand = async (output, context) => {
502
474
  if (output.statusCode !== 200 && output.statusCode >= 300) {
503
- return de_CreateBackendCommandError(output, context);
475
+ return de_CommandError(output, context);
504
476
  }
505
477
  const contents = map({
506
478
  $metadata: deserializeMetadata(output),
@@ -517,37 +489,9 @@ export const de_CreateBackendCommand = async (output, context) => {
517
489
  Object.assign(contents, doc);
518
490
  return contents;
519
491
  };
520
- const de_CreateBackendCommandError = async (output, context) => {
521
- const parsedOutput = {
522
- ...output,
523
- body: await parseErrorBody(output.body, context),
524
- };
525
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
526
- switch (errorCode) {
527
- case "BadRequestException":
528
- case "com.amazonaws.amplifybackend#BadRequestException":
529
- throw await de_BadRequestExceptionRes(parsedOutput, context);
530
- case "GatewayTimeoutException":
531
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
532
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
533
- case "NotFoundException":
534
- case "com.amazonaws.amplifybackend#NotFoundException":
535
- throw await de_NotFoundExceptionRes(parsedOutput, context);
536
- case "TooManyRequestsException":
537
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
538
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
539
- default:
540
- const parsedBody = parsedOutput.body;
541
- return throwDefaultError({
542
- output,
543
- parsedBody,
544
- errorCode,
545
- });
546
- }
547
- };
548
492
  export const de_CreateBackendAPICommand = async (output, context) => {
549
493
  if (output.statusCode !== 200 && output.statusCode >= 300) {
550
- return de_CreateBackendAPICommandError(output, context);
494
+ return de_CommandError(output, context);
551
495
  }
552
496
  const contents = map({
553
497
  $metadata: deserializeMetadata(output),
@@ -564,37 +508,9 @@ export const de_CreateBackendAPICommand = async (output, context) => {
564
508
  Object.assign(contents, doc);
565
509
  return contents;
566
510
  };
567
- const de_CreateBackendAPICommandError = async (output, context) => {
568
- const parsedOutput = {
569
- ...output,
570
- body: await parseErrorBody(output.body, context),
571
- };
572
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
573
- switch (errorCode) {
574
- case "BadRequestException":
575
- case "com.amazonaws.amplifybackend#BadRequestException":
576
- throw await de_BadRequestExceptionRes(parsedOutput, context);
577
- case "GatewayTimeoutException":
578
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
579
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
580
- case "NotFoundException":
581
- case "com.amazonaws.amplifybackend#NotFoundException":
582
- throw await de_NotFoundExceptionRes(parsedOutput, context);
583
- case "TooManyRequestsException":
584
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
585
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
586
- default:
587
- const parsedBody = parsedOutput.body;
588
- return throwDefaultError({
589
- output,
590
- parsedBody,
591
- errorCode,
592
- });
593
- }
594
- };
595
511
  export const de_CreateBackendAuthCommand = async (output, context) => {
596
512
  if (output.statusCode !== 200 && output.statusCode >= 300) {
597
- return de_CreateBackendAuthCommandError(output, context);
513
+ return de_CommandError(output, context);
598
514
  }
599
515
  const contents = map({
600
516
  $metadata: deserializeMetadata(output),
@@ -611,37 +527,9 @@ export const de_CreateBackendAuthCommand = async (output, context) => {
611
527
  Object.assign(contents, doc);
612
528
  return contents;
613
529
  };
614
- const de_CreateBackendAuthCommandError = async (output, context) => {
615
- const parsedOutput = {
616
- ...output,
617
- body: await parseErrorBody(output.body, context),
618
- };
619
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
620
- switch (errorCode) {
621
- case "BadRequestException":
622
- case "com.amazonaws.amplifybackend#BadRequestException":
623
- throw await de_BadRequestExceptionRes(parsedOutput, context);
624
- case "GatewayTimeoutException":
625
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
626
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
627
- case "NotFoundException":
628
- case "com.amazonaws.amplifybackend#NotFoundException":
629
- throw await de_NotFoundExceptionRes(parsedOutput, context);
630
- case "TooManyRequestsException":
631
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
632
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
633
- default:
634
- const parsedBody = parsedOutput.body;
635
- return throwDefaultError({
636
- output,
637
- parsedBody,
638
- errorCode,
639
- });
640
- }
641
- };
642
530
  export const de_CreateBackendConfigCommand = async (output, context) => {
643
531
  if (output.statusCode !== 200 && output.statusCode >= 300) {
644
- return de_CreateBackendConfigCommandError(output, context);
532
+ return de_CommandError(output, context);
645
533
  }
646
534
  const contents = map({
647
535
  $metadata: deserializeMetadata(output),
@@ -656,37 +544,9 @@ export const de_CreateBackendConfigCommand = async (output, context) => {
656
544
  Object.assign(contents, doc);
657
545
  return contents;
658
546
  };
659
- const de_CreateBackendConfigCommandError = async (output, context) => {
660
- const parsedOutput = {
661
- ...output,
662
- body: await parseErrorBody(output.body, context),
663
- };
664
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
665
- switch (errorCode) {
666
- case "BadRequestException":
667
- case "com.amazonaws.amplifybackend#BadRequestException":
668
- throw await de_BadRequestExceptionRes(parsedOutput, context);
669
- case "GatewayTimeoutException":
670
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
671
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
672
- case "NotFoundException":
673
- case "com.amazonaws.amplifybackend#NotFoundException":
674
- throw await de_NotFoundExceptionRes(parsedOutput, context);
675
- case "TooManyRequestsException":
676
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
677
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
678
- default:
679
- const parsedBody = parsedOutput.body;
680
- return throwDefaultError({
681
- output,
682
- parsedBody,
683
- errorCode,
684
- });
685
- }
686
- };
687
547
  export const de_CreateBackendStorageCommand = async (output, context) => {
688
548
  if (output.statusCode !== 200 && output.statusCode >= 300) {
689
- return de_CreateBackendStorageCommandError(output, context);
549
+ return de_CommandError(output, context);
690
550
  }
691
551
  const contents = map({
692
552
  $metadata: deserializeMetadata(output),
@@ -701,37 +561,9 @@ export const de_CreateBackendStorageCommand = async (output, context) => {
701
561
  Object.assign(contents, doc);
702
562
  return contents;
703
563
  };
704
- const de_CreateBackendStorageCommandError = async (output, context) => {
705
- const parsedOutput = {
706
- ...output,
707
- body: await parseErrorBody(output.body, context),
708
- };
709
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
710
- switch (errorCode) {
711
- case "BadRequestException":
712
- case "com.amazonaws.amplifybackend#BadRequestException":
713
- throw await de_BadRequestExceptionRes(parsedOutput, context);
714
- case "GatewayTimeoutException":
715
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
716
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
717
- case "NotFoundException":
718
- case "com.amazonaws.amplifybackend#NotFoundException":
719
- throw await de_NotFoundExceptionRes(parsedOutput, context);
720
- case "TooManyRequestsException":
721
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
722
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
723
- default:
724
- const parsedBody = parsedOutput.body;
725
- return throwDefaultError({
726
- output,
727
- parsedBody,
728
- errorCode,
729
- });
730
- }
731
- };
732
564
  export const de_CreateTokenCommand = async (output, context) => {
733
565
  if (output.statusCode !== 200 && output.statusCode >= 300) {
734
- return de_CreateTokenCommandError(output, context);
566
+ return de_CommandError(output, context);
735
567
  }
736
568
  const contents = map({
737
569
  $metadata: deserializeMetadata(output),
@@ -746,37 +578,9 @@ export const de_CreateTokenCommand = async (output, context) => {
746
578
  Object.assign(contents, doc);
747
579
  return contents;
748
580
  };
749
- const de_CreateTokenCommandError = async (output, context) => {
750
- const parsedOutput = {
751
- ...output,
752
- body: await parseErrorBody(output.body, context),
753
- };
754
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
755
- switch (errorCode) {
756
- case "BadRequestException":
757
- case "com.amazonaws.amplifybackend#BadRequestException":
758
- throw await de_BadRequestExceptionRes(parsedOutput, context);
759
- case "GatewayTimeoutException":
760
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
761
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
762
- case "NotFoundException":
763
- case "com.amazonaws.amplifybackend#NotFoundException":
764
- throw await de_NotFoundExceptionRes(parsedOutput, context);
765
- case "TooManyRequestsException":
766
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
767
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
768
- default:
769
- const parsedBody = parsedOutput.body;
770
- return throwDefaultError({
771
- output,
772
- parsedBody,
773
- errorCode,
774
- });
775
- }
776
- };
777
581
  export const de_DeleteBackendCommand = async (output, context) => {
778
582
  if (output.statusCode !== 200 && output.statusCode >= 300) {
779
- return de_DeleteBackendCommandError(output, context);
583
+ return de_CommandError(output, context);
780
584
  }
781
585
  const contents = map({
782
586
  $metadata: deserializeMetadata(output),
@@ -793,37 +597,9 @@ export const de_DeleteBackendCommand = async (output, context) => {
793
597
  Object.assign(contents, doc);
794
598
  return contents;
795
599
  };
796
- const de_DeleteBackendCommandError = async (output, context) => {
797
- const parsedOutput = {
798
- ...output,
799
- body: await parseErrorBody(output.body, context),
800
- };
801
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
802
- switch (errorCode) {
803
- case "BadRequestException":
804
- case "com.amazonaws.amplifybackend#BadRequestException":
805
- throw await de_BadRequestExceptionRes(parsedOutput, context);
806
- case "GatewayTimeoutException":
807
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
808
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
809
- case "NotFoundException":
810
- case "com.amazonaws.amplifybackend#NotFoundException":
811
- throw await de_NotFoundExceptionRes(parsedOutput, context);
812
- case "TooManyRequestsException":
813
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
814
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
815
- default:
816
- const parsedBody = parsedOutput.body;
817
- return throwDefaultError({
818
- output,
819
- parsedBody,
820
- errorCode,
821
- });
822
- }
823
- };
824
600
  export const de_DeleteBackendAPICommand = async (output, context) => {
825
601
  if (output.statusCode !== 200 && output.statusCode >= 300) {
826
- return de_DeleteBackendAPICommandError(output, context);
602
+ return de_CommandError(output, context);
827
603
  }
828
604
  const contents = map({
829
605
  $metadata: deserializeMetadata(output),
@@ -840,37 +616,9 @@ export const de_DeleteBackendAPICommand = async (output, context) => {
840
616
  Object.assign(contents, doc);
841
617
  return contents;
842
618
  };
843
- const de_DeleteBackendAPICommandError = async (output, context) => {
844
- const parsedOutput = {
845
- ...output,
846
- body: await parseErrorBody(output.body, context),
847
- };
848
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
849
- switch (errorCode) {
850
- case "BadRequestException":
851
- case "com.amazonaws.amplifybackend#BadRequestException":
852
- throw await de_BadRequestExceptionRes(parsedOutput, context);
853
- case "GatewayTimeoutException":
854
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
855
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
856
- case "NotFoundException":
857
- case "com.amazonaws.amplifybackend#NotFoundException":
858
- throw await de_NotFoundExceptionRes(parsedOutput, context);
859
- case "TooManyRequestsException":
860
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
861
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
862
- default:
863
- const parsedBody = parsedOutput.body;
864
- return throwDefaultError({
865
- output,
866
- parsedBody,
867
- errorCode,
868
- });
869
- }
870
- };
871
619
  export const de_DeleteBackendAuthCommand = async (output, context) => {
872
620
  if (output.statusCode !== 200 && output.statusCode >= 300) {
873
- return de_DeleteBackendAuthCommandError(output, context);
621
+ return de_CommandError(output, context);
874
622
  }
875
623
  const contents = map({
876
624
  $metadata: deserializeMetadata(output),
@@ -887,37 +635,9 @@ export const de_DeleteBackendAuthCommand = async (output, context) => {
887
635
  Object.assign(contents, doc);
888
636
  return contents;
889
637
  };
890
- const de_DeleteBackendAuthCommandError = async (output, context) => {
891
- const parsedOutput = {
892
- ...output,
893
- body: await parseErrorBody(output.body, context),
894
- };
895
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
896
- switch (errorCode) {
897
- case "BadRequestException":
898
- case "com.amazonaws.amplifybackend#BadRequestException":
899
- throw await de_BadRequestExceptionRes(parsedOutput, context);
900
- case "GatewayTimeoutException":
901
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
902
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
903
- case "NotFoundException":
904
- case "com.amazonaws.amplifybackend#NotFoundException":
905
- throw await de_NotFoundExceptionRes(parsedOutput, context);
906
- case "TooManyRequestsException":
907
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
908
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
909
- default:
910
- const parsedBody = parsedOutput.body;
911
- return throwDefaultError({
912
- output,
913
- parsedBody,
914
- errorCode,
915
- });
916
- }
917
- };
918
638
  export const de_DeleteBackendStorageCommand = async (output, context) => {
919
639
  if (output.statusCode !== 200 && output.statusCode >= 300) {
920
- return de_DeleteBackendStorageCommandError(output, context);
640
+ return de_CommandError(output, context);
921
641
  }
922
642
  const contents = map({
923
643
  $metadata: deserializeMetadata(output),
@@ -932,37 +652,9 @@ export const de_DeleteBackendStorageCommand = async (output, context) => {
932
652
  Object.assign(contents, doc);
933
653
  return contents;
934
654
  };
935
- const de_DeleteBackendStorageCommandError = async (output, context) => {
936
- const parsedOutput = {
937
- ...output,
938
- body: await parseErrorBody(output.body, context),
939
- };
940
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
941
- switch (errorCode) {
942
- case "BadRequestException":
943
- case "com.amazonaws.amplifybackend#BadRequestException":
944
- throw await de_BadRequestExceptionRes(parsedOutput, context);
945
- case "GatewayTimeoutException":
946
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
947
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
948
- case "NotFoundException":
949
- case "com.amazonaws.amplifybackend#NotFoundException":
950
- throw await de_NotFoundExceptionRes(parsedOutput, context);
951
- case "TooManyRequestsException":
952
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
953
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
954
- default:
955
- const parsedBody = parsedOutput.body;
956
- return throwDefaultError({
957
- output,
958
- parsedBody,
959
- errorCode,
960
- });
961
- }
962
- };
963
655
  export const de_DeleteTokenCommand = async (output, context) => {
964
656
  if (output.statusCode !== 200 && output.statusCode >= 300) {
965
- return de_DeleteTokenCommandError(output, context);
657
+ return de_CommandError(output, context);
966
658
  }
967
659
  const contents = map({
968
660
  $metadata: deserializeMetadata(output),
@@ -974,37 +666,9 @@ export const de_DeleteTokenCommand = async (output, context) => {
974
666
  Object.assign(contents, doc);
975
667
  return contents;
976
668
  };
977
- const de_DeleteTokenCommandError = async (output, context) => {
978
- const parsedOutput = {
979
- ...output,
980
- body: await parseErrorBody(output.body, context),
981
- };
982
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
983
- switch (errorCode) {
984
- case "BadRequestException":
985
- case "com.amazonaws.amplifybackend#BadRequestException":
986
- throw await de_BadRequestExceptionRes(parsedOutput, context);
987
- case "GatewayTimeoutException":
988
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
989
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
990
- case "NotFoundException":
991
- case "com.amazonaws.amplifybackend#NotFoundException":
992
- throw await de_NotFoundExceptionRes(parsedOutput, context);
993
- case "TooManyRequestsException":
994
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
995
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
996
- default:
997
- const parsedBody = parsedOutput.body;
998
- return throwDefaultError({
999
- output,
1000
- parsedBody,
1001
- errorCode,
1002
- });
1003
- }
1004
- };
1005
669
  export const de_GenerateBackendAPIModelsCommand = async (output, context) => {
1006
670
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1007
- return de_GenerateBackendAPIModelsCommandError(output, context);
671
+ return de_CommandError(output, context);
1008
672
  }
1009
673
  const contents = map({
1010
674
  $metadata: deserializeMetadata(output),
@@ -1021,37 +685,9 @@ export const de_GenerateBackendAPIModelsCommand = async (output, context) => {
1021
685
  Object.assign(contents, doc);
1022
686
  return contents;
1023
687
  };
1024
- const de_GenerateBackendAPIModelsCommandError = async (output, context) => {
1025
- const parsedOutput = {
1026
- ...output,
1027
- body: await parseErrorBody(output.body, context),
1028
- };
1029
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1030
- switch (errorCode) {
1031
- case "BadRequestException":
1032
- case "com.amazonaws.amplifybackend#BadRequestException":
1033
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1034
- case "GatewayTimeoutException":
1035
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1036
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1037
- case "NotFoundException":
1038
- case "com.amazonaws.amplifybackend#NotFoundException":
1039
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1040
- case "TooManyRequestsException":
1041
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1042
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1043
- default:
1044
- const parsedBody = parsedOutput.body;
1045
- return throwDefaultError({
1046
- output,
1047
- parsedBody,
1048
- errorCode,
1049
- });
1050
- }
1051
- };
1052
688
  export const de_GetBackendCommand = async (output, context) => {
1053
689
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1054
- return de_GetBackendCommandError(output, context);
690
+ return de_CommandError(output, context);
1055
691
  }
1056
692
  const contents = map({
1057
693
  $metadata: deserializeMetadata(output),
@@ -1069,37 +705,9 @@ export const de_GetBackendCommand = async (output, context) => {
1069
705
  Object.assign(contents, doc);
1070
706
  return contents;
1071
707
  };
1072
- const de_GetBackendCommandError = async (output, context) => {
1073
- const parsedOutput = {
1074
- ...output,
1075
- body: await parseErrorBody(output.body, context),
1076
- };
1077
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1078
- switch (errorCode) {
1079
- case "BadRequestException":
1080
- case "com.amazonaws.amplifybackend#BadRequestException":
1081
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1082
- case "GatewayTimeoutException":
1083
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1084
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1085
- case "NotFoundException":
1086
- case "com.amazonaws.amplifybackend#NotFoundException":
1087
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1088
- case "TooManyRequestsException":
1089
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1090
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1091
- default:
1092
- const parsedBody = parsedOutput.body;
1093
- return throwDefaultError({
1094
- output,
1095
- parsedBody,
1096
- errorCode,
1097
- });
1098
- }
1099
- };
1100
708
  export const de_GetBackendAPICommand = async (output, context) => {
1101
709
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1102
- return de_GetBackendAPICommandError(output, context);
710
+ return de_CommandError(output, context);
1103
711
  }
1104
712
  const contents = map({
1105
713
  $metadata: deserializeMetadata(output),
@@ -1115,37 +723,9 @@ export const de_GetBackendAPICommand = async (output, context) => {
1115
723
  Object.assign(contents, doc);
1116
724
  return contents;
1117
725
  };
1118
- const de_GetBackendAPICommandError = async (output, context) => {
1119
- const parsedOutput = {
1120
- ...output,
1121
- body: await parseErrorBody(output.body, context),
1122
- };
1123
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1124
- switch (errorCode) {
1125
- case "BadRequestException":
1126
- case "com.amazonaws.amplifybackend#BadRequestException":
1127
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1128
- case "GatewayTimeoutException":
1129
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1130
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1131
- case "NotFoundException":
1132
- case "com.amazonaws.amplifybackend#NotFoundException":
1133
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1134
- case "TooManyRequestsException":
1135
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1136
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1137
- default:
1138
- const parsedBody = parsedOutput.body;
1139
- return throwDefaultError({
1140
- output,
1141
- parsedBody,
1142
- errorCode,
1143
- });
1144
- }
1145
- };
1146
726
  export const de_GetBackendAPIModelsCommand = async (output, context) => {
1147
727
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1148
- return de_GetBackendAPIModelsCommandError(output, context);
728
+ return de_CommandError(output, context);
1149
729
  }
1150
730
  const contents = map({
1151
731
  $metadata: deserializeMetadata(output),
@@ -1159,37 +739,9 @@ export const de_GetBackendAPIModelsCommand = async (output, context) => {
1159
739
  Object.assign(contents, doc);
1160
740
  return contents;
1161
741
  };
1162
- const de_GetBackendAPIModelsCommandError = async (output, context) => {
1163
- const parsedOutput = {
1164
- ...output,
1165
- body: await parseErrorBody(output.body, context),
1166
- };
1167
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1168
- switch (errorCode) {
1169
- case "BadRequestException":
1170
- case "com.amazonaws.amplifybackend#BadRequestException":
1171
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1172
- case "GatewayTimeoutException":
1173
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1174
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1175
- case "NotFoundException":
1176
- case "com.amazonaws.amplifybackend#NotFoundException":
1177
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1178
- case "TooManyRequestsException":
1179
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1180
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1181
- default:
1182
- const parsedBody = parsedOutput.body;
1183
- return throwDefaultError({
1184
- output,
1185
- parsedBody,
1186
- errorCode,
1187
- });
1188
- }
1189
- };
1190
742
  export const de_GetBackendAuthCommand = async (output, context) => {
1191
743
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1192
- return de_GetBackendAuthCommandError(output, context);
744
+ return de_CommandError(output, context);
1193
745
  }
1194
746
  const contents = map({
1195
747
  $metadata: deserializeMetadata(output),
@@ -1205,37 +757,9 @@ export const de_GetBackendAuthCommand = async (output, context) => {
1205
757
  Object.assign(contents, doc);
1206
758
  return contents;
1207
759
  };
1208
- const de_GetBackendAuthCommandError = async (output, context) => {
1209
- const parsedOutput = {
1210
- ...output,
1211
- body: await parseErrorBody(output.body, context),
1212
- };
1213
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1214
- switch (errorCode) {
1215
- case "BadRequestException":
1216
- case "com.amazonaws.amplifybackend#BadRequestException":
1217
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1218
- case "GatewayTimeoutException":
1219
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1220
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1221
- case "NotFoundException":
1222
- case "com.amazonaws.amplifybackend#NotFoundException":
1223
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1224
- case "TooManyRequestsException":
1225
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1226
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1227
- default:
1228
- const parsedBody = parsedOutput.body;
1229
- return throwDefaultError({
1230
- output,
1231
- parsedBody,
1232
- errorCode,
1233
- });
1234
- }
1235
- };
1236
760
  export const de_GetBackendJobCommand = async (output, context) => {
1237
761
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1238
- return de_GetBackendJobCommandError(output, context);
762
+ return de_CommandError(output, context);
1239
763
  }
1240
764
  const contents = map({
1241
765
  $metadata: deserializeMetadata(output),
@@ -1254,37 +778,9 @@ export const de_GetBackendJobCommand = async (output, context) => {
1254
778
  Object.assign(contents, doc);
1255
779
  return contents;
1256
780
  };
1257
- const de_GetBackendJobCommandError = async (output, context) => {
1258
- const parsedOutput = {
1259
- ...output,
1260
- body: await parseErrorBody(output.body, context),
1261
- };
1262
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1263
- switch (errorCode) {
1264
- case "BadRequestException":
1265
- case "com.amazonaws.amplifybackend#BadRequestException":
1266
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1267
- case "GatewayTimeoutException":
1268
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1269
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1270
- case "NotFoundException":
1271
- case "com.amazonaws.amplifybackend#NotFoundException":
1272
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1273
- case "TooManyRequestsException":
1274
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1275
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1276
- default:
1277
- const parsedBody = parsedOutput.body;
1278
- return throwDefaultError({
1279
- output,
1280
- parsedBody,
1281
- errorCode,
1282
- });
1283
- }
1284
- };
1285
781
  export const de_GetBackendStorageCommand = async (output, context) => {
1286
782
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1287
- return de_GetBackendStorageCommandError(output, context);
783
+ return de_CommandError(output, context);
1288
784
  }
1289
785
  const contents = map({
1290
786
  $metadata: deserializeMetadata(output),
@@ -1299,37 +795,9 @@ export const de_GetBackendStorageCommand = async (output, context) => {
1299
795
  Object.assign(contents, doc);
1300
796
  return contents;
1301
797
  };
1302
- const de_GetBackendStorageCommandError = async (output, context) => {
1303
- const parsedOutput = {
1304
- ...output,
1305
- body: await parseErrorBody(output.body, context),
1306
- };
1307
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1308
- switch (errorCode) {
1309
- case "BadRequestException":
1310
- case "com.amazonaws.amplifybackend#BadRequestException":
1311
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1312
- case "GatewayTimeoutException":
1313
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1314
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1315
- case "NotFoundException":
1316
- case "com.amazonaws.amplifybackend#NotFoundException":
1317
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1318
- case "TooManyRequestsException":
1319
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1320
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1321
- default:
1322
- const parsedBody = parsedOutput.body;
1323
- return throwDefaultError({
1324
- output,
1325
- parsedBody,
1326
- errorCode,
1327
- });
1328
- }
1329
- };
1330
798
  export const de_GetTokenCommand = async (output, context) => {
1331
799
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1332
- return de_GetTokenCommandError(output, context);
800
+ return de_CommandError(output, context);
1333
801
  }
1334
802
  const contents = map({
1335
803
  $metadata: deserializeMetadata(output),
@@ -1344,37 +812,9 @@ export const de_GetTokenCommand = async (output, context) => {
1344
812
  Object.assign(contents, doc);
1345
813
  return contents;
1346
814
  };
1347
- const de_GetTokenCommandError = async (output, context) => {
1348
- const parsedOutput = {
1349
- ...output,
1350
- body: await parseErrorBody(output.body, context),
1351
- };
1352
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1353
- switch (errorCode) {
1354
- case "BadRequestException":
1355
- case "com.amazonaws.amplifybackend#BadRequestException":
1356
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1357
- case "GatewayTimeoutException":
1358
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1359
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1360
- case "NotFoundException":
1361
- case "com.amazonaws.amplifybackend#NotFoundException":
1362
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1363
- case "TooManyRequestsException":
1364
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1365
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1366
- default:
1367
- const parsedBody = parsedOutput.body;
1368
- return throwDefaultError({
1369
- output,
1370
- parsedBody,
1371
- errorCode,
1372
- });
1373
- }
1374
- };
1375
815
  export const de_ImportBackendAuthCommand = async (output, context) => {
1376
816
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1377
- return de_ImportBackendAuthCommandError(output, context);
817
+ return de_CommandError(output, context);
1378
818
  }
1379
819
  const contents = map({
1380
820
  $metadata: deserializeMetadata(output),
@@ -1391,37 +831,9 @@ export const de_ImportBackendAuthCommand = async (output, context) => {
1391
831
  Object.assign(contents, doc);
1392
832
  return contents;
1393
833
  };
1394
- const de_ImportBackendAuthCommandError = async (output, context) => {
1395
- const parsedOutput = {
1396
- ...output,
1397
- body: await parseErrorBody(output.body, context),
1398
- };
1399
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1400
- switch (errorCode) {
1401
- case "BadRequestException":
1402
- case "com.amazonaws.amplifybackend#BadRequestException":
1403
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1404
- case "GatewayTimeoutException":
1405
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1406
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1407
- case "NotFoundException":
1408
- case "com.amazonaws.amplifybackend#NotFoundException":
1409
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1410
- case "TooManyRequestsException":
1411
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1412
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1413
- default:
1414
- const parsedBody = parsedOutput.body;
1415
- return throwDefaultError({
1416
- output,
1417
- parsedBody,
1418
- errorCode,
1419
- });
1420
- }
1421
- };
1422
834
  export const de_ImportBackendStorageCommand = async (output, context) => {
1423
835
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1424
- return de_ImportBackendStorageCommandError(output, context);
836
+ return de_CommandError(output, context);
1425
837
  }
1426
838
  const contents = map({
1427
839
  $metadata: deserializeMetadata(output),
@@ -1436,37 +848,9 @@ export const de_ImportBackendStorageCommand = async (output, context) => {
1436
848
  Object.assign(contents, doc);
1437
849
  return contents;
1438
850
  };
1439
- const de_ImportBackendStorageCommandError = async (output, context) => {
1440
- const parsedOutput = {
1441
- ...output,
1442
- body: await parseErrorBody(output.body, context),
1443
- };
1444
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1445
- switch (errorCode) {
1446
- case "BadRequestException":
1447
- case "com.amazonaws.amplifybackend#BadRequestException":
1448
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1449
- case "GatewayTimeoutException":
1450
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1451
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1452
- case "NotFoundException":
1453
- case "com.amazonaws.amplifybackend#NotFoundException":
1454
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1455
- case "TooManyRequestsException":
1456
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1457
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1458
- default:
1459
- const parsedBody = parsedOutput.body;
1460
- return throwDefaultError({
1461
- output,
1462
- parsedBody,
1463
- errorCode,
1464
- });
1465
- }
1466
- };
1467
851
  export const de_ListBackendJobsCommand = async (output, context) => {
1468
852
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1469
- return de_ListBackendJobsCommandError(output, context);
853
+ return de_CommandError(output, context);
1470
854
  }
1471
855
  const contents = map({
1472
856
  $metadata: deserializeMetadata(output),
@@ -1479,37 +863,9 @@ export const de_ListBackendJobsCommand = async (output, context) => {
1479
863
  Object.assign(contents, doc);
1480
864
  return contents;
1481
865
  };
1482
- const de_ListBackendJobsCommandError = async (output, context) => {
1483
- const parsedOutput = {
1484
- ...output,
1485
- body: await parseErrorBody(output.body, context),
1486
- };
1487
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1488
- switch (errorCode) {
1489
- case "BadRequestException":
1490
- case "com.amazonaws.amplifybackend#BadRequestException":
1491
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1492
- case "GatewayTimeoutException":
1493
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1494
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1495
- case "NotFoundException":
1496
- case "com.amazonaws.amplifybackend#NotFoundException":
1497
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1498
- case "TooManyRequestsException":
1499
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1500
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1501
- default:
1502
- const parsedBody = parsedOutput.body;
1503
- return throwDefaultError({
1504
- output,
1505
- parsedBody,
1506
- errorCode,
1507
- });
1508
- }
1509
- };
1510
866
  export const de_ListS3BucketsCommand = async (output, context) => {
1511
867
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1512
- return de_ListS3BucketsCommandError(output, context);
868
+ return de_CommandError(output, context);
1513
869
  }
1514
870
  const contents = map({
1515
871
  $metadata: deserializeMetadata(output),
@@ -1522,37 +878,9 @@ export const de_ListS3BucketsCommand = async (output, context) => {
1522
878
  Object.assign(contents, doc);
1523
879
  return contents;
1524
880
  };
1525
- const de_ListS3BucketsCommandError = async (output, context) => {
1526
- const parsedOutput = {
1527
- ...output,
1528
- body: await parseErrorBody(output.body, context),
1529
- };
1530
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1531
- switch (errorCode) {
1532
- case "BadRequestException":
1533
- case "com.amazonaws.amplifybackend#BadRequestException":
1534
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1535
- case "GatewayTimeoutException":
1536
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1537
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1538
- case "NotFoundException":
1539
- case "com.amazonaws.amplifybackend#NotFoundException":
1540
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1541
- case "TooManyRequestsException":
1542
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1543
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1544
- default:
1545
- const parsedBody = parsedOutput.body;
1546
- return throwDefaultError({
1547
- output,
1548
- parsedBody,
1549
- errorCode,
1550
- });
1551
- }
1552
- };
1553
881
  export const de_RemoveAllBackendsCommand = async (output, context) => {
1554
882
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1555
- return de_RemoveAllBackendsCommandError(output, context);
883
+ return de_CommandError(output, context);
1556
884
  }
1557
885
  const contents = map({
1558
886
  $metadata: deserializeMetadata(output),
@@ -1568,37 +896,9 @@ export const de_RemoveAllBackendsCommand = async (output, context) => {
1568
896
  Object.assign(contents, doc);
1569
897
  return contents;
1570
898
  };
1571
- const de_RemoveAllBackendsCommandError = async (output, context) => {
1572
- const parsedOutput = {
1573
- ...output,
1574
- body: await parseErrorBody(output.body, context),
1575
- };
1576
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1577
- switch (errorCode) {
1578
- case "BadRequestException":
1579
- case "com.amazonaws.amplifybackend#BadRequestException":
1580
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1581
- case "GatewayTimeoutException":
1582
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1583
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1584
- case "NotFoundException":
1585
- case "com.amazonaws.amplifybackend#NotFoundException":
1586
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1587
- case "TooManyRequestsException":
1588
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1589
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1590
- default:
1591
- const parsedBody = parsedOutput.body;
1592
- return throwDefaultError({
1593
- output,
1594
- parsedBody,
1595
- errorCode,
1596
- });
1597
- }
1598
- };
1599
899
  export const de_RemoveBackendConfigCommand = async (output, context) => {
1600
900
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1601
- return de_RemoveBackendConfigCommandError(output, context);
901
+ return de_CommandError(output, context);
1602
902
  }
1603
903
  const contents = map({
1604
904
  $metadata: deserializeMetadata(output),
@@ -1610,37 +910,9 @@ export const de_RemoveBackendConfigCommand = async (output, context) => {
1610
910
  Object.assign(contents, doc);
1611
911
  return contents;
1612
912
  };
1613
- const de_RemoveBackendConfigCommandError = async (output, context) => {
1614
- const parsedOutput = {
1615
- ...output,
1616
- body: await parseErrorBody(output.body, context),
1617
- };
1618
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1619
- switch (errorCode) {
1620
- case "BadRequestException":
1621
- case "com.amazonaws.amplifybackend#BadRequestException":
1622
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1623
- case "GatewayTimeoutException":
1624
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1625
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1626
- case "NotFoundException":
1627
- case "com.amazonaws.amplifybackend#NotFoundException":
1628
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1629
- case "TooManyRequestsException":
1630
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1631
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1632
- default:
1633
- const parsedBody = parsedOutput.body;
1634
- return throwDefaultError({
1635
- output,
1636
- parsedBody,
1637
- errorCode,
1638
- });
1639
- }
1640
- };
1641
913
  export const de_UpdateBackendAPICommand = async (output, context) => {
1642
914
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1643
- return de_UpdateBackendAPICommandError(output, context);
915
+ return de_CommandError(output, context);
1644
916
  }
1645
917
  const contents = map({
1646
918
  $metadata: deserializeMetadata(output),
@@ -1657,37 +929,9 @@ export const de_UpdateBackendAPICommand = async (output, context) => {
1657
929
  Object.assign(contents, doc);
1658
930
  return contents;
1659
931
  };
1660
- const de_UpdateBackendAPICommandError = async (output, context) => {
1661
- const parsedOutput = {
1662
- ...output,
1663
- body: await parseErrorBody(output.body, context),
1664
- };
1665
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1666
- switch (errorCode) {
1667
- case "BadRequestException":
1668
- case "com.amazonaws.amplifybackend#BadRequestException":
1669
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1670
- case "GatewayTimeoutException":
1671
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1672
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1673
- case "NotFoundException":
1674
- case "com.amazonaws.amplifybackend#NotFoundException":
1675
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1676
- case "TooManyRequestsException":
1677
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1678
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1679
- default:
1680
- const parsedBody = parsedOutput.body;
1681
- return throwDefaultError({
1682
- output,
1683
- parsedBody,
1684
- errorCode,
1685
- });
1686
- }
1687
- };
1688
932
  export const de_UpdateBackendAuthCommand = async (output, context) => {
1689
933
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1690
- return de_UpdateBackendAuthCommandError(output, context);
934
+ return de_CommandError(output, context);
1691
935
  }
1692
936
  const contents = map({
1693
937
  $metadata: deserializeMetadata(output),
@@ -1704,37 +948,9 @@ export const de_UpdateBackendAuthCommand = async (output, context) => {
1704
948
  Object.assign(contents, doc);
1705
949
  return contents;
1706
950
  };
1707
- const de_UpdateBackendAuthCommandError = async (output, context) => {
1708
- const parsedOutput = {
1709
- ...output,
1710
- body: await parseErrorBody(output.body, context),
1711
- };
1712
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1713
- switch (errorCode) {
1714
- case "BadRequestException":
1715
- case "com.amazonaws.amplifybackend#BadRequestException":
1716
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1717
- case "GatewayTimeoutException":
1718
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1719
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1720
- case "NotFoundException":
1721
- case "com.amazonaws.amplifybackend#NotFoundException":
1722
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1723
- case "TooManyRequestsException":
1724
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1725
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1726
- default:
1727
- const parsedBody = parsedOutput.body;
1728
- return throwDefaultError({
1729
- output,
1730
- parsedBody,
1731
- errorCode,
1732
- });
1733
- }
1734
- };
1735
951
  export const de_UpdateBackendConfigCommand = async (output, context) => {
1736
952
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1737
- return de_UpdateBackendConfigCommandError(output, context);
953
+ return de_CommandError(output, context);
1738
954
  }
1739
955
  const contents = map({
1740
956
  $metadata: deserializeMetadata(output),
@@ -1749,37 +965,9 @@ export const de_UpdateBackendConfigCommand = async (output, context) => {
1749
965
  Object.assign(contents, doc);
1750
966
  return contents;
1751
967
  };
1752
- const de_UpdateBackendConfigCommandError = async (output, context) => {
1753
- const parsedOutput = {
1754
- ...output,
1755
- body: await parseErrorBody(output.body, context),
1756
- };
1757
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1758
- switch (errorCode) {
1759
- case "BadRequestException":
1760
- case "com.amazonaws.amplifybackend#BadRequestException":
1761
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1762
- case "GatewayTimeoutException":
1763
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1764
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1765
- case "NotFoundException":
1766
- case "com.amazonaws.amplifybackend#NotFoundException":
1767
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1768
- case "TooManyRequestsException":
1769
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1770
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1771
- default:
1772
- const parsedBody = parsedOutput.body;
1773
- return throwDefaultError({
1774
- output,
1775
- parsedBody,
1776
- errorCode,
1777
- });
1778
- }
1779
- };
1780
968
  export const de_UpdateBackendJobCommand = async (output, context) => {
1781
969
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1782
- return de_UpdateBackendJobCommandError(output, context);
970
+ return de_CommandError(output, context);
1783
971
  }
1784
972
  const contents = map({
1785
973
  $metadata: deserializeMetadata(output),
@@ -1798,37 +986,9 @@ export const de_UpdateBackendJobCommand = async (output, context) => {
1798
986
  Object.assign(contents, doc);
1799
987
  return contents;
1800
988
  };
1801
- const de_UpdateBackendJobCommandError = async (output, context) => {
1802
- const parsedOutput = {
1803
- ...output,
1804
- body: await parseErrorBody(output.body, context),
1805
- };
1806
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1807
- switch (errorCode) {
1808
- case "BadRequestException":
1809
- case "com.amazonaws.amplifybackend#BadRequestException":
1810
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1811
- case "GatewayTimeoutException":
1812
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1813
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1814
- case "NotFoundException":
1815
- case "com.amazonaws.amplifybackend#NotFoundException":
1816
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1817
- case "TooManyRequestsException":
1818
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1819
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1820
- default:
1821
- const parsedBody = parsedOutput.body;
1822
- return throwDefaultError({
1823
- output,
1824
- parsedBody,
1825
- errorCode,
1826
- });
1827
- }
1828
- };
1829
989
  export const de_UpdateBackendStorageCommand = async (output, context) => {
1830
990
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1831
- return de_UpdateBackendStorageCommandError(output, context);
991
+ return de_CommandError(output, context);
1832
992
  }
1833
993
  const contents = map({
1834
994
  $metadata: deserializeMetadata(output),
@@ -1843,7 +1003,7 @@ export const de_UpdateBackendStorageCommand = async (output, context) => {
1843
1003
  Object.assign(contents, doc);
1844
1004
  return contents;
1845
1005
  };
1846
- const de_UpdateBackendStorageCommandError = async (output, context) => {
1006
+ const de_CommandError = async (output, context) => {
1847
1007
  const parsedOutput = {
1848
1008
  ...output,
1849
1009
  body: await parseErrorBody(output.body, context),