@aws-sdk/client-elasticsearch-service 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 +105 -1513
  2. package/dist-es/protocols/Aws_restJson1.js +97 -1505
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -651,7 +651,7 @@ export const se_UpgradeElasticsearchDomainCommand = async (input, context) => {
651
651
  };
652
652
  export const de_AcceptInboundCrossClusterSearchConnectionCommand = async (output, context) => {
653
653
  if (output.statusCode !== 200 && output.statusCode >= 300) {
654
- return de_AcceptInboundCrossClusterSearchConnectionCommandError(output, context);
654
+ return de_CommandError(output, context);
655
655
  }
656
656
  const contents = map({
657
657
  $metadata: deserializeMetadata(output),
@@ -663,34 +663,9 @@ export const de_AcceptInboundCrossClusterSearchConnectionCommand = async (output
663
663
  Object.assign(contents, doc);
664
664
  return contents;
665
665
  };
666
- const de_AcceptInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
667
- const parsedOutput = {
668
- ...output,
669
- body: await parseErrorBody(output.body, context),
670
- };
671
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
672
- switch (errorCode) {
673
- case "DisabledOperationException":
674
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
675
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
676
- case "LimitExceededException":
677
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
678
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
679
- case "ResourceNotFoundException":
680
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
681
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
682
- default:
683
- const parsedBody = parsedOutput.body;
684
- return throwDefaultError({
685
- output,
686
- parsedBody,
687
- errorCode,
688
- });
689
- }
690
- };
691
666
  export const de_AddTagsCommand = async (output, context) => {
692
667
  if (output.statusCode !== 200 && output.statusCode >= 300) {
693
- return de_AddTagsCommandError(output, context);
668
+ return de_CommandError(output, context);
694
669
  }
695
670
  const contents = map({
696
671
  $metadata: deserializeMetadata(output),
@@ -698,37 +673,9 @@ export const de_AddTagsCommand = async (output, context) => {
698
673
  await collectBody(output.body, context);
699
674
  return contents;
700
675
  };
701
- const de_AddTagsCommandError = async (output, context) => {
702
- const parsedOutput = {
703
- ...output,
704
- body: await parseErrorBody(output.body, context),
705
- };
706
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
707
- switch (errorCode) {
708
- case "BaseException":
709
- case "com.amazonaws.elasticsearchservice#BaseException":
710
- throw await de_BaseExceptionRes(parsedOutput, context);
711
- case "InternalException":
712
- case "com.amazonaws.elasticsearchservice#InternalException":
713
- throw await de_InternalExceptionRes(parsedOutput, context);
714
- case "LimitExceededException":
715
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
716
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
717
- case "ValidationException":
718
- case "com.amazonaws.elasticsearchservice#ValidationException":
719
- throw await de_ValidationExceptionRes(parsedOutput, context);
720
- default:
721
- const parsedBody = parsedOutput.body;
722
- return throwDefaultError({
723
- output,
724
- parsedBody,
725
- errorCode,
726
- });
727
- }
728
- };
729
676
  export const de_AssociatePackageCommand = async (output, context) => {
730
677
  if (output.statusCode !== 200 && output.statusCode >= 300) {
731
- return de_AssociatePackageCommandError(output, context);
678
+ return de_CommandError(output, context);
732
679
  }
733
680
  const contents = map({
734
681
  $metadata: deserializeMetadata(output),
@@ -740,43 +687,9 @@ export const de_AssociatePackageCommand = async (output, context) => {
740
687
  Object.assign(contents, doc);
741
688
  return contents;
742
689
  };
743
- const de_AssociatePackageCommandError = async (output, context) => {
744
- const parsedOutput = {
745
- ...output,
746
- body: await parseErrorBody(output.body, context),
747
- };
748
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
749
- switch (errorCode) {
750
- case "AccessDeniedException":
751
- case "com.amazonaws.elasticsearchservice#AccessDeniedException":
752
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
753
- case "BaseException":
754
- case "com.amazonaws.elasticsearchservice#BaseException":
755
- throw await de_BaseExceptionRes(parsedOutput, context);
756
- case "ConflictException":
757
- case "com.amazonaws.elasticsearchservice#ConflictException":
758
- throw await de_ConflictExceptionRes(parsedOutput, context);
759
- case "InternalException":
760
- case "com.amazonaws.elasticsearchservice#InternalException":
761
- throw await de_InternalExceptionRes(parsedOutput, context);
762
- case "ResourceNotFoundException":
763
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
764
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
765
- case "ValidationException":
766
- case "com.amazonaws.elasticsearchservice#ValidationException":
767
- throw await de_ValidationExceptionRes(parsedOutput, context);
768
- default:
769
- const parsedBody = parsedOutput.body;
770
- return throwDefaultError({
771
- output,
772
- parsedBody,
773
- errorCode,
774
- });
775
- }
776
- };
777
690
  export const de_AuthorizeVpcEndpointAccessCommand = async (output, context) => {
778
691
  if (output.statusCode !== 200 && output.statusCode >= 300) {
779
- return de_AuthorizeVpcEndpointAccessCommandError(output, context);
692
+ return de_CommandError(output, context);
780
693
  }
781
694
  const contents = map({
782
695
  $metadata: deserializeMetadata(output),
@@ -788,43 +701,9 @@ export const de_AuthorizeVpcEndpointAccessCommand = async (output, context) => {
788
701
  Object.assign(contents, doc);
789
702
  return contents;
790
703
  };
791
- const de_AuthorizeVpcEndpointAccessCommandError = async (output, context) => {
792
- const parsedOutput = {
793
- ...output,
794
- body: await parseErrorBody(output.body, context),
795
- };
796
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
797
- switch (errorCode) {
798
- case "BaseException":
799
- case "com.amazonaws.elasticsearchservice#BaseException":
800
- throw await de_BaseExceptionRes(parsedOutput, context);
801
- case "DisabledOperationException":
802
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
803
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
804
- case "InternalException":
805
- case "com.amazonaws.elasticsearchservice#InternalException":
806
- throw await de_InternalExceptionRes(parsedOutput, context);
807
- case "LimitExceededException":
808
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
809
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
810
- case "ResourceNotFoundException":
811
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
812
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
813
- case "ValidationException":
814
- case "com.amazonaws.elasticsearchservice#ValidationException":
815
- throw await de_ValidationExceptionRes(parsedOutput, context);
816
- default:
817
- const parsedBody = parsedOutput.body;
818
- return throwDefaultError({
819
- output,
820
- parsedBody,
821
- errorCode,
822
- });
823
- }
824
- };
825
704
  export const de_CancelElasticsearchServiceSoftwareUpdateCommand = async (output, context) => {
826
705
  if (output.statusCode !== 200 && output.statusCode >= 300) {
827
- return de_CancelElasticsearchServiceSoftwareUpdateCommandError(output, context);
706
+ return de_CommandError(output, context);
828
707
  }
829
708
  const contents = map({
830
709
  $metadata: deserializeMetadata(output),
@@ -836,37 +715,9 @@ export const de_CancelElasticsearchServiceSoftwareUpdateCommand = async (output,
836
715
  Object.assign(contents, doc);
837
716
  return contents;
838
717
  };
839
- const de_CancelElasticsearchServiceSoftwareUpdateCommandError = async (output, context) => {
840
- const parsedOutput = {
841
- ...output,
842
- body: await parseErrorBody(output.body, context),
843
- };
844
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
845
- switch (errorCode) {
846
- case "BaseException":
847
- case "com.amazonaws.elasticsearchservice#BaseException":
848
- throw await de_BaseExceptionRes(parsedOutput, context);
849
- case "InternalException":
850
- case "com.amazonaws.elasticsearchservice#InternalException":
851
- throw await de_InternalExceptionRes(parsedOutput, context);
852
- case "ResourceNotFoundException":
853
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
854
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
855
- case "ValidationException":
856
- case "com.amazonaws.elasticsearchservice#ValidationException":
857
- throw await de_ValidationExceptionRes(parsedOutput, context);
858
- default:
859
- const parsedBody = parsedOutput.body;
860
- return throwDefaultError({
861
- output,
862
- parsedBody,
863
- errorCode,
864
- });
865
- }
866
- };
867
718
  export const de_CreateElasticsearchDomainCommand = async (output, context) => {
868
719
  if (output.statusCode !== 200 && output.statusCode >= 300) {
869
- return de_CreateElasticsearchDomainCommandError(output, context);
720
+ return de_CommandError(output, context);
870
721
  }
871
722
  const contents = map({
872
723
  $metadata: deserializeMetadata(output),
@@ -878,46 +729,9 @@ export const de_CreateElasticsearchDomainCommand = async (output, context) => {
878
729
  Object.assign(contents, doc);
879
730
  return contents;
880
731
  };
881
- const de_CreateElasticsearchDomainCommandError = async (output, context) => {
882
- const parsedOutput = {
883
- ...output,
884
- body: await parseErrorBody(output.body, context),
885
- };
886
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
887
- switch (errorCode) {
888
- case "BaseException":
889
- case "com.amazonaws.elasticsearchservice#BaseException":
890
- throw await de_BaseExceptionRes(parsedOutput, context);
891
- case "DisabledOperationException":
892
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
893
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
894
- case "InternalException":
895
- case "com.amazonaws.elasticsearchservice#InternalException":
896
- throw await de_InternalExceptionRes(parsedOutput, context);
897
- case "InvalidTypeException":
898
- case "com.amazonaws.elasticsearchservice#InvalidTypeException":
899
- throw await de_InvalidTypeExceptionRes(parsedOutput, context);
900
- case "LimitExceededException":
901
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
902
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
903
- case "ResourceAlreadyExistsException":
904
- case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
905
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
906
- case "ValidationException":
907
- case "com.amazonaws.elasticsearchservice#ValidationException":
908
- throw await de_ValidationExceptionRes(parsedOutput, context);
909
- default:
910
- const parsedBody = parsedOutput.body;
911
- return throwDefaultError({
912
- output,
913
- parsedBody,
914
- errorCode,
915
- });
916
- }
917
- };
918
732
  export const de_CreateOutboundCrossClusterSearchConnectionCommand = async (output, context) => {
919
733
  if (output.statusCode !== 200 && output.statusCode >= 300) {
920
- return de_CreateOutboundCrossClusterSearchConnectionCommandError(output, context);
734
+ return de_CommandError(output, context);
921
735
  }
922
736
  const contents = map({
923
737
  $metadata: deserializeMetadata(output),
@@ -933,37 +747,9 @@ export const de_CreateOutboundCrossClusterSearchConnectionCommand = async (outpu
933
747
  Object.assign(contents, doc);
934
748
  return contents;
935
749
  };
936
- const de_CreateOutboundCrossClusterSearchConnectionCommandError = async (output, context) => {
937
- const parsedOutput = {
938
- ...output,
939
- body: await parseErrorBody(output.body, context),
940
- };
941
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
942
- switch (errorCode) {
943
- case "DisabledOperationException":
944
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
945
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
946
- case "InternalException":
947
- case "com.amazonaws.elasticsearchservice#InternalException":
948
- throw await de_InternalExceptionRes(parsedOutput, context);
949
- case "LimitExceededException":
950
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
951
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
952
- case "ResourceAlreadyExistsException":
953
- case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
954
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
955
- default:
956
- const parsedBody = parsedOutput.body;
957
- return throwDefaultError({
958
- output,
959
- parsedBody,
960
- errorCode,
961
- });
962
- }
963
- };
964
750
  export const de_CreatePackageCommand = async (output, context) => {
965
751
  if (output.statusCode !== 200 && output.statusCode >= 300) {
966
- return de_CreatePackageCommandError(output, context);
752
+ return de_CommandError(output, context);
967
753
  }
968
754
  const contents = map({
969
755
  $metadata: deserializeMetadata(output),
@@ -975,46 +761,9 @@ export const de_CreatePackageCommand = async (output, context) => {
975
761
  Object.assign(contents, doc);
976
762
  return contents;
977
763
  };
978
- const de_CreatePackageCommandError = async (output, context) => {
979
- const parsedOutput = {
980
- ...output,
981
- body: await parseErrorBody(output.body, context),
982
- };
983
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
984
- switch (errorCode) {
985
- case "AccessDeniedException":
986
- case "com.amazonaws.elasticsearchservice#AccessDeniedException":
987
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
988
- case "BaseException":
989
- case "com.amazonaws.elasticsearchservice#BaseException":
990
- throw await de_BaseExceptionRes(parsedOutput, context);
991
- case "InternalException":
992
- case "com.amazonaws.elasticsearchservice#InternalException":
993
- throw await de_InternalExceptionRes(parsedOutput, context);
994
- case "InvalidTypeException":
995
- case "com.amazonaws.elasticsearchservice#InvalidTypeException":
996
- throw await de_InvalidTypeExceptionRes(parsedOutput, context);
997
- case "LimitExceededException":
998
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
999
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1000
- case "ResourceAlreadyExistsException":
1001
- case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
1002
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1003
- case "ValidationException":
1004
- case "com.amazonaws.elasticsearchservice#ValidationException":
1005
- throw await de_ValidationExceptionRes(parsedOutput, context);
1006
- default:
1007
- const parsedBody = parsedOutput.body;
1008
- return throwDefaultError({
1009
- output,
1010
- parsedBody,
1011
- errorCode,
1012
- });
1013
- }
1014
- };
1015
764
  export const de_CreateVpcEndpointCommand = async (output, context) => {
1016
765
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1017
- return de_CreateVpcEndpointCommandError(output, context);
766
+ return de_CommandError(output, context);
1018
767
  }
1019
768
  const contents = map({
1020
769
  $metadata: deserializeMetadata(output),
@@ -1026,43 +775,9 @@ export const de_CreateVpcEndpointCommand = async (output, context) => {
1026
775
  Object.assign(contents, doc);
1027
776
  return contents;
1028
777
  };
1029
- const de_CreateVpcEndpointCommandError = async (output, context) => {
1030
- const parsedOutput = {
1031
- ...output,
1032
- body: await parseErrorBody(output.body, context),
1033
- };
1034
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1035
- switch (errorCode) {
1036
- case "BaseException":
1037
- case "com.amazonaws.elasticsearchservice#BaseException":
1038
- throw await de_BaseExceptionRes(parsedOutput, context);
1039
- case "ConflictException":
1040
- case "com.amazonaws.elasticsearchservice#ConflictException":
1041
- throw await de_ConflictExceptionRes(parsedOutput, context);
1042
- case "DisabledOperationException":
1043
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1044
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1045
- case "InternalException":
1046
- case "com.amazonaws.elasticsearchservice#InternalException":
1047
- throw await de_InternalExceptionRes(parsedOutput, context);
1048
- case "LimitExceededException":
1049
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
1050
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1051
- case "ValidationException":
1052
- case "com.amazonaws.elasticsearchservice#ValidationException":
1053
- throw await de_ValidationExceptionRes(parsedOutput, context);
1054
- default:
1055
- const parsedBody = parsedOutput.body;
1056
- return throwDefaultError({
1057
- output,
1058
- parsedBody,
1059
- errorCode,
1060
- });
1061
- }
1062
- };
1063
778
  export const de_DeleteElasticsearchDomainCommand = async (output, context) => {
1064
779
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1065
- return de_DeleteElasticsearchDomainCommandError(output, context);
780
+ return de_CommandError(output, context);
1066
781
  }
1067
782
  const contents = map({
1068
783
  $metadata: deserializeMetadata(output),
@@ -1074,37 +789,9 @@ export const de_DeleteElasticsearchDomainCommand = async (output, context) => {
1074
789
  Object.assign(contents, doc);
1075
790
  return contents;
1076
791
  };
1077
- const de_DeleteElasticsearchDomainCommandError = async (output, context) => {
1078
- const parsedOutput = {
1079
- ...output,
1080
- body: await parseErrorBody(output.body, context),
1081
- };
1082
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1083
- switch (errorCode) {
1084
- case "BaseException":
1085
- case "com.amazonaws.elasticsearchservice#BaseException":
1086
- throw await de_BaseExceptionRes(parsedOutput, context);
1087
- case "InternalException":
1088
- case "com.amazonaws.elasticsearchservice#InternalException":
1089
- throw await de_InternalExceptionRes(parsedOutput, context);
1090
- case "ResourceNotFoundException":
1091
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1092
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1093
- case "ValidationException":
1094
- case "com.amazonaws.elasticsearchservice#ValidationException":
1095
- throw await de_ValidationExceptionRes(parsedOutput, context);
1096
- default:
1097
- const parsedBody = parsedOutput.body;
1098
- return throwDefaultError({
1099
- output,
1100
- parsedBody,
1101
- errorCode,
1102
- });
1103
- }
1104
- };
1105
792
  export const de_DeleteElasticsearchServiceRoleCommand = async (output, context) => {
1106
793
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1107
- return de_DeleteElasticsearchServiceRoleCommandError(output, context);
794
+ return de_CommandError(output, context);
1108
795
  }
1109
796
  const contents = map({
1110
797
  $metadata: deserializeMetadata(output),
@@ -1112,34 +799,9 @@ export const de_DeleteElasticsearchServiceRoleCommand = async (output, context)
1112
799
  await collectBody(output.body, context);
1113
800
  return contents;
1114
801
  };
1115
- const de_DeleteElasticsearchServiceRoleCommandError = async (output, context) => {
1116
- const parsedOutput = {
1117
- ...output,
1118
- body: await parseErrorBody(output.body, context),
1119
- };
1120
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1121
- switch (errorCode) {
1122
- case "BaseException":
1123
- case "com.amazonaws.elasticsearchservice#BaseException":
1124
- throw await de_BaseExceptionRes(parsedOutput, context);
1125
- case "InternalException":
1126
- case "com.amazonaws.elasticsearchservice#InternalException":
1127
- throw await de_InternalExceptionRes(parsedOutput, context);
1128
- case "ValidationException":
1129
- case "com.amazonaws.elasticsearchservice#ValidationException":
1130
- throw await de_ValidationExceptionRes(parsedOutput, context);
1131
- default:
1132
- const parsedBody = parsedOutput.body;
1133
- return throwDefaultError({
1134
- output,
1135
- parsedBody,
1136
- errorCode,
1137
- });
1138
- }
1139
- };
1140
802
  export const de_DeleteInboundCrossClusterSearchConnectionCommand = async (output, context) => {
1141
803
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1142
- return de_DeleteInboundCrossClusterSearchConnectionCommandError(output, context);
804
+ return de_CommandError(output, context);
1143
805
  }
1144
806
  const contents = map({
1145
807
  $metadata: deserializeMetadata(output),
@@ -1151,31 +813,9 @@ export const de_DeleteInboundCrossClusterSearchConnectionCommand = async (output
1151
813
  Object.assign(contents, doc);
1152
814
  return contents;
1153
815
  };
1154
- const de_DeleteInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
1155
- const parsedOutput = {
1156
- ...output,
1157
- body: await parseErrorBody(output.body, context),
1158
- };
1159
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1160
- switch (errorCode) {
1161
- case "DisabledOperationException":
1162
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1163
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1164
- case "ResourceNotFoundException":
1165
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1166
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1167
- default:
1168
- const parsedBody = parsedOutput.body;
1169
- return throwDefaultError({
1170
- output,
1171
- parsedBody,
1172
- errorCode,
1173
- });
1174
- }
1175
- };
1176
816
  export const de_DeleteOutboundCrossClusterSearchConnectionCommand = async (output, context) => {
1177
817
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1178
- return de_DeleteOutboundCrossClusterSearchConnectionCommandError(output, context);
818
+ return de_CommandError(output, context);
1179
819
  }
1180
820
  const contents = map({
1181
821
  $metadata: deserializeMetadata(output),
@@ -1187,31 +827,9 @@ export const de_DeleteOutboundCrossClusterSearchConnectionCommand = async (outpu
1187
827
  Object.assign(contents, doc);
1188
828
  return contents;
1189
829
  };
1190
- const de_DeleteOutboundCrossClusterSearchConnectionCommandError = async (output, context) => {
1191
- const parsedOutput = {
1192
- ...output,
1193
- body: await parseErrorBody(output.body, context),
1194
- };
1195
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1196
- switch (errorCode) {
1197
- case "DisabledOperationException":
1198
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1199
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1200
- case "ResourceNotFoundException":
1201
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1202
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1203
- default:
1204
- const parsedBody = parsedOutput.body;
1205
- return throwDefaultError({
1206
- output,
1207
- parsedBody,
1208
- errorCode,
1209
- });
1210
- }
1211
- };
1212
830
  export const de_DeletePackageCommand = async (output, context) => {
1213
831
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1214
- return de_DeletePackageCommandError(output, context);
832
+ return de_CommandError(output, context);
1215
833
  }
1216
834
  const contents = map({
1217
835
  $metadata: deserializeMetadata(output),
@@ -1223,43 +841,9 @@ export const de_DeletePackageCommand = async (output, context) => {
1223
841
  Object.assign(contents, doc);
1224
842
  return contents;
1225
843
  };
1226
- const de_DeletePackageCommandError = async (output, context) => {
1227
- const parsedOutput = {
1228
- ...output,
1229
- body: await parseErrorBody(output.body, context),
1230
- };
1231
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1232
- switch (errorCode) {
1233
- case "AccessDeniedException":
1234
- case "com.amazonaws.elasticsearchservice#AccessDeniedException":
1235
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1236
- case "BaseException":
1237
- case "com.amazonaws.elasticsearchservice#BaseException":
1238
- throw await de_BaseExceptionRes(parsedOutput, context);
1239
- case "ConflictException":
1240
- case "com.amazonaws.elasticsearchservice#ConflictException":
1241
- throw await de_ConflictExceptionRes(parsedOutput, context);
1242
- case "InternalException":
1243
- case "com.amazonaws.elasticsearchservice#InternalException":
1244
- throw await de_InternalExceptionRes(parsedOutput, context);
1245
- case "ResourceNotFoundException":
1246
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1247
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1248
- case "ValidationException":
1249
- case "com.amazonaws.elasticsearchservice#ValidationException":
1250
- throw await de_ValidationExceptionRes(parsedOutput, context);
1251
- default:
1252
- const parsedBody = parsedOutput.body;
1253
- return throwDefaultError({
1254
- output,
1255
- parsedBody,
1256
- errorCode,
1257
- });
1258
- }
1259
- };
1260
844
  export const de_DeleteVpcEndpointCommand = async (output, context) => {
1261
845
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1262
- return de_DeleteVpcEndpointCommandError(output, context);
846
+ return de_CommandError(output, context);
1263
847
  }
1264
848
  const contents = map({
1265
849
  $metadata: deserializeMetadata(output),
@@ -1271,37 +855,9 @@ export const de_DeleteVpcEndpointCommand = async (output, context) => {
1271
855
  Object.assign(contents, doc);
1272
856
  return contents;
1273
857
  };
1274
- const de_DeleteVpcEndpointCommandError = async (output, context) => {
1275
- const parsedOutput = {
1276
- ...output,
1277
- body: await parseErrorBody(output.body, context),
1278
- };
1279
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1280
- switch (errorCode) {
1281
- case "BaseException":
1282
- case "com.amazonaws.elasticsearchservice#BaseException":
1283
- throw await de_BaseExceptionRes(parsedOutput, context);
1284
- case "DisabledOperationException":
1285
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1286
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1287
- case "InternalException":
1288
- case "com.amazonaws.elasticsearchservice#InternalException":
1289
- throw await de_InternalExceptionRes(parsedOutput, context);
1290
- case "ResourceNotFoundException":
1291
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1292
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1293
- default:
1294
- const parsedBody = parsedOutput.body;
1295
- return throwDefaultError({
1296
- output,
1297
- parsedBody,
1298
- errorCode,
1299
- });
1300
- }
1301
- };
1302
858
  export const de_DescribeDomainAutoTunesCommand = async (output, context) => {
1303
859
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1304
- return de_DescribeDomainAutoTunesCommandError(output, context);
860
+ return de_CommandError(output, context);
1305
861
  }
1306
862
  const contents = map({
1307
863
  $metadata: deserializeMetadata(output),
@@ -1314,37 +870,9 @@ export const de_DescribeDomainAutoTunesCommand = async (output, context) => {
1314
870
  Object.assign(contents, doc);
1315
871
  return contents;
1316
872
  };
1317
- const de_DescribeDomainAutoTunesCommandError = async (output, context) => {
1318
- const parsedOutput = {
1319
- ...output,
1320
- body: await parseErrorBody(output.body, context),
1321
- };
1322
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1323
- switch (errorCode) {
1324
- case "BaseException":
1325
- case "com.amazonaws.elasticsearchservice#BaseException":
1326
- throw await de_BaseExceptionRes(parsedOutput, context);
1327
- case "InternalException":
1328
- case "com.amazonaws.elasticsearchservice#InternalException":
1329
- throw await de_InternalExceptionRes(parsedOutput, context);
1330
- case "ResourceNotFoundException":
1331
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1332
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1333
- case "ValidationException":
1334
- case "com.amazonaws.elasticsearchservice#ValidationException":
1335
- throw await de_ValidationExceptionRes(parsedOutput, context);
1336
- default:
1337
- const parsedBody = parsedOutput.body;
1338
- return throwDefaultError({
1339
- output,
1340
- parsedBody,
1341
- errorCode,
1342
- });
1343
- }
1344
- };
1345
873
  export const de_DescribeDomainChangeProgressCommand = async (output, context) => {
1346
874
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1347
- return de_DescribeDomainChangeProgressCommandError(output, context);
875
+ return de_CommandError(output, context);
1348
876
  }
1349
877
  const contents = map({
1350
878
  $metadata: deserializeMetadata(output),
@@ -1356,37 +884,9 @@ export const de_DescribeDomainChangeProgressCommand = async (output, context) =>
1356
884
  Object.assign(contents, doc);
1357
885
  return contents;
1358
886
  };
1359
- const de_DescribeDomainChangeProgressCommandError = async (output, context) => {
1360
- const parsedOutput = {
1361
- ...output,
1362
- body: await parseErrorBody(output.body, context),
1363
- };
1364
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1365
- switch (errorCode) {
1366
- case "BaseException":
1367
- case "com.amazonaws.elasticsearchservice#BaseException":
1368
- throw await de_BaseExceptionRes(parsedOutput, context);
1369
- case "InternalException":
1370
- case "com.amazonaws.elasticsearchservice#InternalException":
1371
- throw await de_InternalExceptionRes(parsedOutput, context);
1372
- case "ResourceNotFoundException":
1373
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1374
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1375
- case "ValidationException":
1376
- case "com.amazonaws.elasticsearchservice#ValidationException":
1377
- throw await de_ValidationExceptionRes(parsedOutput, context);
1378
- default:
1379
- const parsedBody = parsedOutput.body;
1380
- return throwDefaultError({
1381
- output,
1382
- parsedBody,
1383
- errorCode,
1384
- });
1385
- }
1386
- };
1387
887
  export const de_DescribeElasticsearchDomainCommand = async (output, context) => {
1388
888
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1389
- return de_DescribeElasticsearchDomainCommandError(output, context);
889
+ return de_CommandError(output, context);
1390
890
  }
1391
891
  const contents = map({
1392
892
  $metadata: deserializeMetadata(output),
@@ -1398,37 +898,9 @@ export const de_DescribeElasticsearchDomainCommand = async (output, context) =>
1398
898
  Object.assign(contents, doc);
1399
899
  return contents;
1400
900
  };
1401
- const de_DescribeElasticsearchDomainCommandError = async (output, context) => {
1402
- const parsedOutput = {
1403
- ...output,
1404
- body: await parseErrorBody(output.body, context),
1405
- };
1406
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1407
- switch (errorCode) {
1408
- case "BaseException":
1409
- case "com.amazonaws.elasticsearchservice#BaseException":
1410
- throw await de_BaseExceptionRes(parsedOutput, context);
1411
- case "InternalException":
1412
- case "com.amazonaws.elasticsearchservice#InternalException":
1413
- throw await de_InternalExceptionRes(parsedOutput, context);
1414
- case "ResourceNotFoundException":
1415
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1416
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1417
- case "ValidationException":
1418
- case "com.amazonaws.elasticsearchservice#ValidationException":
1419
- throw await de_ValidationExceptionRes(parsedOutput, context);
1420
- default:
1421
- const parsedBody = parsedOutput.body;
1422
- return throwDefaultError({
1423
- output,
1424
- parsedBody,
1425
- errorCode,
1426
- });
1427
- }
1428
- };
1429
901
  export const de_DescribeElasticsearchDomainConfigCommand = async (output, context) => {
1430
902
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1431
- return de_DescribeElasticsearchDomainConfigCommandError(output, context);
903
+ return de_CommandError(output, context);
1432
904
  }
1433
905
  const contents = map({
1434
906
  $metadata: deserializeMetadata(output),
@@ -1440,37 +912,9 @@ export const de_DescribeElasticsearchDomainConfigCommand = async (output, contex
1440
912
  Object.assign(contents, doc);
1441
913
  return contents;
1442
914
  };
1443
- const de_DescribeElasticsearchDomainConfigCommandError = async (output, context) => {
1444
- const parsedOutput = {
1445
- ...output,
1446
- body: await parseErrorBody(output.body, context),
1447
- };
1448
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1449
- switch (errorCode) {
1450
- case "BaseException":
1451
- case "com.amazonaws.elasticsearchservice#BaseException":
1452
- throw await de_BaseExceptionRes(parsedOutput, context);
1453
- case "InternalException":
1454
- case "com.amazonaws.elasticsearchservice#InternalException":
1455
- throw await de_InternalExceptionRes(parsedOutput, context);
1456
- case "ResourceNotFoundException":
1457
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1458
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1459
- case "ValidationException":
1460
- case "com.amazonaws.elasticsearchservice#ValidationException":
1461
- throw await de_ValidationExceptionRes(parsedOutput, context);
1462
- default:
1463
- const parsedBody = parsedOutput.body;
1464
- return throwDefaultError({
1465
- output,
1466
- parsedBody,
1467
- errorCode,
1468
- });
1469
- }
1470
- };
1471
915
  export const de_DescribeElasticsearchDomainsCommand = async (output, context) => {
1472
916
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1473
- return de_DescribeElasticsearchDomainsCommandError(output, context);
917
+ return de_CommandError(output, context);
1474
918
  }
1475
919
  const contents = map({
1476
920
  $metadata: deserializeMetadata(output),
@@ -1482,34 +926,9 @@ export const de_DescribeElasticsearchDomainsCommand = async (output, context) =>
1482
926
  Object.assign(contents, doc);
1483
927
  return contents;
1484
928
  };
1485
- const de_DescribeElasticsearchDomainsCommandError = async (output, context) => {
1486
- const parsedOutput = {
1487
- ...output,
1488
- body: await parseErrorBody(output.body, context),
1489
- };
1490
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1491
- switch (errorCode) {
1492
- case "BaseException":
1493
- case "com.amazonaws.elasticsearchservice#BaseException":
1494
- throw await de_BaseExceptionRes(parsedOutput, context);
1495
- case "InternalException":
1496
- case "com.amazonaws.elasticsearchservice#InternalException":
1497
- throw await de_InternalExceptionRes(parsedOutput, context);
1498
- case "ValidationException":
1499
- case "com.amazonaws.elasticsearchservice#ValidationException":
1500
- throw await de_ValidationExceptionRes(parsedOutput, context);
1501
- default:
1502
- const parsedBody = parsedOutput.body;
1503
- return throwDefaultError({
1504
- output,
1505
- parsedBody,
1506
- errorCode,
1507
- });
1508
- }
1509
- };
1510
929
  export const de_DescribeElasticsearchInstanceTypeLimitsCommand = async (output, context) => {
1511
930
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1512
- return de_DescribeElasticsearchInstanceTypeLimitsCommandError(output, context);
931
+ return de_CommandError(output, context);
1513
932
  }
1514
933
  const contents = map({
1515
934
  $metadata: deserializeMetadata(output),
@@ -1521,43 +940,9 @@ export const de_DescribeElasticsearchInstanceTypeLimitsCommand = async (output,
1521
940
  Object.assign(contents, doc);
1522
941
  return contents;
1523
942
  };
1524
- const de_DescribeElasticsearchInstanceTypeLimitsCommandError = async (output, context) => {
1525
- const parsedOutput = {
1526
- ...output,
1527
- body: await parseErrorBody(output.body, context),
1528
- };
1529
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1530
- switch (errorCode) {
1531
- case "BaseException":
1532
- case "com.amazonaws.elasticsearchservice#BaseException":
1533
- throw await de_BaseExceptionRes(parsedOutput, context);
1534
- case "InternalException":
1535
- case "com.amazonaws.elasticsearchservice#InternalException":
1536
- throw await de_InternalExceptionRes(parsedOutput, context);
1537
- case "InvalidTypeException":
1538
- case "com.amazonaws.elasticsearchservice#InvalidTypeException":
1539
- throw await de_InvalidTypeExceptionRes(parsedOutput, context);
1540
- case "LimitExceededException":
1541
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
1542
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1543
- case "ResourceNotFoundException":
1544
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1545
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1546
- case "ValidationException":
1547
- case "com.amazonaws.elasticsearchservice#ValidationException":
1548
- throw await de_ValidationExceptionRes(parsedOutput, context);
1549
- default:
1550
- const parsedBody = parsedOutput.body;
1551
- return throwDefaultError({
1552
- output,
1553
- parsedBody,
1554
- errorCode,
1555
- });
1556
- }
1557
- };
1558
943
  export const de_DescribeInboundCrossClusterSearchConnectionsCommand = async (output, context) => {
1559
944
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1560
- return de_DescribeInboundCrossClusterSearchConnectionsCommandError(output, context);
945
+ return de_CommandError(output, context);
1561
946
  }
1562
947
  const contents = map({
1563
948
  $metadata: deserializeMetadata(output),
@@ -1570,31 +955,9 @@ export const de_DescribeInboundCrossClusterSearchConnectionsCommand = async (out
1570
955
  Object.assign(contents, doc);
1571
956
  return contents;
1572
957
  };
1573
- const de_DescribeInboundCrossClusterSearchConnectionsCommandError = async (output, context) => {
1574
- const parsedOutput = {
1575
- ...output,
1576
- body: await parseErrorBody(output.body, context),
1577
- };
1578
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1579
- switch (errorCode) {
1580
- case "DisabledOperationException":
1581
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1582
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1583
- case "InvalidPaginationTokenException":
1584
- case "com.amazonaws.elasticsearchservice#InvalidPaginationTokenException":
1585
- throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
1586
- default:
1587
- const parsedBody = parsedOutput.body;
1588
- return throwDefaultError({
1589
- output,
1590
- parsedBody,
1591
- errorCode,
1592
- });
1593
- }
1594
- };
1595
958
  export const de_DescribeOutboundCrossClusterSearchConnectionsCommand = async (output, context) => {
1596
959
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1597
- return de_DescribeOutboundCrossClusterSearchConnectionsCommandError(output, context);
960
+ return de_CommandError(output, context);
1598
961
  }
1599
962
  const contents = map({
1600
963
  $metadata: deserializeMetadata(output),
@@ -1607,31 +970,9 @@ export const de_DescribeOutboundCrossClusterSearchConnectionsCommand = async (ou
1607
970
  Object.assign(contents, doc);
1608
971
  return contents;
1609
972
  };
1610
- const de_DescribeOutboundCrossClusterSearchConnectionsCommandError = async (output, context) => {
1611
- const parsedOutput = {
1612
- ...output,
1613
- body: await parseErrorBody(output.body, context),
1614
- };
1615
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1616
- switch (errorCode) {
1617
- case "DisabledOperationException":
1618
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1619
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1620
- case "InvalidPaginationTokenException":
1621
- case "com.amazonaws.elasticsearchservice#InvalidPaginationTokenException":
1622
- throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
1623
- default:
1624
- const parsedBody = parsedOutput.body;
1625
- return throwDefaultError({
1626
- output,
1627
- parsedBody,
1628
- errorCode,
1629
- });
1630
- }
1631
- };
1632
973
  export const de_DescribePackagesCommand = async (output, context) => {
1633
974
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1634
- return de_DescribePackagesCommandError(output, context);
975
+ return de_CommandError(output, context);
1635
976
  }
1636
977
  const contents = map({
1637
978
  $metadata: deserializeMetadata(output),
@@ -1644,40 +985,9 @@ export const de_DescribePackagesCommand = async (output, context) => {
1644
985
  Object.assign(contents, doc);
1645
986
  return contents;
1646
987
  };
1647
- const de_DescribePackagesCommandError = async (output, context) => {
1648
- const parsedOutput = {
1649
- ...output,
1650
- body: await parseErrorBody(output.body, context),
1651
- };
1652
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1653
- switch (errorCode) {
1654
- case "AccessDeniedException":
1655
- case "com.amazonaws.elasticsearchservice#AccessDeniedException":
1656
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1657
- case "BaseException":
1658
- case "com.amazonaws.elasticsearchservice#BaseException":
1659
- throw await de_BaseExceptionRes(parsedOutput, context);
1660
- case "InternalException":
1661
- case "com.amazonaws.elasticsearchservice#InternalException":
1662
- throw await de_InternalExceptionRes(parsedOutput, context);
1663
- case "ResourceNotFoundException":
1664
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1665
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1666
- case "ValidationException":
1667
- case "com.amazonaws.elasticsearchservice#ValidationException":
1668
- throw await de_ValidationExceptionRes(parsedOutput, context);
1669
- default:
1670
- const parsedBody = parsedOutput.body;
1671
- return throwDefaultError({
1672
- output,
1673
- parsedBody,
1674
- errorCode,
1675
- });
1676
- }
1677
- };
1678
988
  export const de_DescribeReservedElasticsearchInstanceOfferingsCommand = async (output, context) => {
1679
989
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1680
- return de_DescribeReservedElasticsearchInstanceOfferingsCommandError(output, context);
990
+ return de_CommandError(output, context);
1681
991
  }
1682
992
  const contents = map({
1683
993
  $metadata: deserializeMetadata(output),
@@ -1690,37 +1000,9 @@ export const de_DescribeReservedElasticsearchInstanceOfferingsCommand = async (o
1690
1000
  Object.assign(contents, doc);
1691
1001
  return contents;
1692
1002
  };
1693
- const de_DescribeReservedElasticsearchInstanceOfferingsCommandError = async (output, context) => {
1694
- const parsedOutput = {
1695
- ...output,
1696
- body: await parseErrorBody(output.body, context),
1697
- };
1698
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1699
- switch (errorCode) {
1700
- case "DisabledOperationException":
1701
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1702
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1703
- case "InternalException":
1704
- case "com.amazonaws.elasticsearchservice#InternalException":
1705
- throw await de_InternalExceptionRes(parsedOutput, context);
1706
- case "ResourceNotFoundException":
1707
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1708
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1709
- case "ValidationException":
1710
- case "com.amazonaws.elasticsearchservice#ValidationException":
1711
- throw await de_ValidationExceptionRes(parsedOutput, context);
1712
- default:
1713
- const parsedBody = parsedOutput.body;
1714
- return throwDefaultError({
1715
- output,
1716
- parsedBody,
1717
- errorCode,
1718
- });
1719
- }
1720
- };
1721
1003
  export const de_DescribeReservedElasticsearchInstancesCommand = async (output, context) => {
1722
1004
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1723
- return de_DescribeReservedElasticsearchInstancesCommandError(output, context);
1005
+ return de_CommandError(output, context);
1724
1006
  }
1725
1007
  const contents = map({
1726
1008
  $metadata: deserializeMetadata(output),
@@ -1733,37 +1015,9 @@ export const de_DescribeReservedElasticsearchInstancesCommand = async (output, c
1733
1015
  Object.assign(contents, doc);
1734
1016
  return contents;
1735
1017
  };
1736
- const de_DescribeReservedElasticsearchInstancesCommandError = async (output, context) => {
1737
- const parsedOutput = {
1738
- ...output,
1739
- body: await parseErrorBody(output.body, context),
1740
- };
1741
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1742
- switch (errorCode) {
1743
- case "DisabledOperationException":
1744
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1745
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1746
- case "InternalException":
1747
- case "com.amazonaws.elasticsearchservice#InternalException":
1748
- throw await de_InternalExceptionRes(parsedOutput, context);
1749
- case "ResourceNotFoundException":
1750
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1751
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1752
- case "ValidationException":
1753
- case "com.amazonaws.elasticsearchservice#ValidationException":
1754
- throw await de_ValidationExceptionRes(parsedOutput, context);
1755
- default:
1756
- const parsedBody = parsedOutput.body;
1757
- return throwDefaultError({
1758
- output,
1759
- parsedBody,
1760
- errorCode,
1761
- });
1762
- }
1763
- };
1764
1018
  export const de_DescribeVpcEndpointsCommand = async (output, context) => {
1765
1019
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1766
- return de_DescribeVpcEndpointsCommandError(output, context);
1020
+ return de_CommandError(output, context);
1767
1021
  }
1768
1022
  const contents = map({
1769
1023
  $metadata: deserializeMetadata(output),
@@ -1776,37 +1030,9 @@ export const de_DescribeVpcEndpointsCommand = async (output, context) => {
1776
1030
  Object.assign(contents, doc);
1777
1031
  return contents;
1778
1032
  };
1779
- const de_DescribeVpcEndpointsCommandError = async (output, context) => {
1780
- const parsedOutput = {
1781
- ...output,
1782
- body: await parseErrorBody(output.body, context),
1783
- };
1784
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1785
- switch (errorCode) {
1786
- case "BaseException":
1787
- case "com.amazonaws.elasticsearchservice#BaseException":
1788
- throw await de_BaseExceptionRes(parsedOutput, context);
1789
- case "DisabledOperationException":
1790
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1791
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1792
- case "InternalException":
1793
- case "com.amazonaws.elasticsearchservice#InternalException":
1794
- throw await de_InternalExceptionRes(parsedOutput, context);
1795
- case "ValidationException":
1796
- case "com.amazonaws.elasticsearchservice#ValidationException":
1797
- throw await de_ValidationExceptionRes(parsedOutput, context);
1798
- default:
1799
- const parsedBody = parsedOutput.body;
1800
- return throwDefaultError({
1801
- output,
1802
- parsedBody,
1803
- errorCode,
1804
- });
1805
- }
1806
- };
1807
1033
  export const de_DissociatePackageCommand = async (output, context) => {
1808
1034
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1809
- return de_DissociatePackageCommandError(output, context);
1035
+ return de_CommandError(output, context);
1810
1036
  }
1811
1037
  const contents = map({
1812
1038
  $metadata: deserializeMetadata(output),
@@ -1818,43 +1044,9 @@ export const de_DissociatePackageCommand = async (output, context) => {
1818
1044
  Object.assign(contents, doc);
1819
1045
  return contents;
1820
1046
  };
1821
- const de_DissociatePackageCommandError = async (output, context) => {
1822
- const parsedOutput = {
1823
- ...output,
1824
- body: await parseErrorBody(output.body, context),
1825
- };
1826
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1827
- switch (errorCode) {
1828
- case "AccessDeniedException":
1829
- case "com.amazonaws.elasticsearchservice#AccessDeniedException":
1830
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1831
- case "BaseException":
1832
- case "com.amazonaws.elasticsearchservice#BaseException":
1833
- throw await de_BaseExceptionRes(parsedOutput, context);
1834
- case "ConflictException":
1835
- case "com.amazonaws.elasticsearchservice#ConflictException":
1836
- throw await de_ConflictExceptionRes(parsedOutput, context);
1837
- case "InternalException":
1838
- case "com.amazonaws.elasticsearchservice#InternalException":
1839
- throw await de_InternalExceptionRes(parsedOutput, context);
1840
- case "ResourceNotFoundException":
1841
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1842
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1843
- case "ValidationException":
1844
- case "com.amazonaws.elasticsearchservice#ValidationException":
1845
- throw await de_ValidationExceptionRes(parsedOutput, context);
1846
- default:
1847
- const parsedBody = parsedOutput.body;
1848
- return throwDefaultError({
1849
- output,
1850
- parsedBody,
1851
- errorCode,
1852
- });
1853
- }
1854
- };
1855
1047
  export const de_GetCompatibleElasticsearchVersionsCommand = async (output, context) => {
1856
1048
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1857
- return de_GetCompatibleElasticsearchVersionsCommandError(output, context);
1049
+ return de_CommandError(output, context);
1858
1050
  }
1859
1051
  const contents = map({
1860
1052
  $metadata: deserializeMetadata(output),
@@ -1866,40 +1058,9 @@ export const de_GetCompatibleElasticsearchVersionsCommand = async (output, conte
1866
1058
  Object.assign(contents, doc);
1867
1059
  return contents;
1868
1060
  };
1869
- const de_GetCompatibleElasticsearchVersionsCommandError = async (output, context) => {
1870
- const parsedOutput = {
1871
- ...output,
1872
- body: await parseErrorBody(output.body, context),
1873
- };
1874
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1875
- switch (errorCode) {
1876
- case "BaseException":
1877
- case "com.amazonaws.elasticsearchservice#BaseException":
1878
- throw await de_BaseExceptionRes(parsedOutput, context);
1879
- case "DisabledOperationException":
1880
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1881
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1882
- case "InternalException":
1883
- case "com.amazonaws.elasticsearchservice#InternalException":
1884
- throw await de_InternalExceptionRes(parsedOutput, context);
1885
- case "ResourceNotFoundException":
1886
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1887
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1888
- case "ValidationException":
1889
- case "com.amazonaws.elasticsearchservice#ValidationException":
1890
- throw await de_ValidationExceptionRes(parsedOutput, context);
1891
- default:
1892
- const parsedBody = parsedOutput.body;
1893
- return throwDefaultError({
1894
- output,
1895
- parsedBody,
1896
- errorCode,
1897
- });
1898
- }
1899
- };
1900
1061
  export const de_GetPackageVersionHistoryCommand = async (output, context) => {
1901
1062
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1902
- return de_GetPackageVersionHistoryCommandError(output, context);
1063
+ return de_CommandError(output, context);
1903
1064
  }
1904
1065
  const contents = map({
1905
1066
  $metadata: deserializeMetadata(output),
@@ -1913,40 +1074,9 @@ export const de_GetPackageVersionHistoryCommand = async (output, context) => {
1913
1074
  Object.assign(contents, doc);
1914
1075
  return contents;
1915
1076
  };
1916
- const de_GetPackageVersionHistoryCommandError = async (output, context) => {
1917
- const parsedOutput = {
1918
- ...output,
1919
- body: await parseErrorBody(output.body, context),
1920
- };
1921
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1922
- switch (errorCode) {
1923
- case "AccessDeniedException":
1924
- case "com.amazonaws.elasticsearchservice#AccessDeniedException":
1925
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1926
- case "BaseException":
1927
- case "com.amazonaws.elasticsearchservice#BaseException":
1928
- throw await de_BaseExceptionRes(parsedOutput, context);
1929
- case "InternalException":
1930
- case "com.amazonaws.elasticsearchservice#InternalException":
1931
- throw await de_InternalExceptionRes(parsedOutput, context);
1932
- case "ResourceNotFoundException":
1933
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1934
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1935
- case "ValidationException":
1936
- case "com.amazonaws.elasticsearchservice#ValidationException":
1937
- throw await de_ValidationExceptionRes(parsedOutput, context);
1938
- default:
1939
- const parsedBody = parsedOutput.body;
1940
- return throwDefaultError({
1941
- output,
1942
- parsedBody,
1943
- errorCode,
1944
- });
1945
- }
1946
- };
1947
1077
  export const de_GetUpgradeHistoryCommand = async (output, context) => {
1948
1078
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1949
- return de_GetUpgradeHistoryCommandError(output, context);
1079
+ return de_CommandError(output, context);
1950
1080
  }
1951
1081
  const contents = map({
1952
1082
  $metadata: deserializeMetadata(output),
@@ -1959,40 +1089,9 @@ export const de_GetUpgradeHistoryCommand = async (output, context) => {
1959
1089
  Object.assign(contents, doc);
1960
1090
  return contents;
1961
1091
  };
1962
- const de_GetUpgradeHistoryCommandError = async (output, context) => {
1963
- const parsedOutput = {
1964
- ...output,
1965
- body: await parseErrorBody(output.body, context),
1966
- };
1967
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1968
- switch (errorCode) {
1969
- case "BaseException":
1970
- case "com.amazonaws.elasticsearchservice#BaseException":
1971
- throw await de_BaseExceptionRes(parsedOutput, context);
1972
- case "DisabledOperationException":
1973
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
1974
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1975
- case "InternalException":
1976
- case "com.amazonaws.elasticsearchservice#InternalException":
1977
- throw await de_InternalExceptionRes(parsedOutput, context);
1978
- case "ResourceNotFoundException":
1979
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
1980
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1981
- case "ValidationException":
1982
- case "com.amazonaws.elasticsearchservice#ValidationException":
1983
- throw await de_ValidationExceptionRes(parsedOutput, context);
1984
- default:
1985
- const parsedBody = parsedOutput.body;
1986
- return throwDefaultError({
1987
- output,
1988
- parsedBody,
1989
- errorCode,
1990
- });
1991
- }
1992
- };
1993
1092
  export const de_GetUpgradeStatusCommand = async (output, context) => {
1994
1093
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1995
- return de_GetUpgradeStatusCommandError(output, context);
1094
+ return de_CommandError(output, context);
1996
1095
  }
1997
1096
  const contents = map({
1998
1097
  $metadata: deserializeMetadata(output),
@@ -2006,40 +1105,9 @@ export const de_GetUpgradeStatusCommand = async (output, context) => {
2006
1105
  Object.assign(contents, doc);
2007
1106
  return contents;
2008
1107
  };
2009
- const de_GetUpgradeStatusCommandError = async (output, context) => {
2010
- const parsedOutput = {
2011
- ...output,
2012
- body: await parseErrorBody(output.body, context),
2013
- };
2014
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2015
- switch (errorCode) {
2016
- case "BaseException":
2017
- case "com.amazonaws.elasticsearchservice#BaseException":
2018
- throw await de_BaseExceptionRes(parsedOutput, context);
2019
- case "DisabledOperationException":
2020
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
2021
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2022
- case "InternalException":
2023
- case "com.amazonaws.elasticsearchservice#InternalException":
2024
- throw await de_InternalExceptionRes(parsedOutput, context);
2025
- case "ResourceNotFoundException":
2026
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2027
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2028
- case "ValidationException":
2029
- case "com.amazonaws.elasticsearchservice#ValidationException":
2030
- throw await de_ValidationExceptionRes(parsedOutput, context);
2031
- default:
2032
- const parsedBody = parsedOutput.body;
2033
- return throwDefaultError({
2034
- output,
2035
- parsedBody,
2036
- errorCode,
2037
- });
2038
- }
2039
- };
2040
1108
  export const de_ListDomainNamesCommand = async (output, context) => {
2041
1109
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2042
- return de_ListDomainNamesCommandError(output, context);
1110
+ return de_CommandError(output, context);
2043
1111
  }
2044
1112
  const contents = map({
2045
1113
  $metadata: deserializeMetadata(output),
@@ -2051,31 +1119,9 @@ export const de_ListDomainNamesCommand = async (output, context) => {
2051
1119
  Object.assign(contents, doc);
2052
1120
  return contents;
2053
1121
  };
2054
- const de_ListDomainNamesCommandError = async (output, context) => {
2055
- const parsedOutput = {
2056
- ...output,
2057
- body: await parseErrorBody(output.body, context),
2058
- };
2059
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2060
- switch (errorCode) {
2061
- case "BaseException":
2062
- case "com.amazonaws.elasticsearchservice#BaseException":
2063
- throw await de_BaseExceptionRes(parsedOutput, context);
2064
- case "ValidationException":
2065
- case "com.amazonaws.elasticsearchservice#ValidationException":
2066
- throw await de_ValidationExceptionRes(parsedOutput, context);
2067
- default:
2068
- const parsedBody = parsedOutput.body;
2069
- return throwDefaultError({
2070
- output,
2071
- parsedBody,
2072
- errorCode,
2073
- });
2074
- }
2075
- };
2076
1122
  export const de_ListDomainsForPackageCommand = async (output, context) => {
2077
1123
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2078
- return de_ListDomainsForPackageCommandError(output, context);
1124
+ return de_CommandError(output, context);
2079
1125
  }
2080
1126
  const contents = map({
2081
1127
  $metadata: deserializeMetadata(output),
@@ -2088,40 +1134,9 @@ export const de_ListDomainsForPackageCommand = async (output, context) => {
2088
1134
  Object.assign(contents, doc);
2089
1135
  return contents;
2090
1136
  };
2091
- const de_ListDomainsForPackageCommandError = async (output, context) => {
2092
- const parsedOutput = {
2093
- ...output,
2094
- body: await parseErrorBody(output.body, context),
2095
- };
2096
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2097
- switch (errorCode) {
2098
- case "AccessDeniedException":
2099
- case "com.amazonaws.elasticsearchservice#AccessDeniedException":
2100
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2101
- case "BaseException":
2102
- case "com.amazonaws.elasticsearchservice#BaseException":
2103
- throw await de_BaseExceptionRes(parsedOutput, context);
2104
- case "InternalException":
2105
- case "com.amazonaws.elasticsearchservice#InternalException":
2106
- throw await de_InternalExceptionRes(parsedOutput, context);
2107
- case "ResourceNotFoundException":
2108
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2109
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2110
- case "ValidationException":
2111
- case "com.amazonaws.elasticsearchservice#ValidationException":
2112
- throw await de_ValidationExceptionRes(parsedOutput, context);
2113
- default:
2114
- const parsedBody = parsedOutput.body;
2115
- return throwDefaultError({
2116
- output,
2117
- parsedBody,
2118
- errorCode,
2119
- });
2120
- }
2121
- };
2122
1137
  export const de_ListElasticsearchInstanceTypesCommand = async (output, context) => {
2123
1138
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2124
- return de_ListElasticsearchInstanceTypesCommandError(output, context);
1139
+ return de_CommandError(output, context);
2125
1140
  }
2126
1141
  const contents = map({
2127
1142
  $metadata: deserializeMetadata(output),
@@ -2134,37 +1149,9 @@ export const de_ListElasticsearchInstanceTypesCommand = async (output, context)
2134
1149
  Object.assign(contents, doc);
2135
1150
  return contents;
2136
1151
  };
2137
- const de_ListElasticsearchInstanceTypesCommandError = async (output, context) => {
2138
- const parsedOutput = {
2139
- ...output,
2140
- body: await parseErrorBody(output.body, context),
2141
- };
2142
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2143
- switch (errorCode) {
2144
- case "BaseException":
2145
- case "com.amazonaws.elasticsearchservice#BaseException":
2146
- throw await de_BaseExceptionRes(parsedOutput, context);
2147
- case "InternalException":
2148
- case "com.amazonaws.elasticsearchservice#InternalException":
2149
- throw await de_InternalExceptionRes(parsedOutput, context);
2150
- case "ResourceNotFoundException":
2151
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2152
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2153
- case "ValidationException":
2154
- case "com.amazonaws.elasticsearchservice#ValidationException":
2155
- throw await de_ValidationExceptionRes(parsedOutput, context);
2156
- default:
2157
- const parsedBody = parsedOutput.body;
2158
- return throwDefaultError({
2159
- output,
2160
- parsedBody,
2161
- errorCode,
2162
- });
2163
- }
2164
- };
2165
1152
  export const de_ListElasticsearchVersionsCommand = async (output, context) => {
2166
1153
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2167
- return de_ListElasticsearchVersionsCommandError(output, context);
1154
+ return de_CommandError(output, context);
2168
1155
  }
2169
1156
  const contents = map({
2170
1157
  $metadata: deserializeMetadata(output),
@@ -2177,37 +1164,9 @@ export const de_ListElasticsearchVersionsCommand = async (output, context) => {
2177
1164
  Object.assign(contents, doc);
2178
1165
  return contents;
2179
1166
  };
2180
- const de_ListElasticsearchVersionsCommandError = async (output, context) => {
2181
- const parsedOutput = {
2182
- ...output,
2183
- body: await parseErrorBody(output.body, context),
2184
- };
2185
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2186
- switch (errorCode) {
2187
- case "BaseException":
2188
- case "com.amazonaws.elasticsearchservice#BaseException":
2189
- throw await de_BaseExceptionRes(parsedOutput, context);
2190
- case "InternalException":
2191
- case "com.amazonaws.elasticsearchservice#InternalException":
2192
- throw await de_InternalExceptionRes(parsedOutput, context);
2193
- case "ResourceNotFoundException":
2194
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2195
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2196
- case "ValidationException":
2197
- case "com.amazonaws.elasticsearchservice#ValidationException":
2198
- throw await de_ValidationExceptionRes(parsedOutput, context);
2199
- default:
2200
- const parsedBody = parsedOutput.body;
2201
- return throwDefaultError({
2202
- output,
2203
- parsedBody,
2204
- errorCode,
2205
- });
2206
- }
2207
- };
2208
1167
  export const de_ListPackagesForDomainCommand = async (output, context) => {
2209
1168
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2210
- return de_ListPackagesForDomainCommandError(output, context);
1169
+ return de_CommandError(output, context);
2211
1170
  }
2212
1171
  const contents = map({
2213
1172
  $metadata: deserializeMetadata(output),
@@ -2220,40 +1179,9 @@ export const de_ListPackagesForDomainCommand = async (output, context) => {
2220
1179
  Object.assign(contents, doc);
2221
1180
  return contents;
2222
1181
  };
2223
- const de_ListPackagesForDomainCommandError = async (output, context) => {
2224
- const parsedOutput = {
2225
- ...output,
2226
- body: await parseErrorBody(output.body, context),
2227
- };
2228
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2229
- switch (errorCode) {
2230
- case "AccessDeniedException":
2231
- case "com.amazonaws.elasticsearchservice#AccessDeniedException":
2232
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2233
- case "BaseException":
2234
- case "com.amazonaws.elasticsearchservice#BaseException":
2235
- throw await de_BaseExceptionRes(parsedOutput, context);
2236
- case "InternalException":
2237
- case "com.amazonaws.elasticsearchservice#InternalException":
2238
- throw await de_InternalExceptionRes(parsedOutput, context);
2239
- case "ResourceNotFoundException":
2240
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2241
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2242
- case "ValidationException":
2243
- case "com.amazonaws.elasticsearchservice#ValidationException":
2244
- throw await de_ValidationExceptionRes(parsedOutput, context);
2245
- default:
2246
- const parsedBody = parsedOutput.body;
2247
- return throwDefaultError({
2248
- output,
2249
- parsedBody,
2250
- errorCode,
2251
- });
2252
- }
2253
- };
2254
1182
  export const de_ListTagsCommand = async (output, context) => {
2255
1183
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2256
- return de_ListTagsCommandError(output, context);
1184
+ return de_CommandError(output, context);
2257
1185
  }
2258
1186
  const contents = map({
2259
1187
  $metadata: deserializeMetadata(output),
@@ -2265,37 +1193,9 @@ export const de_ListTagsCommand = async (output, context) => {
2265
1193
  Object.assign(contents, doc);
2266
1194
  return contents;
2267
1195
  };
2268
- const de_ListTagsCommandError = async (output, context) => {
2269
- const parsedOutput = {
2270
- ...output,
2271
- body: await parseErrorBody(output.body, context),
2272
- };
2273
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2274
- switch (errorCode) {
2275
- case "BaseException":
2276
- case "com.amazonaws.elasticsearchservice#BaseException":
2277
- throw await de_BaseExceptionRes(parsedOutput, context);
2278
- case "InternalException":
2279
- case "com.amazonaws.elasticsearchservice#InternalException":
2280
- throw await de_InternalExceptionRes(parsedOutput, context);
2281
- case "ResourceNotFoundException":
2282
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2283
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2284
- case "ValidationException":
2285
- case "com.amazonaws.elasticsearchservice#ValidationException":
2286
- throw await de_ValidationExceptionRes(parsedOutput, context);
2287
- default:
2288
- const parsedBody = parsedOutput.body;
2289
- return throwDefaultError({
2290
- output,
2291
- parsedBody,
2292
- errorCode,
2293
- });
2294
- }
2295
- };
2296
1196
  export const de_ListVpcEndpointAccessCommand = async (output, context) => {
2297
1197
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2298
- return de_ListVpcEndpointAccessCommandError(output, context);
1198
+ return de_CommandError(output, context);
2299
1199
  }
2300
1200
  const contents = map({
2301
1201
  $metadata: deserializeMetadata(output),
@@ -2308,37 +1208,9 @@ export const de_ListVpcEndpointAccessCommand = async (output, context) => {
2308
1208
  Object.assign(contents, doc);
2309
1209
  return contents;
2310
1210
  };
2311
- const de_ListVpcEndpointAccessCommandError = async (output, context) => {
2312
- const parsedOutput = {
2313
- ...output,
2314
- body: await parseErrorBody(output.body, context),
2315
- };
2316
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2317
- switch (errorCode) {
2318
- case "BaseException":
2319
- case "com.amazonaws.elasticsearchservice#BaseException":
2320
- throw await de_BaseExceptionRes(parsedOutput, context);
2321
- case "DisabledOperationException":
2322
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
2323
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2324
- case "InternalException":
2325
- case "com.amazonaws.elasticsearchservice#InternalException":
2326
- throw await de_InternalExceptionRes(parsedOutput, context);
2327
- case "ResourceNotFoundException":
2328
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2329
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2330
- default:
2331
- const parsedBody = parsedOutput.body;
2332
- return throwDefaultError({
2333
- output,
2334
- parsedBody,
2335
- errorCode,
2336
- });
2337
- }
2338
- };
2339
1211
  export const de_ListVpcEndpointsCommand = async (output, context) => {
2340
1212
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2341
- return de_ListVpcEndpointsCommandError(output, context);
1213
+ return de_CommandError(output, context);
2342
1214
  }
2343
1215
  const contents = map({
2344
1216
  $metadata: deserializeMetadata(output),
@@ -2351,126 +1223,39 @@ export const de_ListVpcEndpointsCommand = async (output, context) => {
2351
1223
  Object.assign(contents, doc);
2352
1224
  return contents;
2353
1225
  };
2354
- const de_ListVpcEndpointsCommandError = async (output, context) => {
2355
- const parsedOutput = {
2356
- ...output,
2357
- body: await parseErrorBody(output.body, context),
2358
- };
2359
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2360
- switch (errorCode) {
2361
- case "BaseException":
2362
- case "com.amazonaws.elasticsearchservice#BaseException":
2363
- throw await de_BaseExceptionRes(parsedOutput, context);
2364
- case "DisabledOperationException":
2365
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
2366
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2367
- case "InternalException":
2368
- case "com.amazonaws.elasticsearchservice#InternalException":
2369
- throw await de_InternalExceptionRes(parsedOutput, context);
2370
- default:
2371
- const parsedBody = parsedOutput.body;
2372
- return throwDefaultError({
2373
- output,
2374
- parsedBody,
2375
- errorCode,
2376
- });
2377
- }
2378
- };
2379
1226
  export const de_ListVpcEndpointsForDomainCommand = async (output, context) => {
2380
1227
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2381
- return de_ListVpcEndpointsForDomainCommandError(output, context);
2382
- }
2383
- const contents = map({
2384
- $metadata: deserializeMetadata(output),
2385
- });
2386
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2387
- const doc = take(data, {
2388
- NextToken: __expectString,
2389
- VpcEndpointSummaryList: _json,
2390
- });
2391
- Object.assign(contents, doc);
2392
- return contents;
2393
- };
2394
- const de_ListVpcEndpointsForDomainCommandError = async (output, context) => {
2395
- const parsedOutput = {
2396
- ...output,
2397
- body: await parseErrorBody(output.body, context),
2398
- };
2399
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2400
- switch (errorCode) {
2401
- case "BaseException":
2402
- case "com.amazonaws.elasticsearchservice#BaseException":
2403
- throw await de_BaseExceptionRes(parsedOutput, context);
2404
- case "DisabledOperationException":
2405
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
2406
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2407
- case "InternalException":
2408
- case "com.amazonaws.elasticsearchservice#InternalException":
2409
- throw await de_InternalExceptionRes(parsedOutput, context);
2410
- case "ResourceNotFoundException":
2411
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2412
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2413
- default:
2414
- const parsedBody = parsedOutput.body;
2415
- return throwDefaultError({
2416
- output,
2417
- parsedBody,
2418
- errorCode,
2419
- });
2420
- }
2421
- };
2422
- export const de_PurchaseReservedElasticsearchInstanceOfferingCommand = async (output, context) => {
2423
- if (output.statusCode !== 200 && output.statusCode >= 300) {
2424
- return de_PurchaseReservedElasticsearchInstanceOfferingCommandError(output, context);
1228
+ return de_CommandError(output, context);
2425
1229
  }
2426
1230
  const contents = map({
2427
- $metadata: deserializeMetadata(output),
2428
- });
2429
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2430
- const doc = take(data, {
2431
- ReservationName: __expectString,
2432
- ReservedElasticsearchInstanceId: __expectString,
2433
- });
2434
- Object.assign(contents, doc);
2435
- return contents;
2436
- };
2437
- const de_PurchaseReservedElasticsearchInstanceOfferingCommandError = async (output, context) => {
2438
- const parsedOutput = {
2439
- ...output,
2440
- body: await parseErrorBody(output.body, context),
2441
- };
2442
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2443
- switch (errorCode) {
2444
- case "DisabledOperationException":
2445
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
2446
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2447
- case "InternalException":
2448
- case "com.amazonaws.elasticsearchservice#InternalException":
2449
- throw await de_InternalExceptionRes(parsedOutput, context);
2450
- case "LimitExceededException":
2451
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
2452
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2453
- case "ResourceAlreadyExistsException":
2454
- case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
2455
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
2456
- case "ResourceNotFoundException":
2457
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2458
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2459
- case "ValidationException":
2460
- case "com.amazonaws.elasticsearchservice#ValidationException":
2461
- throw await de_ValidationExceptionRes(parsedOutput, context);
2462
- default:
2463
- const parsedBody = parsedOutput.body;
2464
- return throwDefaultError({
2465
- output,
2466
- parsedBody,
2467
- errorCode,
2468
- });
1231
+ $metadata: deserializeMetadata(output),
1232
+ });
1233
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1234
+ const doc = take(data, {
1235
+ NextToken: __expectString,
1236
+ VpcEndpointSummaryList: _json,
1237
+ });
1238
+ Object.assign(contents, doc);
1239
+ return contents;
1240
+ };
1241
+ export const de_PurchaseReservedElasticsearchInstanceOfferingCommand = async (output, context) => {
1242
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1243
+ return de_CommandError(output, context);
2469
1244
  }
1245
+ const contents = map({
1246
+ $metadata: deserializeMetadata(output),
1247
+ });
1248
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1249
+ const doc = take(data, {
1250
+ ReservationName: __expectString,
1251
+ ReservedElasticsearchInstanceId: __expectString,
1252
+ });
1253
+ Object.assign(contents, doc);
1254
+ return contents;
2470
1255
  };
2471
1256
  export const de_RejectInboundCrossClusterSearchConnectionCommand = async (output, context) => {
2472
1257
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2473
- return de_RejectInboundCrossClusterSearchConnectionCommandError(output, context);
1258
+ return de_CommandError(output, context);
2474
1259
  }
2475
1260
  const contents = map({
2476
1261
  $metadata: deserializeMetadata(output),
@@ -2482,31 +1267,9 @@ export const de_RejectInboundCrossClusterSearchConnectionCommand = async (output
2482
1267
  Object.assign(contents, doc);
2483
1268
  return contents;
2484
1269
  };
2485
- const de_RejectInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
2486
- const parsedOutput = {
2487
- ...output,
2488
- body: await parseErrorBody(output.body, context),
2489
- };
2490
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2491
- switch (errorCode) {
2492
- case "DisabledOperationException":
2493
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
2494
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2495
- case "ResourceNotFoundException":
2496
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2497
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2498
- default:
2499
- const parsedBody = parsedOutput.body;
2500
- return throwDefaultError({
2501
- output,
2502
- parsedBody,
2503
- errorCode,
2504
- });
2505
- }
2506
- };
2507
1270
  export const de_RemoveTagsCommand = async (output, context) => {
2508
1271
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2509
- return de_RemoveTagsCommandError(output, context);
1272
+ return de_CommandError(output, context);
2510
1273
  }
2511
1274
  const contents = map({
2512
1275
  $metadata: deserializeMetadata(output),
@@ -2514,34 +1277,9 @@ export const de_RemoveTagsCommand = async (output, context) => {
2514
1277
  await collectBody(output.body, context);
2515
1278
  return contents;
2516
1279
  };
2517
- const de_RemoveTagsCommandError = async (output, context) => {
2518
- const parsedOutput = {
2519
- ...output,
2520
- body: await parseErrorBody(output.body, context),
2521
- };
2522
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2523
- switch (errorCode) {
2524
- case "BaseException":
2525
- case "com.amazonaws.elasticsearchservice#BaseException":
2526
- throw await de_BaseExceptionRes(parsedOutput, context);
2527
- case "InternalException":
2528
- case "com.amazonaws.elasticsearchservice#InternalException":
2529
- throw await de_InternalExceptionRes(parsedOutput, context);
2530
- case "ValidationException":
2531
- case "com.amazonaws.elasticsearchservice#ValidationException":
2532
- throw await de_ValidationExceptionRes(parsedOutput, context);
2533
- default:
2534
- const parsedBody = parsedOutput.body;
2535
- return throwDefaultError({
2536
- output,
2537
- parsedBody,
2538
- errorCode,
2539
- });
2540
- }
2541
- };
2542
1280
  export const de_RevokeVpcEndpointAccessCommand = async (output, context) => {
2543
1281
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2544
- return de_RevokeVpcEndpointAccessCommandError(output, context);
1282
+ return de_CommandError(output, context);
2545
1283
  }
2546
1284
  const contents = map({
2547
1285
  $metadata: deserializeMetadata(output),
@@ -2549,40 +1287,9 @@ export const de_RevokeVpcEndpointAccessCommand = async (output, context) => {
2549
1287
  await collectBody(output.body, context);
2550
1288
  return contents;
2551
1289
  };
2552
- const de_RevokeVpcEndpointAccessCommandError = async (output, context) => {
2553
- const parsedOutput = {
2554
- ...output,
2555
- body: await parseErrorBody(output.body, context),
2556
- };
2557
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2558
- switch (errorCode) {
2559
- case "BaseException":
2560
- case "com.amazonaws.elasticsearchservice#BaseException":
2561
- throw await de_BaseExceptionRes(parsedOutput, context);
2562
- case "DisabledOperationException":
2563
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
2564
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2565
- case "InternalException":
2566
- case "com.amazonaws.elasticsearchservice#InternalException":
2567
- throw await de_InternalExceptionRes(parsedOutput, context);
2568
- case "ResourceNotFoundException":
2569
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2570
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2571
- case "ValidationException":
2572
- case "com.amazonaws.elasticsearchservice#ValidationException":
2573
- throw await de_ValidationExceptionRes(parsedOutput, context);
2574
- default:
2575
- const parsedBody = parsedOutput.body;
2576
- return throwDefaultError({
2577
- output,
2578
- parsedBody,
2579
- errorCode,
2580
- });
2581
- }
2582
- };
2583
1290
  export const de_StartElasticsearchServiceSoftwareUpdateCommand = async (output, context) => {
2584
1291
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2585
- return de_StartElasticsearchServiceSoftwareUpdateCommandError(output, context);
1292
+ return de_CommandError(output, context);
2586
1293
  }
2587
1294
  const contents = map({
2588
1295
  $metadata: deserializeMetadata(output),
@@ -2594,37 +1301,9 @@ export const de_StartElasticsearchServiceSoftwareUpdateCommand = async (output,
2594
1301
  Object.assign(contents, doc);
2595
1302
  return contents;
2596
1303
  };
2597
- const de_StartElasticsearchServiceSoftwareUpdateCommandError = async (output, context) => {
2598
- const parsedOutput = {
2599
- ...output,
2600
- body: await parseErrorBody(output.body, context),
2601
- };
2602
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2603
- switch (errorCode) {
2604
- case "BaseException":
2605
- case "com.amazonaws.elasticsearchservice#BaseException":
2606
- throw await de_BaseExceptionRes(parsedOutput, context);
2607
- case "InternalException":
2608
- case "com.amazonaws.elasticsearchservice#InternalException":
2609
- throw await de_InternalExceptionRes(parsedOutput, context);
2610
- case "ResourceNotFoundException":
2611
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2612
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2613
- case "ValidationException":
2614
- case "com.amazonaws.elasticsearchservice#ValidationException":
2615
- throw await de_ValidationExceptionRes(parsedOutput, context);
2616
- default:
2617
- const parsedBody = parsedOutput.body;
2618
- return throwDefaultError({
2619
- output,
2620
- parsedBody,
2621
- errorCode,
2622
- });
2623
- }
2624
- };
2625
1304
  export const de_UpdateElasticsearchDomainConfigCommand = async (output, context) => {
2626
1305
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2627
- return de_UpdateElasticsearchDomainConfigCommandError(output, context);
1306
+ return de_CommandError(output, context);
2628
1307
  }
2629
1308
  const contents = map({
2630
1309
  $metadata: deserializeMetadata(output),
@@ -2637,43 +1316,9 @@ export const de_UpdateElasticsearchDomainConfigCommand = async (output, context)
2637
1316
  Object.assign(contents, doc);
2638
1317
  return contents;
2639
1318
  };
2640
- const de_UpdateElasticsearchDomainConfigCommandError = async (output, context) => {
2641
- const parsedOutput = {
2642
- ...output,
2643
- body: await parseErrorBody(output.body, context),
2644
- };
2645
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2646
- switch (errorCode) {
2647
- case "BaseException":
2648
- case "com.amazonaws.elasticsearchservice#BaseException":
2649
- throw await de_BaseExceptionRes(parsedOutput, context);
2650
- case "InternalException":
2651
- case "com.amazonaws.elasticsearchservice#InternalException":
2652
- throw await de_InternalExceptionRes(parsedOutput, context);
2653
- case "InvalidTypeException":
2654
- case "com.amazonaws.elasticsearchservice#InvalidTypeException":
2655
- throw await de_InvalidTypeExceptionRes(parsedOutput, context);
2656
- case "LimitExceededException":
2657
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
2658
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2659
- case "ResourceNotFoundException":
2660
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2661
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2662
- case "ValidationException":
2663
- case "com.amazonaws.elasticsearchservice#ValidationException":
2664
- throw await de_ValidationExceptionRes(parsedOutput, context);
2665
- default:
2666
- const parsedBody = parsedOutput.body;
2667
- return throwDefaultError({
2668
- output,
2669
- parsedBody,
2670
- errorCode,
2671
- });
2672
- }
2673
- };
2674
1319
  export const de_UpdatePackageCommand = async (output, context) => {
2675
1320
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2676
- return de_UpdatePackageCommandError(output, context);
1321
+ return de_CommandError(output, context);
2677
1322
  }
2678
1323
  const contents = map({
2679
1324
  $metadata: deserializeMetadata(output),
@@ -2685,43 +1330,9 @@ export const de_UpdatePackageCommand = async (output, context) => {
2685
1330
  Object.assign(contents, doc);
2686
1331
  return contents;
2687
1332
  };
2688
- const de_UpdatePackageCommandError = async (output, context) => {
2689
- const parsedOutput = {
2690
- ...output,
2691
- body: await parseErrorBody(output.body, context),
2692
- };
2693
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2694
- switch (errorCode) {
2695
- case "AccessDeniedException":
2696
- case "com.amazonaws.elasticsearchservice#AccessDeniedException":
2697
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2698
- case "BaseException":
2699
- case "com.amazonaws.elasticsearchservice#BaseException":
2700
- throw await de_BaseExceptionRes(parsedOutput, context);
2701
- case "InternalException":
2702
- case "com.amazonaws.elasticsearchservice#InternalException":
2703
- throw await de_InternalExceptionRes(parsedOutput, context);
2704
- case "LimitExceededException":
2705
- case "com.amazonaws.elasticsearchservice#LimitExceededException":
2706
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2707
- case "ResourceNotFoundException":
2708
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2709
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2710
- case "ValidationException":
2711
- case "com.amazonaws.elasticsearchservice#ValidationException":
2712
- throw await de_ValidationExceptionRes(parsedOutput, context);
2713
- default:
2714
- const parsedBody = parsedOutput.body;
2715
- return throwDefaultError({
2716
- output,
2717
- parsedBody,
2718
- errorCode,
2719
- });
2720
- }
2721
- };
2722
1333
  export const de_UpdateVpcEndpointCommand = async (output, context) => {
2723
1334
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2724
- return de_UpdateVpcEndpointCommandError(output, context);
1335
+ return de_CommandError(output, context);
2725
1336
  }
2726
1337
  const contents = map({
2727
1338
  $metadata: deserializeMetadata(output),
@@ -2733,43 +1344,9 @@ export const de_UpdateVpcEndpointCommand = async (output, context) => {
2733
1344
  Object.assign(contents, doc);
2734
1345
  return contents;
2735
1346
  };
2736
- const de_UpdateVpcEndpointCommandError = async (output, context) => {
2737
- const parsedOutput = {
2738
- ...output,
2739
- body: await parseErrorBody(output.body, context),
2740
- };
2741
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2742
- switch (errorCode) {
2743
- case "BaseException":
2744
- case "com.amazonaws.elasticsearchservice#BaseException":
2745
- throw await de_BaseExceptionRes(parsedOutput, context);
2746
- case "ConflictException":
2747
- case "com.amazonaws.elasticsearchservice#ConflictException":
2748
- throw await de_ConflictExceptionRes(parsedOutput, context);
2749
- case "DisabledOperationException":
2750
- case "com.amazonaws.elasticsearchservice#DisabledOperationException":
2751
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2752
- case "InternalException":
2753
- case "com.amazonaws.elasticsearchservice#InternalException":
2754
- throw await de_InternalExceptionRes(parsedOutput, context);
2755
- case "ResourceNotFoundException":
2756
- case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2757
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2758
- case "ValidationException":
2759
- case "com.amazonaws.elasticsearchservice#ValidationException":
2760
- throw await de_ValidationExceptionRes(parsedOutput, context);
2761
- default:
2762
- const parsedBody = parsedOutput.body;
2763
- return throwDefaultError({
2764
- output,
2765
- parsedBody,
2766
- errorCode,
2767
- });
2768
- }
2769
- };
2770
1347
  export const de_UpgradeElasticsearchDomainCommand = async (output, context) => {
2771
1348
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2772
- return de_UpgradeElasticsearchDomainCommandError(output, context);
1349
+ return de_CommandError(output, context);
2773
1350
  }
2774
1351
  const contents = map({
2775
1352
  $metadata: deserializeMetadata(output),
@@ -2784,31 +1361,46 @@ export const de_UpgradeElasticsearchDomainCommand = async (output, context) => {
2784
1361
  Object.assign(contents, doc);
2785
1362
  return contents;
2786
1363
  };
2787
- const de_UpgradeElasticsearchDomainCommandError = async (output, context) => {
1364
+ const de_CommandError = async (output, context) => {
2788
1365
  const parsedOutput = {
2789
1366
  ...output,
2790
1367
  body: await parseErrorBody(output.body, context),
2791
1368
  };
2792
1369
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2793
1370
  switch (errorCode) {
2794
- case "BaseException":
2795
- case "com.amazonaws.elasticsearchservice#BaseException":
2796
- throw await de_BaseExceptionRes(parsedOutput, context);
2797
1371
  case "DisabledOperationException":
2798
1372
  case "com.amazonaws.elasticsearchservice#DisabledOperationException":
2799
1373
  throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2800
- case "InternalException":
2801
- case "com.amazonaws.elasticsearchservice#InternalException":
2802
- throw await de_InternalExceptionRes(parsedOutput, context);
2803
- case "ResourceAlreadyExistsException":
2804
- case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
2805
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1374
+ case "LimitExceededException":
1375
+ case "com.amazonaws.elasticsearchservice#LimitExceededException":
1376
+ throw await de_LimitExceededExceptionRes(parsedOutput, context);
2806
1377
  case "ResourceNotFoundException":
2807
1378
  case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
2808
1379
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1380
+ case "BaseException":
1381
+ case "com.amazonaws.elasticsearchservice#BaseException":
1382
+ throw await de_BaseExceptionRes(parsedOutput, context);
1383
+ case "InternalException":
1384
+ case "com.amazonaws.elasticsearchservice#InternalException":
1385
+ throw await de_InternalExceptionRes(parsedOutput, context);
2809
1386
  case "ValidationException":
2810
1387
  case "com.amazonaws.elasticsearchservice#ValidationException":
2811
1388
  throw await de_ValidationExceptionRes(parsedOutput, context);
1389
+ case "AccessDeniedException":
1390
+ case "com.amazonaws.elasticsearchservice#AccessDeniedException":
1391
+ throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1392
+ case "ConflictException":
1393
+ case "com.amazonaws.elasticsearchservice#ConflictException":
1394
+ throw await de_ConflictExceptionRes(parsedOutput, context);
1395
+ case "InvalidTypeException":
1396
+ case "com.amazonaws.elasticsearchservice#InvalidTypeException":
1397
+ throw await de_InvalidTypeExceptionRes(parsedOutput, context);
1398
+ case "ResourceAlreadyExistsException":
1399
+ case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
1400
+ throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1401
+ case "InvalidPaginationTokenException":
1402
+ case "com.amazonaws.elasticsearchservice#InvalidPaginationTokenException":
1403
+ throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
2812
1404
  default:
2813
1405
  const parsedBody = parsedOutput.body;
2814
1406
  return throwDefaultError({