@aws-sdk/client-appsync 3.504.0 → 3.508.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 (24) hide show
  1. package/README.md +16 -0
  2. package/dist-cjs/commands/GetGraphqlApiEnvironmentVariablesCommand.js +1 -0
  3. package/dist-cjs/commands/PutGraphqlApiEnvironmentVariablesCommand.js +1 -0
  4. package/dist-cjs/index.js +210 -1924
  5. package/dist-es/AppSync.js +4 -0
  6. package/dist-es/commands/GetGraphqlApiEnvironmentVariablesCommand.js +24 -0
  7. package/dist-es/commands/PutGraphqlApiEnvironmentVariablesCommand.js +24 -0
  8. package/dist-es/commands/index.js +2 -0
  9. package/dist-es/protocols/Aws_restJson1.js +166 -1922
  10. package/dist-types/AppSync.d.ts +14 -0
  11. package/dist-types/AppSyncClient.d.ts +4 -2
  12. package/dist-types/commands/GetGraphqlApiEnvironmentVariablesCommand.d.ts +76 -0
  13. package/dist-types/commands/PutGraphqlApiEnvironmentVariablesCommand.d.ts +127 -0
  14. package/dist-types/commands/index.d.ts +2 -0
  15. package/dist-types/models/models_0.d.ts +70 -0
  16. package/dist-types/protocols/Aws_restJson1.d.ts +18 -0
  17. package/dist-types/ts3.4/AppSync.d.ts +46 -0
  18. package/dist-types/ts3.4/AppSyncClient.d.ts +12 -0
  19. package/dist-types/ts3.4/commands/GetGraphqlApiEnvironmentVariablesCommand.d.ts +30 -0
  20. package/dist-types/ts3.4/commands/PutGraphqlApiEnvironmentVariablesCommand.d.ts +30 -0
  21. package/dist-types/ts3.4/commands/index.d.ts +2 -0
  22. package/dist-types/ts3.4/models/models_0.d.ts +13 -0
  23. package/dist-types/ts3.4/protocols/Aws_restJson1.d.ts +24 -0
  24. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -427,6 +427,15 @@ export const se_GetGraphqlApiCommand = async (input, context) => {
427
427
  b.m("GET").h(headers).b(body);
428
428
  return b.build();
429
429
  };
