@aws-sdk/client-codecatalyst 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 +40 -1298
  2. package/dist-es/protocols/Aws_restJson1.js +64 -1322
  3. package/package.json +2 -2
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -536,7 +536,7 @@ export const se_VerifySessionCommand = async (input, context) => {
536
536
  };
537
537
  export const de_CreateAccessTokenCommand = async (output, context) => {
538
538
  if (output.statusCode !== 201 && output.statusCode >= 300) {
539
- return de_CreateAccessTokenCommandError(output, context);
539
+ return de_CommandError(output, context);
540
540
  }
541
541
  const contents = map({
542
542
  $metadata: deserializeMetadata(output),
@@ -551,43 +551,9 @@ export const de_CreateAccessTokenCommand = async (output, context) => {
551
551
  Object.assign(contents, doc);
552
552
  return contents;
553
553
  };
554
- const de_CreateAccessTokenCommandError = async (output, context) => {
555
- const parsedOutput = {
556
- ...output,
557
- body: await parseErrorBody(output.body, context),
558
- };
559
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
560
- switch (errorCode) {
561
- case "AccessDeniedException":
562
- case "com.amazonaws.codecatalyst#AccessDeniedException":
563
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
564
- case "ConflictException":
565
- case "com.amazonaws.codecatalyst#ConflictException":
566
- throw await de_ConflictExceptionRes(parsedOutput, context);
567
- case "ResourceNotFoundException":
568
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
569
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
570
- case "ServiceQuotaExceededException":
571
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
572
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
573
- case "ThrottlingException":
574
- case "com.amazonaws.codecatalyst#ThrottlingException":
575
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
576
- case "ValidationException":
577
- case "com.amazonaws.codecatalyst#ValidationException":
578
- throw await de_ValidationExceptionRes(parsedOutput, context);
579
- default:
580
- const parsedBody = parsedOutput.body;
581
- return throwDefaultError({
582
- output,
583
- parsedBody,
584
- errorCode,
585
- });
586
- }
587
- };
588
554
  export const de_CreateDevEnvironmentCommand = async (output, context) => {
589
555
  if (output.statusCode !== 201 && output.statusCode >= 300) {
590
- return de_CreateDevEnvironmentCommandError(output, context);
556
+ return de_CommandError(output, context);
591
557
  }
592
558
  const contents = map({
593
559
  $metadata: deserializeMetadata(output),
@@ -602,43 +568,9 @@ export const de_CreateDevEnvironmentCommand = async (output, context) => {
602
568
  Object.assign(contents, doc);
603
569
  return contents;
604
570
  };
605
- const de_CreateDevEnvironmentCommandError = async (output, context) => {
606
- const parsedOutput = {
607
- ...output,
608
- body: await parseErrorBody(output.body, context),
609
- };
610
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
611
- switch (errorCode) {
612
- case "AccessDeniedException":
613
- case "com.amazonaws.codecatalyst#AccessDeniedException":
614
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
615
- case "ConflictException":
616
- case "com.amazonaws.codecatalyst#ConflictException":
617
- throw await de_ConflictExceptionRes(parsedOutput, context);
618
- case "ResourceNotFoundException":
619
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
620
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
621
- case "ServiceQuotaExceededException":
622
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
623
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
624
- case "ThrottlingException":
625
- case "com.amazonaws.codecatalyst#ThrottlingException":
626
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
627
- case "ValidationException":
628
- case "com.amazonaws.codecatalyst#ValidationException":
629
- throw await de_ValidationExceptionRes(parsedOutput, context);
630
- default:
631
- const parsedBody = parsedOutput.body;
632
- return throwDefaultError({
633
- output,
634
- parsedBody,
635
- errorCode,
636
- });
637
- }
638
- };
639
571
  export const de_CreateProjectCommand = async (output, context) => {
640
572
  if (output.statusCode !== 201 && output.statusCode >= 300) {
641
- return de_CreateProjectCommandError(output, context);
573
+ return de_CommandError(output, context);
642
574
  }
643
575
  const contents = map({
644
576
  $metadata: deserializeMetadata(output),
@@ -653,43 +585,9 @@ export const de_CreateProjectCommand = async (output, context) => {
653
585
  Object.assign(contents, doc);
654
586
  return contents;
655
587
  };
656
- const de_CreateProjectCommandError = async (output, context) => {
657
- const parsedOutput = {
658
- ...output,
659
- body: await parseErrorBody(output.body, context),
660
- };
661
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
662
- switch (errorCode) {
663
- case "AccessDeniedException":
664
- case "com.amazonaws.codecatalyst#AccessDeniedException":
665
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
666
- case "ConflictException":
667
- case "com.amazonaws.codecatalyst#ConflictException":
668
- throw await de_ConflictExceptionRes(parsedOutput, context);
669
- case "ResourceNotFoundException":
670
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
671
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
672
- case "ServiceQuotaExceededException":
673
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
674
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
675
- case "ThrottlingException":
676
- case "com.amazonaws.codecatalyst#ThrottlingException":
677
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
678
- case "ValidationException":
679
- case "com.amazonaws.codecatalyst#ValidationException":
680
- throw await de_ValidationExceptionRes(parsedOutput, context);
681
- default:
682
- const parsedBody = parsedOutput.body;
683
- return throwDefaultError({
684
- output,
685
- parsedBody,
686
- errorCode,
687
- });
688
- }
689
- };
690
588
  export const de_CreateSourceRepositoryCommand = async (output, context) => {
691
589
  if (output.statusCode !== 201 && output.statusCode >= 300) {
692
- return de_CreateSourceRepositoryCommandError(output, context);
590
+ return de_CommandError(output, context);
693
591
  }
694
592
  const contents = map({
695
593
  $metadata: deserializeMetadata(output),
@@ -704,43 +602,9 @@ export const de_CreateSourceRepositoryCommand = async (output, context) => {
704
602
  Object.assign(contents, doc);
705
603
  return contents;
706
604
  };
707
- const de_CreateSourceRepositoryCommandError = async (output, context) => {
708
- const parsedOutput = {
709
- ...output,
710
- body: await parseErrorBody(output.body, context),
711
- };
712
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
713
- switch (errorCode) {
714
- case "AccessDeniedException":
715
- case "com.amazonaws.codecatalyst#AccessDeniedException":
716
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
717
- case "ConflictException":
718
- case "com.amazonaws.codecatalyst#ConflictException":
719
- throw await de_ConflictExceptionRes(parsedOutput, context);
720
- case "ResourceNotFoundException":
721
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
722
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
723
- case "ServiceQuotaExceededException":
724
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
725
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
726
- case "ThrottlingException":
727
- case "com.amazonaws.codecatalyst#ThrottlingException":
728
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
729
- case "ValidationException":
730
- case "com.amazonaws.codecatalyst#ValidationException":
731
- throw await de_ValidationExceptionRes(parsedOutput, context);
732
- default:
733
- const parsedBody = parsedOutput.body;
734
- return throwDefaultError({
735
- output,
736
- parsedBody,
737
- errorCode,
738
- });
739
- }
740
- };
741
605
  export const de_CreateSourceRepositoryBranchCommand = async (output, context) => {
742
606
  if (output.statusCode !== 201 && output.statusCode >= 300) {
743
- return de_CreateSourceRepositoryBranchCommandError(output, context);
607
+ return de_CommandError(output, context);
744
608
  }
745
609
  const contents = map({
746
610
  $metadata: deserializeMetadata(output),
@@ -755,43 +619,9 @@ export const de_CreateSourceRepositoryBranchCommand = async (output, context) =>
755
619
  Object.assign(contents, doc);
756
620
  return contents;
757
621
  };
758
- const de_CreateSourceRepositoryBranchCommandError = async (output, context) => {
759
- const parsedOutput = {
760
- ...output,
761
- body: await parseErrorBody(output.body, context),
762
- };
763
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
764
- switch (errorCode) {
765
- case "AccessDeniedException":
766
- case "com.amazonaws.codecatalyst#AccessDeniedException":
767
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
768
- case "ConflictException":
769
- case "com.amazonaws.codecatalyst#ConflictException":
770
- throw await de_ConflictExceptionRes(parsedOutput, context);
771
- case "ResourceNotFoundException":
772
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
773
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
774
- case "ServiceQuotaExceededException":
775
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
776
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
777
- case "ThrottlingException":
778
- case "com.amazonaws.codecatalyst#ThrottlingException":
779
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
780
- case "ValidationException":
781
- case "com.amazonaws.codecatalyst#ValidationException":
782
- throw await de_ValidationExceptionRes(parsedOutput, context);
783
- default:
784
- const parsedBody = parsedOutput.body;
785
- return throwDefaultError({
786
- output,
787
- parsedBody,
788
- errorCode,
789
- });
790
- }
791
- };
792
622
  export const de_DeleteAccessTokenCommand = async (output, context) => {
793
623
  if (output.statusCode !== 200 && output.statusCode >= 300) {
794
- return de_DeleteAccessTokenCommandError(output, context);
624
+ return de_CommandError(output, context);
795
625
  }
796
626
  const contents = map({
797
627
  $metadata: deserializeMetadata(output),
@@ -799,43 +629,9 @@ export const de_DeleteAccessTokenCommand = async (output, context) => {
799
629
  await collectBody(output.body, context);
800
630
  return contents;
801
631
  };
802
- const de_DeleteAccessTokenCommandError = async (output, context) => {
803
- const parsedOutput = {
804
- ...output,
805
- body: await parseErrorBody(output.body, context),
806
- };
807
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
808
- switch (errorCode) {
809
- case "AccessDeniedException":
810
- case "com.amazonaws.codecatalyst#AccessDeniedException":
811
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
812
- case "ConflictException":
813
- case "com.amazonaws.codecatalyst#ConflictException":
814
- throw await de_ConflictExceptionRes(parsedOutput, context);
815
- case "ResourceNotFoundException":
816
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
817
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
818
- case "ServiceQuotaExceededException":
819
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
820
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
821
- case "ThrottlingException":
822
- case "com.amazonaws.codecatalyst#ThrottlingException":
823
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
824
- case "ValidationException":
825
- case "com.amazonaws.codecatalyst#ValidationException":
826
- throw await de_ValidationExceptionRes(parsedOutput, context);
827
- default:
828
- const parsedBody = parsedOutput.body;
829
- return throwDefaultError({
830
- output,
831
- parsedBody,
832
- errorCode,
833
- });
834
- }
835
- };
836
632
  export const de_DeleteDevEnvironmentCommand = async (output, context) => {
837
633
  if (output.statusCode !== 200 && output.statusCode >= 300) {
838
- return de_DeleteDevEnvironmentCommandError(output, context);
634
+ return de_CommandError(output, context);
839
635
  }
840
636
  const contents = map({
841
637
  $metadata: deserializeMetadata(output),
@@ -849,43 +645,9 @@ export const de_DeleteDevEnvironmentCommand = async (output, context) => {
849
645
  Object.assign(contents, doc);
850
646
  return contents;
851
647
  };
852
- const de_DeleteDevEnvironmentCommandError = async (output, context) => {
853
- const parsedOutput = {
854
- ...output,
855
- body: await parseErrorBody(output.body, context),
856
- };
857
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
858
- switch (errorCode) {
859
- case "AccessDeniedException":
860
- case "com.amazonaws.codecatalyst#AccessDeniedException":
861
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
862
- case "ConflictException":
863
- case "com.amazonaws.codecatalyst#ConflictException":
864
- throw await de_ConflictExceptionRes(parsedOutput, context);
865
- case "ResourceNotFoundException":
866
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
867
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
868
- case "ServiceQuotaExceededException":
869
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
870
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
871
- case "ThrottlingException":
872
- case "com.amazonaws.codecatalyst#ThrottlingException":
873
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
874
- case "ValidationException":
875
- case "com.amazonaws.codecatalyst#ValidationException":
876
- throw await de_ValidationExceptionRes(parsedOutput, context);
877
- default:
878
- const parsedBody = parsedOutput.body;
879
- return throwDefaultError({
880
- output,
881
- parsedBody,
882
- errorCode,
883
- });
884
- }
885
- };
886
648
  export const de_DeleteProjectCommand = async (output, context) => {
887
649
  if (output.statusCode !== 200 && output.statusCode >= 300) {
888
- return de_DeleteProjectCommandError(output, context);
650
+ return de_CommandError(output, context);
889
651
  }
890
652
  const contents = map({
891
653
  $metadata: deserializeMetadata(output),
@@ -899,43 +661,9 @@ export const de_DeleteProjectCommand = async (output, context) => {
899
661
  Object.assign(contents, doc);
900
662
  return contents;
901
663
  };
902
- const de_DeleteProjectCommandError = async (output, context) => {
903
- const parsedOutput = {
904
- ...output,
905
- body: await parseErrorBody(output.body, context),
906
- };
907
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
908
- switch (errorCode) {
909
- case "AccessDeniedException":
910
- case "com.amazonaws.codecatalyst#AccessDeniedException":
911
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
912
- case "ConflictException":
913
- case "com.amazonaws.codecatalyst#ConflictException":
914
- throw await de_ConflictExceptionRes(parsedOutput, context);
915
- case "ResourceNotFoundException":
916
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
917
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
918
- case "ServiceQuotaExceededException":
919
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
920
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
921
- case "ThrottlingException":
922
- case "com.amazonaws.codecatalyst#ThrottlingException":
923
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
924
- case "ValidationException":
925
- case "com.amazonaws.codecatalyst#ValidationException":
926
- throw await de_ValidationExceptionRes(parsedOutput, context);
927
- default:
928
- const parsedBody = parsedOutput.body;
929
- return throwDefaultError({
930
- output,
931
- parsedBody,
932
- errorCode,
933
- });
934
- }
935
- };
936
664
  export const de_DeleteSourceRepositoryCommand = async (output, context) => {
937
665
  if (output.statusCode !== 200 && output.statusCode >= 300) {
938
- return de_DeleteSourceRepositoryCommandError(output, context);
666
+ return de_CommandError(output, context);
939
667
  }
940
668
  const contents = map({
941
669
  $metadata: deserializeMetadata(output),
@@ -949,43 +677,9 @@ export const de_DeleteSourceRepositoryCommand = async (output, context) => {
949
677
  Object.assign(contents, doc);
950
678
  return contents;
951
679
  };
952
- const de_DeleteSourceRepositoryCommandError = async (output, context) => {
953
- const parsedOutput = {
954
- ...output,
955
- body: await parseErrorBody(output.body, context),
956
- };
957
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
958
- switch (errorCode) {
959
- case "AccessDeniedException":
960
- case "com.amazonaws.codecatalyst#AccessDeniedException":
961
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
962
- case "ConflictException":
963
- case "com.amazonaws.codecatalyst#ConflictException":
964
- throw await de_ConflictExceptionRes(parsedOutput, context);
965
- case "ResourceNotFoundException":
966
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
967
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
968
- case "ServiceQuotaExceededException":
969
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
970
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
971
- case "ThrottlingException":
972
- case "com.amazonaws.codecatalyst#ThrottlingException":
973
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
974
- case "ValidationException":
975
- case "com.amazonaws.codecatalyst#ValidationException":
976
- throw await de_ValidationExceptionRes(parsedOutput, context);
977
- default:
978
- const parsedBody = parsedOutput.body;
979
- return throwDefaultError({
980
- output,
981
- parsedBody,
982
- errorCode,
983
- });
984
- }
985
- };
986
680
  export const de_DeleteSpaceCommand = async (output, context) => {
987
681
  if (output.statusCode !== 200 && output.statusCode >= 300) {
988
- return de_DeleteSpaceCommandError(output, context);
682
+ return de_CommandError(output, context);
989
683
  }
990
684
  const contents = map({
991
685
  $metadata: deserializeMetadata(output),
@@ -998,43 +692,9 @@ export const de_DeleteSpaceCommand = async (output, context) => {
998
692
  Object.assign(contents, doc);
999
693
  return contents;
1000
694
  };
1001
- const de_DeleteSpaceCommandError = async (output, context) => {
1002
- const parsedOutput = {
1003
- ...output,
1004
- body: await parseErrorBody(output.body, context),
1005
- };
1006
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1007
- switch (errorCode) {
1008
- case "AccessDeniedException":
1009
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1010
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1011
- case "ConflictException":
1012
- case "com.amazonaws.codecatalyst#ConflictException":
1013
- throw await de_ConflictExceptionRes(parsedOutput, context);
1014
- case "ResourceNotFoundException":
1015
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1016
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1017
- case "ServiceQuotaExceededException":
1018
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1019
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1020
- case "ThrottlingException":
1021
- case "com.amazonaws.codecatalyst#ThrottlingException":
1022
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1023
- case "ValidationException":
1024
- case "com.amazonaws.codecatalyst#ValidationException":
1025
- throw await de_ValidationExceptionRes(parsedOutput, context);
1026
- default:
1027
- const parsedBody = parsedOutput.body;
1028
- return throwDefaultError({
1029
- output,
1030
- parsedBody,
1031
- errorCode,
1032
- });
1033
- }
1034
- };
1035
695
  export const de_GetDevEnvironmentCommand = async (output, context) => {
1036
696
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1037
- return de_GetDevEnvironmentCommandError(output, context);
697
+ return de_CommandError(output, context);
1038
698
  }
1039
699
  const contents = map({
1040
700
  $metadata: deserializeMetadata(output),
@@ -1059,43 +719,9 @@ export const de_GetDevEnvironmentCommand = async (output, context) => {
1059
719
  Object.assign(contents, doc);
1060
720
  return contents;
1061
721
  };
1062
- const de_GetDevEnvironmentCommandError = async (output, context) => {
1063
- const parsedOutput = {
1064
- ...output,
1065
- body: await parseErrorBody(output.body, context),
1066
- };
1067
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1068
- switch (errorCode) {
1069
- case "AccessDeniedException":
1070
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1071
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1072
- case "ConflictException":
1073
- case "com.amazonaws.codecatalyst#ConflictException":
1074
- throw await de_ConflictExceptionRes(parsedOutput, context);
1075
- case "ResourceNotFoundException":
1076
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1077
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1078
- case "ServiceQuotaExceededException":
1079
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1080
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1081
- case "ThrottlingException":
1082
- case "com.amazonaws.codecatalyst#ThrottlingException":
1083
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1084
- case "ValidationException":
1085
- case "com.amazonaws.codecatalyst#ValidationException":
1086
- throw await de_ValidationExceptionRes(parsedOutput, context);
1087
- default:
1088
- const parsedBody = parsedOutput.body;
1089
- return throwDefaultError({
1090
- output,
1091
- parsedBody,
1092
- errorCode,
1093
- });
1094
- }
1095
- };
1096
722
  export const de_GetProjectCommand = async (output, context) => {
1097
723
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1098
- return de_GetProjectCommandError(output, context);
724
+ return de_CommandError(output, context);
1099
725
  }
1100
726
  const contents = map({
1101
727
  $metadata: deserializeMetadata(output),
@@ -1110,43 +736,9 @@ export const de_GetProjectCommand = async (output, context) => {
1110
736
  Object.assign(contents, doc);
1111
737
  return contents;
1112
738
  };
1113
- const de_GetProjectCommandError = async (output, context) => {
1114
- const parsedOutput = {
1115
- ...output,
1116
- body: await parseErrorBody(output.body, context),
1117
- };
1118
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1119
- switch (errorCode) {
1120
- case "AccessDeniedException":
1121
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1122
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1123
- case "ConflictException":
1124
- case "com.amazonaws.codecatalyst#ConflictException":
1125
- throw await de_ConflictExceptionRes(parsedOutput, context);
1126
- case "ResourceNotFoundException":
1127
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1128
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1129
- case "ServiceQuotaExceededException":
1130
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1131
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1132
- case "ThrottlingException":
1133
- case "com.amazonaws.codecatalyst#ThrottlingException":
1134
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1135
- case "ValidationException":
1136
- case "com.amazonaws.codecatalyst#ValidationException":
1137
- throw await de_ValidationExceptionRes(parsedOutput, context);
1138
- default:
1139
- const parsedBody = parsedOutput.body;
1140
- return throwDefaultError({
1141
- output,
1142
- parsedBody,
1143
- errorCode,
1144
- });
1145
- }
1146
- };
1147
739
  export const de_GetSourceRepositoryCommand = async (output, context) => {
1148
740
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1149
- return de_GetSourceRepositoryCommandError(output, context);
741
+ return de_CommandError(output, context);
1150
742
  }
1151
743
  const contents = map({
1152
744
  $metadata: deserializeMetadata(output),
@@ -1163,43 +755,9 @@ export const de_GetSourceRepositoryCommand = async (output, context) => {
1163
755
  Object.assign(contents, doc);
1164
756
  return contents;
1165
757
  };
1166
- const de_GetSourceRepositoryCommandError = async (output, context) => {
1167
- const parsedOutput = {
1168
- ...output,
1169
- body: await parseErrorBody(output.body, context),
1170
- };
1171
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1172
- switch (errorCode) {
1173
- case "AccessDeniedException":
1174
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1175
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1176
- case "ConflictException":
1177
- case "com.amazonaws.codecatalyst#ConflictException":
1178
- throw await de_ConflictExceptionRes(parsedOutput, context);
1179
- case "ResourceNotFoundException":
1180
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1181
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1182
- case "ServiceQuotaExceededException":
1183
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1184
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1185
- case "ThrottlingException":
1186
- case "com.amazonaws.codecatalyst#ThrottlingException":
1187
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1188
- case "ValidationException":
1189
- case "com.amazonaws.codecatalyst#ValidationException":
1190
- throw await de_ValidationExceptionRes(parsedOutput, context);
1191
- default:
1192
- const parsedBody = parsedOutput.body;
1193
- return throwDefaultError({
1194
- output,
1195
- parsedBody,
1196
- errorCode,
1197
- });
1198
- }
1199
- };
1200
758
  export const de_GetSourceRepositoryCloneUrlsCommand = async (output, context) => {
1201
759
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1202
- return de_GetSourceRepositoryCloneUrlsCommandError(output, context);
760
+ return de_CommandError(output, context);
1203
761
  }
1204
762
  const contents = map({
1205
763
  $metadata: deserializeMetadata(output),
@@ -1211,43 +769,9 @@ export const de_GetSourceRepositoryCloneUrlsCommand = async (output, context) =>
1211
769
  Object.assign(contents, doc);
1212
770
  return contents;
1213
771
  };
1214
- const de_GetSourceRepositoryCloneUrlsCommandError = async (output, context) => {
1215
- const parsedOutput = {
1216
- ...output,
1217
- body: await parseErrorBody(output.body, context),
1218
- };
1219
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1220
- switch (errorCode) {
1221
- case "AccessDeniedException":
1222
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1223
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1224
- case "ConflictException":
1225
- case "com.amazonaws.codecatalyst#ConflictException":
1226
- throw await de_ConflictExceptionRes(parsedOutput, context);
1227
- case "ResourceNotFoundException":
1228
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1229
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1230
- case "ServiceQuotaExceededException":
1231
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1232
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1233
- case "ThrottlingException":
1234
- case "com.amazonaws.codecatalyst#ThrottlingException":
1235
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1236
- case "ValidationException":
1237
- case "com.amazonaws.codecatalyst#ValidationException":
1238
- throw await de_ValidationExceptionRes(parsedOutput, context);
1239
- default:
1240
- const parsedBody = parsedOutput.body;
1241
- return throwDefaultError({
1242
- output,
1243
- parsedBody,
1244
- errorCode,
1245
- });
1246
- }
1247
- };
1248
772
  export const de_GetSpaceCommand = async (output, context) => {
1249
773
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1250
- return de_GetSpaceCommandError(output, context);
774
+ return de_CommandError(output, context);
1251
775
  }
1252
776
  const contents = map({
1253
777
  $metadata: deserializeMetadata(output),
@@ -1262,43 +786,9 @@ export const de_GetSpaceCommand = async (output, context) => {
1262
786
  Object.assign(contents, doc);
1263
787
  return contents;
1264
788
  };
1265
- const de_GetSpaceCommandError = async (output, context) => {
1266
- const parsedOutput = {
1267
- ...output,
1268
- body: await parseErrorBody(output.body, context),
1269
- };
1270
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1271
- switch (errorCode) {
1272
- case "AccessDeniedException":
1273
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1274
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1275
- case "ConflictException":
1276
- case "com.amazonaws.codecatalyst#ConflictException":
1277
- throw await de_ConflictExceptionRes(parsedOutput, context);
1278
- case "ResourceNotFoundException":
1279
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1280
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1281
- case "ServiceQuotaExceededException":
1282
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1283
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1284
- case "ThrottlingException":
1285
- case "com.amazonaws.codecatalyst#ThrottlingException":
1286
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1287
- case "ValidationException":
1288
- case "com.amazonaws.codecatalyst#ValidationException":
1289
- throw await de_ValidationExceptionRes(parsedOutput, context);
1290
- default:
1291
- const parsedBody = parsedOutput.body;
1292
- return throwDefaultError({
1293
- output,
1294
- parsedBody,
1295
- errorCode,
1296
- });
1297
- }
1298
- };
1299
789
  export const de_GetSubscriptionCommand = async (output, context) => {
1300
790
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1301
- return de_GetSubscriptionCommandError(output, context);
791
+ return de_CommandError(output, context);
1302
792
  }
1303
793
  const contents = map({
1304
794
  $metadata: deserializeMetadata(output),
@@ -1311,43 +801,9 @@ export const de_GetSubscriptionCommand = async (output, context) => {
1311
801
  Object.assign(contents, doc);
1312
802
  return contents;
1313
803
  };
1314
- const de_GetSubscriptionCommandError = async (output, context) => {
1315
- const parsedOutput = {
1316
- ...output,
1317
- body: await parseErrorBody(output.body, context),
1318
- };
1319
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1320
- switch (errorCode) {
1321
- case "AccessDeniedException":
1322
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1323
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1324
- case "ConflictException":
1325
- case "com.amazonaws.codecatalyst#ConflictException":
1326
- throw await de_ConflictExceptionRes(parsedOutput, context);
1327
- case "ResourceNotFoundException":
1328
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1329
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1330
- case "ServiceQuotaExceededException":
1331
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1332
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1333
- case "ThrottlingException":
1334
- case "com.amazonaws.codecatalyst#ThrottlingException":
1335
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1336
- case "ValidationException":
1337
- case "com.amazonaws.codecatalyst#ValidationException":
1338
- throw await de_ValidationExceptionRes(parsedOutput, context);
1339
- default:
1340
- const parsedBody = parsedOutput.body;
1341
- return throwDefaultError({
1342
- output,
1343
- parsedBody,
1344
- errorCode,
1345
- });
1346
- }
1347
- };
1348
804
  export const de_GetUserDetailsCommand = async (output, context) => {
1349
805
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1350
- return de_GetUserDetailsCommandError(output, context);
806
+ return de_CommandError(output, context);
1351
807
  }
1352
808
  const contents = map({
1353
809
  $metadata: deserializeMetadata(output),
@@ -1363,43 +819,9 @@ export const de_GetUserDetailsCommand = async (output, context) => {
1363
819
  Object.assign(contents, doc);
1364
820
  return contents;
1365
821
  };
1366
- const de_GetUserDetailsCommandError = async (output, context) => {
1367
- const parsedOutput = {
1368
- ...output,
1369
- body: await parseErrorBody(output.body, context),
1370
- };
1371
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1372
- switch (errorCode) {
1373
- case "AccessDeniedException":
1374
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1375
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1376
- case "ConflictException":
1377
- case "com.amazonaws.codecatalyst#ConflictException":
1378
- throw await de_ConflictExceptionRes(parsedOutput, context);
1379
- case "ResourceNotFoundException":
1380
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1381
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1382
- case "ServiceQuotaExceededException":
1383
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1384
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1385
- case "ThrottlingException":
1386
- case "com.amazonaws.codecatalyst#ThrottlingException":
1387
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1388
- case "ValidationException":
1389
- case "com.amazonaws.codecatalyst#ValidationException":
1390
- throw await de_ValidationExceptionRes(parsedOutput, context);
1391
- default:
1392
- const parsedBody = parsedOutput.body;
1393
- return throwDefaultError({
1394
- output,
1395
- parsedBody,
1396
- errorCode,
1397
- });
1398
- }
1399
- };
1400
822
  export const de_GetWorkflowCommand = async (output, context) => {
1401
823
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1402
- return de_GetWorkflowCommandError(output, context);
824
+ return de_CommandError(output, context);
1403
825
  }
1404
826
  const contents = map({
1405
827
  $metadata: deserializeMetadata(output),
@@ -1421,43 +843,9 @@ export const de_GetWorkflowCommand = async (output, context) => {
1421
843
  Object.assign(contents, doc);
1422
844
  return contents;
1423
845
  };
1424
- const de_GetWorkflowCommandError = async (output, context) => {
1425
- const parsedOutput = {
1426
- ...output,
1427
- body: await parseErrorBody(output.body, context),
1428
- };
1429
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1430
- switch (errorCode) {
1431
- case "AccessDeniedException":
1432
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1433
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1434
- case "ConflictException":
1435
- case "com.amazonaws.codecatalyst#ConflictException":
1436
- throw await de_ConflictExceptionRes(parsedOutput, context);
1437
- case "ResourceNotFoundException":
1438
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1439
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1440
- case "ServiceQuotaExceededException":
1441
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1442
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1443
- case "ThrottlingException":
1444
- case "com.amazonaws.codecatalyst#ThrottlingException":
1445
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1446
- case "ValidationException":
1447
- case "com.amazonaws.codecatalyst#ValidationException":
1448
- throw await de_ValidationExceptionRes(parsedOutput, context);
1449
- default:
1450
- const parsedBody = parsedOutput.body;
1451
- return throwDefaultError({
1452
- output,
1453
- parsedBody,
1454
- errorCode,
1455
- });
1456
- }
1457
- };
1458
846
  export const de_GetWorkflowRunCommand = async (output, context) => {
1459
847
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1460
- return de_GetWorkflowRunCommandError(output, context);
848
+ return de_CommandError(output, context);
1461
849
  }
1462
850
  const contents = map({
1463
851
  $metadata: deserializeMetadata(output),
@@ -1477,43 +865,9 @@ export const de_GetWorkflowRunCommand = async (output, context) => {
1477
865
  Object.assign(contents, doc);
1478
866
  return contents;
1479
867
  };
1480
- const de_GetWorkflowRunCommandError = async (output, context) => {
1481
- const parsedOutput = {
1482
- ...output,
1483
- body: await parseErrorBody(output.body, context),
1484
- };
1485
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1486
- switch (errorCode) {
1487
- case "AccessDeniedException":
1488
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1489
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1490
- case "ConflictException":
1491
- case "com.amazonaws.codecatalyst#ConflictException":
1492
- throw await de_ConflictExceptionRes(parsedOutput, context);
1493
- case "ResourceNotFoundException":
1494
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1495
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1496
- case "ServiceQuotaExceededException":
1497
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1498
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1499
- case "ThrottlingException":
1500
- case "com.amazonaws.codecatalyst#ThrottlingException":
1501
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1502
- case "ValidationException":
1503
- case "com.amazonaws.codecatalyst#ValidationException":
1504
- throw await de_ValidationExceptionRes(parsedOutput, context);
1505
- default:
1506
- const parsedBody = parsedOutput.body;
1507
- return throwDefaultError({
1508
- output,
1509
- parsedBody,
1510
- errorCode,
1511
- });
1512
- }
1513
- };
1514
868
  export const de_ListAccessTokensCommand = async (output, context) => {
1515
869
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1516
- return de_ListAccessTokensCommandError(output, context);
870
+ return de_CommandError(output, context);
1517
871
  }
1518
872
  const contents = map({
1519
873
  $metadata: deserializeMetadata(output),
@@ -1526,43 +880,9 @@ export const de_ListAccessTokensCommand = async (output, context) => {
1526
880
  Object.assign(contents, doc);
1527
881
  return contents;
1528
882
  };
1529
- const de_ListAccessTokensCommandError = async (output, context) => {
1530
- const parsedOutput = {
1531
- ...output,
1532
- body: await parseErrorBody(output.body, context),
1533
- };
1534
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1535
- switch (errorCode) {
1536
- case "AccessDeniedException":
1537
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1538
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1539
- case "ConflictException":
1540
- case "com.amazonaws.codecatalyst#ConflictException":
1541
- throw await de_ConflictExceptionRes(parsedOutput, context);
1542
- case "ResourceNotFoundException":
1543
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1544
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1545
- case "ServiceQuotaExceededException":
1546
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1547
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1548
- case "ThrottlingException":
1549
- case "com.amazonaws.codecatalyst#ThrottlingException":
1550
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1551
- case "ValidationException":
1552
- case "com.amazonaws.codecatalyst#ValidationException":
1553
- throw await de_ValidationExceptionRes(parsedOutput, context);
1554
- default:
1555
- const parsedBody = parsedOutput.body;
1556
- return throwDefaultError({
1557
- output,
1558
- parsedBody,
1559
- errorCode,
1560
- });
1561
- }
1562
- };
1563
883
  export const de_ListDevEnvironmentsCommand = async (output, context) => {
1564
884
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1565
- return de_ListDevEnvironmentsCommandError(output, context);
885
+ return de_CommandError(output, context);
1566
886
  }
1567
887
  const contents = map({
1568
888
  $metadata: deserializeMetadata(output),
@@ -1575,43 +895,9 @@ export const de_ListDevEnvironmentsCommand = async (output, context) => {
1575
895
  Object.assign(contents, doc);
1576
896
  return contents;
1577
897
  };
1578
- const de_ListDevEnvironmentsCommandError = async (output, context) => {
1579
- const parsedOutput = {
1580
- ...output,
1581
- body: await parseErrorBody(output.body, context),
1582
- };
1583
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1584
- switch (errorCode) {
1585
- case "AccessDeniedException":
1586
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1587
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1588
- case "ConflictException":
1589
- case "com.amazonaws.codecatalyst#ConflictException":
1590
- throw await de_ConflictExceptionRes(parsedOutput, context);
1591
- case "ResourceNotFoundException":
1592
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1593
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1594
- case "ServiceQuotaExceededException":
1595
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1596
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1597
- case "ThrottlingException":
1598
- case "com.amazonaws.codecatalyst#ThrottlingException":
1599
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1600
- case "ValidationException":
1601
- case "com.amazonaws.codecatalyst#ValidationException":
1602
- throw await de_ValidationExceptionRes(parsedOutput, context);
1603
- default:
1604
- const parsedBody = parsedOutput.body;
1605
- return throwDefaultError({
1606
- output,
1607
- parsedBody,
1608
- errorCode,
1609
- });
1610
- }
1611
- };
1612
898
  export const de_ListDevEnvironmentSessionsCommand = async (output, context) => {
1613
899
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1614
- return de_ListDevEnvironmentSessionsCommandError(output, context);
900
+ return de_CommandError(output, context);
1615
901
  }
1616
902
  const contents = map({
1617
903
  $metadata: deserializeMetadata(output),
@@ -1624,43 +910,9 @@ export const de_ListDevEnvironmentSessionsCommand = async (output, context) => {
1624
910
  Object.assign(contents, doc);
1625
911
  return contents;
1626
912
  };
1627
- const de_ListDevEnvironmentSessionsCommandError = async (output, context) => {
1628
- const parsedOutput = {
1629
- ...output,
1630
- body: await parseErrorBody(output.body, context),
1631
- };
1632
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1633
- switch (errorCode) {
1634
- case "AccessDeniedException":
1635
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1636
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1637
- case "ConflictException":
1638
- case "com.amazonaws.codecatalyst#ConflictException":
1639
- throw await de_ConflictExceptionRes(parsedOutput, context);
1640
- case "ResourceNotFoundException":
1641
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1642
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1643
- case "ServiceQuotaExceededException":
1644
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1645
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1646
- case "ThrottlingException":
1647
- case "com.amazonaws.codecatalyst#ThrottlingException":
1648
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1649
- case "ValidationException":
1650
- case "com.amazonaws.codecatalyst#ValidationException":
1651
- throw await de_ValidationExceptionRes(parsedOutput, context);
1652
- default:
1653
- const parsedBody = parsedOutput.body;
1654
- return throwDefaultError({
1655
- output,
1656
- parsedBody,
1657
- errorCode,
1658
- });
1659
- }
1660
- };
1661
913
  export const de_ListEventLogsCommand = async (output, context) => {
1662
914
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1663
- return de_ListEventLogsCommandError(output, context);
915
+ return de_CommandError(output, context);
1664
916
  }
1665
917
  const contents = map({
1666
918
  $metadata: deserializeMetadata(output),
@@ -1673,43 +925,9 @@ export const de_ListEventLogsCommand = async (output, context) => {
1673
925
  Object.assign(contents, doc);
1674
926
  return contents;
1675
927
  };
1676
- const de_ListEventLogsCommandError = async (output, context) => {
1677
- const parsedOutput = {
1678
- ...output,
1679
- body: await parseErrorBody(output.body, context),
1680
- };
1681
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1682
- switch (errorCode) {
1683
- case "AccessDeniedException":
1684
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1685
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1686
- case "ConflictException":
1687
- case "com.amazonaws.codecatalyst#ConflictException":
1688
- throw await de_ConflictExceptionRes(parsedOutput, context);
1689
- case "ResourceNotFoundException":
1690
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1691
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1692
- case "ServiceQuotaExceededException":
1693
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1694
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1695
- case "ThrottlingException":
1696
- case "com.amazonaws.codecatalyst#ThrottlingException":
1697
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1698
- case "ValidationException":
1699
- case "com.amazonaws.codecatalyst#ValidationException":
1700
- throw await de_ValidationExceptionRes(parsedOutput, context);
1701
- default:
1702
- const parsedBody = parsedOutput.body;
1703
- return throwDefaultError({
1704
- output,
1705
- parsedBody,
1706
- errorCode,
1707
- });
1708
- }
1709
- };
1710
928
  export const de_ListProjectsCommand = async (output, context) => {
1711
929
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1712
- return de_ListProjectsCommandError(output, context);
930
+ return de_CommandError(output, context);
1713
931
  }
1714
932
  const contents = map({
1715
933
  $metadata: deserializeMetadata(output),
@@ -1722,43 +940,9 @@ export const de_ListProjectsCommand = async (output, context) => {
1722
940
  Object.assign(contents, doc);
1723
941
  return contents;
1724
942
  };
1725
- const de_ListProjectsCommandError = async (output, context) => {
1726
- const parsedOutput = {
1727
- ...output,
1728
- body: await parseErrorBody(output.body, context),
1729
- };
1730
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1731
- switch (errorCode) {
1732
- case "AccessDeniedException":
1733
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1734
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1735
- case "ConflictException":
1736
- case "com.amazonaws.codecatalyst#ConflictException":
1737
- throw await de_ConflictExceptionRes(parsedOutput, context);
1738
- case "ResourceNotFoundException":
1739
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1740
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1741
- case "ServiceQuotaExceededException":
1742
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1743
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1744
- case "ThrottlingException":
1745
- case "com.amazonaws.codecatalyst#ThrottlingException":
1746
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1747
- case "ValidationException":
1748
- case "com.amazonaws.codecatalyst#ValidationException":
1749
- throw await de_ValidationExceptionRes(parsedOutput, context);
1750
- default:
1751
- const parsedBody = parsedOutput.body;
1752
- return throwDefaultError({
1753
- output,
1754
- parsedBody,
1755
- errorCode,
1756
- });
1757
- }
1758
- };
1759
943
  export const de_ListSourceRepositoriesCommand = async (output, context) => {
1760
944
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1761
- return de_ListSourceRepositoriesCommandError(output, context);
945
+ return de_CommandError(output, context);
1762
946
  }
1763
947
  const contents = map({
1764
948
  $metadata: deserializeMetadata(output),
@@ -1771,43 +955,9 @@ export const de_ListSourceRepositoriesCommand = async (output, context) => {
1771
955
  Object.assign(contents, doc);
1772
956
  return contents;
1773
957
  };
1774
- const de_ListSourceRepositoriesCommandError = async (output, context) => {
1775
- const parsedOutput = {
1776
- ...output,
1777
- body: await parseErrorBody(output.body, context),
1778
- };
1779
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1780
- switch (errorCode) {
1781
- case "AccessDeniedException":
1782
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1783
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1784
- case "ConflictException":
1785
- case "com.amazonaws.codecatalyst#ConflictException":
1786
- throw await de_ConflictExceptionRes(parsedOutput, context);
1787
- case "ResourceNotFoundException":
1788
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1789
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1790
- case "ServiceQuotaExceededException":
1791
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1792
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1793
- case "ThrottlingException":
1794
- case "com.amazonaws.codecatalyst#ThrottlingException":
1795
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1796
- case "ValidationException":
1797
- case "com.amazonaws.codecatalyst#ValidationException":
1798
- throw await de_ValidationExceptionRes(parsedOutput, context);
1799
- default:
1800
- const parsedBody = parsedOutput.body;
1801
- return throwDefaultError({
1802
- output,
1803
- parsedBody,
1804
- errorCode,
1805
- });
1806
- }
1807
- };
1808
958
  export const de_ListSourceRepositoryBranchesCommand = async (output, context) => {
1809
959
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1810
- return de_ListSourceRepositoryBranchesCommandError(output, context);
960
+ return de_CommandError(output, context);
1811
961
  }
1812
962
  const contents = map({
1813
963
  $metadata: deserializeMetadata(output),
@@ -1820,43 +970,9 @@ export const de_ListSourceRepositoryBranchesCommand = async (output, context) =>
1820
970
  Object.assign(contents, doc);
1821
971
  return contents;
1822
972
  };
1823
- const de_ListSourceRepositoryBranchesCommandError = async (output, context) => {
1824
- const parsedOutput = {
1825
- ...output,
1826
- body: await parseErrorBody(output.body, context),
1827
- };
1828
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1829
- switch (errorCode) {
1830
- case "AccessDeniedException":
1831
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1832
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1833
- case "ConflictException":
1834
- case "com.amazonaws.codecatalyst#ConflictException":
1835
- throw await de_ConflictExceptionRes(parsedOutput, context);
1836
- case "ResourceNotFoundException":
1837
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1838
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1839
- case "ServiceQuotaExceededException":
1840
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1841
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1842
- case "ThrottlingException":
1843
- case "com.amazonaws.codecatalyst#ThrottlingException":
1844
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1845
- case "ValidationException":
1846
- case "com.amazonaws.codecatalyst#ValidationException":
1847
- throw await de_ValidationExceptionRes(parsedOutput, context);
1848
- default:
1849
- const parsedBody = parsedOutput.body;
1850
- return throwDefaultError({
1851
- output,
1852
- parsedBody,
1853
- errorCode,
1854
- });
1855
- }
1856
- };
1857
973
  export const de_ListSpacesCommand = async (output, context) => {
1858
974
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1859
- return de_ListSpacesCommandError(output, context);
975
+ return de_CommandError(output, context);
1860
976
  }
1861
977
  const contents = map({
1862
978
  $metadata: deserializeMetadata(output),
@@ -1869,43 +985,9 @@ export const de_ListSpacesCommand = async (output, context) => {
1869
985
  Object.assign(contents, doc);
1870
986
  return contents;
1871
987
  };
1872
- const de_ListSpacesCommandError = async (output, context) => {
1873
- const parsedOutput = {
1874
- ...output,
1875
- body: await parseErrorBody(output.body, context),
1876
- };
1877
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1878
- switch (errorCode) {
1879
- case "AccessDeniedException":
1880
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1881
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1882
- case "ConflictException":
1883
- case "com.amazonaws.codecatalyst#ConflictException":
1884
- throw await de_ConflictExceptionRes(parsedOutput, context);
1885
- case "ResourceNotFoundException":
1886
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1887
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1888
- case "ServiceQuotaExceededException":
1889
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1890
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1891
- case "ThrottlingException":
1892
- case "com.amazonaws.codecatalyst#ThrottlingException":
1893
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1894
- case "ValidationException":
1895
- case "com.amazonaws.codecatalyst#ValidationException":
1896
- throw await de_ValidationExceptionRes(parsedOutput, context);
1897
- default:
1898
- const parsedBody = parsedOutput.body;
1899
- return throwDefaultError({
1900
- output,
1901
- parsedBody,
1902
- errorCode,
1903
- });
1904
- }
1905
- };
1906
988
  export const de_ListWorkflowRunsCommand = async (output, context) => {
1907
989
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1908
- return de_ListWorkflowRunsCommandError(output, context);
990
+ return de_CommandError(output, context);
1909
991
  }
1910
992
  const contents = map({
1911
993
  $metadata: deserializeMetadata(output),
@@ -1918,143 +1000,41 @@ export const de_ListWorkflowRunsCommand = async (output, context) => {
1918
1000
  Object.assign(contents, doc);
1919
1001
  return contents;
1920
1002
  };
1921
- const de_ListWorkflowRunsCommandError = async (output, context) => {
1922
- const parsedOutput = {
1923
- ...output,
1924
- body: await parseErrorBody(output.body, context),
1925
- };
1926
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1927
- switch (errorCode) {
1928
- case "AccessDeniedException":
1929
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1930
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1931
- case "ConflictException":
1932
- case "com.amazonaws.codecatalyst#ConflictException":
1933
- throw await de_ConflictExceptionRes(parsedOutput, context);
1934
- case "ResourceNotFoundException":
1935
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1936
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1937
- case "ServiceQuotaExceededException":
1938
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1939
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1940
- case "ThrottlingException":
1941
- case "com.amazonaws.codecatalyst#ThrottlingException":
1942
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1943
- case "ValidationException":
1944
- case "com.amazonaws.codecatalyst#ValidationException":
1945
- throw await de_ValidationExceptionRes(parsedOutput, context);
1946
- default:
1947
- const parsedBody = parsedOutput.body;
1948
- return throwDefaultError({
1949
- output,
1950
- parsedBody,
1951
- errorCode,
1952
- });
1953
- }
1954
- };
1955
1003
  export const de_ListWorkflowsCommand = async (output, context) => {
1956
1004
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1957
- return de_ListWorkflowsCommandError(output, context);
1005
+ return de_CommandError(output, context);
1958
1006
  }
1959
- const contents = map({
1960
- $metadata: deserializeMetadata(output),
1961
- });
1962
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1963
- const doc = take(data, {
1964
- items: (_) => de_WorkflowSummaries(_, context),
1965
- nextToken: __expectString,
1966
- });
1967
- Object.assign(contents, doc);
1968
- return contents;
1969
- };
1970
- const de_ListWorkflowsCommandError = async (output, context) => {
1971
- const parsedOutput = {
1972
- ...output,
1973
- body: await parseErrorBody(output.body, context),
1974
- };
1975
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1976
- switch (errorCode) {
1977
- case "AccessDeniedException":
1978
- case "com.amazonaws.codecatalyst#AccessDeniedException":
1979
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1980
- case "ConflictException":
1981
- case "com.amazonaws.codecatalyst#ConflictException":
1982
- throw await de_ConflictExceptionRes(parsedOutput, context);
1983
- case "ResourceNotFoundException":
1984
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
1985
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1986
- case "ServiceQuotaExceededException":
1987
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
1988
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1989
- case "ThrottlingException":
1990
- case "com.amazonaws.codecatalyst#ThrottlingException":
1991
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1992
- case "ValidationException":
1993
- case "com.amazonaws.codecatalyst#ValidationException":
1994
- throw await de_ValidationExceptionRes(parsedOutput, context);
1995
- default:
1996
- const parsedBody = parsedOutput.body;
1997
- return throwDefaultError({
1998
- output,
1999
- parsedBody,
2000
- errorCode,
2001
- });
2002
- }
2003
- };
2004
- export const de_StartDevEnvironmentCommand = async (output, context) => {
2005
- if (output.statusCode !== 200 && output.statusCode >= 300) {
2006
- return de_StartDevEnvironmentCommandError(output, context);
2007
- }
2008
- const contents = map({
2009
- $metadata: deserializeMetadata(output),
2010
- });
2011
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2012
- const doc = take(data, {
2013
- id: __expectString,
2014
- projectName: __expectString,
2015
- spaceName: __expectString,
2016
- status: __expectString,
2017
- });
2018
- Object.assign(contents, doc);
2019
- return contents;
2020
- };
2021
- const de_StartDevEnvironmentCommandError = async (output, context) => {
2022
- const parsedOutput = {
2023
- ...output,
2024
- body: await parseErrorBody(output.body, context),
2025
- };
2026
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2027
- switch (errorCode) {
2028
- case "AccessDeniedException":
2029
- case "com.amazonaws.codecatalyst#AccessDeniedException":
2030
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2031
- case "ConflictException":
2032
- case "com.amazonaws.codecatalyst#ConflictException":
2033
- throw await de_ConflictExceptionRes(parsedOutput, context);
2034
- case "ResourceNotFoundException":
2035
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
2036
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2037
- case "ServiceQuotaExceededException":
2038
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
2039
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2040
- case "ThrottlingException":
2041
- case "com.amazonaws.codecatalyst#ThrottlingException":
2042
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
2043
- case "ValidationException":
2044
- case "com.amazonaws.codecatalyst#ValidationException":
2045
- throw await de_ValidationExceptionRes(parsedOutput, context);
2046
- default:
2047
- const parsedBody = parsedOutput.body;
2048
- return throwDefaultError({
2049
- output,
2050
- parsedBody,
2051
- errorCode,
2052
- });
1007
+ const contents = map({
1008
+ $metadata: deserializeMetadata(output),
1009
+ });
1010
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1011
+ const doc = take(data, {
1012
+ items: (_) => de_WorkflowSummaries(_, context),
1013
+ nextToken: __expectString,
1014
+ });
1015
+ Object.assign(contents, doc);
1016
+ return contents;
1017
+ };
1018
+ export const de_StartDevEnvironmentCommand = async (output, context) => {
1019
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1020
+ return de_CommandError(output, context);
2053
1021
  }
1022
+ const contents = map({
1023
+ $metadata: deserializeMetadata(output),
1024
+ });
1025
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1026
+ const doc = take(data, {
1027
+ id: __expectString,
1028
+ projectName: __expectString,
1029
+ spaceName: __expectString,
1030
+ status: __expectString,
1031
+ });
1032
+ Object.assign(contents, doc);
1033
+ return contents;
2054
1034
  };
2055
1035
  export const de_StartDevEnvironmentSessionCommand = async (output, context) => {
2056
1036
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2057
- return de_StartDevEnvironmentSessionCommandError(output, context);
1037
+ return de_CommandError(output, context);
2058
1038
  }
2059
1039
  const contents = map({
2060
1040
  $metadata: deserializeMetadata(output),
@@ -2070,43 +1050,9 @@ export const de_StartDevEnvironmentSessionCommand = async (output, context) => {
2070
1050
  Object.assign(contents, doc);
2071
1051
  return contents;
2072
1052
  };
2073
- const de_StartDevEnvironmentSessionCommandError = async (output, context) => {
2074
- const parsedOutput = {
2075
- ...output,
2076
- body: await parseErrorBody(output.body, context),
2077
- };
2078
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2079
- switch (errorCode) {
2080
- case "AccessDeniedException":
2081
- case "com.amazonaws.codecatalyst#AccessDeniedException":
2082
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2083
- case "ConflictException":
2084
- case "com.amazonaws.codecatalyst#ConflictException":
2085
- throw await de_ConflictExceptionRes(parsedOutput, context);
2086
- case "ResourceNotFoundException":
2087
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
2088
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2089
- case "ServiceQuotaExceededException":
2090
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
2091
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2092
- case "ThrottlingException":
2093
- case "com.amazonaws.codecatalyst#ThrottlingException":
2094
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
2095
- case "ValidationException":
2096
- case "com.amazonaws.codecatalyst#ValidationException":
2097
- throw await de_ValidationExceptionRes(parsedOutput, context);
2098
- default:
2099
- const parsedBody = parsedOutput.body;
2100
- return throwDefaultError({
2101
- output,
2102
- parsedBody,
2103
- errorCode,
2104
- });
2105
- }
2106
- };
2107
1053
  export const de_StartWorkflowRunCommand = async (output, context) => {
2108
1054
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2109
- return de_StartWorkflowRunCommandError(output, context);
1055
+ return de_CommandError(output, context);
2110
1056
  }
2111
1057
  const contents = map({
2112
1058
  $metadata: deserializeMetadata(output),
@@ -2121,43 +1067,9 @@ export const de_StartWorkflowRunCommand = async (output, context) => {
2121
1067
  Object.assign(contents, doc);
2122
1068
  return contents;
2123
1069
  };
2124
- const de_StartWorkflowRunCommandError = async (output, context) => {
2125
- const parsedOutput = {
2126
- ...output,
2127
- body: await parseErrorBody(output.body, context),
2128
- };
2129
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2130
- switch (errorCode) {
2131
- case "AccessDeniedException":
2132
- case "com.amazonaws.codecatalyst#AccessDeniedException":
2133
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2134
- case "ConflictException":
2135
- case "com.amazonaws.codecatalyst#ConflictException":
2136
- throw await de_ConflictExceptionRes(parsedOutput, context);
2137
- case "ResourceNotFoundException":
2138
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
2139
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2140
- case "ServiceQuotaExceededException":
2141
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
2142
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2143
- case "ThrottlingException":
2144
- case "com.amazonaws.codecatalyst#ThrottlingException":
2145
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
2146
- case "ValidationException":
2147
- case "com.amazonaws.codecatalyst#ValidationException":
2148
- throw await de_ValidationExceptionRes(parsedOutput, context);
2149
- default:
2150
- const parsedBody = parsedOutput.body;
2151
- return throwDefaultError({
2152
- output,
2153
- parsedBody,
2154
- errorCode,
2155
- });
2156
- }
2157
- };
2158
1070
  export const de_StopDevEnvironmentCommand = async (output, context) => {
2159
1071
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2160
- return de_StopDevEnvironmentCommandError(output, context);
1072
+ return de_CommandError(output, context);
2161
1073
  }
2162
1074
  const contents = map({
2163
1075
  $metadata: deserializeMetadata(output),
@@ -2172,43 +1084,9 @@ export const de_StopDevEnvironmentCommand = async (output, context) => {
2172
1084
  Object.assign(contents, doc);
2173
1085
  return contents;
2174
1086
  };
2175
- const de_StopDevEnvironmentCommandError = async (output, context) => {
2176
- const parsedOutput = {
2177
- ...output,
2178
- body: await parseErrorBody(output.body, context),
2179
- };
2180
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2181
- switch (errorCode) {
2182
- case "AccessDeniedException":
2183
- case "com.amazonaws.codecatalyst#AccessDeniedException":
2184
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2185
- case "ConflictException":
2186
- case "com.amazonaws.codecatalyst#ConflictException":
2187
- throw await de_ConflictExceptionRes(parsedOutput, context);
2188
- case "ResourceNotFoundException":
2189
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
2190
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2191
- case "ServiceQuotaExceededException":
2192
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
2193
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2194
- case "ThrottlingException":
2195
- case "com.amazonaws.codecatalyst#ThrottlingException":
2196
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
2197
- case "ValidationException":
2198
- case "com.amazonaws.codecatalyst#ValidationException":
2199
- throw await de_ValidationExceptionRes(parsedOutput, context);
2200
- default:
2201
- const parsedBody = parsedOutput.body;
2202
- return throwDefaultError({
2203
- output,
2204
- parsedBody,
2205
- errorCode,
2206
- });
2207
- }
2208
- };
2209
1087
  export const de_StopDevEnvironmentSessionCommand = async (output, context) => {
2210
1088
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2211
- return de_StopDevEnvironmentSessionCommandError(output, context);
1089
+ return de_CommandError(output, context);
2212
1090
  }
2213
1091
  const contents = map({
2214
1092
  $metadata: deserializeMetadata(output),
@@ -2223,43 +1101,9 @@ export const de_StopDevEnvironmentSessionCommand = async (output, context) => {
2223
1101
  Object.assign(contents, doc);
2224
1102
  return contents;
2225
1103
  };
2226
- const de_StopDevEnvironmentSessionCommandError = async (output, context) => {
2227
- const parsedOutput = {
2228
- ...output,
2229
- body: await parseErrorBody(output.body, context),
2230
- };
2231
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2232
- switch (errorCode) {
2233
- case "AccessDeniedException":
2234
- case "com.amazonaws.codecatalyst#AccessDeniedException":
2235
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2236
- case "ConflictException":
2237
- case "com.amazonaws.codecatalyst#ConflictException":
2238
- throw await de_ConflictExceptionRes(parsedOutput, context);
2239
- case "ResourceNotFoundException":
2240
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
2241
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2242
- case "ServiceQuotaExceededException":
2243
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
2244
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2245
- case "ThrottlingException":
2246
- case "com.amazonaws.codecatalyst#ThrottlingException":
2247
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
2248
- case "ValidationException":
2249
- case "com.amazonaws.codecatalyst#ValidationException":
2250
- throw await de_ValidationExceptionRes(parsedOutput, context);
2251
- default:
2252
- const parsedBody = parsedOutput.body;
2253
- return throwDefaultError({
2254
- output,
2255
- parsedBody,
2256
- errorCode,
2257
- });
2258
- }
2259
- };
2260
1104
  export const de_UpdateDevEnvironmentCommand = async (output, context) => {
2261
1105
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2262
- return de_UpdateDevEnvironmentCommandError(output, context);
1106
+ return de_CommandError(output, context);
2263
1107
  }
2264
1108
  const contents = map({
2265
1109
  $metadata: deserializeMetadata(output),
@@ -2278,43 +1122,9 @@ export const de_UpdateDevEnvironmentCommand = async (output, context) => {
2278
1122
  Object.assign(contents, doc);
2279
1123
  return contents;
2280
1124
  };
2281
- const de_UpdateDevEnvironmentCommandError = async (output, context) => {
2282
- const parsedOutput = {
2283
- ...output,
2284
- body: await parseErrorBody(output.body, context),
2285
- };
2286
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2287
- switch (errorCode) {
2288
- case "AccessDeniedException":
2289
- case "com.amazonaws.codecatalyst#AccessDeniedException":
2290
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2291
- case "ConflictException":
2292
- case "com.amazonaws.codecatalyst#ConflictException":
2293
- throw await de_ConflictExceptionRes(parsedOutput, context);
2294
- case "ResourceNotFoundException":
2295
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
2296
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2297
- case "ServiceQuotaExceededException":
2298
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
2299
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2300
- case "ThrottlingException":
2301
- case "com.amazonaws.codecatalyst#ThrottlingException":
2302
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
2303
- case "ValidationException":
2304
- case "com.amazonaws.codecatalyst#ValidationException":
2305
- throw await de_ValidationExceptionRes(parsedOutput, context);
2306
- default:
2307
- const parsedBody = parsedOutput.body;
2308
- return throwDefaultError({
2309
- output,
2310
- parsedBody,
2311
- errorCode,
2312
- });
2313
- }
2314
- };
2315
1125
  export const de_UpdateProjectCommand = async (output, context) => {
2316
1126
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2317
- return de_UpdateProjectCommandError(output, context);
1127
+ return de_CommandError(output, context);
2318
1128
  }
2319
1129
  const contents = map({
2320
1130
  $metadata: deserializeMetadata(output),
@@ -2329,43 +1139,9 @@ export const de_UpdateProjectCommand = async (output, context) => {
2329
1139
  Object.assign(contents, doc);
2330
1140
  return contents;
2331
1141
  };
2332
- const de_UpdateProjectCommandError = async (output, context) => {
2333
- const parsedOutput = {
2334
- ...output,
2335
- body: await parseErrorBody(output.body, context),
2336
- };
2337
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2338
- switch (errorCode) {
2339
- case "AccessDeniedException":
2340
- case "com.amazonaws.codecatalyst#AccessDeniedException":
2341
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2342
- case "ConflictException":
2343
- case "com.amazonaws.codecatalyst#ConflictException":
2344
- throw await de_ConflictExceptionRes(parsedOutput, context);
2345
- case "ResourceNotFoundException":
2346
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
2347
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2348
- case "ServiceQuotaExceededException":
2349
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
2350
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2351
- case "ThrottlingException":
2352
- case "com.amazonaws.codecatalyst#ThrottlingException":
2353
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
2354
- case "ValidationException":
2355
- case "com.amazonaws.codecatalyst#ValidationException":
2356
- throw await de_ValidationExceptionRes(parsedOutput, context);
2357
- default:
2358
- const parsedBody = parsedOutput.body;
2359
- return throwDefaultError({
2360
- output,
2361
- parsedBody,
2362
- errorCode,
2363
- });
2364
- }
2365
- };
2366
1142
  export const de_UpdateSpaceCommand = async (output, context) => {
2367
1143
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2368
- return de_UpdateSpaceCommandError(output, context);
1144
+ return de_CommandError(output, context);
2369
1145
  }
2370
1146
  const contents = map({
2371
1147
  $metadata: deserializeMetadata(output),
@@ -2379,43 +1155,9 @@ export const de_UpdateSpaceCommand = async (output, context) => {
2379
1155
  Object.assign(contents, doc);
2380
1156
  return contents;
2381
1157
  };
2382
- const de_UpdateSpaceCommandError = async (output, context) => {
2383
- const parsedOutput = {
2384
- ...output,
2385
- body: await parseErrorBody(output.body, context),
2386
- };
2387
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2388
- switch (errorCode) {
2389
- case "AccessDeniedException":
2390
- case "com.amazonaws.codecatalyst#AccessDeniedException":
2391
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2392
- case "ConflictException":
2393
- case "com.amazonaws.codecatalyst#ConflictException":
2394
- throw await de_ConflictExceptionRes(parsedOutput, context);
2395
- case "ResourceNotFoundException":
2396
- case "com.amazonaws.codecatalyst#ResourceNotFoundException":
2397
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2398
- case "ServiceQuotaExceededException":
2399
- case "com.amazonaws.codecatalyst#ServiceQuotaExceededException":
2400
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2401
- case "ThrottlingException":
2402
- case "com.amazonaws.codecatalyst#ThrottlingException":
2403
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
2404
- case "ValidationException":
2405
- case "com.amazonaws.codecatalyst#ValidationException":
2406
- throw await de_ValidationExceptionRes(parsedOutput, context);
2407
- default:
2408
- const parsedBody = parsedOutput.body;
2409
- return throwDefaultError({
2410
- output,
2411
- parsedBody,
2412
- errorCode,
2413
- });
2414
- }
2415
- };
2416
1158
  export const de_VerifySessionCommand = async (output, context) => {
2417
1159
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2418
- return de_VerifySessionCommandError(output, context);
1160
+ return de_CommandError(output, context);
2419
1161
  }
2420
1162
  const contents = map({
2421
1163
  $metadata: deserializeMetadata(output),
@@ -2427,7 +1169,7 @@ export const de_VerifySessionCommand = async (output, context) => {
2427
1169
  Object.assign(contents, doc);
2428
1170
  return contents;
2429
1171
  };
2430
- const de_VerifySessionCommandError = async (output, context) => {
1172
+ const de_CommandError = async (output, context) => {
2431
1173
  const parsedOutput = {
2432
1174
  ...output,
2433
1175
  body: await parseErrorBody(output.body, context),