@aws-sdk/client-lakeformation 3.504.0 → 3.507.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/index.js +132 -1733
  2. package/dist-es/protocols/Aws_restJson1.js +321 -1922
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -860,7 +860,7 @@ export const se_UpdateTableStorageOptimizerCommand = async (input, context) => {
860
860
  };
861
861
  export const de_AddLFTagsToResourceCommand = async (output, context) => {
862
862
  if (output.statusCode !== 200 && output.statusCode >= 300) {
863
- return de_AddLFTagsToResourceCommandError(output, context);
863
+ return de_CommandError(output, context);
864
864
  }
865
865
  const contents = map({
866
866
  $metadata: deserializeMetadata(output),
@@ -872,43 +872,9 @@ export const de_AddLFTagsToResourceCommand = async (output, context) => {
872
872
  Object.assign(contents, doc);
873
873
  return contents;
874
874
  };
875
- const de_AddLFTagsToResourceCommandError = async (output, context) => {
876
- const parsedOutput = {
877
- ...output,
878
- body: await parseErrorBody(output.body, context),
879
- };
880
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
881
- switch (errorCode) {
882
- case "AccessDeniedException":
883
- case "com.amazonaws.lakeformation#AccessDeniedException":
884
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
885
- case "ConcurrentModificationException":
886
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
887
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
888
- case "EntityNotFoundException":
889
- case "com.amazonaws.lakeformation#EntityNotFoundException":
890
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
891
- case "InternalServiceException":
892
- case "com.amazonaws.lakeformation#InternalServiceException":
893
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
894
- case "InvalidInputException":
895
- case "com.amazonaws.lakeformation#InvalidInputException":
896
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
897
- case "OperationTimeoutException":
898
- case "com.amazonaws.lakeformation#OperationTimeoutException":
899
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
900
- default:
901
- const parsedBody = parsedOutput.body;
902
- return throwDefaultError({
903
- output,
904
- parsedBody,
905
- errorCode,
906
- });
907
- }
908
- };
909
875
  export const de_AssumeDecoratedRoleWithSAMLCommand = async (output, context) => {
910
876
  if (output.statusCode !== 200 && output.statusCode >= 300) {
911
- return de_AssumeDecoratedRoleWithSAMLCommandError(output, context);
877
+ return de_CommandError(output, context);
912
878
  }
913
879
  const contents = map({
914
880
  $metadata: deserializeMetadata(output),
@@ -923,40 +889,9 @@ export const de_AssumeDecoratedRoleWithSAMLCommand = async (output, context) =>
923
889
  Object.assign(contents, doc);
924
890
  return contents;
925
891
  };
926
- const de_AssumeDecoratedRoleWithSAMLCommandError = async (output, context) => {
927
- const parsedOutput = {
928
- ...output,
929
- body: await parseErrorBody(output.body, context),
930
- };
931
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
932
- switch (errorCode) {
933
- case "AccessDeniedException":
934
- case "com.amazonaws.lakeformation#AccessDeniedException":
935
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
936
- case "EntityNotFoundException":
937
- case "com.amazonaws.lakeformation#EntityNotFoundException":
938
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
939
- case "InternalServiceException":
940
- case "com.amazonaws.lakeformation#InternalServiceException":
941
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
942
- case "InvalidInputException":
943
- case "com.amazonaws.lakeformation#InvalidInputException":
944
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
945
- case "OperationTimeoutException":
946
- case "com.amazonaws.lakeformation#OperationTimeoutException":
947
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
948
- default:
949
- const parsedBody = parsedOutput.body;
950
- return throwDefaultError({
951
- output,
952
- parsedBody,
953
- errorCode,
954
- });
955
- }
956
- };
957
892
  export const de_BatchGrantPermissionsCommand = async (output, context) => {
958
893
  if (output.statusCode !== 200 && output.statusCode >= 300) {
959
- return de_BatchGrantPermissionsCommandError(output, context);
894
+ return de_CommandError(output, context);
960
895
  }
961
896
  const contents = map({
962
897
  $metadata: deserializeMetadata(output),
@@ -968,31 +903,9 @@ export const de_BatchGrantPermissionsCommand = async (output, context) => {
968
903
  Object.assign(contents, doc);
969
904
  return contents;
970
905
  };
971
- const de_BatchGrantPermissionsCommandError = async (output, context) => {
972
- const parsedOutput = {
973
- ...output,
974
- body: await parseErrorBody(output.body, context),
975
- };
976
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
977
- switch (errorCode) {
978
- case "InvalidInputException":
979
- case "com.amazonaws.lakeformation#InvalidInputException":
980
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
981
- case "OperationTimeoutException":
982
- case "com.amazonaws.lakeformation#OperationTimeoutException":
983
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
984
- default:
985
- const parsedBody = parsedOutput.body;
986
- return throwDefaultError({
987
- output,
988
- parsedBody,
989
- errorCode,
990
- });
991
- }
992
- };
993
906
  export const de_BatchRevokePermissionsCommand = async (output, context) => {
994
907
  if (output.statusCode !== 200 && output.statusCode >= 300) {
995
- return de_BatchRevokePermissionsCommandError(output, context);
908
+ return de_CommandError(output, context);
996
909
  }
997
910
  const contents = map({
998
911
  $metadata: deserializeMetadata(output),
@@ -1004,31 +917,9 @@ export const de_BatchRevokePermissionsCommand = async (output, context) => {
1004
917
  Object.assign(contents, doc);
1005
918
  return contents;
1006
919
  };
1007
- const de_BatchRevokePermissionsCommandError = async (output, context) => {
1008
- const parsedOutput = {
1009
- ...output,
1010
- body: await parseErrorBody(output.body, context),
1011
- };
1012
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1013
- switch (errorCode) {
1014
- case "InvalidInputException":
1015
- case "com.amazonaws.lakeformation#InvalidInputException":
1016
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1017
- case "OperationTimeoutException":
1018
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1019
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1020
- default:
1021
- const parsedBody = parsedOutput.body;
1022
- return throwDefaultError({
1023
- output,
1024
- parsedBody,
1025
- errorCode,
1026
- });
1027
- }
1028
- };
1029
920
  export const de_CancelTransactionCommand = async (output, context) => {
1030
921
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1031
- return de_CancelTransactionCommandError(output, context);
922
+ return de_CommandError(output, context);
1032
923
  }
1033
924
  const contents = map({
1034
925
  $metadata: deserializeMetadata(output),
@@ -1036,46 +927,9 @@ export const de_CancelTransactionCommand = async (output, context) => {
1036
927
  await collectBody(output.body, context);
1037
928
  return contents;
1038
929
  };
1039
- const de_CancelTransactionCommandError = async (output, context) => {
1040
- const parsedOutput = {
1041
- ...output,
1042
- body: await parseErrorBody(output.body, context),
1043
- };
1044
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1045
- switch (errorCode) {
1046
- case "ConcurrentModificationException":
1047
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
1048
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1049
- case "EntityNotFoundException":
1050
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1051
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1052
- case "InternalServiceException":
1053
- case "com.amazonaws.lakeformation#InternalServiceException":
1054
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1055
- case "InvalidInputException":
1056
- case "com.amazonaws.lakeformation#InvalidInputException":
1057
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1058
- case "OperationTimeoutException":
1059
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1060
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1061
- case "TransactionCommitInProgressException":
1062
- case "com.amazonaws.lakeformation#TransactionCommitInProgressException":
1063
- throw await de_TransactionCommitInProgressExceptionRes(parsedOutput, context);
1064
- case "TransactionCommittedException":
1065
- case "com.amazonaws.lakeformation#TransactionCommittedException":
1066
- throw await de_TransactionCommittedExceptionRes(parsedOutput, context);
1067
- default:
1068
- const parsedBody = parsedOutput.body;
1069
- return throwDefaultError({
1070
- output,
1071
- parsedBody,
1072
- errorCode,
1073
- });
1074
- }
1075
- };
1076
930
  export const de_CommitTransactionCommand = async (output, context) => {
1077
931
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1078
- return de_CommitTransactionCommandError(output, context);
932
+ return de_CommandError(output, context);
1079
933
  }
1080
934
  const contents = map({
1081
935
  $metadata: deserializeMetadata(output),
@@ -1087,43 +941,9 @@ export const de_CommitTransactionCommand = async (output, context) => {
1087
941
  Object.assign(contents, doc);
1088
942
  return contents;
1089
943
  };
1090
- const de_CommitTransactionCommandError = async (output, context) => {
1091
- const parsedOutput = {
1092
- ...output,
1093
- body: await parseErrorBody(output.body, context),
1094
- };
1095
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1096
- switch (errorCode) {
1097
- case "ConcurrentModificationException":
1098
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
1099
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1100
- case "EntityNotFoundException":
1101
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1102
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1103
- case "InternalServiceException":
1104
- case "com.amazonaws.lakeformation#InternalServiceException":
1105
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1106
- case "InvalidInputException":
1107
- case "com.amazonaws.lakeformation#InvalidInputException":
1108
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1109
- case "OperationTimeoutException":
1110
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1111
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1112
- case "TransactionCanceledException":
1113
- case "com.amazonaws.lakeformation#TransactionCanceledException":
1114
- throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
1115
- default:
1116
- const parsedBody = parsedOutput.body;
1117
- return throwDefaultError({
1118
- output,
1119
- parsedBody,
1120
- errorCode,
1121
- });
1122
- }
1123
- };
1124
944
  export const de_CreateDataCellsFilterCommand = async (output, context) => {
1125
945
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1126
- return de_CreateDataCellsFilterCommandError(output, context);
946
+ return de_CommandError(output, context);
1127
947
  }
1128
948
  const contents = map({
1129
949
  $metadata: deserializeMetadata(output),
@@ -1131,46 +951,9 @@ export const de_CreateDataCellsFilterCommand = async (output, context) => {
1131
951
  await collectBody(output.body, context);
1132
952
  return contents;
1133
953
  };
1134
- const de_CreateDataCellsFilterCommandError = async (output, context) => {
1135
- const parsedOutput = {
1136
- ...output,
1137
- body: await parseErrorBody(output.body, context),
1138
- };
1139
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1140
- switch (errorCode) {
1141
- case "AccessDeniedException":
1142
- case "com.amazonaws.lakeformation#AccessDeniedException":
1143
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1144
- case "AlreadyExistsException":
1145
- case "com.amazonaws.lakeformation#AlreadyExistsException":
1146
- throw await de_AlreadyExistsExceptionRes(parsedOutput, context);
1147
- case "EntityNotFoundException":
1148
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1149
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1150
- case "InternalServiceException":
1151
- case "com.amazonaws.lakeformation#InternalServiceException":
1152
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1153
- case "InvalidInputException":
1154
- case "com.amazonaws.lakeformation#InvalidInputException":
1155
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1156
- case "OperationTimeoutException":
1157
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1158
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1159
- case "ResourceNumberLimitExceededException":
1160
- case "com.amazonaws.lakeformation#ResourceNumberLimitExceededException":
1161
- throw await de_ResourceNumberLimitExceededExceptionRes(parsedOutput, context);
1162
- default:
1163
- const parsedBody = parsedOutput.body;
1164
- return throwDefaultError({
1165
- output,
1166
- parsedBody,
1167
- errorCode,
1168
- });
1169
- }
1170
- };
1171
954
  export const de_CreateLakeFormationIdentityCenterConfigurationCommand = async (output, context) => {
1172
955
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1173
- return de_CreateLakeFormationIdentityCenterConfigurationCommandError(output, context);
956
+ return de_CommandError(output, context);
1174
957
  }
1175
958
  const contents = map({
1176
959
  $metadata: deserializeMetadata(output),
@@ -1182,43 +965,19 @@ export const de_CreateLakeFormationIdentityCenterConfigurationCommand = async (o
1182
965
  Object.assign(contents, doc);
1183
966
  return contents;
1184
967
  };
1185
- const de_CreateLakeFormationIdentityCenterConfigurationCommandError = async (output, context) => {
1186
- const parsedOutput = {
1187
- ...output,
1188
- body: await parseErrorBody(output.body, context),
1189
- };
1190
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1191
- switch (errorCode) {
1192
- case "AccessDeniedException":
1193
- case "com.amazonaws.lakeformation#AccessDeniedException":
1194
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1195
- case "AlreadyExistsException":
1196
- case "com.amazonaws.lakeformation#AlreadyExistsException":
1197
- throw await de_AlreadyExistsExceptionRes(parsedOutput, context);
1198
- case "ConcurrentModificationException":
1199
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
1200
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1201
- case "InternalServiceException":
1202
- case "com.amazonaws.lakeformation#InternalServiceException":
1203
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1204
- case "InvalidInputException":
1205
- case "com.amazonaws.lakeformation#InvalidInputException":
1206
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1207
- case "OperationTimeoutException":
1208
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1209
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1210
- default:
1211
- const parsedBody = parsedOutput.body;
1212
- return throwDefaultError({
1213
- output,
1214
- parsedBody,
1215
- errorCode,
1216
- });
968
+ export const de_CreateLakeFormationOptInCommand = async (output, context) => {
969
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
970
+ return de_CommandError(output, context);
1217
971
  }
972
+ const contents = map({
973
+ $metadata: deserializeMetadata(output),
974
+ });
975
+ await collectBody(output.body, context);
976
+ return contents;
1218
977
  };
1219
- export const de_CreateLakeFormationOptInCommand = async (output, context) => {
978
+ export const de_CreateLFTagCommand = async (output, context) => {
1220
979
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1221
- return de_CreateLakeFormationOptInCommandError(output, context);
980
+ return de_CommandError(output, context);
1222
981
  }
1223
982
  const contents = map({
1224
983
  $metadata: deserializeMetadata(output),
@@ -1226,87 +985,9 @@ export const de_CreateLakeFormationOptInCommand = async (output, context) => {
1226
985
  await collectBody(output.body, context);
1227
986
  return contents;
1228
987
  };
1229
- const de_CreateLakeFormationOptInCommandError = async (output, context) => {
1230
- const parsedOutput = {
1231
- ...output,
1232
- body: await parseErrorBody(output.body, context),
1233
- };
1234
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1235
- switch (errorCode) {
1236
- case "AccessDeniedException":
1237
- case "com.amazonaws.lakeformation#AccessDeniedException":
1238
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1239
- case "ConcurrentModificationException":
1240
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
1241
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1242
- case "EntityNotFoundException":
1243
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1244
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1245
- case "InternalServiceException":
1246
- case "com.amazonaws.lakeformation#InternalServiceException":
1247
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1248
- case "InvalidInputException":
1249
- case "com.amazonaws.lakeformation#InvalidInputException":
1250
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1251
- case "OperationTimeoutException":
1252
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1253
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1254
- default:
1255
- const parsedBody = parsedOutput.body;
1256
- return throwDefaultError({
1257
- output,
1258
- parsedBody,
1259
- errorCode,
1260
- });
1261
- }
1262
- };
1263
- export const de_CreateLFTagCommand = async (output, context) => {
1264
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1265
- return de_CreateLFTagCommandError(output, context);
1266
- }
1267
- const contents = map({
1268
- $metadata: deserializeMetadata(output),
1269
- });
1270
- await collectBody(output.body, context);
1271
- return contents;
1272
- };
1273
- const de_CreateLFTagCommandError = async (output, context) => {
1274
- const parsedOutput = {
1275
- ...output,
1276
- body: await parseErrorBody(output.body, context),
1277
- };
1278
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1279
- switch (errorCode) {
1280
- case "AccessDeniedException":
1281
- case "com.amazonaws.lakeformation#AccessDeniedException":
1282
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1283
- case "EntityNotFoundException":
1284
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1285
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1286
- case "InternalServiceException":
1287
- case "com.amazonaws.lakeformation#InternalServiceException":
1288
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1289
- case "InvalidInputException":
1290
- case "com.amazonaws.lakeformation#InvalidInputException":
1291
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1292
- case "OperationTimeoutException":
1293
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1294
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1295
- case "ResourceNumberLimitExceededException":
1296
- case "com.amazonaws.lakeformation#ResourceNumberLimitExceededException":
1297
- throw await de_ResourceNumberLimitExceededExceptionRes(parsedOutput, context);
1298
- default:
1299
- const parsedBody = parsedOutput.body;
1300
- return throwDefaultError({
1301
- output,
1302
- parsedBody,
1303
- errorCode,
1304
- });
1305
- }
1306
- };
1307
988
  export const de_DeleteDataCellsFilterCommand = async (output, context) => {
1308
989
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1309
- return de_DeleteDataCellsFilterCommandError(output, context);
990
+ return de_CommandError(output, context);
1310
991
  }
1311
992
  const contents = map({
1312
993
  $metadata: deserializeMetadata(output),
@@ -1314,40 +995,9 @@ export const de_DeleteDataCellsFilterCommand = async (output, context) => {
1314
995
  await collectBody(output.body, context);
1315
996
  return contents;
1316
997
  };
1317
- const de_DeleteDataCellsFilterCommandError = async (output, context) => {
1318
- const parsedOutput = {
1319
- ...output,
1320
- body: await parseErrorBody(output.body, context),
1321
- };
1322
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1323
- switch (errorCode) {
1324
- case "AccessDeniedException":
1325
- case "com.amazonaws.lakeformation#AccessDeniedException":
1326
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1327
- case "EntityNotFoundException":
1328
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1329
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1330
- case "InternalServiceException":
1331
- case "com.amazonaws.lakeformation#InternalServiceException":
1332
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1333
- case "InvalidInputException":
1334
- case "com.amazonaws.lakeformation#InvalidInputException":
1335
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1336
- case "OperationTimeoutException":
1337
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1338
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1339
- default:
1340
- const parsedBody = parsedOutput.body;
1341
- return throwDefaultError({
1342
- output,
1343
- parsedBody,
1344
- errorCode,
1345
- });
1346
- }
1347
- };
1348
998
  export const de_DeleteLakeFormationIdentityCenterConfigurationCommand = async (output, context) => {
1349
999
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1350
- return de_DeleteLakeFormationIdentityCenterConfigurationCommandError(output, context);
1000
+ return de_CommandError(output, context);
1351
1001
  }
1352
1002
  const contents = map({
1353
1003
  $metadata: deserializeMetadata(output),
@@ -1355,43 +1005,9 @@ export const de_DeleteLakeFormationIdentityCenterConfigurationCommand = async (o
1355
1005
  await collectBody(output.body, context);
1356
1006
  return contents;
1357
1007
  };
1358
- const de_DeleteLakeFormationIdentityCenterConfigurationCommandError = async (output, context) => {
1359
- const parsedOutput = {
1360
- ...output,
1361
- body: await parseErrorBody(output.body, context),
1362
- };
1363
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1364
- switch (errorCode) {
1365
- case "AccessDeniedException":
1366
- case "com.amazonaws.lakeformation#AccessDeniedException":
1367
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1368
- case "ConcurrentModificationException":
1369
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
1370
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1371
- case "EntityNotFoundException":
1372
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1373
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1374
- case "InternalServiceException":
1375
- case "com.amazonaws.lakeformation#InternalServiceException":
1376
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1377
- case "InvalidInputException":
1378
- case "com.amazonaws.lakeformation#InvalidInputException":
1379
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1380
- case "OperationTimeoutException":
1381
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1382
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1383
- default:
1384
- const parsedBody = parsedOutput.body;
1385
- return throwDefaultError({
1386
- output,
1387
- parsedBody,
1388
- errorCode,
1389
- });
1390
- }
1391
- };
1392
1008
  export const de_DeleteLakeFormationOptInCommand = async (output, context) => {
1393
1009
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1394
- return de_DeleteLakeFormationOptInCommandError(output, context);
1010
+ return de_CommandError(output, context);
1395
1011
  }
1396
1012
  const contents = map({
1397
1013
  $metadata: deserializeMetadata(output),
@@ -1399,1117 +1015,200 @@ export const de_DeleteLakeFormationOptInCommand = async (output, context) => {
1399
1015
  await collectBody(output.body, context);
1400
1016
  return contents;
1401
1017
  };
1402
- const de_DeleteLakeFormationOptInCommandError = async (output, context) => {
1403
- const parsedOutput = {
1404
- ...output,
1405
- body: await parseErrorBody(output.body, context),
1406
- };
1407
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1408
- switch (errorCode) {
1409
- case "AccessDeniedException":
1410
- case "com.amazonaws.lakeformation#AccessDeniedException":
1411
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1412
- case "ConcurrentModificationException":
1413
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
1414
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1415
- case "EntityNotFoundException":
1416
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1417
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1418
- case "InternalServiceException":
1419
- case "com.amazonaws.lakeformation#InternalServiceException":
1420
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1421
- case "InvalidInputException":
1422
- case "com.amazonaws.lakeformation#InvalidInputException":
1423
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1424
- case "OperationTimeoutException":
1425
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1426
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1427
- default:
1428
- const parsedBody = parsedOutput.body;
1429
- return throwDefaultError({
1430
- output,
1431
- parsedBody,
1432
- errorCode,
1433
- });
1434
- }
1435
- };
1436
1018
  export const de_DeleteLFTagCommand = async (output, context) => {
1437
1019
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1438
- return de_DeleteLFTagCommandError(output, context);
1439
- }
1440
- const contents = map({
1441
- $metadata: deserializeMetadata(output),
1442
- });
1443
- await collectBody(output.body, context);
1444
- return contents;
1445
- };
1446
- const de_DeleteLFTagCommandError = async (output, context) => {
1447
- const parsedOutput = {
1448
- ...output,
1449
- body: await parseErrorBody(output.body, context),
1450
- };
1451
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1452
- switch (errorCode) {
1453
- case "AccessDeniedException":
1454
- case "com.amazonaws.lakeformation#AccessDeniedException":
1455
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1456
- case "EntityNotFoundException":
1457
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1458
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1459
- case "InternalServiceException":
1460
- case "com.amazonaws.lakeformation#InternalServiceException":
1461
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1462
- case "InvalidInputException":
1463
- case "com.amazonaws.lakeformation#InvalidInputException":
1464
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1465
- case "OperationTimeoutException":
1466
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1467
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1468
- default:
1469
- const parsedBody = parsedOutput.body;
1470
- return throwDefaultError({
1471
- output,
1472
- parsedBody,
1473
- errorCode,
1474
- });
1475
- }
1476
- };
1477
- export const de_DeleteObjectsOnCancelCommand = async (output, context) => {
1478
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1479
- return de_DeleteObjectsOnCancelCommandError(output, context);
1480
- }
1481
- const contents = map({
1482
- $metadata: deserializeMetadata(output),
1483
- });
1484
- await collectBody(output.body, context);
1485
- return contents;
1486
- };
1487
- const de_DeleteObjectsOnCancelCommandError = async (output, context) => {
1488
- const parsedOutput = {
1489
- ...output,
1490
- body: await parseErrorBody(output.body, context),
1491
- };
1492
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1493
- switch (errorCode) {
1494
- case "ConcurrentModificationException":
1495
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
1496
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1497
- case "EntityNotFoundException":
1498
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1499
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1500
- case "InternalServiceException":
1501
- case "com.amazonaws.lakeformation#InternalServiceException":
1502
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1503
- case "InvalidInputException":
1504
- case "com.amazonaws.lakeformation#InvalidInputException":
1505
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1506
- case "OperationTimeoutException":
1507
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1508
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1509
- case "ResourceNotReadyException":
1510
- case "com.amazonaws.lakeformation#ResourceNotReadyException":
1511
- throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
1512
- case "TransactionCanceledException":
1513
- case "com.amazonaws.lakeformation#TransactionCanceledException":
1514
- throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
1515
- case "TransactionCommittedException":
1516
- case "com.amazonaws.lakeformation#TransactionCommittedException":
1517
- throw await de_TransactionCommittedExceptionRes(parsedOutput, context);
1518
- default:
1519
- const parsedBody = parsedOutput.body;
1520
- return throwDefaultError({
1521
- output,
1522
- parsedBody,
1523
- errorCode,
1524
- });
1525
- }
1526
- };
1527
- export const de_DeregisterResourceCommand = async (output, context) => {
1528
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1529
- return de_DeregisterResourceCommandError(output, context);
1020
+ return de_CommandError(output, context);
1530
1021
  }
1531
1022
  const contents = map({
1532
1023
  $metadata: deserializeMetadata(output),
1533
1024
  });
1534
1025
  await collectBody(output.body, context);
1535
- return contents;
1536
- };
1537
- const de_DeregisterResourceCommandError = async (output, context) => {
1538
- const parsedOutput = {
1539
- ...output,
1540
- body: await parseErrorBody(output.body, context),
1541
- };
1542
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1543
- switch (errorCode) {
1544
- case "EntityNotFoundException":
1545
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1546
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1547
- case "InternalServiceException":
1548
- case "com.amazonaws.lakeformation#InternalServiceException":
1549
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1550
- case "InvalidInputException":
1551
- case "com.amazonaws.lakeformation#InvalidInputException":
1552
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1553
- case "OperationTimeoutException":
1554
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1555
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1556
- default:
1557
- const parsedBody = parsedOutput.body;
1558
- return throwDefaultError({
1559
- output,
1560
- parsedBody,
1561
- errorCode,
1562
- });
1563
- }
1564
- };
1565
- export const de_DescribeLakeFormationIdentityCenterConfigurationCommand = async (output, context) => {
1566
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1567
- return de_DescribeLakeFormationIdentityCenterConfigurationCommandError(output, context);
1568
- }
1569
- const contents = map({
1570
- $metadata: deserializeMetadata(output),
1571
- });
1572
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1573
- const doc = take(data, {
1574
- ApplicationArn: __expectString,
1575
- CatalogId: __expectString,
1576
- ExternalFiltering: _json,
1577
- InstanceArn: __expectString,
1578
- });
1579
- Object.assign(contents, doc);
1580
- return contents;
1581
- };
1582
- const de_DescribeLakeFormationIdentityCenterConfigurationCommandError = async (output, context) => {
1583
- const parsedOutput = {
1584
- ...output,
1585
- body: await parseErrorBody(output.body, context),
1586
- };
1587
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1588
- switch (errorCode) {
1589
- case "AccessDeniedException":
1590
- case "com.amazonaws.lakeformation#AccessDeniedException":
1591
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1592
- case "EntityNotFoundException":
1593
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1594
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1595
- case "InternalServiceException":
1596
- case "com.amazonaws.lakeformation#InternalServiceException":
1597
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1598
- case "InvalidInputException":
1599
- case "com.amazonaws.lakeformation#InvalidInputException":
1600
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1601
- case "OperationTimeoutException":
1602
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1603
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1604
- default:
1605
- const parsedBody = parsedOutput.body;
1606
- return throwDefaultError({
1607
- output,
1608
- parsedBody,
1609
- errorCode,
1610
- });
1611
- }
1612
- };
1613
- export const de_DescribeResourceCommand = async (output, context) => {
1614
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1615
- return de_DescribeResourceCommandError(output, context);
1616
- }
1617
- const contents = map({
1618
- $metadata: deserializeMetadata(output),
1619
- });
1620
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1621
- const doc = take(data, {
1622
- ResourceInfo: (_) => de_ResourceInfo(_, context),
1623
- });
1624
- Object.assign(contents, doc);
1625
- return contents;
1626
- };
1627
- const de_DescribeResourceCommandError = async (output, context) => {
1628
- const parsedOutput = {
1629
- ...output,
1630
- body: await parseErrorBody(output.body, context),
1631
- };
1632
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1633
- switch (errorCode) {
1634
- case "EntityNotFoundException":
1635
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1636
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1637
- case "InternalServiceException":
1638
- case "com.amazonaws.lakeformation#InternalServiceException":
1639
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1640
- case "InvalidInputException":
1641
- case "com.amazonaws.lakeformation#InvalidInputException":
1642
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1643
- case "OperationTimeoutException":
1644
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1645
- throw await de_OperationTimeoutExceptionRes(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_DescribeTransactionCommand = async (output, context) => {
1656
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1657
- return de_DescribeTransactionCommandError(output, context);
1658
- }
1659
- const contents = map({
1660
- $metadata: deserializeMetadata(output),
1661
- });
1662
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1663
- const doc = take(data, {
1664
- TransactionDescription: (_) => de_TransactionDescription(_, context),
1665
- });
1666
- Object.assign(contents, doc);
1667
- return contents;
1668
- };
1669
- const de_DescribeTransactionCommandError = async (output, context) => {
1670
- const parsedOutput = {
1671
- ...output,
1672
- body: await parseErrorBody(output.body, context),
1673
- };
1674
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1675
- switch (errorCode) {
1676
- case "EntityNotFoundException":
1677
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1678
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1679
- case "InternalServiceException":
1680
- case "com.amazonaws.lakeformation#InternalServiceException":
1681
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1682
- case "InvalidInputException":
1683
- case "com.amazonaws.lakeformation#InvalidInputException":
1684
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1685
- case "OperationTimeoutException":
1686
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1687
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1688
- default:
1689
- const parsedBody = parsedOutput.body;
1690
- return throwDefaultError({
1691
- output,
1692
- parsedBody,
1693
- errorCode,
1694
- });
1695
- }
1696
- };
1697
- export const de_ExtendTransactionCommand = async (output, context) => {
1698
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1699
- return de_ExtendTransactionCommandError(output, context);
1700
- }
1701
- const contents = map({
1702
- $metadata: deserializeMetadata(output),
1703
- });
1704
- await collectBody(output.body, context);
1705
- return contents;
1706
- };
1707
- const de_ExtendTransactionCommandError = async (output, context) => {
1708
- const parsedOutput = {
1709
- ...output,
1710
- body: await parseErrorBody(output.body, context),
1711
- };
1712
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1713
- switch (errorCode) {
1714
- case "EntityNotFoundException":
1715
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1716
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1717
- case "InternalServiceException":
1718
- case "com.amazonaws.lakeformation#InternalServiceException":
1719
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1720
- case "InvalidInputException":
1721
- case "com.amazonaws.lakeformation#InvalidInputException":
1722
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1723
- case "OperationTimeoutException":
1724
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1725
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1726
- case "TransactionCanceledException":
1727
- case "com.amazonaws.lakeformation#TransactionCanceledException":
1728
- throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
1729
- case "TransactionCommitInProgressException":
1730
- case "com.amazonaws.lakeformation#TransactionCommitInProgressException":
1731
- throw await de_TransactionCommitInProgressExceptionRes(parsedOutput, context);
1732
- case "TransactionCommittedException":
1733
- case "com.amazonaws.lakeformation#TransactionCommittedException":
1734
- throw await de_TransactionCommittedExceptionRes(parsedOutput, context);
1735
- default:
1736
- const parsedBody = parsedOutput.body;
1737
- return throwDefaultError({
1738
- output,
1739
- parsedBody,
1740
- errorCode,
1741
- });
1742
- }
1743
- };
1744
- export const de_GetDataCellsFilterCommand = async (output, context) => {
1745
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1746
- return de_GetDataCellsFilterCommandError(output, context);
1747
- }
1748
- const contents = map({
1749
- $metadata: deserializeMetadata(output),
1750
- });
1751
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1752
- const doc = take(data, {
1753
- DataCellsFilter: _json,
1754
- });
1755
- Object.assign(contents, doc);
1756
- return contents;
1757
- };
1758
- const de_GetDataCellsFilterCommandError = async (output, context) => {
1759
- const parsedOutput = {
1760
- ...output,
1761
- body: await parseErrorBody(output.body, context),
1762
- };
1763
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1764
- switch (errorCode) {
1765
- case "AccessDeniedException":
1766
- case "com.amazonaws.lakeformation#AccessDeniedException":
1767
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1768
- case "EntityNotFoundException":
1769
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1770
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1771
- case "InternalServiceException":
1772
- case "com.amazonaws.lakeformation#InternalServiceException":
1773
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1774
- case "InvalidInputException":
1775
- case "com.amazonaws.lakeformation#InvalidInputException":
1776
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1777
- case "OperationTimeoutException":
1778
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1779
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1780
- default:
1781
- const parsedBody = parsedOutput.body;
1782
- return throwDefaultError({
1783
- output,
1784
- parsedBody,
1785
- errorCode,
1786
- });
1787
- }
1788
- };
1789
- export const de_GetDataLakeSettingsCommand = async (output, context) => {
1790
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1791
- return de_GetDataLakeSettingsCommandError(output, context);
1792
- }
1793
- const contents = map({
1794
- $metadata: deserializeMetadata(output),
1795
- });
1796
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1797
- const doc = take(data, {
1798
- DataLakeSettings: _json,
1799
- });
1800
- Object.assign(contents, doc);
1801
- return contents;
1802
- };
1803
- const de_GetDataLakeSettingsCommandError = async (output, context) => {
1804
- const parsedOutput = {
1805
- ...output,
1806
- body: await parseErrorBody(output.body, context),
1807
- };
1808
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1809
- switch (errorCode) {
1810
- case "EntityNotFoundException":
1811
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1812
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1813
- case "InternalServiceException":
1814
- case "com.amazonaws.lakeformation#InternalServiceException":
1815
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1816
- case "InvalidInputException":
1817
- case "com.amazonaws.lakeformation#InvalidInputException":
1818
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1819
- default:
1820
- const parsedBody = parsedOutput.body;
1821
- return throwDefaultError({
1822
- output,
1823
- parsedBody,
1824
- errorCode,
1825
- });
1826
- }
1827
- };
1828
- export const de_GetEffectivePermissionsForPathCommand = async (output, context) => {
1829
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1830
- return de_GetEffectivePermissionsForPathCommandError(output, context);
1831
- }
1832
- const contents = map({
1833
- $metadata: deserializeMetadata(output),
1834
- });
1835
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1836
- const doc = take(data, {
1837
- NextToken: __expectString,
1838
- Permissions: (_) => de_PrincipalResourcePermissionsList(_, context),
1839
- });
1840
- Object.assign(contents, doc);
1841
- return contents;
1842
- };
1843
- const de_GetEffectivePermissionsForPathCommandError = 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 "EntityNotFoundException":
1851
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1852
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1853
- case "InternalServiceException":
1854
- case "com.amazonaws.lakeformation#InternalServiceException":
1855
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1856
- case "InvalidInputException":
1857
- case "com.amazonaws.lakeformation#InvalidInputException":
1858
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1859
- case "OperationTimeoutException":
1860
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1861
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1862
- default:
1863
- const parsedBody = parsedOutput.body;
1864
- return throwDefaultError({
1865
- output,
1866
- parsedBody,
1867
- errorCode,
1868
- });
1869
- }
1870
- };
1871
- export const de_GetLFTagCommand = async (output, context) => {
1872
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1873
- return de_GetLFTagCommandError(output, context);
1874
- }
1875
- const contents = map({
1876
- $metadata: deserializeMetadata(output),
1877
- });
1878
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1879
- const doc = take(data, {
1880
- CatalogId: __expectString,
1881
- TagKey: __expectString,
1882
- TagValues: _json,
1883
- });
1884
- Object.assign(contents, doc);
1885
- return contents;
1886
- };
1887
- const de_GetLFTagCommandError = async (output, context) => {
1888
- const parsedOutput = {
1889
- ...output,
1890
- body: await parseErrorBody(output.body, context),
1891
- };
1892
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1893
- switch (errorCode) {
1894
- case "AccessDeniedException":
1895
- case "com.amazonaws.lakeformation#AccessDeniedException":
1896
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1897
- case "EntityNotFoundException":
1898
- case "com.amazonaws.lakeformation#EntityNotFoundException":
1899
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
1900
- case "InternalServiceException":
1901
- case "com.amazonaws.lakeformation#InternalServiceException":
1902
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1903
- case "InvalidInputException":
1904
- case "com.amazonaws.lakeformation#InvalidInputException":
1905
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1906
- case "OperationTimeoutException":
1907
- case "com.amazonaws.lakeformation#OperationTimeoutException":
1908
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1909
- default:
1910
- const parsedBody = parsedOutput.body;
1911
- return throwDefaultError({
1912
- output,
1913
- parsedBody,
1914
- errorCode,
1915
- });
1916
- }
1917
- };
1918
- export const de_GetQueryStateCommand = async (output, context) => {
1919
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1920
- return de_GetQueryStateCommandError(output, context);
1921
- }
1922
- const contents = map({
1923
- $metadata: deserializeMetadata(output),
1924
- });
1925
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1926
- const doc = take(data, {
1927
- Error: __expectString,
1928
- State: __expectString,
1929
- });
1930
- Object.assign(contents, doc);
1931
- return contents;
1932
- };
1933
- const de_GetQueryStateCommandError = async (output, context) => {
1934
- const parsedOutput = {
1935
- ...output,
1936
- body: await parseErrorBody(output.body, context),
1937
- };
1938
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1939
- switch (errorCode) {
1940
- case "AccessDeniedException":
1941
- case "com.amazonaws.lakeformation#AccessDeniedException":
1942
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1943
- case "InternalServiceException":
1944
- case "com.amazonaws.lakeformation#InternalServiceException":
1945
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1946
- case "InvalidInputException":
1947
- case "com.amazonaws.lakeformation#InvalidInputException":
1948
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1949
- default:
1950
- const parsedBody = parsedOutput.body;
1951
- return throwDefaultError({
1952
- output,
1953
- parsedBody,
1954
- errorCode,
1955
- });
1956
- }
1957
- };
1958
- export const de_GetQueryStatisticsCommand = async (output, context) => {
1959
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1960
- return de_GetQueryStatisticsCommandError(output, context);
1961
- }
1962
- const contents = map({
1963
- $metadata: deserializeMetadata(output),
1964
- });
1965
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1966
- const doc = take(data, {
1967
- ExecutionStatistics: _json,
1968
- PlanningStatistics: _json,
1969
- QuerySubmissionTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
1970
- });
1971
- Object.assign(contents, doc);
1972
- return contents;
1973
- };
1974
- const de_GetQueryStatisticsCommandError = async (output, context) => {
1975
- const parsedOutput = {
1976
- ...output,
1977
- body: await parseErrorBody(output.body, context),
1978
- };
1979
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1980
- switch (errorCode) {
1981
- case "AccessDeniedException":
1982
- case "com.amazonaws.lakeformation#AccessDeniedException":
1983
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1984
- case "ExpiredException":
1985
- case "com.amazonaws.lakeformation#ExpiredException":
1986
- throw await de_ExpiredExceptionRes(parsedOutput, context);
1987
- case "InternalServiceException":
1988
- case "com.amazonaws.lakeformation#InternalServiceException":
1989
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
1990
- case "InvalidInputException":
1991
- case "com.amazonaws.lakeformation#InvalidInputException":
1992
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1993
- case "StatisticsNotReadyYetException":
1994
- case "com.amazonaws.lakeformation#StatisticsNotReadyYetException":
1995
- throw await de_StatisticsNotReadyYetExceptionRes(parsedOutput, context);
1996
- case "ThrottledException":
1997
- case "com.amazonaws.lakeformation#ThrottledException":
1998
- throw await de_ThrottledExceptionRes(parsedOutput, context);
1999
- default:
2000
- const parsedBody = parsedOutput.body;
2001
- return throwDefaultError({
2002
- output,
2003
- parsedBody,
2004
- errorCode,
2005
- });
2006
- }
2007
- };
2008
- export const de_GetResourceLFTagsCommand = async (output, context) => {
2009
- if (output.statusCode !== 200 && output.statusCode >= 300) {
2010
- return de_GetResourceLFTagsCommandError(output, context);
2011
- }
2012
- const contents = map({
2013
- $metadata: deserializeMetadata(output),
2014
- });
2015
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2016
- const doc = take(data, {
2017
- LFTagOnDatabase: _json,
2018
- LFTagsOnColumns: _json,
2019
- LFTagsOnTable: _json,
2020
- });
2021
- Object.assign(contents, doc);
2022
- return contents;
2023
- };
2024
- const de_GetResourceLFTagsCommandError = async (output, context) => {
2025
- const parsedOutput = {
2026
- ...output,
2027
- body: await parseErrorBody(output.body, context),
2028
- };
2029
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2030
- switch (errorCode) {
2031
- case "AccessDeniedException":
2032
- case "com.amazonaws.lakeformation#AccessDeniedException":
2033
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2034
- case "EntityNotFoundException":
2035
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2036
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2037
- case "GlueEncryptionException":
2038
- case "com.amazonaws.lakeformation#GlueEncryptionException":
2039
- throw await de_GlueEncryptionExceptionRes(parsedOutput, context);
2040
- case "InternalServiceException":
2041
- case "com.amazonaws.lakeformation#InternalServiceException":
2042
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2043
- case "InvalidInputException":
2044
- case "com.amazonaws.lakeformation#InvalidInputException":
2045
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2046
- case "OperationTimeoutException":
2047
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2048
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2049
- default:
2050
- const parsedBody = parsedOutput.body;
2051
- return throwDefaultError({
2052
- output,
2053
- parsedBody,
2054
- errorCode,
2055
- });
2056
- }
2057
- };
2058
- export const de_GetTableObjectsCommand = async (output, context) => {
2059
- if (output.statusCode !== 200 && output.statusCode >= 300) {
2060
- return de_GetTableObjectsCommandError(output, context);
2061
- }
2062
- const contents = map({
2063
- $metadata: deserializeMetadata(output),
2064
- });
2065
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2066
- const doc = take(data, {
2067
- NextToken: __expectString,
2068
- Objects: _json,
2069
- });
2070
- Object.assign(contents, doc);
2071
- return contents;
2072
- };
2073
- const de_GetTableObjectsCommandError = async (output, context) => {
2074
- const parsedOutput = {
2075
- ...output,
2076
- body: await parseErrorBody(output.body, context),
2077
- };
2078
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2079
- switch (errorCode) {
2080
- case "EntityNotFoundException":
2081
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2082
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2083
- case "InternalServiceException":
2084
- case "com.amazonaws.lakeformation#InternalServiceException":
2085
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2086
- case "InvalidInputException":
2087
- case "com.amazonaws.lakeformation#InvalidInputException":
2088
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2089
- case "OperationTimeoutException":
2090
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2091
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2092
- case "ResourceNotReadyException":
2093
- case "com.amazonaws.lakeformation#ResourceNotReadyException":
2094
- throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
2095
- case "TransactionCanceledException":
2096
- case "com.amazonaws.lakeformation#TransactionCanceledException":
2097
- throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
2098
- case "TransactionCommittedException":
2099
- case "com.amazonaws.lakeformation#TransactionCommittedException":
2100
- throw await de_TransactionCommittedExceptionRes(parsedOutput, context);
2101
- default:
2102
- const parsedBody = parsedOutput.body;
2103
- return throwDefaultError({
2104
- output,
2105
- parsedBody,
2106
- errorCode,
2107
- });
1026
+ return contents;
1027
+ };
1028
+ export const de_DeleteObjectsOnCancelCommand = async (output, context) => {
1029
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1030
+ return de_CommandError(output, context);
2108
1031
  }
1032
+ const contents = map({
1033
+ $metadata: deserializeMetadata(output),
1034
+ });
1035
+ await collectBody(output.body, context);
1036
+ return contents;
2109
1037
  };
2110
- export const de_GetTemporaryGluePartitionCredentialsCommand = async (output, context) => {
1038
+ export const de_DeregisterResourceCommand = async (output, context) => {
1039
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1040
+ return de_CommandError(output, context);
1041
+ }
1042
+ const contents = map({
1043
+ $metadata: deserializeMetadata(output),
1044
+ });
1045
+ await collectBody(output.body, context);
1046
+ return contents;
1047
+ };
1048
+ export const de_DescribeLakeFormationIdentityCenterConfigurationCommand = async (output, context) => {
2111
1049
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2112
- return de_GetTemporaryGluePartitionCredentialsCommandError(output, context);
1050
+ return de_CommandError(output, context);
2113
1051
  }
2114
1052
  const contents = map({
2115
1053
  $metadata: deserializeMetadata(output),
2116
1054
  });
2117
1055
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2118
1056
  const doc = take(data, {
2119
- AccessKeyId: __expectString,
2120
- Expiration: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
2121
- SecretAccessKey: __expectString,
2122
- SessionToken: __expectString,
1057
+ ApplicationArn: __expectString,
1058
+ CatalogId: __expectString,
1059
+ ExternalFiltering: _json,
1060
+ InstanceArn: __expectString,
2123
1061
  });
2124
1062
  Object.assign(contents, doc);
2125
1063
  return contents;
2126
1064
  };
2127
- const de_GetTemporaryGluePartitionCredentialsCommandError = async (output, context) => {
2128
- const parsedOutput = {
2129
- ...output,
2130
- body: await parseErrorBody(output.body, context),
2131
- };
2132
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2133
- switch (errorCode) {
2134
- case "AccessDeniedException":
2135
- case "com.amazonaws.lakeformation#AccessDeniedException":
2136
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2137
- case "EntityNotFoundException":
2138
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2139
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2140
- case "InternalServiceException":
2141
- case "com.amazonaws.lakeformation#InternalServiceException":
2142
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2143
- case "InvalidInputException":
2144
- case "com.amazonaws.lakeformation#InvalidInputException":
2145
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2146
- case "OperationTimeoutException":
2147
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2148
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2149
- case "PermissionTypeMismatchException":
2150
- case "com.amazonaws.lakeformation#PermissionTypeMismatchException":
2151
- throw await de_PermissionTypeMismatchExceptionRes(parsedOutput, context);
2152
- default:
2153
- const parsedBody = parsedOutput.body;
2154
- return throwDefaultError({
2155
- output,
2156
- parsedBody,
2157
- errorCode,
2158
- });
2159
- }
2160
- };
2161
- export const de_GetTemporaryGlueTableCredentialsCommand = async (output, context) => {
1065
+ export const de_DescribeResourceCommand = async (output, context) => {
2162
1066
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2163
- return de_GetTemporaryGlueTableCredentialsCommandError(output, context);
1067
+ return de_CommandError(output, context);
2164
1068
  }
2165
1069
  const contents = map({
2166
1070
  $metadata: deserializeMetadata(output),
2167
1071
  });
2168
1072
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2169
1073
  const doc = take(data, {
2170
- AccessKeyId: __expectString,
2171
- Expiration: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
2172
- SecretAccessKey: __expectString,
2173
- SessionToken: __expectString,
2174
- VendedS3Path: _json,
1074
+ ResourceInfo: (_) => de_ResourceInfo(_, context),
2175
1075
  });
2176
1076
  Object.assign(contents, doc);
2177
1077
  return contents;
2178
1078
  };
2179
- const de_GetTemporaryGlueTableCredentialsCommandError = async (output, context) => {
2180
- const parsedOutput = {
2181
- ...output,
2182
- body: await parseErrorBody(output.body, context),
2183
- };
2184
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2185
- switch (errorCode) {
2186
- case "AccessDeniedException":
2187
- case "com.amazonaws.lakeformation#AccessDeniedException":
2188
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2189
- case "EntityNotFoundException":
2190
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2191
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2192
- case "InternalServiceException":
2193
- case "com.amazonaws.lakeformation#InternalServiceException":
2194
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2195
- case "InvalidInputException":
2196
- case "com.amazonaws.lakeformation#InvalidInputException":
2197
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2198
- case "OperationTimeoutException":
2199
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2200
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2201
- case "PermissionTypeMismatchException":
2202
- case "com.amazonaws.lakeformation#PermissionTypeMismatchException":
2203
- throw await de_PermissionTypeMismatchExceptionRes(parsedOutput, context);
2204
- default:
2205
- const parsedBody = parsedOutput.body;
2206
- return throwDefaultError({
2207
- output,
2208
- parsedBody,
2209
- errorCode,
2210
- });
2211
- }
2212
- };
2213
- export const de_GetWorkUnitResultsCommand = async (output, context) => {
1079
+ export const de_DescribeTransactionCommand = async (output, context) => {
2214
1080
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2215
- return de_GetWorkUnitResultsCommandError(output, context);
1081
+ return de_CommandError(output, context);
2216
1082
  }
2217
1083
  const contents = map({
2218
1084
  $metadata: deserializeMetadata(output),
2219
1085
  });
2220
- const data = output.body;
2221
- context.sdkStreamMixin(data);
2222
- contents.ResultStream = data;
1086
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1087
+ const doc = take(data, {
1088
+ TransactionDescription: (_) => de_TransactionDescription(_, context),
1089
+ });
1090
+ Object.assign(contents, doc);
2223
1091
  return contents;
2224
1092
  };
2225
- const de_GetWorkUnitResultsCommandError = async (output, context) => {
2226
- const parsedOutput = {
2227
- ...output,
2228
- body: await parseErrorBody(output.body, context),
2229
- };
2230
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2231
- switch (errorCode) {
2232
- case "AccessDeniedException":
2233
- case "com.amazonaws.lakeformation#AccessDeniedException":
2234
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2235
- case "ExpiredException":
2236
- case "com.amazonaws.lakeformation#ExpiredException":
2237
- throw await de_ExpiredExceptionRes(parsedOutput, context);
2238
- case "InternalServiceException":
2239
- case "com.amazonaws.lakeformation#InternalServiceException":
2240
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2241
- case "InvalidInputException":
2242
- case "com.amazonaws.lakeformation#InvalidInputException":
2243
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2244
- case "ThrottledException":
2245
- case "com.amazonaws.lakeformation#ThrottledException":
2246
- throw await de_ThrottledExceptionRes(parsedOutput, context);
2247
- default:
2248
- const parsedBody = parsedOutput.body;
2249
- return throwDefaultError({
2250
- output,
2251
- parsedBody,
2252
- errorCode,
2253
- });
1093
+ export const de_ExtendTransactionCommand = async (output, context) => {
1094
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1095
+ return de_CommandError(output, context);
2254
1096
  }
1097
+ const contents = map({
1098
+ $metadata: deserializeMetadata(output),
1099
+ });
1100
+ await collectBody(output.body, context);
1101
+ return contents;
2255
1102
  };
2256
- export const de_GetWorkUnitsCommand = async (output, context) => {
1103
+ export const de_GetDataCellsFilterCommand = async (output, context) => {
2257
1104
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2258
- return de_GetWorkUnitsCommandError(output, context);
1105
+ return de_CommandError(output, context);
2259
1106
  }
2260
1107
  const contents = map({
2261
1108
  $metadata: deserializeMetadata(output),
2262
1109
  });
2263
1110
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2264
1111
  const doc = take(data, {
2265
- NextToken: __expectString,
2266
- QueryId: __expectString,
2267
- WorkUnitRanges: _json,
1112
+ DataCellsFilter: _json,
2268
1113
  });
2269
1114
  Object.assign(contents, doc);
2270
1115
  return contents;
2271
1116
  };
2272
- const de_GetWorkUnitsCommandError = async (output, context) => {
2273
- const parsedOutput = {
2274
- ...output,
2275
- body: await parseErrorBody(output.body, context),
2276
- };
2277
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2278
- switch (errorCode) {
2279
- case "AccessDeniedException":
2280
- case "com.amazonaws.lakeformation#AccessDeniedException":
2281
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2282
- case "ExpiredException":
2283
- case "com.amazonaws.lakeformation#ExpiredException":
2284
- throw await de_ExpiredExceptionRes(parsedOutput, context);
2285
- case "InternalServiceException":
2286
- case "com.amazonaws.lakeformation#InternalServiceException":
2287
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2288
- case "InvalidInputException":
2289
- case "com.amazonaws.lakeformation#InvalidInputException":
2290
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2291
- case "WorkUnitsNotReadyYetException":
2292
- case "com.amazonaws.lakeformation#WorkUnitsNotReadyYetException":
2293
- throw await de_WorkUnitsNotReadyYetExceptionRes(parsedOutput, context);
2294
- default:
2295
- const parsedBody = parsedOutput.body;
2296
- return throwDefaultError({
2297
- output,
2298
- parsedBody,
2299
- errorCode,
2300
- });
2301
- }
2302
- };
2303
- export const de_GrantPermissionsCommand = async (output, context) => {
1117
+ export const de_GetDataLakeSettingsCommand = async (output, context) => {
2304
1118
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2305
- return de_GrantPermissionsCommandError(output, context);
1119
+ return de_CommandError(output, context);
2306
1120
  }
2307
1121
  const contents = map({
2308
1122
  $metadata: deserializeMetadata(output),
2309
1123
  });
2310
- await collectBody(output.body, context);
1124
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1125
+ const doc = take(data, {
1126
+ DataLakeSettings: _json,
1127
+ });
1128
+ Object.assign(contents, doc);
2311
1129
  return contents;
2312
1130
  };
2313
- const de_GrantPermissionsCommandError = async (output, context) => {
2314
- const parsedOutput = {
2315
- ...output,
2316
- body: await parseErrorBody(output.body, context),
2317
- };
2318
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2319
- switch (errorCode) {
2320
- case "ConcurrentModificationException":
2321
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
2322
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2323
- case "EntityNotFoundException":
2324
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2325
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2326
- case "InvalidInputException":
2327
- case "com.amazonaws.lakeformation#InvalidInputException":
2328
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2329
- default:
2330
- const parsedBody = parsedOutput.body;
2331
- return throwDefaultError({
2332
- output,
2333
- parsedBody,
2334
- errorCode,
2335
- });
2336
- }
2337
- };
2338
- export const de_ListDataCellsFilterCommand = async (output, context) => {
1131
+ export const de_GetEffectivePermissionsForPathCommand = async (output, context) => {
2339
1132
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2340
- return de_ListDataCellsFilterCommandError(output, context);
1133
+ return de_CommandError(output, context);
2341
1134
  }
2342
1135
  const contents = map({
2343
1136
  $metadata: deserializeMetadata(output),
2344
1137
  });
2345
1138
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2346
1139
  const doc = take(data, {
2347
- DataCellsFilters: _json,
2348
1140
  NextToken: __expectString,
1141
+ Permissions: (_) => de_PrincipalResourcePermissionsList(_, context),
2349
1142
  });
2350
1143
  Object.assign(contents, doc);
2351
1144
  return contents;
2352
1145
  };
2353
- const de_ListDataCellsFilterCommandError = async (output, context) => {
2354
- const parsedOutput = {
2355
- ...output,
2356
- body: await parseErrorBody(output.body, context),
2357
- };
2358
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2359
- switch (errorCode) {
2360
- case "AccessDeniedException":
2361
- case "com.amazonaws.lakeformation#AccessDeniedException":
2362
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2363
- case "InternalServiceException":
2364
- case "com.amazonaws.lakeformation#InternalServiceException":
2365
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2366
- case "InvalidInputException":
2367
- case "com.amazonaws.lakeformation#InvalidInputException":
2368
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2369
- case "OperationTimeoutException":
2370
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2371
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2372
- default:
2373
- const parsedBody = parsedOutput.body;
2374
- return throwDefaultError({
2375
- output,
2376
- parsedBody,
2377
- errorCode,
2378
- });
1146
+ export const de_GetLFTagCommand = async (output, context) => {
1147
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1148
+ return de_CommandError(output, context);
2379
1149
  }
1150
+ const contents = map({
1151
+ $metadata: deserializeMetadata(output),
1152
+ });
1153
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1154
+ const doc = take(data, {
1155
+ CatalogId: __expectString,
1156
+ TagKey: __expectString,
1157
+ TagValues: _json,
1158
+ });
1159
+ Object.assign(contents, doc);
1160
+ return contents;
2380
1161
  };
2381
- export const de_ListLakeFormationOptInsCommand = async (output, context) => {
1162
+ export const de_GetQueryStateCommand = async (output, context) => {
2382
1163
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2383
- return de_ListLakeFormationOptInsCommandError(output, context);
1164
+ return de_CommandError(output, context);
2384
1165
  }
2385
1166
  const contents = map({
2386
1167
  $metadata: deserializeMetadata(output),
2387
1168
  });
2388
1169
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2389
1170
  const doc = take(data, {
2390
- LakeFormationOptInsInfoList: (_) => de_LakeFormationOptInsInfoList(_, context),
2391
- NextToken: __expectString,
1171
+ Error: __expectString,
1172
+ State: __expectString,
2392
1173
  });
2393
1174
  Object.assign(contents, doc);
2394
1175
  return contents;
2395
1176
  };
2396
- const de_ListLakeFormationOptInsCommandError = async (output, context) => {
2397
- const parsedOutput = {
2398
- ...output,
2399
- body: await parseErrorBody(output.body, context),
2400
- };
2401
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2402
- switch (errorCode) {
2403
- case "AccessDeniedException":
2404
- case "com.amazonaws.lakeformation#AccessDeniedException":
2405
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2406
- case "InternalServiceException":
2407
- case "com.amazonaws.lakeformation#InternalServiceException":
2408
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2409
- case "InvalidInputException":
2410
- case "com.amazonaws.lakeformation#InvalidInputException":
2411
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2412
- case "OperationTimeoutException":
2413
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2414
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2415
- default:
2416
- const parsedBody = parsedOutput.body;
2417
- return throwDefaultError({
2418
- output,
2419
- parsedBody,
2420
- errorCode,
2421
- });
2422
- }
2423
- };
2424
- export const de_ListLFTagsCommand = async (output, context) => {
1177
+ export const de_GetQueryStatisticsCommand = async (output, context) => {
2425
1178
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2426
- return de_ListLFTagsCommandError(output, context);
1179
+ return de_CommandError(output, context);
2427
1180
  }
2428
1181
  const contents = map({
2429
1182
  $metadata: deserializeMetadata(output),
2430
1183
  });
2431
1184
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2432
1185
  const doc = take(data, {
2433
- LFTags: _json,
2434
- NextToken: __expectString,
1186
+ ExecutionStatistics: _json,
1187
+ PlanningStatistics: _json,
1188
+ QuerySubmissionTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
2435
1189
  });
2436
1190
  Object.assign(contents, doc);
2437
1191
  return contents;
2438
1192
  };
2439
- const de_ListLFTagsCommandError = async (output, context) => {
2440
- const parsedOutput = {
2441
- ...output,
2442
- body: await parseErrorBody(output.body, context),
2443
- };
2444
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2445
- switch (errorCode) {
2446
- case "AccessDeniedException":
2447
- case "com.amazonaws.lakeformation#AccessDeniedException":
2448
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2449
- case "EntityNotFoundException":
2450
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2451
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2452
- case "InternalServiceException":
2453
- case "com.amazonaws.lakeformation#InternalServiceException":
2454
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2455
- case "InvalidInputException":
2456
- case "com.amazonaws.lakeformation#InvalidInputException":
2457
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2458
- case "OperationTimeoutException":
2459
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2460
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2461
- default:
2462
- const parsedBody = parsedOutput.body;
2463
- return throwDefaultError({
2464
- output,
2465
- parsedBody,
2466
- errorCode,
2467
- });
2468
- }
2469
- };
2470
- export const de_ListPermissionsCommand = async (output, context) => {
1193
+ export const de_GetResourceLFTagsCommand = async (output, context) => {
2471
1194
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2472
- return de_ListPermissionsCommandError(output, context);
1195
+ return de_CommandError(output, context);
2473
1196
  }
2474
1197
  const contents = map({
2475
1198
  $metadata: deserializeMetadata(output),
2476
1199
  });
2477
1200
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2478
1201
  const doc = take(data, {
2479
- NextToken: __expectString,
2480
- PrincipalResourcePermissions: (_) => de_PrincipalResourcePermissionsList(_, context),
1202
+ LFTagOnDatabase: _json,
1203
+ LFTagsOnColumns: _json,
1204
+ LFTagsOnTable: _json,
2481
1205
  });
2482
1206
  Object.assign(contents, doc);
2483
1207
  return contents;
2484
1208
  };
2485
- const de_ListPermissionsCommandError = async (output, context) => {
2486
- const parsedOutput = {
2487
- ...output,
2488
- body: await parseErrorBody(output.body, context),
2489
- };
2490
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2491
- switch (errorCode) {
2492
- case "InternalServiceException":
2493
- case "com.amazonaws.lakeformation#InternalServiceException":
2494
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2495
- case "InvalidInputException":
2496
- case "com.amazonaws.lakeformation#InvalidInputException":
2497
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2498
- case "OperationTimeoutException":
2499
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2500
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2501
- default:
2502
- const parsedBody = parsedOutput.body;
2503
- return throwDefaultError({
2504
- output,
2505
- parsedBody,
2506
- errorCode,
2507
- });
2508
- }
2509
- };
2510
- export const de_ListResourcesCommand = async (output, context) => {
1209
+ export const de_GetTableObjectsCommand = async (output, context) => {
2511
1210
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2512
- return de_ListResourcesCommandError(output, context);
1211
+ return de_CommandError(output, context);
2513
1212
  }
2514
1213
  const contents = map({
2515
1214
  $metadata: deserializeMetadata(output),
@@ -2517,82 +1216,61 @@ export const de_ListResourcesCommand = async (output, context) => {
2517
1216
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2518
1217
  const doc = take(data, {
2519
1218
  NextToken: __expectString,
2520
- ResourceInfoList: (_) => de_ResourceInfoList(_, context),
1219
+ Objects: _json,
2521
1220
  });
2522
1221
  Object.assign(contents, doc);
2523
1222
  return contents;
2524
1223
  };
2525
- const de_ListResourcesCommandError = async (output, context) => {
2526
- const parsedOutput = {
2527
- ...output,
2528
- body: await parseErrorBody(output.body, context),
2529
- };
2530
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2531
- switch (errorCode) {
2532
- case "InternalServiceException":
2533
- case "com.amazonaws.lakeformation#InternalServiceException":
2534
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2535
- case "InvalidInputException":
2536
- case "com.amazonaws.lakeformation#InvalidInputException":
2537
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2538
- case "OperationTimeoutException":
2539
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2540
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2541
- default:
2542
- const parsedBody = parsedOutput.body;
2543
- return throwDefaultError({
2544
- output,
2545
- parsedBody,
2546
- errorCode,
2547
- });
1224
+ export const de_GetTemporaryGluePartitionCredentialsCommand = async (output, context) => {
1225
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1226
+ return de_CommandError(output, context);
2548
1227
  }
1228
+ const contents = map({
1229
+ $metadata: deserializeMetadata(output),
1230
+ });
1231
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1232
+ const doc = take(data, {
1233
+ AccessKeyId: __expectString,
1234
+ Expiration: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1235
+ SecretAccessKey: __expectString,
1236
+ SessionToken: __expectString,
1237
+ });
1238
+ Object.assign(contents, doc);
1239
+ return contents;
2549
1240
  };
2550
- export const de_ListTableStorageOptimizersCommand = async (output, context) => {
1241
+ export const de_GetTemporaryGlueTableCredentialsCommand = async (output, context) => {
2551
1242
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2552
- return de_ListTableStorageOptimizersCommandError(output, context);
1243
+ return de_CommandError(output, context);
2553
1244
  }
2554
1245
  const contents = map({
2555
1246
  $metadata: deserializeMetadata(output),
2556
1247
  });
2557
1248
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2558
1249
  const doc = take(data, {
2559
- NextToken: __expectString,
2560
- StorageOptimizerList: _json,
1250
+ AccessKeyId: __expectString,
1251
+ Expiration: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1252
+ SecretAccessKey: __expectString,
1253
+ SessionToken: __expectString,
1254
+ VendedS3Path: _json,
2561
1255
  });
2562
1256
  Object.assign(contents, doc);
2563
1257
  return contents;
2564
1258
  };
2565
- const de_ListTableStorageOptimizersCommandError = async (output, context) => {
2566
- const parsedOutput = {
2567
- ...output,
2568
- body: await parseErrorBody(output.body, context),
2569
- };
2570
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2571
- switch (errorCode) {
2572
- case "AccessDeniedException":
2573
- case "com.amazonaws.lakeformation#AccessDeniedException":
2574
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2575
- case "EntityNotFoundException":
2576
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2577
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2578
- case "InternalServiceException":
2579
- case "com.amazonaws.lakeformation#InternalServiceException":
2580
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2581
- case "InvalidInputException":
2582
- case "com.amazonaws.lakeformation#InvalidInputException":
2583
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2584
- default:
2585
- const parsedBody = parsedOutput.body;
2586
- return throwDefaultError({
2587
- output,
2588
- parsedBody,
2589
- errorCode,
2590
- });
1259
+ export const de_GetWorkUnitResultsCommand = async (output, context) => {
1260
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1261
+ return de_CommandError(output, context);
2591
1262
  }
1263
+ const contents = map({
1264
+ $metadata: deserializeMetadata(output),
1265
+ });
1266
+ const data = output.body;
1267
+ context.sdkStreamMixin(data);
1268
+ contents.ResultStream = data;
1269
+ return contents;
2592
1270
  };
2593
- export const de_ListTransactionsCommand = async (output, context) => {
1271
+ export const de_GetWorkUnitsCommand = async (output, context) => {
2594
1272
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2595
- return de_ListTransactionsCommandError(output, context);
1273
+ return de_CommandError(output, context);
2596
1274
  }
2597
1275
  const contents = map({
2598
1276
  $metadata: deserializeMetadata(output),
@@ -2600,380 +1278,232 @@ export const de_ListTransactionsCommand = async (output, context) => {
2600
1278
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2601
1279
  const doc = take(data, {
2602
1280
  NextToken: __expectString,
2603
- Transactions: (_) => de_TransactionDescriptionList(_, context),
1281
+ QueryId: __expectString,
1282
+ WorkUnitRanges: _json,
2604
1283
  });
2605
1284
  Object.assign(contents, doc);
2606
1285
  return contents;
2607
1286
  };
2608
- const de_ListTransactionsCommandError = async (output, context) => {
2609
- const parsedOutput = {
2610
- ...output,
2611
- body: await parseErrorBody(output.body, context),
2612
- };
2613
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2614
- switch (errorCode) {
2615
- case "InternalServiceException":
2616
- case "com.amazonaws.lakeformation#InternalServiceException":
2617
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2618
- case "InvalidInputException":
2619
- case "com.amazonaws.lakeformation#InvalidInputException":
2620
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2621
- case "OperationTimeoutException":
2622
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2623
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2624
- default:
2625
- const parsedBody = parsedOutput.body;
2626
- return throwDefaultError({
2627
- output,
2628
- parsedBody,
2629
- errorCode,
2630
- });
1287
+ export const de_GrantPermissionsCommand = async (output, context) => {
1288
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1289
+ return de_CommandError(output, context);
2631
1290
  }
1291
+ const contents = map({
1292
+ $metadata: deserializeMetadata(output),
1293
+ });
1294
+ await collectBody(output.body, context);
1295
+ return contents;
2632
1296
  };
2633
- export const de_PutDataLakeSettingsCommand = async (output, context) => {
1297
+ export const de_ListDataCellsFilterCommand = async (output, context) => {
2634
1298
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2635
- return de_PutDataLakeSettingsCommandError(output, context);
1299
+ return de_CommandError(output, context);
2636
1300
  }
2637
1301
  const contents = map({
2638
1302
  $metadata: deserializeMetadata(output),
2639
1303
  });
2640
- await collectBody(output.body, context);
1304
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1305
+ const doc = take(data, {
1306
+ DataCellsFilters: _json,
1307
+ NextToken: __expectString,
1308
+ });
1309
+ Object.assign(contents, doc);
2641
1310
  return contents;
2642
1311
  };
2643
- const de_PutDataLakeSettingsCommandError = async (output, context) => {
2644
- const parsedOutput = {
2645
- ...output,
2646
- body: await parseErrorBody(output.body, context),
2647
- };
2648
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2649
- switch (errorCode) {
2650
- case "InternalServiceException":
2651
- case "com.amazonaws.lakeformation#InternalServiceException":
2652
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2653
- case "InvalidInputException":
2654
- case "com.amazonaws.lakeformation#InvalidInputException":
2655
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2656
- default:
2657
- const parsedBody = parsedOutput.body;
2658
- return throwDefaultError({
2659
- output,
2660
- parsedBody,
2661
- errorCode,
2662
- });
1312
+ export const de_ListLakeFormationOptInsCommand = async (output, context) => {
1313
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1314
+ return de_CommandError(output, context);
2663
1315
  }
1316
+ const contents = map({
1317
+ $metadata: deserializeMetadata(output),
1318
+ });
1319
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1320
+ const doc = take(data, {
1321
+ LakeFormationOptInsInfoList: (_) => de_LakeFormationOptInsInfoList(_, context),
1322
+ NextToken: __expectString,
1323
+ });
1324
+ Object.assign(contents, doc);
1325
+ return contents;
2664
1326
  };
2665
- export const de_RegisterResourceCommand = async (output, context) => {
1327
+ export const de_ListLFTagsCommand = async (output, context) => {
2666
1328
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2667
- return de_RegisterResourceCommandError(output, context);
1329
+ return de_CommandError(output, context);
2668
1330
  }
2669
1331
  const contents = map({
2670
1332
  $metadata: deserializeMetadata(output),
2671
1333
  });
2672
- await collectBody(output.body, context);
1334
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1335
+ const doc = take(data, {
1336
+ LFTags: _json,
1337
+ NextToken: __expectString,
1338
+ });
1339
+ Object.assign(contents, doc);
2673
1340
  return contents;
2674
1341
  };
2675
- const de_RegisterResourceCommandError = async (output, context) => {
2676
- const parsedOutput = {
2677
- ...output,
2678
- body: await parseErrorBody(output.body, context),
2679
- };
2680
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2681
- switch (errorCode) {
2682
- case "AccessDeniedException":
2683
- case "com.amazonaws.lakeformation#AccessDeniedException":
2684
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2685
- case "AlreadyExistsException":
2686
- case "com.amazonaws.lakeformation#AlreadyExistsException":
2687
- throw await de_AlreadyExistsExceptionRes(parsedOutput, context);
2688
- case "EntityNotFoundException":
2689
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2690
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2691
- case "InternalServiceException":
2692
- case "com.amazonaws.lakeformation#InternalServiceException":
2693
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2694
- case "InvalidInputException":
2695
- case "com.amazonaws.lakeformation#InvalidInputException":
2696
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2697
- case "OperationTimeoutException":
2698
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2699
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2700
- case "ResourceNumberLimitExceededException":
2701
- case "com.amazonaws.lakeformation#ResourceNumberLimitExceededException":
2702
- throw await de_ResourceNumberLimitExceededExceptionRes(parsedOutput, context);
2703
- default:
2704
- const parsedBody = parsedOutput.body;
2705
- return throwDefaultError({
2706
- output,
2707
- parsedBody,
2708
- errorCode,
2709
- });
2710
- }
2711
- };
2712
- export const de_RemoveLFTagsFromResourceCommand = async (output, context) => {
1342
+ export const de_ListPermissionsCommand = async (output, context) => {
2713
1343
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2714
- return de_RemoveLFTagsFromResourceCommandError(output, context);
1344
+ return de_CommandError(output, context);
2715
1345
  }
2716
1346
  const contents = map({
2717
1347
  $metadata: deserializeMetadata(output),
2718
1348
  });
2719
1349
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2720
1350
  const doc = take(data, {
2721
- Failures: _json,
1351
+ NextToken: __expectString,
1352
+ PrincipalResourcePermissions: (_) => de_PrincipalResourcePermissionsList(_, context),
2722
1353
  });
2723
1354
  Object.assign(contents, doc);
2724
1355
  return contents;
2725
1356
  };
2726
- const de_RemoveLFTagsFromResourceCommandError = async (output, context) => {
2727
- const parsedOutput = {
2728
- ...output,
2729
- body: await parseErrorBody(output.body, context),
2730
- };
2731
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2732
- switch (errorCode) {
2733
- case "AccessDeniedException":
2734
- case "com.amazonaws.lakeformation#AccessDeniedException":
2735
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2736
- case "ConcurrentModificationException":
2737
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
2738
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2739
- case "EntityNotFoundException":
2740
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2741
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2742
- case "GlueEncryptionException":
2743
- case "com.amazonaws.lakeformation#GlueEncryptionException":
2744
- throw await de_GlueEncryptionExceptionRes(parsedOutput, context);
2745
- case "InternalServiceException":
2746
- case "com.amazonaws.lakeformation#InternalServiceException":
2747
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2748
- case "InvalidInputException":
2749
- case "com.amazonaws.lakeformation#InvalidInputException":
2750
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2751
- case "OperationTimeoutException":
2752
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2753
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2754
- default:
2755
- const parsedBody = parsedOutput.body;
2756
- return throwDefaultError({
2757
- output,
2758
- parsedBody,
2759
- errorCode,
2760
- });
2761
- }
2762
- };
2763
- export const de_RevokePermissionsCommand = async (output, context) => {
1357
+ export const de_ListResourcesCommand = async (output, context) => {
2764
1358
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2765
- return de_RevokePermissionsCommandError(output, context);
1359
+ return de_CommandError(output, context);
2766
1360
  }
2767
1361
  const contents = map({
2768
1362
  $metadata: deserializeMetadata(output),
2769
1363
  });
2770
- await collectBody(output.body, context);
1364
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1365
+ const doc = take(data, {
1366
+ NextToken: __expectString,
1367
+ ResourceInfoList: (_) => de_ResourceInfoList(_, context),
1368
+ });
1369
+ Object.assign(contents, doc);
2771
1370
  return contents;
2772
1371
  };
2773
- const de_RevokePermissionsCommandError = async (output, context) => {
2774
- const parsedOutput = {
2775
- ...output,
2776
- body: await parseErrorBody(output.body, context),
2777
- };
2778
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2779
- switch (errorCode) {
2780
- case "ConcurrentModificationException":
2781
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
2782
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2783
- case "EntityNotFoundException":
2784
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2785
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2786
- case "InvalidInputException":
2787
- case "com.amazonaws.lakeformation#InvalidInputException":
2788
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2789
- default:
2790
- const parsedBody = parsedOutput.body;
2791
- return throwDefaultError({
2792
- output,
2793
- parsedBody,
2794
- errorCode,
2795
- });
1372
+ export const de_ListTableStorageOptimizersCommand = async (output, context) => {
1373
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1374
+ return de_CommandError(output, context);
2796
1375
  }
1376
+ const contents = map({
1377
+ $metadata: deserializeMetadata(output),
1378
+ });
1379
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1380
+ const doc = take(data, {
1381
+ NextToken: __expectString,
1382
+ StorageOptimizerList: _json,
1383
+ });
1384
+ Object.assign(contents, doc);
1385
+ return contents;
2797
1386
  };
2798
- export const de_SearchDatabasesByLFTagsCommand = async (output, context) => {
1387
+ export const de_ListTransactionsCommand = async (output, context) => {
2799
1388
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2800
- return de_SearchDatabasesByLFTagsCommandError(output, context);
1389
+ return de_CommandError(output, context);
2801
1390
  }
2802
1391
  const contents = map({
2803
1392
  $metadata: deserializeMetadata(output),
2804
1393
  });
2805
1394
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2806
1395
  const doc = take(data, {
2807
- DatabaseList: _json,
2808
1396
  NextToken: __expectString,
1397
+ Transactions: (_) => de_TransactionDescriptionList(_, context),
2809
1398
  });
2810
1399
  Object.assign(contents, doc);
2811
1400
  return contents;
2812
1401
  };
2813
- const de_SearchDatabasesByLFTagsCommandError = async (output, context) => {
2814
- const parsedOutput = {
2815
- ...output,
2816
- body: await parseErrorBody(output.body, context),
2817
- };
2818
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2819
- switch (errorCode) {
2820
- case "AccessDeniedException":
2821
- case "com.amazonaws.lakeformation#AccessDeniedException":
2822
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2823
- case "EntityNotFoundException":
2824
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2825
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2826
- case "GlueEncryptionException":
2827
- case "com.amazonaws.lakeformation#GlueEncryptionException":
2828
- throw await de_GlueEncryptionExceptionRes(parsedOutput, context);
2829
- case "InternalServiceException":
2830
- case "com.amazonaws.lakeformation#InternalServiceException":
2831
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2832
- case "InvalidInputException":
2833
- case "com.amazonaws.lakeformation#InvalidInputException":
2834
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2835
- case "OperationTimeoutException":
2836
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2837
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2838
- default:
2839
- const parsedBody = parsedOutput.body;
2840
- return throwDefaultError({
2841
- output,
2842
- parsedBody,
2843
- errorCode,
2844
- });
1402
+ export const de_PutDataLakeSettingsCommand = async (output, context) => {
1403
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1404
+ return de_CommandError(output, context);
2845
1405
  }
1406
+ const contents = map({
1407
+ $metadata: deserializeMetadata(output),
1408
+ });
1409
+ await collectBody(output.body, context);
1410
+ return contents;
2846
1411
  };
2847
- export const de_SearchTablesByLFTagsCommand = async (output, context) => {
1412
+ export const de_RegisterResourceCommand = async (output, context) => {
2848
1413
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2849
- return de_SearchTablesByLFTagsCommandError(output, context);
1414
+ return de_CommandError(output, context);
1415
+ }
1416
+ const contents = map({
1417
+ $metadata: deserializeMetadata(output),
1418
+ });
1419
+ await collectBody(output.body, context);
1420
+ return contents;
1421
+ };
1422
+ export const de_RemoveLFTagsFromResourceCommand = async (output, context) => {
1423
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1424
+ return de_CommandError(output, context);
2850
1425
  }
2851
1426
  const contents = map({
2852
1427
  $metadata: deserializeMetadata(output),
2853
1428
  });
2854
1429
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2855
1430
  const doc = take(data, {
2856
- NextToken: __expectString,
2857
- TableList: _json,
1431
+ Failures: _json,
2858
1432
  });
2859
1433
  Object.assign(contents, doc);
2860
1434
  return contents;
2861
1435
  };
2862
- const de_SearchTablesByLFTagsCommandError = async (output, context) => {
2863
- const parsedOutput = {
2864
- ...output,
2865
- body: await parseErrorBody(output.body, context),
2866
- };
2867
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2868
- switch (errorCode) {
2869
- case "AccessDeniedException":
2870
- case "com.amazonaws.lakeformation#AccessDeniedException":
2871
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2872
- case "EntityNotFoundException":
2873
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2874
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
2875
- case "GlueEncryptionException":
2876
- case "com.amazonaws.lakeformation#GlueEncryptionException":
2877
- throw await de_GlueEncryptionExceptionRes(parsedOutput, context);
2878
- case "InternalServiceException":
2879
- case "com.amazonaws.lakeformation#InternalServiceException":
2880
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2881
- case "InvalidInputException":
2882
- case "com.amazonaws.lakeformation#InvalidInputException":
2883
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2884
- case "OperationTimeoutException":
2885
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2886
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2887
- default:
2888
- const parsedBody = parsedOutput.body;
2889
- return throwDefaultError({
2890
- output,
2891
- parsedBody,
2892
- errorCode,
2893
- });
1436
+ export const de_RevokePermissionsCommand = async (output, context) => {
1437
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1438
+ return de_CommandError(output, context);
2894
1439
  }
1440
+ const contents = map({
1441
+ $metadata: deserializeMetadata(output),
1442
+ });
1443
+ await collectBody(output.body, context);
1444
+ return contents;
2895
1445
  };
2896
- export const de_StartQueryPlanningCommand = async (output, context) => {
1446
+ export const de_SearchDatabasesByLFTagsCommand = async (output, context) => {
2897
1447
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2898
- return de_StartQueryPlanningCommandError(output, context);
1448
+ return de_CommandError(output, context);
2899
1449
  }
2900
1450
  const contents = map({
2901
1451
  $metadata: deserializeMetadata(output),
2902
1452
  });
2903
1453
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2904
1454
  const doc = take(data, {
2905
- QueryId: __expectString,
1455
+ DatabaseList: _json,
1456
+ NextToken: __expectString,
2906
1457
  });
2907
1458
  Object.assign(contents, doc);
2908
1459
  return contents;
2909
1460
  };
2910
- const de_StartQueryPlanningCommandError = async (output, context) => {
2911
- const parsedOutput = {
2912
- ...output,
2913
- body: await parseErrorBody(output.body, context),
2914
- };
2915
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2916
- switch (errorCode) {
2917
- case "AccessDeniedException":
2918
- case "com.amazonaws.lakeformation#AccessDeniedException":
2919
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2920
- case "InternalServiceException":
2921
- case "com.amazonaws.lakeformation#InternalServiceException":
2922
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2923
- case "InvalidInputException":
2924
- case "com.amazonaws.lakeformation#InvalidInputException":
2925
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2926
- case "ThrottledException":
2927
- case "com.amazonaws.lakeformation#ThrottledException":
2928
- throw await de_ThrottledExceptionRes(parsedOutput, context);
2929
- default:
2930
- const parsedBody = parsedOutput.body;
2931
- return throwDefaultError({
2932
- output,
2933
- parsedBody,
2934
- errorCode,
2935
- });
1461
+ export const de_SearchTablesByLFTagsCommand = async (output, context) => {
1462
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1463
+ return de_CommandError(output, context);
2936
1464
  }
1465
+ const contents = map({
1466
+ $metadata: deserializeMetadata(output),
1467
+ });
1468
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1469
+ const doc = take(data, {
1470
+ NextToken: __expectString,
1471
+ TableList: _json,
1472
+ });
1473
+ Object.assign(contents, doc);
1474
+ return contents;
2937
1475
  };
2938
- export const de_StartTransactionCommand = async (output, context) => {
1476
+ export const de_StartQueryPlanningCommand = async (output, context) => {
2939
1477
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2940
- return de_StartTransactionCommandError(output, context);
1478
+ return de_CommandError(output, context);
2941
1479
  }
2942
1480
  const contents = map({
2943
1481
  $metadata: deserializeMetadata(output),
2944
1482
  });
2945
1483
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2946
1484
  const doc = take(data, {
2947
- TransactionId: __expectString,
1485
+ QueryId: __expectString,
2948
1486
  });
2949
1487
  Object.assign(contents, doc);
2950
1488
  return contents;
2951
1489
  };
2952
- const de_StartTransactionCommandError = 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 "InternalServiceException":
2960
- case "com.amazonaws.lakeformation#InternalServiceException":
2961
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
2962
- case "OperationTimeoutException":
2963
- case "com.amazonaws.lakeformation#OperationTimeoutException":
2964
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
2965
- default:
2966
- const parsedBody = parsedOutput.body;
2967
- return throwDefaultError({
2968
- output,
2969
- parsedBody,
2970
- errorCode,
2971
- });
1490
+ export const de_StartTransactionCommand = async (output, context) => {
1491
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1492
+ return de_CommandError(output, context);
2972
1493
  }
1494
+ const contents = map({
1495
+ $metadata: deserializeMetadata(output),
1496
+ });
1497
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1498
+ const doc = take(data, {
1499
+ TransactionId: __expectString,
1500
+ });
1501
+ Object.assign(contents, doc);
1502
+ return contents;
2973
1503
  };
2974
1504
  export const de_UpdateDataCellsFilterCommand = async (output, context) => {
2975
1505
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2976
- return de_UpdateDataCellsFilterCommandError(output, context);
1506
+ return de_CommandError(output, context);
2977
1507
  }
2978
1508
  const contents = map({
2979
1509
  $metadata: deserializeMetadata(output),
@@ -2981,43 +1511,9 @@ export const de_UpdateDataCellsFilterCommand = async (output, context) => {
2981
1511
  await collectBody(output.body, context);
2982
1512
  return contents;
2983
1513
  };
2984
- const de_UpdateDataCellsFilterCommandError = async (output, context) => {
2985
- const parsedOutput = {
2986
- ...output,
2987
- body: await parseErrorBody(output.body, context),
2988
- };
2989
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2990
- switch (errorCode) {
2991
- case "AccessDeniedException":
2992
- case "com.amazonaws.lakeformation#AccessDeniedException":
2993
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2994
- case "ConcurrentModificationException":
2995
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
2996
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2997
- case "EntityNotFoundException":
2998
- case "com.amazonaws.lakeformation#EntityNotFoundException":
2999
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
3000
- case "InternalServiceException":
3001
- case "com.amazonaws.lakeformation#InternalServiceException":
3002
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
3003
- case "InvalidInputException":
3004
- case "com.amazonaws.lakeformation#InvalidInputException":
3005
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3006
- case "OperationTimeoutException":
3007
- case "com.amazonaws.lakeformation#OperationTimeoutException":
3008
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
3009
- default:
3010
- const parsedBody = parsedOutput.body;
3011
- return throwDefaultError({
3012
- output,
3013
- parsedBody,
3014
- errorCode,
3015
- });
3016
- }
3017
- };
3018
1514
  export const de_UpdateLakeFormationIdentityCenterConfigurationCommand = async (output, context) => {
3019
1515
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3020
- return de_UpdateLakeFormationIdentityCenterConfigurationCommandError(output, context);
1516
+ return de_CommandError(output, context);
3021
1517
  }
3022
1518
  const contents = map({
3023
1519
  $metadata: deserializeMetadata(output),
@@ -3025,43 +1521,9 @@ export const de_UpdateLakeFormationIdentityCenterConfigurationCommand = async (o
3025
1521
  await collectBody(output.body, context);
3026
1522
  return contents;
3027
1523
  };
3028
- const de_UpdateLakeFormationIdentityCenterConfigurationCommandError = async (output, context) => {
3029
- const parsedOutput = {
3030
- ...output,
3031
- body: await parseErrorBody(output.body, context),
3032
- };
3033
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3034
- switch (errorCode) {
3035
- case "AccessDeniedException":
3036
- case "com.amazonaws.lakeformation#AccessDeniedException":
3037
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3038
- case "ConcurrentModificationException":
3039
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
3040
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3041
- case "EntityNotFoundException":
3042
- case "com.amazonaws.lakeformation#EntityNotFoundException":
3043
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
3044
- case "InternalServiceException":
3045
- case "com.amazonaws.lakeformation#InternalServiceException":
3046
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
3047
- case "InvalidInputException":
3048
- case "com.amazonaws.lakeformation#InvalidInputException":
3049
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3050
- case "OperationTimeoutException":
3051
- case "com.amazonaws.lakeformation#OperationTimeoutException":
3052
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
3053
- default:
3054
- const parsedBody = parsedOutput.body;
3055
- return throwDefaultError({
3056
- output,
3057
- parsedBody,
3058
- errorCode,
3059
- });
3060
- }
3061
- };
3062
1524
  export const de_UpdateLFTagCommand = async (output, context) => {
3063
1525
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3064
- return de_UpdateLFTagCommandError(output, context);
1526
+ return de_CommandError(output, context);
3065
1527
  }
3066
1528
  const contents = map({
3067
1529
  $metadata: deserializeMetadata(output),
@@ -3069,43 +1531,9 @@ export const de_UpdateLFTagCommand = async (output, context) => {
3069
1531
  await collectBody(output.body, context);
3070
1532
  return contents;
3071
1533
  };
3072
- const de_UpdateLFTagCommandError = async (output, context) => {
3073
- const parsedOutput = {
3074
- ...output,
3075
- body: await parseErrorBody(output.body, context),
3076
- };
3077
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3078
- switch (errorCode) {
3079
- case "AccessDeniedException":
3080
- case "com.amazonaws.lakeformation#AccessDeniedException":
3081
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3082
- case "ConcurrentModificationException":
3083
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
3084
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3085
- case "EntityNotFoundException":
3086
- case "com.amazonaws.lakeformation#EntityNotFoundException":
3087
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
3088
- case "InternalServiceException":
3089
- case "com.amazonaws.lakeformation#InternalServiceException":
3090
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
3091
- case "InvalidInputException":
3092
- case "com.amazonaws.lakeformation#InvalidInputException":
3093
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3094
- case "OperationTimeoutException":
3095
- case "com.amazonaws.lakeformation#OperationTimeoutException":
3096
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
3097
- default:
3098
- const parsedBody = parsedOutput.body;
3099
- return throwDefaultError({
3100
- output,
3101
- parsedBody,
3102
- errorCode,
3103
- });
3104
- }
3105
- };
3106
1534
  export const de_UpdateResourceCommand = async (output, context) => {
3107
1535
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3108
- return de_UpdateResourceCommandError(output, context);
1536
+ return de_CommandError(output, context);
3109
1537
  }
3110
1538
  const contents = map({
3111
1539
  $metadata: deserializeMetadata(output),
@@ -3113,37 +1541,9 @@ export const de_UpdateResourceCommand = async (output, context) => {
3113
1541
  await collectBody(output.body, context);
3114
1542
  return contents;
3115
1543
  };
3116
- const de_UpdateResourceCommandError = async (output, context) => {
3117
- const parsedOutput = {
3118
- ...output,
3119
- body: await parseErrorBody(output.body, context),
3120
- };
3121
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3122
- switch (errorCode) {
3123
- case "EntityNotFoundException":
3124
- case "com.amazonaws.lakeformation#EntityNotFoundException":
3125
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
3126
- case "InternalServiceException":
3127
- case "com.amazonaws.lakeformation#InternalServiceException":
3128
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
3129
- case "InvalidInputException":
3130
- case "com.amazonaws.lakeformation#InvalidInputException":
3131
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3132
- case "OperationTimeoutException":
3133
- case "com.amazonaws.lakeformation#OperationTimeoutException":
3134
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
3135
- default:
3136
- const parsedBody = parsedOutput.body;
3137
- return throwDefaultError({
3138
- output,
3139
- parsedBody,
3140
- errorCode,
3141
- });
3142
- }
3143
- };
3144
1544
  export const de_UpdateTableObjectsCommand = async (output, context) => {
3145
1545
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3146
- return de_UpdateTableObjectsCommandError(output, context);
1546
+ return de_CommandError(output, context);
3147
1547
  }
3148
1548
  const contents = map({
3149
1549
  $metadata: deserializeMetadata(output),
@@ -3151,52 +1551,9 @@ export const de_UpdateTableObjectsCommand = async (output, context) => {
3151
1551
  await collectBody(output.body, context);
3152
1552
  return contents;
3153
1553
  };
3154
- const de_UpdateTableObjectsCommandError = async (output, context) => {
3155
- const parsedOutput = {
3156
- ...output,
3157
- body: await parseErrorBody(output.body, context),
3158
- };
3159
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3160
- switch (errorCode) {
3161
- case "ConcurrentModificationException":
3162
- case "com.amazonaws.lakeformation#ConcurrentModificationException":
3163
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3164
- case "EntityNotFoundException":
3165
- case "com.amazonaws.lakeformation#EntityNotFoundException":
3166
- throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
3167
- case "InternalServiceException":
3168
- case "com.amazonaws.lakeformation#InternalServiceException":
3169
- throw await de_InternalServiceExceptionRes(parsedOutput, context);
3170
- case "InvalidInputException":
3171
- case "com.amazonaws.lakeformation#InvalidInputException":
3172
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3173
- case "OperationTimeoutException":
3174
- case "com.amazonaws.lakeformation#OperationTimeoutException":
3175
- throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
3176
- case "ResourceNotReadyException":
3177
- case "com.amazonaws.lakeformation#ResourceNotReadyException":
3178
- throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
3179
- case "TransactionCanceledException":
3180
- case "com.amazonaws.lakeformation#TransactionCanceledException":
3181
- throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
3182
- case "TransactionCommitInProgressException":
3183
- case "com.amazonaws.lakeformation#TransactionCommitInProgressException":
3184
- throw await de_TransactionCommitInProgressExceptionRes(parsedOutput, context);
3185
- case "TransactionCommittedException":
3186
- case "com.amazonaws.lakeformation#TransactionCommittedException":
3187
- throw await de_TransactionCommittedExceptionRes(parsedOutput, context);
3188
- default:
3189
- const parsedBody = parsedOutput.body;
3190
- return throwDefaultError({
3191
- output,
3192
- parsedBody,
3193
- errorCode,
3194
- });
3195
- }
3196
- };
3197
1554
  export const de_UpdateTableStorageOptimizerCommand = async (output, context) => {
3198
1555
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3199
- return de_UpdateTableStorageOptimizerCommandError(output, context);
1556
+ return de_CommandError(output, context);
3200
1557
  }
3201
1558
  const contents = map({
3202
1559
  $metadata: deserializeMetadata(output),
@@ -3208,7 +1565,7 @@ export const de_UpdateTableStorageOptimizerCommand = async (output, context) =>
3208
1565
  Object.assign(contents, doc);
3209
1566
  return contents;
3210
1567
  };
3211
- const de_UpdateTableStorageOptimizerCommandError = async (output, context) => {
1568
+ const de_CommandError = async (output, context) => {
3212
1569
  const parsedOutput = {
3213
1570
  ...output,
3214
1571
  body: await parseErrorBody(output.body, context),
@@ -3218,6 +1575,9 @@ const de_UpdateTableStorageOptimizerCommandError = async (output, context) => {
3218
1575
  case "AccessDeniedException":
3219
1576
  case "com.amazonaws.lakeformation#AccessDeniedException":
3220
1577
  throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1578
+ case "ConcurrentModificationException":
1579
+ case "com.amazonaws.lakeformation#ConcurrentModificationException":
1580
+ throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3221
1581
  case "EntityNotFoundException":
3222
1582
  case "com.amazonaws.lakeformation#EntityNotFoundException":
3223
1583
  throw await de_EntityNotFoundExceptionRes(parsedOutput, context);
@@ -3227,6 +1587,45 @@ const de_UpdateTableStorageOptimizerCommandError = async (output, context) => {
3227
1587
  case "InvalidInputException":
3228
1588
  case "com.amazonaws.lakeformation#InvalidInputException":
3229
1589
  throw await de_InvalidInputExceptionRes(parsedOutput, context);
1590
+ case "OperationTimeoutException":
1591
+ case "com.amazonaws.lakeformation#OperationTimeoutException":
1592
+ throw await de_OperationTimeoutExceptionRes(parsedOutput, context);
1593
+ case "TransactionCommitInProgressException":
1594
+ case "com.amazonaws.lakeformation#TransactionCommitInProgressException":
1595
+ throw await de_TransactionCommitInProgressExceptionRes(parsedOutput, context);
1596
+ case "TransactionCommittedException":
1597
+ case "com.amazonaws.lakeformation#TransactionCommittedException":
1598
+ throw await de_TransactionCommittedExceptionRes(parsedOutput, context);
1599
+ case "TransactionCanceledException":
1600
+ case "com.amazonaws.lakeformation#TransactionCanceledException":
1601
+ throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
1602
+ case "AlreadyExistsException":
1603
+ case "com.amazonaws.lakeformation#AlreadyExistsException":
1604
+ throw await de_AlreadyExistsExceptionRes(parsedOutput, context);
1605
+ case "ResourceNumberLimitExceededException":
1606
+ case "com.amazonaws.lakeformation#ResourceNumberLimitExceededException":
1607
+ throw await de_ResourceNumberLimitExceededExceptionRes(parsedOutput, context);
1608
+ case "ResourceNotReadyException":
1609
+ case "com.amazonaws.lakeformation#ResourceNotReadyException":
1610
+ throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
1611
+ case "ExpiredException":
1612
+ case "com.amazonaws.lakeformation#ExpiredException":
1613
+ throw await de_ExpiredExceptionRes(parsedOutput, context);
1614
+ case "StatisticsNotReadyYetException":
1615
+ case "com.amazonaws.lakeformation#StatisticsNotReadyYetException":
1616
+ throw await de_StatisticsNotReadyYetExceptionRes(parsedOutput, context);
1617
+ case "ThrottledException":
1618
+ case "com.amazonaws.lakeformation#ThrottledException":
1619
+ throw await de_ThrottledExceptionRes(parsedOutput, context);
1620
+ case "GlueEncryptionException":
1621
+ case "com.amazonaws.lakeformation#GlueEncryptionException":
1622
+ throw await de_GlueEncryptionExceptionRes(parsedOutput, context);
1623
+ case "PermissionTypeMismatchException":
1624
+ case "com.amazonaws.lakeformation#PermissionTypeMismatchException":
1625
+ throw await de_PermissionTypeMismatchExceptionRes(parsedOutput, context);
1626
+ case "WorkUnitsNotReadyYetException":
1627
+ case "com.amazonaws.lakeformation#WorkUnitsNotReadyYetException":
1628
+ throw await de_WorkUnitsNotReadyYetExceptionRes(parsedOutput, context);
3230
1629
  default:
3231
1630
  const parsedBody = parsedOutput.body;
3232
1631
  return throwDefaultError({