430
+ export const se_GetGraphqlApiEnvironmentVariablesCommand = async (input, context) => {
431
+ const b = rb(input, context);
432
+ const headers = {};
433
+ b.bp("/v1/apis/{apiId}/environmentVariables");
434
+ b.p("apiId", () => input.apiId, "{apiId}", false);
435
+ let body;
436
+ b.m("GET").h(headers).b(body);
437
+ return b.build();
438
+ };
430
439
  export const se_GetIntrospectionSchemaCommand = async (input, context) => {
431
440
  const b = rb(input, context);
432
441
  const headers = {};
@@ -627,6 +636,20 @@ export const se_ListTypesByAssociationCommand = async (input, context) => {
627
636
  b.m("GET").h(headers).q(query).b(body);
628
637
  return b.build();
629
638
  };
639
+ export const se_PutGraphqlApiEnvironmentVariablesCommand = async (input, context) => {
640
+ const b = rb(input, context);
641
+ const headers = {
642
+ "content-type": "application/json",
643
+ };
644
+ b.bp("/v1/apis/{apiId}/environmentVariables");
645
+ b.p("apiId", () => input.apiId, "{apiId}", false);
646
+ let body;
647
+ body = JSON.stringify(take(input, {
648
+ environmentVariables: (_) => _json(_),
649
+ }));
650
+ b.m("PUT").h(headers).b(body);
651
+ return b.build();
652
+ };
630
653
  export const se_StartDataSourceIntrospectionCommand = async (input, context) => {
631
654
  const b = rb(input, context);
632
655
  const headers = {
@@ -872,7 +895,7 @@ export const se_UpdateTypeCommand = async (input, context) => {
872
895
  };
873
896
  export const de_AssociateApiCommand = async (output, context) => {
874
897
  if (output.statusCode !== 200 && output.statusCode >= 300) {
875
- return de_AssociateApiCommandError(output, context);
898
+ return de_CommandError(output, context);
876
899
  }
877
900
  const contents = map({
878
901
  $metadata: deserializeMetadata(output),
@@ -884,37 +907,9 @@ export const de_AssociateApiCommand = async (output, context) => {
884
907
  Object.assign(contents, doc);
885
908
  return contents;
886
909
  };
887
- const de_AssociateApiCommandError = async (output, context) => {
888
- const parsedOutput = {
889
- ...output,
890
- body: await parseErrorBody(output.body, context),
891
- };
892
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
893
- switch (errorCode) {
894
- case "AccessDeniedException":
895
- case "com.amazonaws.appsync#AccessDeniedException":
896
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
897
- case "BadRequestException":
898
- case "com.amazonaws.appsync#BadRequestException":
899
- throw await de_BadRequestExceptionRes(parsedOutput, context);
900
- case "InternalFailureException":
901
- case "com.amazonaws.appsync#InternalFailureException":
902
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
903
- case "NotFoundException":
904
- case "com.amazonaws.appsync#NotFoundException":
905
- throw await de_NotFoundExceptionRes(parsedOutput, context);
906
- default:
907
- const parsedBody = parsedOutput.body;
908
- return throwDefaultError({
909
- output,
910
- parsedBody,
911
- errorCode,
912
- });
913
- }
914
- };
915
910
  export const de_AssociateMergedGraphqlApiCommand = async (output, context) => {
916
911
  if (output.statusCode !== 200 && output.statusCode >= 300) {
917
- return de_AssociateMergedGraphqlApiCommandError(output, context);
912
+ return de_CommandError(output, context);
918
913
  }
919
914
  const contents = map({
920
915
  $metadata: deserializeMetadata(output),
@@ -926,43 +921,9 @@ export const de_AssociateMergedGraphqlApiCommand = async (output, context) => {
926
921
  Object.assign(contents, doc);
927
922
  return contents;
928
923
  };
929
- const de_AssociateMergedGraphqlApiCommandError = async (output, context) => {
930
- const parsedOutput = {
931
- ...output,
932
- body: await parseErrorBody(output.body, context),
933
- };
934
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
935
- switch (errorCode) {
936
- case "BadRequestException":
937
- case "com.amazonaws.appsync#BadRequestException":
938
- throw await de_BadRequestExceptionRes(parsedOutput, context);
939
- case "ConcurrentModificationException":
940
- case "com.amazonaws.appsync#ConcurrentModificationException":
941
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
942
- case "InternalFailureException":
943
- case "com.amazonaws.appsync#InternalFailureException":
944
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
945
- case "LimitExceededException":
946
- case "com.amazonaws.appsync#LimitExceededException":
947
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
948
- case "NotFoundException":
949
- case "com.amazonaws.appsync#NotFoundException":
950
- throw await de_NotFoundExceptionRes(parsedOutput, context);
951
- case "UnauthorizedException":
952
- case "com.amazonaws.appsync#UnauthorizedException":
953
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
954
- default:
955
- const parsedBody = parsedOutput.body;
956
- return throwDefaultError({
957
- output,
958
- parsedBody,
959
- errorCode,
960
- });
961
- }
962
- };
963
924
  export const de_AssociateSourceGraphqlApiCommand = async (output, context) => {
964
925
  if (output.statusCode !== 200 && output.statusCode >= 300) {
965
- return de_AssociateSourceGraphqlApiCommandError(output, context);
926
+ return de_CommandError(output, context);
966
927
  }
967
928
  const contents = map({
968
929
  $metadata: deserializeMetadata(output),
@@ -974,43 +935,9 @@ export const de_AssociateSourceGraphqlApiCommand = async (output, context) => {
974
935
  Object.assign(contents, doc);
975
936
  return contents;
976
937
  };
977
- const de_AssociateSourceGraphqlApiCommandError = async (output, context) => {
978
- const parsedOutput = {
979
- ...output,
980
- body: await parseErrorBody(output.body, context),
981
- };
982
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
983
- switch (errorCode) {
984
- case "BadRequestException":
985
- case "com.amazonaws.appsync#BadRequestException":
986
- throw await de_BadRequestExceptionRes(parsedOutput, context);
987
- case "ConcurrentModificationException":
988
- case "com.amazonaws.appsync#ConcurrentModificationException":
989
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
990
- case "InternalFailureException":
991
- case "com.amazonaws.appsync#InternalFailureException":
992
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
993
- case "LimitExceededException":
994
- case "com.amazonaws.appsync#LimitExceededException":
995
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
996
- case "NotFoundException":
997
- case "com.amazonaws.appsync#NotFoundException":
998
- throw await de_NotFoundExceptionRes(parsedOutput, context);
999
- case "UnauthorizedException":
1000
- case "com.amazonaws.appsync#UnauthorizedException":
1001
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1002
- default:
1003
- const parsedBody = parsedOutput.body;
1004
- return throwDefaultError({
1005
- output,
1006
- parsedBody,
1007
- errorCode,
1008
- });
1009
- }
1010
- };
1011
938
  export const de_CreateApiCacheCommand = async (output, context) => {
1012
939
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1013
- return de_CreateApiCacheCommandError(output, context);
940
+ return de_CommandError(output, context);
1014
941
  }
1015
942
  const contents = map({
1016
943
  $metadata: deserializeMetadata(output),
@@ -1022,40 +949,9 @@ export const de_CreateApiCacheCommand = async (output, context) => {
1022
949
  Object.assign(contents, doc);
1023
950
  return contents;
1024
951
  };
1025
- const de_CreateApiCacheCommandError = async (output, context) => {
1026
- const parsedOutput = {
1027
- ...output,
1028
- body: await parseErrorBody(output.body, context),
1029
- };
1030
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1031
- switch (errorCode) {
1032
- case "BadRequestException":
1033
- case "com.amazonaws.appsync#BadRequestException":
1034
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1035
- case "ConcurrentModificationException":
1036
- case "com.amazonaws.appsync#ConcurrentModificationException":
1037
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1038
- case "InternalFailureException":
1039
- case "com.amazonaws.appsync#InternalFailureException":
1040
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1041
- case "NotFoundException":
1042
- case "com.amazonaws.appsync#NotFoundException":
1043
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1044
- case "UnauthorizedException":
1045
- case "com.amazonaws.appsync#UnauthorizedException":
1046
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1047
- default:
1048
- const parsedBody = parsedOutput.body;
1049
- return throwDefaultError({
1050
- output,
1051
- parsedBody,
1052
- errorCode,
1053
- });
1054
- }
1055
- };
1056
952
  export const de_CreateApiKeyCommand = async (output, context) => {
1057
953
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1058
- return de_CreateApiKeyCommandError(output, context);
954
+ return de_CommandError(output, context);
1059
955
  }
1060
956
  const contents = map({
1061
957
  $metadata: deserializeMetadata(output),
@@ -1067,46 +963,9 @@ export const de_CreateApiKeyCommand = async (output, context) => {
1067
963
  Object.assign(contents, doc);
1068
964
  return contents;
1069
965
  };
1070
- const de_CreateApiKeyCommandError = async (output, context) => {
1071
- const parsedOutput = {
1072
- ...output,
1073
- body: await parseErrorBody(output.body, context),
1074
- };
1075
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1076
- switch (errorCode) {
1077
- case "ApiKeyLimitExceededException":
1078
- case "com.amazonaws.appsync#ApiKeyLimitExceededException":
1079
- throw await de_ApiKeyLimitExceededExceptionRes(parsedOutput, context);
1080
- case "ApiKeyValidityOutOfBoundsException":
1081
- case "com.amazonaws.appsync#ApiKeyValidityOutOfBoundsException":
1082
- throw await de_ApiKeyValidityOutOfBoundsExceptionRes(parsedOutput, context);
1083
- case "BadRequestException":
1084
- case "com.amazonaws.appsync#BadRequestException":
1085
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1086
- case "InternalFailureException":
1087
- case "com.amazonaws.appsync#InternalFailureException":
1088
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1089
- case "LimitExceededException":
1090
- case "com.amazonaws.appsync#LimitExceededException":
1091
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1092
- case "NotFoundException":
1093
- case "com.amazonaws.appsync#NotFoundException":
1094
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1095
- case "UnauthorizedException":
1096
- case "com.amazonaws.appsync#UnauthorizedException":
1097
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1098
- default:
1099
- const parsedBody = parsedOutput.body;
1100
- return throwDefaultError({
1101
- output,
1102
- parsedBody,
1103
- errorCode,
1104
- });
1105
- }
1106
- };
1107
966
  export const de_CreateDataSourceCommand = async (output, context) => {
1108
967
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1109
- return de_CreateDataSourceCommandError(output, context);
968
+ return de_CommandError(output, context);
1110
969
  }
1111
970
  const contents = map({
1112
971
  $metadata: deserializeMetadata(output),
@@ -1118,40 +977,9 @@ export const de_CreateDataSourceCommand = async (output, context) => {
1118
977
  Object.assign(contents, doc);
1119
978
  return contents;
1120
979
  };
1121
- const de_CreateDataSourceCommandError = async (output, context) => {
1122
- const parsedOutput = {
1123
- ...output,
1124
- body: await parseErrorBody(output.body, context),
1125
- };
1126
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1127
- switch (errorCode) {
1128
- case "BadRequestException":
1129
- case "com.amazonaws.appsync#BadRequestException":
1130
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1131
- case "ConcurrentModificationException":
1132
- case "com.amazonaws.appsync#ConcurrentModificationException":
1133
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1134
- case "InternalFailureException":
1135
- case "com.amazonaws.appsync#InternalFailureException":
1136
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1137
- case "NotFoundException":
1138
- case "com.amazonaws.appsync#NotFoundException":
1139
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1140
- case "UnauthorizedException":
1141
- case "com.amazonaws.appsync#UnauthorizedException":
1142
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1143
- default:
1144
- const parsedBody = parsedOutput.body;
1145
- return throwDefaultError({
1146
- output,
1147
- parsedBody,
1148
- errorCode,
1149
- });
1150
- }
1151
- };
1152
980
  export const de_CreateDomainNameCommand = async (output, context) => {
1153
981
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1154
- return de_CreateDomainNameCommandError(output, context);
982
+ return de_CommandError(output, context);
1155
983
  }
1156
984
  const contents = map({
1157
985
  $metadata: deserializeMetadata(output),
@@ -1163,34 +991,9 @@ export const de_CreateDomainNameCommand = async (output, context) => {
1163
991
  Object.assign(contents, doc);
1164
992
  return contents;
1165
993
  };
1166
- const de_CreateDomainNameCommandError = async (output, context) => {
1167
- const parsedOutput = {
1168
- ...output,
1169
- body: await parseErrorBody(output.body, context),
1170
- };
1171
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1172
- switch (errorCode) {
1173
- case "AccessDeniedException":
1174
- case "com.amazonaws.appsync#AccessDeniedException":
1175
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1176
- case "BadRequestException":
1177
- case "com.amazonaws.appsync#BadRequestException":
1178
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1179
- case "InternalFailureException":
1180
- case "com.amazonaws.appsync#InternalFailureException":
1181
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1182
- default:
1183
- const parsedBody = parsedOutput.body;
1184
- return throwDefaultError({
1185
- output,
1186
- parsedBody,
1187
- errorCode,
1188
- });
1189
- }
1190
- };
1191
994
  export const de_CreateFunctionCommand = async (output, context) => {
1192
995
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1193
- return de_CreateFunctionCommandError(output, context);
996
+ return de_CommandError(output, context);
1194
997
  }
1195
998
  const contents = map({
1196
999
  $metadata: deserializeMetadata(output),
@@ -1202,37 +1005,9 @@ export const de_CreateFunctionCommand = async (output, context) => {
1202
1005
  Object.assign(contents, doc);
1203
1006
  return contents;
1204
1007
  };
1205
- const de_CreateFunctionCommandError = async (output, context) => {
1206
- const parsedOutput = {
1207
- ...output,
1208
- body: await parseErrorBody(output.body, context),
1209
- };
1210
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1211
- switch (errorCode) {
1212
- case "ConcurrentModificationException":
1213
- case "com.amazonaws.appsync#ConcurrentModificationException":
1214
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1215
- case "InternalFailureException":
1216
- case "com.amazonaws.appsync#InternalFailureException":
1217
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1218
- case "NotFoundException":
1219
- case "com.amazonaws.appsync#NotFoundException":
1220
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1221
- case "UnauthorizedException":
1222
- case "com.amazonaws.appsync#UnauthorizedException":
1223
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1224
- default:
1225
- const parsedBody = parsedOutput.body;
1226
- return throwDefaultError({
1227
- output,
1228
- parsedBody,
1229
- errorCode,
1230
- });
1231
- }
1232
- };
1233
1008
  export const de_CreateGraphqlApiCommand = async (output, context) => {
1234
1009
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1235
- return de_CreateGraphqlApiCommandError(output, context);
1010
+ return de_CommandError(output, context);
1236
1011
  }
1237
1012
  const contents = map({
1238
1013
  $metadata: deserializeMetadata(output),
@@ -1244,43 +1019,9 @@ export const de_CreateGraphqlApiCommand = async (output, context) => {
1244
1019
  Object.assign(contents, doc);
1245
1020
  return contents;
1246
1021
  };
1247
- const de_CreateGraphqlApiCommandError = async (output, context) => {
1248
- const parsedOutput = {
1249
- ...output,
1250
- body: await parseErrorBody(output.body, context),
1251
- };
1252
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1253
- switch (errorCode) {
1254
- case "ApiLimitExceededException":
1255
- case "com.amazonaws.appsync#ApiLimitExceededException":
1256
- throw await de_ApiLimitExceededExceptionRes(parsedOutput, context);
1257
- case "BadRequestException":
1258
- case "com.amazonaws.appsync#BadRequestException":
1259
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1260
- case "ConcurrentModificationException":
1261
- case "com.amazonaws.appsync#ConcurrentModificationException":
1262
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1263
- case "InternalFailureException":
1264
- case "com.amazonaws.appsync#InternalFailureException":
1265
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1266
- case "LimitExceededException":
1267
- case "com.amazonaws.appsync#LimitExceededException":
1268
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1269
- case "UnauthorizedException":
1270
- case "com.amazonaws.appsync#UnauthorizedException":
1271
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1272
- default:
1273
- const parsedBody = parsedOutput.body;
1274
- return throwDefaultError({
1275
- output,
1276
- parsedBody,
1277
- errorCode,
1278
- });
1279
- }
1280
- };
1281
1022
  export const de_CreateResolverCommand = async (output, context) => {
1282
1023
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1283
- return de_CreateResolverCommandError(output, context);
1024
+ return de_CommandError(output, context);
1284
1025
  }
1285
1026
  const contents = map({
1286
1027
  $metadata: deserializeMetadata(output),
@@ -1292,40 +1033,9 @@ export const de_CreateResolverCommand = async (output, context) => {
1292
1033
  Object.assign(contents, doc);
1293
1034
  return contents;
1294
1035
  };
1295
- const de_CreateResolverCommandError = async (output, context) => {
1296
- const parsedOutput = {
1297
- ...output,
1298
- body: await parseErrorBody(output.body, context),
1299
- };
1300
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1301
- switch (errorCode) {
1302
- case "BadRequestException":
1303
- case "com.amazonaws.appsync#BadRequestException":
1304
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1305
- case "ConcurrentModificationException":
1306
- case "com.amazonaws.appsync#ConcurrentModificationException":
1307
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1308
- case "InternalFailureException":
1309
- case "com.amazonaws.appsync#InternalFailureException":
1310
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1311
- case "NotFoundException":
1312
- case "com.amazonaws.appsync#NotFoundException":
1313
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1314
- case "UnauthorizedException":
1315
- case "com.amazonaws.appsync#UnauthorizedException":
1316
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1317
- default:
1318
- const parsedBody = parsedOutput.body;
1319
- return throwDefaultError({
1320
- output,
1321
- parsedBody,
1322
- errorCode,
1323
- });
1324
- }
1325
- };
1326
1036
  export const de_CreateTypeCommand = async (output, context) => {
1327
1037
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1328
- return de_CreateTypeCommandError(output, context);
1038
+ return de_CommandError(output, context);
1329
1039
  }
1330
1040
  const contents = map({
1331
1041
  $metadata: deserializeMetadata(output),
@@ -1337,40 +1047,9 @@ export const de_CreateTypeCommand = async (output, context) => {
1337
1047
  Object.assign(contents, doc);
1338
1048
  return contents;
1339
1049
  };
1340
- const de_CreateTypeCommandError = async (output, context) => {
1341
- const parsedOutput = {
1342
- ...output,
1343
- body: await parseErrorBody(output.body, context),
1344
- };
1345
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1346
- switch (errorCode) {
1347
- case "BadRequestException":
1348
- case "com.amazonaws.appsync#BadRequestException":
1349
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1350
- case "ConcurrentModificationException":
1351
- case "com.amazonaws.appsync#ConcurrentModificationException":
1352
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1353
- case "InternalFailureException":
1354
- case "com.amazonaws.appsync#InternalFailureException":
1355
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1356
- case "NotFoundException":
1357
- case "com.amazonaws.appsync#NotFoundException":
1358
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1359
- case "UnauthorizedException":
1360
- case "com.amazonaws.appsync#UnauthorizedException":
1361
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1362
- default:
1363
- const parsedBody = parsedOutput.body;
1364
- return throwDefaultError({
1365
- output,
1366
- parsedBody,
1367
- errorCode,
1368
- });
1369
- }
1370
- };
1371
1050
  export const de_DeleteApiCacheCommand = async (output, context) => {
1372
1051
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1373
- return de_DeleteApiCacheCommandError(output, context);
1052
+ return de_CommandError(output, context);
1374
1053
  }
1375
1054
  const contents = map({
1376
1055
  $metadata: deserializeMetadata(output),
@@ -1378,40 +1057,9 @@ export const de_DeleteApiCacheCommand = async (output, context) => {
1378
1057
  await collectBody(output.body, context);
1379
1058
  return contents;
1380
1059
  };
1381
- const de_DeleteApiCacheCommandError = async (output, context) => {
1382
- const parsedOutput = {
1383
- ...output,
1384
- body: await parseErrorBody(output.body, context),
1385
- };
1386
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1387
- switch (errorCode) {
1388
- case "BadRequestException":
1389
- case "com.amazonaws.appsync#BadRequestException":
1390
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1391
- case "ConcurrentModificationException":
1392
- case "com.amazonaws.appsync#ConcurrentModificationException":
1393
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1394
- case "InternalFailureException":
1395
- case "com.amazonaws.appsync#InternalFailureException":
1396
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1397
- case "NotFoundException":
1398
- case "com.amazonaws.appsync#NotFoundException":
1399
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1400
- case "UnauthorizedException":
1401
- case "com.amazonaws.appsync#UnauthorizedException":
1402
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1403
- default:
1404
- const parsedBody = parsedOutput.body;
1405
- return throwDefaultError({
1406
- output,
1407
- parsedBody,
1408
- errorCode,
1409
- });
1410
- }
1411
- };
1412
1060
  export const de_DeleteApiKeyCommand = async (output, context) => {
1413
1061
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1414
- return de_DeleteApiKeyCommandError(output, context);
1062
+ return de_CommandError(output, context);
1415
1063
  }
1416
1064
  const contents = map({
1417
1065
  $metadata: deserializeMetadata(output),
@@ -1419,37 +1067,9 @@ export const de_DeleteApiKeyCommand = async (output, context) => {
1419
1067
  await collectBody(output.body, context);
1420
1068
  return contents;
1421
1069
  };
1422
- const de_DeleteApiKeyCommandError = async (output, context) => {
1423
- const parsedOutput = {
1424
- ...output,
1425
- body: await parseErrorBody(output.body, context),
1426
- };
1427
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1428
- switch (errorCode) {
1429
- case "BadRequestException":
1430
- case "com.amazonaws.appsync#BadRequestException":
1431
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1432
- case "InternalFailureException":
1433
- case "com.amazonaws.appsync#InternalFailureException":
1434
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1435
- case "NotFoundException":
1436
- case "com.amazonaws.appsync#NotFoundException":
1437
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1438
- case "UnauthorizedException":
1439
- case "com.amazonaws.appsync#UnauthorizedException":
1440
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1441
- default:
1442
- const parsedBody = parsedOutput.body;
1443
- return throwDefaultError({
1444
- output,
1445
- parsedBody,
1446
- errorCode,
1447
- });
1448
- }
1449
- };
1450
1070
  export const de_DeleteDataSourceCommand = async (output, context) => {
1451
1071
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1452
- return de_DeleteDataSourceCommandError(output, context);
1072
+ return de_CommandError(output, context);
1453
1073
  }
1454
1074
  const contents = map({
1455
1075
  $metadata: deserializeMetadata(output),
@@ -1457,40 +1077,9 @@ export const de_DeleteDataSourceCommand = async (output, context) => {
1457
1077
  await collectBody(output.body, context);
1458
1078
  return contents;
1459
1079
  };
1460
- const de_DeleteDataSourceCommandError = async (output, context) => {
1461
- const parsedOutput = {
1462
- ...output,
1463
- body: await parseErrorBody(output.body, context),
1464
- };
1465
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1466
- switch (errorCode) {
1467
- case "BadRequestException":
1468
- case "com.amazonaws.appsync#BadRequestException":
1469
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1470
- case "ConcurrentModificationException":
1471
- case "com.amazonaws.appsync#ConcurrentModificationException":
1472
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1473
- case "InternalFailureException":
1474
- case "com.amazonaws.appsync#InternalFailureException":
1475
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1476
- case "NotFoundException":
1477
- case "com.amazonaws.appsync#NotFoundException":
1478
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1479
- case "UnauthorizedException":
1480
- case "com.amazonaws.appsync#UnauthorizedException":
1481
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1482
- default:
1483
- const parsedBody = parsedOutput.body;
1484
- return throwDefaultError({
1485
- output,
1486
- parsedBody,
1487
- errorCode,
1488
- });
1489
- }
1490
- };
1491
1080
  export const de_DeleteDomainNameCommand = async (output, context) => {
1492
1081
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1493
- return de_DeleteDomainNameCommandError(output, context);
1082
+ return de_CommandError(output, context);
1494
1083
  }
1495
1084
  const contents = map({
1496
1085
  $metadata: deserializeMetadata(output),
@@ -1498,40 +1087,19 @@ export const de_DeleteDomainNameCommand = async (output, context) => {
1498
1087
  await collectBody(output.body, context);
1499
1088
  return contents;
1500
1089
  };
1501
- const de_DeleteDomainNameCommandError = async (output, context) => {
1502
- const parsedOutput = {
1503
- ...output,
1504
- body: await parseErrorBody(output.body, context),
1505
- };
1506
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1507
- switch (errorCode) {
1508
- case "AccessDeniedException":
1509
- case "com.amazonaws.appsync#AccessDeniedException":
1510
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1511
- case "BadRequestException":
1512
- case "com.amazonaws.appsync#BadRequestException":
1513
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1514
- case "ConcurrentModificationException":
1515
- case "com.amazonaws.appsync#ConcurrentModificationException":
1516
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1517
- case "InternalFailureException":
1518
- case "com.amazonaws.appsync#InternalFailureException":
1519
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1520
- case "NotFoundException":
1521
- case "com.amazonaws.appsync#NotFoundException":
1522
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1523
- default:
1524
- const parsedBody = parsedOutput.body;
1525
- return throwDefaultError({
1526
- output,
1527
- parsedBody,
1528
- errorCode,
1529
- });
1090
+ export const de_DeleteFunctionCommand = async (output, context) => {
1091
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1092
+ return de_CommandError(output, context);
1530
1093
  }
1094
+ const contents = map({
1095
+ $metadata: deserializeMetadata(output),
1096
+ });
1097
+ await collectBody(output.body, context);
1098
+ return contents;
1531
1099
  };
1532
- export const de_DeleteFunctionCommand = async (output, context) => {
1100
+ export const de_DeleteGraphqlApiCommand = async (output, context) => {
1533
1101
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1534
- return de_DeleteFunctionCommandError(output, context);
1102
+ return de_CommandError(output, context);
1535
1103
  }
1536
1104
  const contents = map({
1537
1105
  $metadata: deserializeMetadata(output),
@@ -1539,37 +1107,19 @@ export const de_DeleteFunctionCommand = async (output, context) => {
1539
1107
  await collectBody(output.body, context);
1540
1108
  return contents;
1541
1109
  };
1542
- const de_DeleteFunctionCommandError = async (output, context) => {
1543
- const parsedOutput = {
1544
- ...output,
1545
- body: await parseErrorBody(output.body, context),
1546
- };
1547
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1548
- switch (errorCode) {
1549
- case "ConcurrentModificationException":
1550
- case "com.amazonaws.appsync#ConcurrentModificationException":
1551
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1552
- case "InternalFailureException":
1553
- case "com.amazonaws.appsync#InternalFailureException":
1554
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1555
- case "NotFoundException":
1556
- case "com.amazonaws.appsync#NotFoundException":
1557
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1558
- case "UnauthorizedException":
1559
- case "com.amazonaws.appsync#UnauthorizedException":
1560
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1561
- default:
1562
- const parsedBody = parsedOutput.body;
1563
- return throwDefaultError({
1564
- output,
1565
- parsedBody,
1566
- errorCode,
1567
- });
1110
+ export const de_DeleteResolverCommand = async (output, context) => {
1111
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1112
+ return de_CommandError(output, context);
1568
1113
  }
1114
+ const contents = map({
1115
+ $metadata: deserializeMetadata(output),
1116
+ });
1117
+ await collectBody(output.body, context);
1118
+ return contents;
1569
1119
  };
1570
- export const de_DeleteGraphqlApiCommand = async (output, context) => {
1120
+ export const de_DeleteTypeCommand = async (output, context) => {
1571
1121
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1572
- return de_DeleteGraphqlApiCommandError(output, context);
1122
+ return de_CommandError(output, context);
1573
1123
  }
1574
1124
  const contents = map({
1575
1125
  $metadata: deserializeMetadata(output),
@@ -1577,125 +1127,9 @@ export const de_DeleteGraphqlApiCommand = async (output, context) => {
1577
1127
  await collectBody(output.body, context);
1578
1128
  return contents;
1579
1129
  };
1580
- const de_DeleteGraphqlApiCommandError = async (output, context) => {
1581
- const parsedOutput = {
1582
- ...output,
1583
- body: await parseErrorBody(output.body, context),
1584
- };
1585
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1586
- switch (errorCode) {
1587
- case "AccessDeniedException":
1588
- case "com.amazonaws.appsync#AccessDeniedException":
1589
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1590
- case "BadRequestException":
1591
- case "com.amazonaws.appsync#BadRequestException":
1592
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1593
- case "ConcurrentModificationException":
1594
- case "com.amazonaws.appsync#ConcurrentModificationException":
1595
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1596
- case "InternalFailureException":
1597
- case "com.amazonaws.appsync#InternalFailureException":
1598
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1599
- case "NotFoundException":
1600
- case "com.amazonaws.appsync#NotFoundException":
1601
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1602
- case "UnauthorizedException":
1603
- case "com.amazonaws.appsync#UnauthorizedException":
1604
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1605
- default:
1606
- const parsedBody = parsedOutput.body;
1607
- return throwDefaultError({
1608
- output,
1609
- parsedBody,
1610
- errorCode,
1611
- });
1612
- }
1613
- };
1614
- export const de_DeleteResolverCommand = async (output, context) => {
1615
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1616
- return de_DeleteResolverCommandError(output, context);
1617
- }
1618
- const contents = map({
1619
- $metadata: deserializeMetadata(output),
1620
- });
1621
- await collectBody(output.body, context);
1622
- return contents;
1623
- };
1624
- const de_DeleteResolverCommandError = async (output, context) => {
1625
- const parsedOutput = {
1626
- ...output,
1627
- body: await parseErrorBody(output.body, context),
1628
- };
1629
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1630
- switch (errorCode) {
1631
- case "BadRequestException":
1632
- case "com.amazonaws.appsync#BadRequestException":
1633
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1634
- case "ConcurrentModificationException":
1635
- case "com.amazonaws.appsync#ConcurrentModificationException":
1636
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1637
- case "InternalFailureException":
1638
- case "com.amazonaws.appsync#InternalFailureException":
1639
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1640
- case "NotFoundException":
1641
- case "com.amazonaws.appsync#NotFoundException":
1642
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1643
- case "UnauthorizedException":
1644
- case "com.amazonaws.appsync#UnauthorizedException":
1645
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1646
- default:
1647
- const parsedBody = parsedOutput.body;
1648
- return throwDefaultError({
1649
- output,
1650
- parsedBody,
1651
- errorCode,
1652
- });
1653
- }
1654
- };
1655
- export const de_DeleteTypeCommand = async (output, context) => {
1656
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1657
- return de_DeleteTypeCommandError(output, context);
1658
- }
1659
- const contents = map({
1660
- $metadata: deserializeMetadata(output),
1661
- });
1662
- await collectBody(output.body, context);
1663
- return contents;
1664
- };
1665
- const de_DeleteTypeCommandError = async (output, context) => {
1666
- const parsedOutput = {
1667
- ...output,
1668
- body: await parseErrorBody(output.body, context),
1669
- };
1670
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1671
- switch (errorCode) {
1672
- case "BadRequestException":
1673
- case "com.amazonaws.appsync#BadRequestException":
1674
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1675
- case "ConcurrentModificationException":
1676
- case "com.amazonaws.appsync#ConcurrentModificationException":
1677
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1678
- case "InternalFailureException":
1679
- case "com.amazonaws.appsync#InternalFailureException":
1680
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1681
- case "NotFoundException":
1682
- case "com.amazonaws.appsync#NotFoundException":
1683
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1684
- case "UnauthorizedException":
1685
- case "com.amazonaws.appsync#UnauthorizedException":
1686
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1687
- default:
1688
- const parsedBody = parsedOutput.body;
1689
- return throwDefaultError({
1690
- output,
1691
- parsedBody,
1692
- errorCode,
1693
- });
1694
- }
1695
- };
1696
1130
  export const de_DisassociateApiCommand = async (output, context) => {
1697
1131
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1698
- return de_DisassociateApiCommandError(output, context);
1132
+ return de_CommandError(output, context);
1699
1133
  }
1700
1134
  const contents = map({
1701
1135
  $metadata: deserializeMetadata(output),
@@ -1703,40 +1137,9 @@ export const de_DisassociateApiCommand = async (output, context) => {
1703
1137
  await collectBody(output.body, context);
1704
1138
  return contents;
1705
1139
  };
1706
- const de_DisassociateApiCommandError = async (output, context) => {
1707
- const parsedOutput = {
1708
- ...output,
1709
- body: await parseErrorBody(output.body, context),
1710
- };
1711
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1712
- switch (errorCode) {
1713
- case "AccessDeniedException":
1714
- case "com.amazonaws.appsync#AccessDeniedException":
1715
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1716
- case "BadRequestException":
1717
- case "com.amazonaws.appsync#BadRequestException":
1718
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1719
- case "ConcurrentModificationException":
1720
- case "com.amazonaws.appsync#ConcurrentModificationException":
1721
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1722
- case "InternalFailureException":
1723
- case "com.amazonaws.appsync#InternalFailureException":
1724
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1725
- case "NotFoundException":
1726
- case "com.amazonaws.appsync#NotFoundException":
1727
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1728
- default:
1729
- const parsedBody = parsedOutput.body;
1730
- return throwDefaultError({
1731
- output,
1732
- parsedBody,
1733
- errorCode,
1734
- });
1735
- }
1736
- };
1737
1140
  export const de_DisassociateMergedGraphqlApiCommand = async (output, context) => {
1738
1141
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1739
- return de_DisassociateMergedGraphqlApiCommandError(output, context);
1142
+ return de_CommandError(output, context);
1740
1143
  }
1741
1144
  const contents = map({
1742
1145
  $metadata: deserializeMetadata(output),
@@ -1748,40 +1151,9 @@ export const de_DisassociateMergedGraphqlApiCommand = async (output, context) =>
1748
1151
  Object.assign(contents, doc);
1749
1152
  return contents;
1750
1153
  };
1751
- const de_DisassociateMergedGraphqlApiCommandError = async (output, context) => {
1752
- const parsedOutput = {
1753
- ...output,
1754
- body: await parseErrorBody(output.body, context),
1755
- };
1756
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1757
- switch (errorCode) {
1758
- case "BadRequestException":
1759
- case "com.amazonaws.appsync#BadRequestException":
1760
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1761
- case "ConcurrentModificationException":
1762
- case "com.amazonaws.appsync#ConcurrentModificationException":
1763
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1764
- case "InternalFailureException":
1765
- case "com.amazonaws.appsync#InternalFailureException":
1766
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1767
- case "NotFoundException":
1768
- case "com.amazonaws.appsync#NotFoundException":
1769
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1770
- case "UnauthorizedException":
1771
- case "com.amazonaws.appsync#UnauthorizedException":
1772
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1773
- default:
1774
- const parsedBody = parsedOutput.body;
1775
- return throwDefaultError({
1776
- output,
1777
- parsedBody,
1778
- errorCode,
1779
- });
1780
- }
1781
- };
1782
1154
  export const de_DisassociateSourceGraphqlApiCommand = async (output, context) => {
1783
1155
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1784
- return de_DisassociateSourceGraphqlApiCommandError(output, context);
1156
+ return de_CommandError(output, context);
1785
1157
  }
1786
1158
  const contents = map({
1787
1159
  $metadata: deserializeMetadata(output),
@@ -1793,40 +1165,9 @@ export const de_DisassociateSourceGraphqlApiCommand = async (output, context) =>
1793
1165
  Object.assign(contents, doc);
1794
1166
  return contents;
1795
1167
  };
1796
- const de_DisassociateSourceGraphqlApiCommandError = async (output, context) => {
1797
- const parsedOutput = {
1798
- ...output,
1799
- body: await parseErrorBody(output.body, context),
1800
- };
1801
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1802
- switch (errorCode) {
1803
- case "BadRequestException":
1804
- case "com.amazonaws.appsync#BadRequestException":
1805
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1806
- case "ConcurrentModificationException":
1807
- case "com.amazonaws.appsync#ConcurrentModificationException":
1808
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1809
- case "InternalFailureException":
1810
- case "com.amazonaws.appsync#InternalFailureException":
1811
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1812
- case "NotFoundException":
1813
- case "com.amazonaws.appsync#NotFoundException":
1814
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1815
- case "UnauthorizedException":
1816
- case "com.amazonaws.appsync#UnauthorizedException":
1817
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1818
- default:
1819
- const parsedBody = parsedOutput.body;
1820
- return throwDefaultError({
1821
- output,
1822
- parsedBody,
1823
- errorCode,
1824
- });
1825
- }
1826
- };
1827
1168
  export const de_EvaluateCodeCommand = async (output, context) => {
1828
1169
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1829
- return de_EvaluateCodeCommandError(output, context);
1170
+ return de_CommandError(output, context);
1830
1171
  }
1831
1172
  const contents = map({
1832
1173
  $metadata: deserializeMetadata(output),
@@ -1840,34 +1181,9 @@ export const de_EvaluateCodeCommand = async (output, context) => {
1840
1181
  Object.assign(contents, doc);
1841
1182
  return contents;
1842
1183
  };
1843
- const de_EvaluateCodeCommandError = async (output, context) => {
1844
- const parsedOutput = {
1845
- ...output,
1846
- body: await parseErrorBody(output.body, context),
1847
- };
1848
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1849
- switch (errorCode) {
1850
- case "AccessDeniedException":
1851
- case "com.amazonaws.appsync#AccessDeniedException":
1852
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1853
- case "BadRequestException":
1854
- case "com.amazonaws.appsync#BadRequestException":
1855
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1856
- case "InternalFailureException":
1857
- case "com.amazonaws.appsync#InternalFailureException":
1858
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1859
- default:
1860
- const parsedBody = parsedOutput.body;
1861
- return throwDefaultError({
1862
- output,
1863
- parsedBody,
1864
- errorCode,
1865
- });
1866
- }
1867
- };
1868
1184
  export const de_EvaluateMappingTemplateCommand = async (output, context) => {
1869
1185
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1870
- return de_EvaluateMappingTemplateCommandError(output, context);
1186
+ return de_CommandError(output, context);
1871
1187
  }
1872
1188
  const contents = map({
1873
1189
  $metadata: deserializeMetadata(output),
@@ -1881,34 +1197,9 @@ export const de_EvaluateMappingTemplateCommand = async (output, context) => {
1881
1197
  Object.assign(contents, doc);
1882
1198
  return contents;
1883
1199
  };
1884
- const de_EvaluateMappingTemplateCommandError = async (output, context) => {
1885
- const parsedOutput = {
1886
- ...output,
1887
- body: await parseErrorBody(output.body, context),
1888
- };
1889
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1890
- switch (errorCode) {
1891
- case "AccessDeniedException":
1892
- case "com.amazonaws.appsync#AccessDeniedException":
1893
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1894
- case "BadRequestException":
1895
- case "com.amazonaws.appsync#BadRequestException":
1896
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1897
- case "InternalFailureException":
1898
- case "com.amazonaws.appsync#InternalFailureException":
1899
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1900
- default:
1901
- const parsedBody = parsedOutput.body;
1902
- return throwDefaultError({
1903
- output,
1904
- parsedBody,
1905
- errorCode,
1906
- });
1907
- }
1908
- };
1909
1200
  export const de_FlushApiCacheCommand = async (output, context) => {
1910
1201
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1911
- return de_FlushApiCacheCommandError(output, context);
1202
+ return de_CommandError(output, context);
1912
1203
  }
1913
1204
  const contents = map({
1914
1205
  $metadata: deserializeMetadata(output),
@@ -1916,40 +1207,9 @@ export const de_FlushApiCacheCommand = async (output, context) => {
1916
1207
  await collectBody(output.body, context);
1917
1208
  return contents;
1918
1209
  };
1919
- const de_FlushApiCacheCommandError = async (output, context) => {
1920
- const parsedOutput = {
1921
- ...output,
1922
- body: await parseErrorBody(output.body, context),
1923
- };
1924
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1925
- switch (errorCode) {
1926
- case "BadRequestException":
1927
- case "com.amazonaws.appsync#BadRequestException":
1928
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1929
- case "ConcurrentModificationException":
1930
- case "com.amazonaws.appsync#ConcurrentModificationException":
1931
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1932
- case "InternalFailureException":
1933
- case "com.amazonaws.appsync#InternalFailureException":
1934
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1935
- case "NotFoundException":
1936
- case "com.amazonaws.appsync#NotFoundException":
1937
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1938
- case "UnauthorizedException":
1939
- case "com.amazonaws.appsync#UnauthorizedException":
1940
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1941
- default:
1942
- const parsedBody = parsedOutput.body;
1943
- return throwDefaultError({
1944
- output,
1945
- parsedBody,
1946
- errorCode,
1947
- });
1948
- }
1949
- };
1950
1210
  export const de_GetApiAssociationCommand = async (output, context) => {
1951
1211
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1952
- return de_GetApiAssociationCommandError(output, context);
1212
+ return de_CommandError(output, context);
1953
1213
  }
1954
1214
  const contents = map({
1955
1215
  $metadata: deserializeMetadata(output),
@@ -1961,37 +1221,9 @@ export const de_GetApiAssociationCommand = async (output, context) => {
1961
1221
  Object.assign(contents, doc);
1962
1222
  return contents;
1963
1223
  };
1964
- const de_GetApiAssociationCommandError = async (output, context) => {
1965
- const parsedOutput = {
1966
- ...output,
1967
- body: await parseErrorBody(output.body, context),
1968
- };
1969
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1970
- switch (errorCode) {
1971
- case "AccessDeniedException":
1972
- case "com.amazonaws.appsync#AccessDeniedException":
1973
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1974
- case "BadRequestException":
1975
- case "com.amazonaws.appsync#BadRequestException":
1976
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1977
- case "InternalFailureException":
1978
- case "com.amazonaws.appsync#InternalFailureException":
1979
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1980
- case "NotFoundException":
1981
- case "com.amazonaws.appsync#NotFoundException":
1982
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1983
- default:
1984
- const parsedBody = parsedOutput.body;
1985
- return throwDefaultError({
1986
- output,
1987
- parsedBody,
1988
- errorCode,
1989
- });
1990
- }
1991
- };
1992
1224
  export const de_GetApiCacheCommand = async (output, context) => {
1993
1225
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1994
- return de_GetApiCacheCommandError(output, context);
1226
+ return de_CommandError(output, context);
1995
1227
  }
1996
1228
  const contents = map({
1997
1229
  $metadata: deserializeMetadata(output),
@@ -2003,40 +1235,9 @@ export const de_GetApiCacheCommand = async (output, context) => {
2003
1235
  Object.assign(contents, doc);
2004
1236
  return contents;
2005
1237
  };
2006
- const de_GetApiCacheCommandError = async (output, context) => {
2007
- const parsedOutput = {
2008
- ...output,
2009
- body: await parseErrorBody(output.body, context),
2010
- };
2011
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2012
- switch (errorCode) {
2013
- case "BadRequestException":
2014
- case "com.amazonaws.appsync#BadRequestException":
2015
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2016
- case "ConcurrentModificationException":
2017
- case "com.amazonaws.appsync#ConcurrentModificationException":
2018
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2019
- case "InternalFailureException":
2020
- case "com.amazonaws.appsync#InternalFailureException":
2021
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2022
- case "NotFoundException":
2023
- case "com.amazonaws.appsync#NotFoundException":
2024
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2025
- case "UnauthorizedException":
2026
- case "com.amazonaws.appsync#UnauthorizedException":
2027
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2028
- default:
2029
- const parsedBody = parsedOutput.body;
2030
- return throwDefaultError({
2031
- output,
2032
- parsedBody,
2033
- errorCode,
2034
- });
2035
- }
2036
- };
2037
1238
  export const de_GetDataSourceCommand = async (output, context) => {
2038
1239
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2039
- return de_GetDataSourceCommandError(output, context);
1240
+ return de_CommandError(output, context);
2040
1241
  }
2041
1242
  const contents = map({
2042
1243
  $metadata: deserializeMetadata(output),
@@ -2048,40 +1249,9 @@ export const de_GetDataSourceCommand = async (output, context) => {
2048
1249
  Object.assign(contents, doc);
2049
1250
  return contents;
2050
1251
  };
2051
- const de_GetDataSourceCommandError = async (output, context) => {
2052
- const parsedOutput = {
2053
- ...output,
2054
- body: await parseErrorBody(output.body, context),
2055
- };
2056
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2057
- switch (errorCode) {
2058
- case "BadRequestException":
2059
- case "com.amazonaws.appsync#BadRequestException":
2060
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2061
- case "ConcurrentModificationException":
2062
- case "com.amazonaws.appsync#ConcurrentModificationException":
2063
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2064
- case "InternalFailureException":
2065
- case "com.amazonaws.appsync#InternalFailureException":
2066
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2067
- case "NotFoundException":
2068
- case "com.amazonaws.appsync#NotFoundException":
2069
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2070
- case "UnauthorizedException":
2071
- case "com.amazonaws.appsync#UnauthorizedException":
2072
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2073
- default:
2074
- const parsedBody = parsedOutput.body;
2075
- return throwDefaultError({
2076
- output,
2077
- parsedBody,
2078
- errorCode,
2079
- });
2080
- }
2081
- };
2082
1252
  export const de_GetDataSourceIntrospectionCommand = async (output, context) => {
2083
1253
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2084
- return de_GetDataSourceIntrospectionCommandError(output, context);
1254
+ return de_CommandError(output, context);
2085
1255
  }
2086
1256
  const contents = map({
2087
1257
  $metadata: deserializeMetadata(output),
@@ -2096,34 +1266,9 @@ export const de_GetDataSourceIntrospectionCommand = async (output, context) => {
2096
1266
  Object.assign(contents, doc);
2097
1267
  return contents;
2098
1268
  };
2099
- const de_GetDataSourceIntrospectionCommandError = async (output, context) => {
2100
- const parsedOutput = {
2101
- ...output,
2102
- body: await parseErrorBody(output.body, context),
2103
- };
2104
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2105
- switch (errorCode) {
2106
- case "BadRequestException":
2107
- case "com.amazonaws.appsync#BadRequestException":
2108
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2109
- case "InternalFailureException":
2110
- case "com.amazonaws.appsync#InternalFailureException":
2111
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2112
- case "NotFoundException":
2113
- case "com.amazonaws.appsync#NotFoundException":
2114
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2115
- default:
2116
- const parsedBody = parsedOutput.body;
2117
- return throwDefaultError({
2118
- output,
2119
- parsedBody,
2120
- errorCode,
2121
- });
2122
- }
2123
- };
2124
1269
  export const de_GetDomainNameCommand = async (output, context) => {
2125
1270
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2126
- return de_GetDomainNameCommandError(output, context);
1271
+ return de_CommandError(output, context);
2127
1272
  }
2128
1273
  const contents = map({
2129
1274
  $metadata: deserializeMetadata(output),
@@ -2135,37 +1280,9 @@ export const de_GetDomainNameCommand = async (output, context) => {
2135
1280
  Object.assign(contents, doc);
2136
1281
  return contents;
2137
1282
  };
2138
- const de_GetDomainNameCommandError = async (output, context) => {
2139
- const parsedOutput = {
2140
- ...output,
2141
- body: await parseErrorBody(output.body, context),
2142
- };
2143
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2144
- switch (errorCode) {
2145
- case "AccessDeniedException":
2146
- case "com.amazonaws.appsync#AccessDeniedException":
2147
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2148
- case "BadRequestException":
2149
- case "com.amazonaws.appsync#BadRequestException":
2150
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2151
- case "InternalFailureException":
2152
- case "com.amazonaws.appsync#InternalFailureException":
2153
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2154
- case "NotFoundException":
2155
- case "com.amazonaws.appsync#NotFoundException":
2156
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2157
- default:
2158
- const parsedBody = parsedOutput.body;
2159
- return throwDefaultError({
2160
- output,
2161
- parsedBody,
2162
- errorCode,
2163
- });
2164
- }
2165
- };
2166
1283
  export const de_GetFunctionCommand = async (output, context) => {
2167
1284
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2168
- return de_GetFunctionCommandError(output, context);
1285
+ return de_CommandError(output, context);
2169
1286
  }
2170
1287
  const contents = map({
2171
1288
  $metadata: deserializeMetadata(output),
@@ -2177,34 +1294,9 @@ export const de_GetFunctionCommand = async (output, context) => {
2177
1294
  Object.assign(contents, doc);
2178
1295
  return contents;
2179
1296
  };
2180
- const de_GetFunctionCommandError = 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 "ConcurrentModificationException":
2188
- case "com.amazonaws.appsync#ConcurrentModificationException":
2189
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2190
- case "NotFoundException":
2191
- case "com.amazonaws.appsync#NotFoundException":
2192
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2193
- case "UnauthorizedException":
2194
- case "com.amazonaws.appsync#UnauthorizedException":
2195
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2196
- default:
2197
- const parsedBody = parsedOutput.body;
2198
- return throwDefaultError({
2199
- output,
2200
- parsedBody,
2201
- errorCode,
2202
- });
2203
- }
2204
- };
2205
1297
  export const de_GetGraphqlApiCommand = async (output, context) => {
2206
1298
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2207
- return de_GetGraphqlApiCommandError(output, context);
1299
+ return de_CommandError(output, context);
2208
1300
  }
2209
1301
  const contents = map({
2210
1302
  $metadata: deserializeMetadata(output),
@@ -2216,40 +1308,23 @@ export const de_GetGraphqlApiCommand = async (output, context) => {
2216
1308
  Object.assign(contents, doc);
2217
1309
  return contents;
2218
1310
  };
2219
- const de_GetGraphqlApiCommandError = async (output, context) => {
2220
- const parsedOutput = {
2221
- ...output,
2222
- body: await parseErrorBody(output.body, context),
2223
- };
2224
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2225
- switch (errorCode) {
2226
- case "AccessDeniedException":
2227
- case "com.amazonaws.appsync#AccessDeniedException":
2228
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2229
- case "BadRequestException":
2230
- case "com.amazonaws.appsync#BadRequestException":
2231
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2232
- case "InternalFailureException":
2233
- case "com.amazonaws.appsync#InternalFailureException":
2234
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2235
- case "NotFoundException":
2236
- case "com.amazonaws.appsync#NotFoundException":
2237
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2238
- case "UnauthorizedException":
2239
- case "com.amazonaws.appsync#UnauthorizedException":
2240
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2241
- default:
2242
- const parsedBody = parsedOutput.body;
2243
- return throwDefaultError({
2244
- output,
2245
- parsedBody,
2246
- errorCode,
2247
- });
1311
+ export const de_GetGraphqlApiEnvironmentVariablesCommand = async (output, context) => {
1312
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1313
+ return de_CommandError(output, context);
2248
1314
  }
1315
+ const contents = map({
1316
+ $metadata: deserializeMetadata(output),
1317
+ });
1318
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1319
+ const doc = take(data, {
1320
+ environmentVariables: _json,
1321
+ });
1322
+ Object.assign(contents, doc);
1323
+ return contents;
2249
1324
  };
2250
1325
  export const de_GetIntrospectionSchemaCommand = async (output, context) => {
2251
1326
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2252
- return de_GetIntrospectionSchemaCommandError(output, context);
1327
+ return de_CommandError(output, context);
2253
1328
  }
2254
1329
  const contents = map({
2255
1330
  $metadata: deserializeMetadata(output),
@@ -2258,37 +1333,9 @@ export const de_GetIntrospectionSchemaCommand = async (output, context) => {
2258
1333
  contents.schema = data;
2259
1334
  return contents;
2260
1335
  };
2261
- const de_GetIntrospectionSchemaCommandError = async (output, context) => {
2262
- const parsedOutput = {
2263
- ...output,
2264
- body: await parseErrorBody(output.body, context),
2265
- };
2266
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2267
- switch (errorCode) {
2268
- case "GraphQLSchemaException":
2269
- case "com.amazonaws.appsync#GraphQLSchemaException":
2270
- throw await de_GraphQLSchemaExceptionRes(parsedOutput, context);
2271
- case "InternalFailureException":
2272
- case "com.amazonaws.appsync#InternalFailureException":
2273
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2274
- case "NotFoundException":
2275
- case "com.amazonaws.appsync#NotFoundException":
2276
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2277
- case "UnauthorizedException":
2278
- case "com.amazonaws.appsync#UnauthorizedException":
2279
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2280
- default:
2281
- const parsedBody = parsedOutput.body;
2282
- return throwDefaultError({
2283
- output,
2284
- parsedBody,
2285
- errorCode,
2286
- });
2287
- }
2288
- };
2289
1336
  export const de_GetResolverCommand = async (output, context) => {
2290
1337
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2291
- return de_GetResolverCommandError(output, context);
1338
+ return de_CommandError(output, context);
2292
1339
  }
2293
1340
  const contents = map({
2294
1341
  $metadata: deserializeMetadata(output),
@@ -2300,34 +1347,9 @@ export const de_GetResolverCommand = async (output, context) => {
2300
1347
  Object.assign(contents, doc);
2301
1348
  return contents;
2302
1349
  };
2303
- const de_GetResolverCommandError = async (output, context) => {
2304
- const parsedOutput = {
2305
- ...output,
2306
- body: await parseErrorBody(output.body, context),
2307
- };
2308
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2309
- switch (errorCode) {
2310
- case "ConcurrentModificationException":
2311
- case "com.amazonaws.appsync#ConcurrentModificationException":
2312
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2313
- case "NotFoundException":
2314
- case "com.amazonaws.appsync#NotFoundException":
2315
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2316
- case "UnauthorizedException":
2317
- case "com.amazonaws.appsync#UnauthorizedException":
2318
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2319
- default:
2320
- const parsedBody = parsedOutput.body;
2321
- return throwDefaultError({
2322
- output,
2323
- parsedBody,
2324
- errorCode,
2325
- });
2326
- }
2327
- };
2328
1350
  export const de_GetSchemaCreationStatusCommand = async (output, context) => {
2329
1351
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2330
- return de_GetSchemaCreationStatusCommandError(output, context);
1352
+ return de_CommandError(output, context);
2331
1353
  }
2332
1354
  const contents = map({
2333
1355
  $metadata: deserializeMetadata(output),
@@ -2340,37 +1362,9 @@ export const de_GetSchemaCreationStatusCommand = async (output, context) => {
2340
1362
  Object.assign(contents, doc);
2341
1363
  return contents;
2342
1364
  };
2343
- const de_GetSchemaCreationStatusCommandError = async (output, context) => {
2344
- const parsedOutput = {
2345
- ...output,
2346
- body: await parseErrorBody(output.body, context),
2347
- };
2348
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2349
- switch (errorCode) {
2350
- case "BadRequestException":
2351
- case "com.amazonaws.appsync#BadRequestException":
2352
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2353
- case "InternalFailureException":
2354
- case "com.amazonaws.appsync#InternalFailureException":
2355
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2356
- case "NotFoundException":
2357
- case "com.amazonaws.appsync#NotFoundException":
2358
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2359
- case "UnauthorizedException":
2360
- case "com.amazonaws.appsync#UnauthorizedException":
2361
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2362
- default:
2363
- const parsedBody = parsedOutput.body;
2364
- return throwDefaultError({
2365
- output,
2366
- parsedBody,
2367
- errorCode,
2368
- });
2369
- }
2370
- };
2371
1365
  export const de_GetSourceApiAssociationCommand = async (output, context) => {
2372
1366
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2373
- return de_GetSourceApiAssociationCommandError(output, context);
1367
+ return de_CommandError(output, context);
2374
1368
  }
2375
1369
  const contents = map({
2376
1370
  $metadata: deserializeMetadata(output),
@@ -2382,37 +1376,9 @@ export const de_GetSourceApiAssociationCommand = async (output, context) => {
2382
1376
  Object.assign(contents, doc);
2383
1377
  return contents;
2384
1378
  };
2385
- const de_GetSourceApiAssociationCommandError = async (output, context) => {
2386
- const parsedOutput = {
2387
- ...output,
2388
- body: await parseErrorBody(output.body, context),
2389
- };
2390
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2391
- switch (errorCode) {
2392
- case "BadRequestException":
2393
- case "com.amazonaws.appsync#BadRequestException":
2394
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2395
- case "InternalFailureException":
2396
- case "com.amazonaws.appsync#InternalFailureException":
2397
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2398
- case "NotFoundException":
2399
- case "com.amazonaws.appsync#NotFoundException":
2400
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2401
- case "UnauthorizedException":
2402
- case "com.amazonaws.appsync#UnauthorizedException":
2403
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2404
- default:
2405
- const parsedBody = parsedOutput.body;
2406
- return throwDefaultError({
2407
- output,
2408
- parsedBody,
2409
- errorCode,
2410
- });
2411
- }
2412
- };
2413
1379
  export const de_GetTypeCommand = async (output, context) => {
2414
1380
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2415
- return de_GetTypeCommandError(output, context);
1381
+ return de_CommandError(output, context);
2416
1382
  }
2417
1383
  const contents = map({
2418
1384
  $metadata: deserializeMetadata(output),
@@ -2424,40 +1390,9 @@ export const de_GetTypeCommand = async (output, context) => {
2424
1390
  Object.assign(contents, doc);
2425
1391
  return contents;
2426
1392
  };
2427
- const de_GetTypeCommandError = async (output, context) => {
2428
- const parsedOutput = {
2429
- ...output,
2430
- body: await parseErrorBody(output.body, context),
2431
- };
2432
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2433
- switch (errorCode) {
2434
- case "BadRequestException":
2435
- case "com.amazonaws.appsync#BadRequestException":
2436
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2437
- case "ConcurrentModificationException":
2438
- case "com.amazonaws.appsync#ConcurrentModificationException":
2439
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2440
- case "InternalFailureException":
2441
- case "com.amazonaws.appsync#InternalFailureException":
2442
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2443
- case "NotFoundException":
2444
- case "com.amazonaws.appsync#NotFoundException":
2445
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2446
- case "UnauthorizedException":
2447
- case "com.amazonaws.appsync#UnauthorizedException":
2448
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2449
- default:
2450
- const parsedBody = parsedOutput.body;
2451
- return throwDefaultError({
2452
- output,
2453
- parsedBody,
2454
- errorCode,
2455
- });
2456
- }
2457
- };
2458
1393
  export const de_ListApiKeysCommand = async (output, context) => {
2459
1394
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2460
- return de_ListApiKeysCommandError(output, context);
1395
+ return de_CommandError(output, context);
2461
1396
  }
2462
1397
  const contents = map({
2463
1398
  $metadata: deserializeMetadata(output),
@@ -2470,37 +1405,9 @@ export const de_ListApiKeysCommand = async (output, context) => {
2470
1405
  Object.assign(contents, doc);
2471
1406
  return contents;
2472
1407
  };
2473
- const de_ListApiKeysCommandError = async (output, context) => {
2474
- const parsedOutput = {
2475
- ...output,
2476
- body: await parseErrorBody(output.body, context),
2477
- };
2478
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2479
- switch (errorCode) {
2480
- case "BadRequestException":
2481
- case "com.amazonaws.appsync#BadRequestException":
2482
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2483
- case "InternalFailureException":
2484
- case "com.amazonaws.appsync#InternalFailureException":
2485
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2486
- case "NotFoundException":
2487
- case "com.amazonaws.appsync#NotFoundException":
2488
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2489
- case "UnauthorizedException":
2490
- case "com.amazonaws.appsync#UnauthorizedException":
2491
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2492
- default:
2493
- const parsedBody = parsedOutput.body;
2494
- return throwDefaultError({
2495
- output,
2496
- parsedBody,
2497
- errorCode,
2498
- });
2499
- }
2500
- };
2501
1408
  export const de_ListDataSourcesCommand = async (output, context) => {
2502
1409
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2503
- return de_ListDataSourcesCommandError(output, context);
1410
+ return de_CommandError(output, context);
2504
1411
  }
2505
1412
  const contents = map({
2506
1413
  $metadata: deserializeMetadata(output),
@@ -2513,37 +1420,9 @@ export const de_ListDataSourcesCommand = async (output, context) => {
2513
1420
  Object.assign(contents, doc);
2514
1421
  return contents;
2515
1422
  };
2516
- const de_ListDataSourcesCommandError = async (output, context) => {
2517
- const parsedOutput = {
2518
- ...output,
2519
- body: await parseErrorBody(output.body, context),
2520
- };
2521
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2522
- switch (errorCode) {
2523
- case "BadRequestException":
2524
- case "com.amazonaws.appsync#BadRequestException":
2525
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2526
- case "InternalFailureException":
2527
- case "com.amazonaws.appsync#InternalFailureException":
2528
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2529
- case "NotFoundException":
2530
- case "com.amazonaws.appsync#NotFoundException":
2531
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2532
- case "UnauthorizedException":
2533
- case "com.amazonaws.appsync#UnauthorizedException":
2534
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2535
- default:
2536
- const parsedBody = parsedOutput.body;
2537
- return throwDefaultError({
2538
- output,
2539
- parsedBody,
2540
- errorCode,
2541
- });
2542
- }
2543
- };
2544
1423
  export const de_ListDomainNamesCommand = async (output, context) => {
2545
1424
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2546
- return de_ListDomainNamesCommandError(output, context);
1425
+ return de_CommandError(output, context);
2547
1426
  }
2548
1427
  const contents = map({
2549
1428
  $metadata: deserializeMetadata(output),
@@ -2556,34 +1435,9 @@ export const de_ListDomainNamesCommand = async (output, context) => {
2556
1435
  Object.assign(contents, doc);
2557
1436
  return contents;
2558
1437
  };
2559
- const de_ListDomainNamesCommandError = async (output, context) => {
2560
- const parsedOutput = {
2561
- ...output,
2562
- body: await parseErrorBody(output.body, context),
2563
- };
2564
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2565
- switch (errorCode) {
2566
- case "AccessDeniedException":
2567
- case "com.amazonaws.appsync#AccessDeniedException":
2568
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2569
- case "BadRequestException":
2570
- case "com.amazonaws.appsync#BadRequestException":
2571
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2572
- case "InternalFailureException":
2573
- case "com.amazonaws.appsync#InternalFailureException":
2574
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2575
- default:
2576
- const parsedBody = parsedOutput.body;
2577
- return throwDefaultError({
2578
- output,
2579
- parsedBody,
2580
- errorCode,
2581
- });
2582
- }
2583
- };
2584
1438
  export const de_ListFunctionsCommand = async (output, context) => {
2585
1439
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2586
- return de_ListFunctionsCommandError(output, context);
1440
+ return de_CommandError(output, context);
2587
1441
  }
2588
1442
  const contents = map({
2589
1443
  $metadata: deserializeMetadata(output),
@@ -2596,37 +1450,9 @@ export const de_ListFunctionsCommand = async (output, context) => {
2596
1450
  Object.assign(contents, doc);
2597
1451
  return contents;
2598
1452
  };
2599
- const de_ListFunctionsCommandError = async (output, context) => {
2600
- const parsedOutput = {
2601
- ...output,
2602
- body: await parseErrorBody(output.body, context),
2603
- };
2604
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2605
- switch (errorCode) {
2606
- case "BadRequestException":
2607
- case "com.amazonaws.appsync#BadRequestException":
2608
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2609
- case "InternalFailureException":
2610
- case "com.amazonaws.appsync#InternalFailureException":
2611
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2612
- case "NotFoundException":
2613
- case "com.amazonaws.appsync#NotFoundException":
2614
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2615
- case "UnauthorizedException":
2616
- case "com.amazonaws.appsync#UnauthorizedException":
2617
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2618
- default:
2619
- const parsedBody = parsedOutput.body;
2620
- return throwDefaultError({
2621
- output,
2622
- parsedBody,
2623
- errorCode,
2624
- });
2625
- }
2626
- };
2627
1453
  export const de_ListGraphqlApisCommand = async (output, context) => {
2628
1454
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2629
- return de_ListGraphqlApisCommandError(output, context);
1455
+ return de_CommandError(output, context);
2630
1456
  }
2631
1457
  const contents = map({
2632
1458
  $metadata: deserializeMetadata(output),
@@ -2639,34 +1465,9 @@ export const de_ListGraphqlApisCommand = async (output, context) => {
2639
1465
  Object.assign(contents, doc);
2640
1466
  return contents;
2641
1467
  };
2642
- const de_ListGraphqlApisCommandError = async (output, context) => {
2643
- const parsedOutput = {
2644
- ...output,
2645
- body: await parseErrorBody(output.body, context),
2646
- };
2647
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2648
- switch (errorCode) {
2649
- case "BadRequestException":
2650
- case "com.amazonaws.appsync#BadRequestException":
2651
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2652
- case "InternalFailureException":
2653
- case "com.amazonaws.appsync#InternalFailureException":
2654
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2655
- case "UnauthorizedException":
2656
- case "com.amazonaws.appsync#UnauthorizedException":
2657
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2658
- default:
2659
- const parsedBody = parsedOutput.body;
2660
- return throwDefaultError({
2661
- output,
2662
- parsedBody,
2663
- errorCode,
2664
- });
2665
- }
2666
- };
2667
1468
  export const de_ListResolversCommand = async (output, context) => {
2668
1469
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2669
- return de_ListResolversCommandError(output, context);
1470
+ return de_CommandError(output, context);
2670
1471
  }
2671
1472
  const contents = map({
2672
1473
  $metadata: deserializeMetadata(output),
@@ -2679,37 +1480,9 @@ export const de_ListResolversCommand = async (output, context) => {
2679
1480
  Object.assign(contents, doc);
2680
1481
  return contents;
2681
1482
  };
2682
- const de_ListResolversCommandError = async (output, context) => {
2683
- const parsedOutput = {
2684
- ...output,
2685
- body: await parseErrorBody(output.body, context),
2686
- };
2687
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2688
- switch (errorCode) {
2689
- case "BadRequestException":
2690
- case "com.amazonaws.appsync#BadRequestException":
2691
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2692
- case "InternalFailureException":
2693
- case "com.amazonaws.appsync#InternalFailureException":
2694
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2695
- case "NotFoundException":
2696
- case "com.amazonaws.appsync#NotFoundException":
2697
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2698
- case "UnauthorizedException":
2699
- case "com.amazonaws.appsync#UnauthorizedException":
2700
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2701
- default:
2702
- const parsedBody = parsedOutput.body;
2703
- return throwDefaultError({
2704
- output,
2705
- parsedBody,
2706
- errorCode,
2707
- });
2708
- }
2709
- };
2710
1483
  export const de_ListResolversByFunctionCommand = async (output, context) => {
2711
1484
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2712
- return de_ListResolversByFunctionCommandError(output, context);
1485
+ return de_CommandError(output, context);
2713
1486
  }
2714
1487
  const contents = map({
2715
1488
  $metadata: deserializeMetadata(output),
@@ -2722,37 +1495,9 @@ export const de_ListResolversByFunctionCommand = async (output, context) => {
2722
1495
  Object.assign(contents, doc);
2723
1496
  return contents;
2724
1497
  };
2725
- const de_ListResolversByFunctionCommandError = async (output, context) => {
2726
- const parsedOutput = {
2727
- ...output,
2728
- body: await parseErrorBody(output.body, context),
2729
- };
2730
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2731
- switch (errorCode) {
2732
- case "BadRequestException":
2733
- case "com.amazonaws.appsync#BadRequestException":
2734
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2735
- case "InternalFailureException":
2736
- case "com.amazonaws.appsync#InternalFailureException":
2737
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2738
- case "NotFoundException":
2739
- case "com.amazonaws.appsync#NotFoundException":
2740
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2741
- case "UnauthorizedException":
2742
- case "com.amazonaws.appsync#UnauthorizedException":
2743
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2744
- default:
2745
- const parsedBody = parsedOutput.body;
2746
- return throwDefaultError({
2747
- output,
2748
- parsedBody,
2749
- errorCode,
2750
- });
2751
- }
2752
- };
2753
1498
  export const de_ListSourceApiAssociationsCommand = async (output, context) => {
2754
1499
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2755
- return de_ListSourceApiAssociationsCommandError(output, context);
1500
+ return de_CommandError(output, context);
2756
1501
  }
2757
1502
  const contents = map({
2758
1503
  $metadata: deserializeMetadata(output),
@@ -2765,37 +1510,9 @@ export const de_ListSourceApiAssociationsCommand = async (output, context) => {
2765
1510
  Object.assign(contents, doc);
2766
1511
  return contents;
2767
1512
  };
2768
- const de_ListSourceApiAssociationsCommandError = async (output, context) => {
2769
- const parsedOutput = {
2770
- ...output,
2771
- body: await parseErrorBody(output.body, context),
2772
- };
2773
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2774
- switch (errorCode) {
2775
- case "BadRequestException":
2776
- case "com.amazonaws.appsync#BadRequestException":
2777
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2778
- case "InternalFailureException":
2779
- case "com.amazonaws.appsync#InternalFailureException":
2780
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2781
- case "NotFoundException":
2782
- case "com.amazonaws.appsync#NotFoundException":
2783
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2784
- case "UnauthorizedException":
2785
- case "com.amazonaws.appsync#UnauthorizedException":
2786
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2787
- default:
2788
- const parsedBody = parsedOutput.body;
2789
- return throwDefaultError({
2790
- output,
2791
- parsedBody,
2792
- errorCode,
2793
- });
2794
- }
2795
- };
2796
1513
  export const de_ListTagsForResourceCommand = async (output, context) => {
2797
1514
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2798
- return de_ListTagsForResourceCommandError(output, context);
1515
+ return de_CommandError(output, context);
2799
1516
  }
2800
1517
  const contents = map({
2801
1518
  $metadata: deserializeMetadata(output),
@@ -2807,43 +1524,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
2807
1524
  Object.assign(contents, doc);
2808
1525
  return contents;
2809
1526
  };
2810
- const de_ListTagsForResourceCommandError = async (output, context) => {
2811
- const parsedOutput = {
2812
- ...output,
2813
- body: await parseErrorBody(output.body, context),
2814
- };
2815
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2816
- switch (errorCode) {
2817
- case "AccessDeniedException":
2818
- case "com.amazonaws.appsync#AccessDeniedException":
2819
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2820
- case "BadRequestException":
2821
- case "com.amazonaws.appsync#BadRequestException":
2822
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2823
- case "InternalFailureException":
2824
- case "com.amazonaws.appsync#InternalFailureException":
2825
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2826
- case "LimitExceededException":
2827
- case "com.amazonaws.appsync#LimitExceededException":
2828
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2829
- case "NotFoundException":
2830
- case "com.amazonaws.appsync#NotFoundException":
2831
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2832
- case "UnauthorizedException":
2833
- case "com.amazonaws.appsync#UnauthorizedException":
2834
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2835
- default:
2836
- const parsedBody = parsedOutput.body;
2837
- return throwDefaultError({
2838
- output,
2839
- parsedBody,
2840
- errorCode,
2841
- });
2842
- }
2843
- };
2844
1527
  export const de_ListTypesCommand = async (output, context) => {
2845
1528
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2846
- return de_ListTypesCommandError(output, context);
1529
+ return de_CommandError(output, context);
2847
1530
  }
2848
1531
  const contents = map({
2849
1532
  $metadata: deserializeMetadata(output),
@@ -2856,40 +1539,9 @@ export const de_ListTypesCommand = async (output, context) => {
2856
1539
  Object.assign(contents, doc);
2857
1540
  return contents;
2858
1541
  };
2859
- const de_ListTypesCommandError = async (output, context) => {
2860
- const parsedOutput = {
2861
- ...output,
2862
- body: await parseErrorBody(output.body, context),
2863
- };
2864
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2865
- switch (errorCode) {
2866
- case "BadRequestException":
2867
- case "com.amazonaws.appsync#BadRequestException":
2868
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2869
- case "ConcurrentModificationException":
2870
- case "com.amazonaws.appsync#ConcurrentModificationException":
2871
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2872
- case "InternalFailureException":
2873
- case "com.amazonaws.appsync#InternalFailureException":
2874
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2875
- case "NotFoundException":
2876
- case "com.amazonaws.appsync#NotFoundException":
2877
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2878
- case "UnauthorizedException":
2879
- case "com.amazonaws.appsync#UnauthorizedException":
2880
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2881
- default:
2882
- const parsedBody = parsedOutput.body;
2883
- return throwDefaultError({
2884
- output,
2885
- parsedBody,
2886
- errorCode,
2887
- });
2888
- }
2889
- };
2890
1542
  export const de_ListTypesByAssociationCommand = async (output, context) => {
2891
1543
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2892
- return de_ListTypesByAssociationCommandError(output, context);
1544
+ return de_CommandError(output, context);
2893
1545
  }
2894
1546
  const contents = map({
2895
1547
  $metadata: deserializeMetadata(output),
@@ -2902,40 +1554,23 @@ export const de_ListTypesByAssociationCommand = async (output, context) => {
2902
1554
  Object.assign(contents, doc);
2903
1555
  return contents;
2904
1556
  };
2905
- const de_ListTypesByAssociationCommandError = async (output, context) => {
2906
- const parsedOutput = {
2907
- ...output,
2908
- body: await parseErrorBody(output.body, context),
2909
- };
2910
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2911
- switch (errorCode) {
2912
- case "BadRequestException":
2913
- case "com.amazonaws.appsync#BadRequestException":
2914
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2915
- case "ConcurrentModificationException":
2916
- case "com.amazonaws.appsync#ConcurrentModificationException":
2917
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2918
- case "InternalFailureException":
2919
- case "com.amazonaws.appsync#InternalFailureException":
2920
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2921
- case "NotFoundException":
2922
- case "com.amazonaws.appsync#NotFoundException":
2923
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2924
- case "UnauthorizedException":
2925
- case "com.amazonaws.appsync#UnauthorizedException":
2926
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2927
- default:
2928
- const parsedBody = parsedOutput.body;
2929
- return throwDefaultError({
2930
- output,
2931
- parsedBody,
2932
- errorCode,
2933
- });
1557
+ export const de_PutGraphqlApiEnvironmentVariablesCommand = async (output, context) => {
1558
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1559
+ return de_CommandError(output, context);
2934
1560
  }
1561
+ const contents = map({
1562
+ $metadata: deserializeMetadata(output),
1563
+ });
1564
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1565
+ const doc = take(data, {
1566
+ environmentVariables: _json,
1567
+ });
1568
+ Object.assign(contents, doc);
1569
+ return contents;
2935
1570
  };
2936
1571
  export const de_StartDataSourceIntrospectionCommand = async (output, context) => {
2937
1572
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2938
- return de_StartDataSourceIntrospectionCommandError(output, context);
1573
+ return de_CommandError(output, context);
2939
1574
  }
2940
1575
  const contents = map({
2941
1576
  $metadata: deserializeMetadata(output),
@@ -2949,37 +1584,9 @@ export const de_StartDataSourceIntrospectionCommand = async (output, context) =>
2949
1584
  Object.assign(contents, doc);
2950
1585
  return contents;
2951
1586
  };
2952
- const de_StartDataSourceIntrospectionCommandError = async (output, context) => {
2953
- const parsedOutput = {
2954
- ...output,
2955
- body: await parseErrorBody(output.body, context),
2956
- };
2957
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2958
- switch (errorCode) {
2959
- case "BadRequestException":
2960
- case "com.amazonaws.appsync#BadRequestException":
2961
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2962
- case "InternalFailureException":
2963
- case "com.amazonaws.appsync#InternalFailureException":
2964
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2965
- case "NotFoundException":
2966
- case "com.amazonaws.appsync#NotFoundException":
2967
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2968
- case "UnauthorizedException":
2969
- case "com.amazonaws.appsync#UnauthorizedException":
2970
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2971
- default:
2972
- const parsedBody = parsedOutput.body;
2973
- return throwDefaultError({
2974
- output,
2975
- parsedBody,
2976
- errorCode,
2977
- });
2978
- }
2979
- };
2980
1587
  export const de_StartSchemaCreationCommand = async (output, context) => {
2981
1588
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2982
- return de_StartSchemaCreationCommandError(output, context);
1589
+ return de_CommandError(output, context);
2983
1590
  }
2984
1591
  const contents = map({
2985
1592
  $metadata: deserializeMetadata(output),
@@ -2991,40 +1598,9 @@ export const de_StartSchemaCreationCommand = async (output, context) => {
2991
1598
  Object.assign(contents, doc);
2992
1599
  return contents;
2993
1600
  };
2994
- const de_StartSchemaCreationCommandError = async (output, context) => {
2995
- const parsedOutput = {
2996
- ...output,
2997
- body: await parseErrorBody(output.body, context),
2998
- };
2999
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3000
- switch (errorCode) {
3001
- case "BadRequestException":
3002
- case "com.amazonaws.appsync#BadRequestException":
3003
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3004
- case "ConcurrentModificationException":
3005
- case "com.amazonaws.appsync#ConcurrentModificationException":
3006
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3007
- case "InternalFailureException":
3008
- case "com.amazonaws.appsync#InternalFailureException":
3009
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3010
- case "NotFoundException":
3011
- case "com.amazonaws.appsync#NotFoundException":
3012
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3013
- case "UnauthorizedException":
3014
- case "com.amazonaws.appsync#UnauthorizedException":
3015
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3016
- default:
3017
- const parsedBody = parsedOutput.body;
3018
- return throwDefaultError({
3019
- output,
3020
- parsedBody,
3021
- errorCode,
3022
- });
3023
- }
3024
- };
3025
1601
  export const de_StartSchemaMergeCommand = async (output, context) => {
3026
1602
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3027
- return de_StartSchemaMergeCommandError(output, context);
1603
+ return de_CommandError(output, context);
3028
1604
  }
3029
1605
  const contents = map({
3030
1606
  $metadata: deserializeMetadata(output),
@@ -3036,40 +1612,9 @@ export const de_StartSchemaMergeCommand = async (output, context) => {
3036
1612
  Object.assign(contents, doc);
3037
1613
  return contents;
3038
1614
  };
3039
- const de_StartSchemaMergeCommandError = async (output, context) => {
3040
- const parsedOutput = {
3041
- ...output,
3042
- body: await parseErrorBody(output.body, context),
3043
- };
3044
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3045
- switch (errorCode) {
3046
- case "BadRequestException":
3047
- case "com.amazonaws.appsync#BadRequestException":
3048
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3049
- case "ConcurrentModificationException":
3050
- case "com.amazonaws.appsync#ConcurrentModificationException":
3051
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3052
- case "InternalFailureException":
3053
- case "com.amazonaws.appsync#InternalFailureException":
3054
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3055
- case "NotFoundException":
3056
- case "com.amazonaws.appsync#NotFoundException":
3057
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3058
- case "UnauthorizedException":
3059
- case "com.amazonaws.appsync#UnauthorizedException":
3060
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3061
- default:
3062
- const parsedBody = parsedOutput.body;
3063
- return throwDefaultError({
3064
- output,
3065
- parsedBody,
3066
- errorCode,
3067
- });
3068
- }
3069
- };
3070
1615
  export const de_TagResourceCommand = async (output, context) => {
3071
1616
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3072
- return de_TagResourceCommandError(output, context);
1617
+ return de_CommandError(output, context);
3073
1618
  }
3074
1619
  const contents = map({
3075
1620
  $metadata: deserializeMetadata(output),
@@ -3077,180 +1622,47 @@ export const de_TagResourceCommand = async (output, context) => {
3077
1622
  await collectBody(output.body, context);
3078
1623
  return contents;
3079
1624
  };
3080
- const de_TagResourceCommandError = async (output, context) => {
3081
- const parsedOutput = {
3082
- ...output,
3083
- body: await parseErrorBody(output.body, context),
3084
- };
3085
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3086
- switch (errorCode) {
3087
- case "AccessDeniedException":
3088
- case "com.amazonaws.appsync#AccessDeniedException":
3089
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3090
- case "BadRequestException":
3091
- case "com.amazonaws.appsync#BadRequestException":
3092
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3093
- case "InternalFailureException":
3094
- case "com.amazonaws.appsync#InternalFailureException":
3095
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3096
- case "LimitExceededException":
3097
- case "com.amazonaws.appsync#LimitExceededException":
3098
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3099
- case "NotFoundException":
3100
- case "com.amazonaws.appsync#NotFoundException":
3101
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3102
- case "UnauthorizedException":
3103
- case "com.amazonaws.appsync#UnauthorizedException":
3104
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3105
- default:
3106
- const parsedBody = parsedOutput.body;
3107
- return throwDefaultError({
3108
- output,
3109
- parsedBody,
3110
- errorCode,
3111
- });
3112
- }
3113
- };
3114
1625
  export const de_UntagResourceCommand = async (output, context) => {
3115
- if (output.statusCode !== 200 && output.statusCode >= 300) {
3116
- return de_UntagResourceCommandError(output, context);
3117
- }
3118
- const contents = map({
3119
- $metadata: deserializeMetadata(output),
3120
- });
3121
- await collectBody(output.body, context);
3122
- return contents;
3123
- };
3124
- const de_UntagResourceCommandError = async (output, context) => {
3125
- const parsedOutput = {
3126
- ...output,
3127
- body: await parseErrorBody(output.body, context),
3128
- };
3129
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3130
- switch (errorCode) {
3131
- case "AccessDeniedException":
3132
- case "com.amazonaws.appsync#AccessDeniedException":
3133
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3134
- case "BadRequestException":
3135
- case "com.amazonaws.appsync#BadRequestException":
3136
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3137
- case "InternalFailureException":
3138
- case "com.amazonaws.appsync#InternalFailureException":
3139
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3140
- case "LimitExceededException":
3141
- case "com.amazonaws.appsync#LimitExceededException":
3142
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3143
- case "NotFoundException":
3144
- case "com.amazonaws.appsync#NotFoundException":
3145
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3146
- case "UnauthorizedException":
3147
- case "com.amazonaws.appsync#UnauthorizedException":
3148
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3149
- default:
3150
- const parsedBody = parsedOutput.body;
3151
- return throwDefaultError({
3152
- output,
3153
- parsedBody,
3154
- errorCode,
3155
- });
3156
- }
3157
- };
3158
- export const de_UpdateApiCacheCommand = async (output, context) => {
3159
- if (output.statusCode !== 200 && output.statusCode >= 300) {
3160
- return de_UpdateApiCacheCommandError(output, context);
3161
- }
3162
- const contents = map({
3163
- $metadata: deserializeMetadata(output),
3164
- });
3165
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3166
- const doc = take(data, {
3167
- apiCache: _json,
3168
- });
3169
- Object.assign(contents, doc);
3170
- return contents;
3171
- };
3172
- const de_UpdateApiCacheCommandError = async (output, context) => {
3173
- const parsedOutput = {
3174
- ...output,
3175
- body: await parseErrorBody(output.body, context),
3176
- };
3177
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3178
- switch (errorCode) {
3179
- case "BadRequestException":
3180
- case "com.amazonaws.appsync#BadRequestException":
3181
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3182
- case "ConcurrentModificationException":
3183
- case "com.amazonaws.appsync#ConcurrentModificationException":
3184
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3185
- case "InternalFailureException":
3186
- case "com.amazonaws.appsync#InternalFailureException":
3187
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3188
- case "NotFoundException":
3189
- case "com.amazonaws.appsync#NotFoundException":
3190
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3191
- case "UnauthorizedException":
3192
- case "com.amazonaws.appsync#UnauthorizedException":
3193
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3194
- default:
3195
- const parsedBody = parsedOutput.body;
3196
- return throwDefaultError({
3197
- output,
3198
- parsedBody,
3199
- errorCode,
3200
- });
1626
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1627
+ return de_CommandError(output, context);
3201
1628
  }
1629
+ const contents = map({
1630
+ $metadata: deserializeMetadata(output),
1631
+ });
1632
+ await collectBody(output.body, context);
1633
+ return contents;
3202
1634
  };
3203
- export const de_UpdateApiKeyCommand = async (output, context) => {
1635
+ export const de_UpdateApiCacheCommand = async (output, context) => {
3204
1636
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3205
- return de_UpdateApiKeyCommandError(output, context);
1637
+ return de_CommandError(output, context);
3206
1638
  }
3207
1639
  const contents = map({
3208
1640
  $metadata: deserializeMetadata(output),
3209
1641
  });
3210
1642
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3211
1643
  const doc = take(data, {
3212
- apiKey: _json,
1644
+ apiCache: _json,
3213
1645
  });
3214
1646
  Object.assign(contents, doc);
3215
1647
  return contents;
3216
1648
  };
3217
- const de_UpdateApiKeyCommandError = async (output, context) => {
3218
- const parsedOutput = {
3219
- ...output,
3220
- body: await parseErrorBody(output.body, context),
3221
- };
3222
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3223
- switch (errorCode) {
3224
- case "ApiKeyValidityOutOfBoundsException":
3225
- case "com.amazonaws.appsync#ApiKeyValidityOutOfBoundsException":
3226
- throw await de_ApiKeyValidityOutOfBoundsExceptionRes(parsedOutput, context);
3227
- case "BadRequestException":
3228
- case "com.amazonaws.appsync#BadRequestException":
3229
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3230
- case "InternalFailureException":
3231
- case "com.amazonaws.appsync#InternalFailureException":
3232
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3233
- case "LimitExceededException":
3234
- case "com.amazonaws.appsync#LimitExceededException":
3235
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3236
- case "NotFoundException":
3237
- case "com.amazonaws.appsync#NotFoundException":
3238
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3239
- case "UnauthorizedException":
3240
- case "com.amazonaws.appsync#UnauthorizedException":
3241
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3242
- default:
3243
- const parsedBody = parsedOutput.body;
3244
- return throwDefaultError({
3245
- output,
3246
- parsedBody,
3247
- errorCode,
3248
- });
1649
+ export const de_UpdateApiKeyCommand = async (output, context) => {
1650
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1651
+ return de_CommandError(output, context);
3249
1652
  }
1653
+ const contents = map({
1654
+ $metadata: deserializeMetadata(output),
1655
+ });
1656
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1657
+ const doc = take(data, {
1658
+ apiKey: _json,
1659
+ });
1660
+ Object.assign(contents, doc);
1661
+ return contents;
3250
1662
  };
3251
1663
  export const de_UpdateDataSourceCommand = async (output, context) => {
3252
1664
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3253
- return de_UpdateDataSourceCommandError(output, context);
1665
+ return de_CommandError(output, context);
3254
1666
  }
3255
1667
  const contents = map({
3256
1668
  $metadata: deserializeMetadata(output),
@@ -3262,40 +1674,9 @@ export const de_UpdateDataSourceCommand = async (output, context) => {
3262
1674
  Object.assign(contents, doc);
3263
1675
  return contents;
3264
1676
  };
3265
- const de_UpdateDataSourceCommandError = async (output, context) => {
3266
- const parsedOutput = {
3267
- ...output,
3268
- body: await parseErrorBody(output.body, context),
3269
- };
3270
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3271
- switch (errorCode) {
3272
- case "BadRequestException":
3273
- case "com.amazonaws.appsync#BadRequestException":
3274
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3275
- case "ConcurrentModificationException":
3276
- case "com.amazonaws.appsync#ConcurrentModificationException":
3277
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3278
- case "InternalFailureException":
3279
- case "com.amazonaws.appsync#InternalFailureException":
3280
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3281
- case "NotFoundException":
3282
- case "com.amazonaws.appsync#NotFoundException":
3283
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3284
- case "UnauthorizedException":
3285
- case "com.amazonaws.appsync#UnauthorizedException":
3286
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3287
- default:
3288
- const parsedBody = parsedOutput.body;
3289
- return throwDefaultError({
3290
- output,
3291
- parsedBody,
3292
- errorCode,
3293
- });
3294
- }
3295
- };
3296
1677
  export const de_UpdateDomainNameCommand = async (output, context) => {
3297
1678
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3298
- return de_UpdateDomainNameCommandError(output, context);
1679
+ return de_CommandError(output, context);
3299
1680
  }
3300
1681
  const contents = map({
3301
1682
  $metadata: deserializeMetadata(output),
@@ -3307,40 +1688,9 @@ export const de_UpdateDomainNameCommand = async (output, context) => {
3307
1688
  Object.assign(contents, doc);
3308
1689
  return contents;
3309
1690
  };
3310
- const de_UpdateDomainNameCommandError = async (output, context) => {
3311
- const parsedOutput = {
3312
- ...output,
3313
- body: await parseErrorBody(output.body, context),
3314
- };
3315
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3316
- switch (errorCode) {
3317
- case "AccessDeniedException":
3318
- case "com.amazonaws.appsync#AccessDeniedException":
3319
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3320
- case "BadRequestException":
3321
- case "com.amazonaws.appsync#BadRequestException":
3322
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3323
- case "ConcurrentModificationException":
3324
- case "com.amazonaws.appsync#ConcurrentModificationException":
3325
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3326
- case "InternalFailureException":
3327
- case "com.amazonaws.appsync#InternalFailureException":
3328
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3329
- case "NotFoundException":
3330
- case "com.amazonaws.appsync#NotFoundException":
3331
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3332
- default:
3333
- const parsedBody = parsedOutput.body;
3334
- return throwDefaultError({
3335
- output,
3336
- parsedBody,
3337
- errorCode,
3338
- });
3339
- }
3340
- };
3341
1691
  export const de_UpdateFunctionCommand = async (output, context) => {
3342
1692
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3343
- return de_UpdateFunctionCommandError(output, context);
1693
+ return de_CommandError(output, context);
3344
1694
  }
3345
1695
  const contents = map({
3346
1696
  $metadata: deserializeMetadata(output),
@@ -3352,37 +1702,9 @@ export const de_UpdateFunctionCommand = async (output, context) => {
3352
1702
  Object.assign(contents, doc);
3353
1703
  return contents;
3354
1704
  };
3355
- const de_UpdateFunctionCommandError = async (output, context) => {
3356
- const parsedOutput = {
3357
- ...output,
3358
- body: await parseErrorBody(output.body, context),
3359
- };
3360
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3361
- switch (errorCode) {
3362
- case "ConcurrentModificationException":
3363
- case "com.amazonaws.appsync#ConcurrentModificationException":
3364
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3365
- case "InternalFailureException":
3366
- case "com.amazonaws.appsync#InternalFailureException":
3367
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3368
- case "NotFoundException":
3369
- case "com.amazonaws.appsync#NotFoundException":
3370
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3371
- case "UnauthorizedException":
3372
- case "com.amazonaws.appsync#UnauthorizedException":
3373
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3374
- default:
3375
- const parsedBody = parsedOutput.body;
3376
- return throwDefaultError({
3377
- output,
3378
- parsedBody,
3379
- errorCode,
3380
- });
3381
- }
3382
- };
3383
1705
  export const de_UpdateGraphqlApiCommand = async (output, context) => {
3384
1706
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3385
- return de_UpdateGraphqlApiCommandError(output, context);
1707
+ return de_CommandError(output, context);
3386
1708
  }
3387
1709
  const contents = map({
3388
1710
  $metadata: deserializeMetadata(output),
@@ -3394,43 +1716,9 @@ export const de_UpdateGraphqlApiCommand = async (output, context) => {
3394
1716
  Object.assign(contents, doc);
3395
1717
  return contents;
3396
1718
  };
3397
- const de_UpdateGraphqlApiCommandError = async (output, context) => {
3398
- const parsedOutput = {
3399
- ...output,
3400
- body: await parseErrorBody(output.body, context),
3401
- };
3402
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3403
- switch (errorCode) {
3404
- case "AccessDeniedException":
3405
- case "com.amazonaws.appsync#AccessDeniedException":
3406
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3407
- case "BadRequestException":
3408
- case "com.amazonaws.appsync#BadRequestException":
3409
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3410
- case "ConcurrentModificationException":
3411
- case "com.amazonaws.appsync#ConcurrentModificationException":
3412
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3413
- case "InternalFailureException":
3414
- case "com.amazonaws.appsync#InternalFailureException":
3415
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3416
- case "NotFoundException":
3417
- case "com.amazonaws.appsync#NotFoundException":
3418
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3419
- case "UnauthorizedException":
3420
- case "com.amazonaws.appsync#UnauthorizedException":
3421
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3422
- default:
3423
- const parsedBody = parsedOutput.body;
3424
- return throwDefaultError({
3425
- output,
3426
- parsedBody,
3427
- errorCode,
3428
- });
3429
- }
3430
- };
3431
1719
  export const de_UpdateResolverCommand = async (output, context) => {
3432
1720
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3433
- return de_UpdateResolverCommandError(output, context);
1721
+ return de_CommandError(output, context);
3434
1722
  }
3435
1723
  const contents = map({
3436
1724
  $metadata: deserializeMetadata(output),
@@ -3442,40 +1730,9 @@ export const de_UpdateResolverCommand = async (output, context) => {
3442
1730
  Object.assign(contents, doc);
3443
1731
  return contents;
3444
1732
  };
3445
- const de_UpdateResolverCommandError = async (output, context) => {
3446
- const parsedOutput = {
3447
- ...output,
3448
- body: await parseErrorBody(output.body, context),
3449
- };
3450
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3451
- switch (errorCode) {
3452
- case "BadRequestException":
3453
- case "com.amazonaws.appsync#BadRequestException":
3454
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3455
- case "ConcurrentModificationException":
3456
- case "com.amazonaws.appsync#ConcurrentModificationException":
3457
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3458
- case "InternalFailureException":
3459
- case "com.amazonaws.appsync#InternalFailureException":
3460
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3461
- case "NotFoundException":
3462
- case "com.amazonaws.appsync#NotFoundException":
3463
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3464
- case "UnauthorizedException":
3465
- case "com.amazonaws.appsync#UnauthorizedException":
3466
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3467
- default:
3468
- const parsedBody = parsedOutput.body;
3469
- return throwDefaultError({
3470
- output,
3471
- parsedBody,
3472
- errorCode,
3473
- });
3474
- }
3475
- };
3476
1733
  export const de_UpdateSourceApiAssociationCommand = async (output, context) => {
3477
1734
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3478
- return de_UpdateSourceApiAssociationCommandError(output, context);
1735
+ return de_CommandError(output, context);
3479
1736
  }
3480
1737
  const contents = map({
3481
1738
  $metadata: deserializeMetadata(output),
@@ -3487,40 +1744,9 @@ export const de_UpdateSourceApiAssociationCommand = async (output, context) => {
3487
1744
  Object.assign(contents, doc);
3488
1745
  return contents;
3489
1746
  };
3490
- const de_UpdateSourceApiAssociationCommandError = async (output, context) => {
3491
- const parsedOutput = {
3492
- ...output,
3493
- body: await parseErrorBody(output.body, context),
3494
- };
3495
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3496
- switch (errorCode) {
3497
- case "BadRequestException":
3498
- case "com.amazonaws.appsync#BadRequestException":
3499
- throw await de_BadRequestExceptionRes(parsedOutput, context);
3500
- case "ConcurrentModificationException":
3501
- case "com.amazonaws.appsync#ConcurrentModificationException":
3502
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3503
- case "InternalFailureException":
3504
- case "com.amazonaws.appsync#InternalFailureException":
3505
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
3506
- case "NotFoundException":
3507
- case "com.amazonaws.appsync#NotFoundException":
3508
- throw await de_NotFoundExceptionRes(parsedOutput, context);
3509
- case "UnauthorizedException":
3510
- case "com.amazonaws.appsync#UnauthorizedException":
3511
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
3512
- default:
3513
- const parsedBody = parsedOutput.body;
3514
- return throwDefaultError({
3515
- output,
3516
- parsedBody,
3517
- errorCode,
3518
- });
3519
- }
3520
- };
3521
1747
  export const de_UpdateTypeCommand = async (output, context) => {
3522
1748
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3523
- return de_UpdateTypeCommandError(output, context);
1749
+ return de_CommandError(output, context);
3524
1750
  }
3525
1751
  const contents = map({
3526
1752
  $metadata: deserializeMetadata(output),
@@ -3532,28 +1758,46 @@ export const de_UpdateTypeCommand = async (output, context) => {
3532
1758
  Object.assign(contents, doc);
3533
1759
  return contents;
3534
1760
  };
3535
- const de_UpdateTypeCommandError = async (output, context) => {
1761
+ const de_CommandError = async (output, context) => {
3536
1762
  const parsedOutput = {
3537
1763
  ...output,
3538
1764
  body: await parseErrorBody(output.body, context),
3539
1765
  };
3540
1766
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3541
1767
  switch (errorCode) {
1768
+ case "AccessDeniedException":
1769
+ case "com.amazonaws.appsync#AccessDeniedException":
1770
+ throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3542
1771
  case "BadRequestException":
3543
1772
  case "com.amazonaws.appsync#BadRequestException":
3544
1773
  throw await de_BadRequestExceptionRes(parsedOutput, context);
3545
- case "ConcurrentModificationException":
3546
- case "com.amazonaws.appsync#ConcurrentModificationException":
3547
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3548
1774
  case "InternalFailureException":
3549
1775
  case "com.amazonaws.appsync#InternalFailureException":
3550
1776
  throw await de_InternalFailureExceptionRes(parsedOutput, context);
3551
1777
  case "NotFoundException":
3552
1778
  case "com.amazonaws.appsync#NotFoundException":
3553
1779
  throw await de_NotFoundExceptionRes(parsedOutput, context);
1780
+ case "ConcurrentModificationException":
1781
+ case "com.amazonaws.appsync#ConcurrentModificationException":
1782
+ throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1783
+ case "LimitExceededException":
1784
+ case "com.amazonaws.appsync#LimitExceededException":
1785
+ throw await de_LimitExceededExceptionRes(parsedOutput, context);
3554
1786
  case "UnauthorizedException":
3555
1787
  case "com.amazonaws.appsync#UnauthorizedException":
3556
1788
  throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1789
+ case "ApiKeyLimitExceededException":
1790
+ case "com.amazonaws.appsync#ApiKeyLimitExceededException":
1791
+ throw await de_ApiKeyLimitExceededExceptionRes(parsedOutput, context);
1792
+ case "ApiKeyValidityOutOfBoundsException":
1793
+ case "com.amazonaws.appsync#ApiKeyValidityOutOfBoundsException":
1794
+ throw await de_ApiKeyValidityOutOfBoundsExceptionRes(parsedOutput, context);
1795
+ case "ApiLimitExceededException":
1796
+ case "com.amazonaws.appsync#ApiLimitExceededException":
1797
+ throw await de_ApiLimitExceededExceptionRes(parsedOutput, context);
1798
+ case "GraphQLSchemaException":
1799
+ case "com.amazonaws.appsync#GraphQLSchemaException":
1800
+ throw await de_GraphQLSchemaExceptionRes(parsedOutput, context);
3557
1801
  default:
3558
1802
  const parsedBody = parsedOutput.body;
3559
1803
  return throwDefaultError({