drizzle-kit 0.20.16-ca9dd07 → 0.20.17-0d9aa5f

Sign up to get free protection for your applications and to get access to all the features.
Files changed (58) hide show
  1. package/bin.cjs +69184 -39095
  2. package/cli/commands/migrate.d.ts +123 -106
  3. package/cli/commands/mysqlIntrospect.d.ts +2 -71
  4. package/cli/commands/mysqlPushUtils.d.ts +4 -8
  5. package/cli/commands/pgIntrospect.d.ts +6 -70
  6. package/cli/commands/pgPushUtils.d.ts +3 -6
  7. package/cli/commands/sqliteIntrospect.d.ts +13 -17
  8. package/cli/commands/sqlitePushUtils.d.ts +4 -10
  9. package/cli/commands/utils.d.ts +39 -255
  10. package/cli/connections.d.ts +13 -0
  11. package/cli/utils.d.ts +13 -0
  12. package/cli/validations/cli.d.ts +169 -0
  13. package/cli/validations/common.d.ts +208 -7
  14. package/cli/validations/mysql.d.ts +6 -342
  15. package/cli/validations/outputs.d.ts +2 -0
  16. package/cli/validations/pg.d.ts +16 -408
  17. package/cli/validations/sqlite.d.ts +22 -0
  18. package/cli/views.d.ts +7 -5
  19. package/global.d.ts +3 -1
  20. package/index.d.mts +25 -17
  21. package/index.d.ts +25 -17
  22. package/index.js +1 -0
  23. package/introspect-sqlite.d.ts +2 -2
  24. package/jsonDiffer.d.ts +14 -29
  25. package/jsonStatements.d.ts +38 -11
  26. package/package.json +28 -51
  27. package/payload.d.mts +5 -5
  28. package/payload.d.ts +5 -5
  29. package/payload.js +16621 -33841
  30. package/payload.mjs +16673 -33904
  31. package/schemaValidator.d.ts +72 -69
  32. package/serializer/mysqlImports.d.ts +3 -7
  33. package/serializer/mysqlSchema.d.ts +1404 -587
  34. package/serializer/mysqlSerializer.d.ts +6 -6
  35. package/serializer/pgImports.d.ts +2 -2
  36. package/serializer/pgSchema.d.ts +1260 -801
  37. package/serializer/pgSerializer.d.ts +2 -2
  38. package/serializer/sqliteImports.d.ts +2 -4
  39. package/serializer/sqliteSchema.d.ts +144 -570
  40. package/serializer/sqliteSerializer.d.ts +4 -4
  41. package/serializer/studio.d.ts +51 -0
  42. package/snapshotsDiffer.d.ts +2334 -1057
  43. package/utils/words.d.ts +1 -1
  44. package/utils-studio.d.mts +0 -1
  45. package/utils-studio.d.ts +0 -1
  46. package/utils-studio.js +3817 -169
  47. package/utils-studio.mjs +3817 -172
  48. package/utils.d.ts +20 -141
  49. package/utils.js +3899 -7070
  50. package/utils.mjs +3972 -7143
  51. package/cli/commands/mysqlUp.d.ts +0 -4
  52. package/cli/commands/pgConnect.d.ts +0 -5
  53. package/cli/commands/pgUp.d.ts +0 -4
  54. package/cli/commands/sqliteUtils.d.ts +0 -162
  55. package/cli/commands/upFolders.d.ts +0 -27
  56. package/drivers/index.d.ts +0 -39
  57. package/introspect-mysql.d.ts +0 -9
  58. package/introspect-pg.d.ts +0 -12
package/serializer/mysqlSchema.d.ts CHANGED
@@ -227,7 +227,6 @@ declare const tableV4: import("zod").ZodObject<{
227
227
  }>;
228
228
  declare const table: import("zod").ZodObject<{
229
229
  name: import("zod").ZodString;
230
- schema: import("zod").ZodOptional<import("zod").ZodString>;
231
230
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
232
231
  name: import("zod").ZodString;
233
232
  type: import("zod").ZodString;
@@ -321,7 +320,6 @@ declare const table: import("zod").ZodObject<{
321
320
  columns: string[];
322
321
  }>>>;
323
322
  }, "strict", import("zod").ZodTypeAny, {
324
- schema?: string | undefined;
325
323
  name: string;
326
324
  columns: Record<string, {
327
325
  default?: any;
@@ -358,7 +356,6 @@ declare const table: import("zod").ZodObject<{
358
356
  columns: string[];
359
357
  }>;
360
358
  }, {
361
- schema?: string | undefined;
362
359
  uniqueConstraints?: Record<string, {
363
360
  name: string;
364
361
  columns: string[];
@@ -395,6 +392,37 @@ declare const table: import("zod").ZodObject<{
395
392
  columns: string[];
396
393
  }>;
397
394
  }>;
395
+ export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
396
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
397
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
398
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
399
+ }, "strip", import("zod").ZodTypeAny, {
400
+ isDefaultAnExpression?: boolean | undefined;
401
+ }, {
402
+ isDefaultAnExpression?: boolean | undefined;
403
+ }>>>;
404
+ }, "strip", import("zod").ZodTypeAny, {
405
+ columns: Record<string, {
406
+ isDefaultAnExpression?: boolean | undefined;
407
+ } | undefined>;
408
+ }, {
409
+ columns: Record<string, {
410
+ isDefaultAnExpression?: boolean | undefined;
411
+ } | undefined>;
412
+ }>>>;
413
+ }, "strip", import("zod").ZodTypeAny, {
414
+ tables: Record<string, {
415
+ columns: Record<string, {
416
+ isDefaultAnExpression?: boolean | undefined;
417
+ } | undefined>;
418
+ } | undefined>;
419
+ }, {
420
+ tables: Record<string, {
421
+ columns: Record<string, {
422
+ isDefaultAnExpression?: boolean | undefined;
423
+ } | undefined>;
424
+ } | undefined>;
425
+ }>>;
398
426
  declare const dialect: import("zod").ZodLiteral<"mysql">;
399
427
  export declare const schemaInternalV3: import("zod").ZodObject<{
400
428
  version: import("zod").ZodLiteral<"3">;
@@ -531,8 +559,6 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
531
559
  }>;
532
560
  }>>;
533
561
  }, "strict", import("zod").ZodTypeAny, {
534
- version: "3";
535
- dialect: "mysql";
536
562
  tables: Record<string, {
537
563
  name: string;
538
564
  columns: Record<string, {
@@ -562,9 +588,9 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
562
588
  columnsTo: string[];
563
589
  }>;
564
590
  }>;
565
- }, {
566
591
  version: "3";
567
592
  dialect: "mysql";
593
+ }, {
568
594
  tables: Record<string, {
569
595
  name: string;
570
596
  columns: Record<string, {
@@ -594,6 +620,8 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
594
620
  columnsTo: string[];
595
621
  }>;
596
622
  }>;
623
+ version: "3";
624
+ dialect: "mysql";
597
625
  }>;
598
626
  export declare const schemaInternalV4: import("zod").ZodObject<{
599
627
  version: import("zod").ZodLiteral<"4">;
@@ -734,8 +762,6 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
734
762
  }>>;
735
763
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
736
764
  }, "strict", import("zod").ZodTypeAny, {
737
- version: "4";
738
- dialect: "mysql";
739
765
  tables: Record<string, {
740
766
  schema?: string | undefined;
741
767
  name: string;
@@ -766,10 +792,10 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
766
792
  columnsTo: string[];
767
793
  }>;
768
794
  }>;
769
- schemas: Record<string, string>;
770
- }, {
771
795
  version: "4";
772
796
  dialect: "mysql";
797
+ schemas: Record<string, string>;
798
+ }, {
773
799
  tables: Record<string, {
774
800
  schema?: string | undefined;
775
801
  name: string;
@@ -800,45 +826,15 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
800
826
  columnsTo: string[];
801
827
  }>;
802
828
  }>;
829
+ version: "4";
830
+ dialect: "mysql";
803
831
  schemas: Record<string, string>;
804
832
  }>;
805
- export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
806
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
807
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
808
- isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
809
- }, "strip", import("zod").ZodTypeAny, {
810
- isDefaultAnExpression?: boolean | undefined;
811
- }, {
812
- isDefaultAnExpression?: boolean | undefined;
813
- }>>>;
814
- }, "strip", import("zod").ZodTypeAny, {
815
- columns: Record<string, {
816
- isDefaultAnExpression?: boolean | undefined;
817
- } | undefined>;
818
- }, {
819
- columns: Record<string, {
820
- isDefaultAnExpression?: boolean | undefined;
821
- } | undefined>;
822
- }>>>;
823
- }, "strip", import("zod").ZodTypeAny, {
824
- tables: Record<string, {
825
- columns: Record<string, {
826
- isDefaultAnExpression?: boolean | undefined;
827
- } | undefined>;
828
- } | undefined>;
829
- }, {
830
- tables: Record<string, {
831
- columns: Record<string, {
832
- isDefaultAnExpression?: boolean | undefined;
833
- } | undefined>;
834
- } | undefined>;
835
- }>>;
836
- export declare const schemaInternal: import("zod").ZodObject<{
833
+ export declare const schemaInternalV5: import("zod").ZodObject<{
837
834
  version: import("zod").ZodLiteral<"5">;
838
835
  dialect: import("zod").ZodLiteral<"mysql">;
839
836
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
840
837
  name: import("zod").ZodString;
841
- schema: import("zod").ZodOptional<import("zod").ZodString>;
842
838
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
843
839
  name: import("zod").ZodString;
844
840
  type: import("zod").ZodString;
@@ -932,7 +928,6 @@ export declare const schemaInternal: import("zod").ZodObject<{
932
928
  columns: string[];
933
929
  }>>>;
934
930
  }, "strict", import("zod").ZodTypeAny, {
935
- schema?: string | undefined;
936
931
  name: string;
937
932
  columns: Record<string, {
938
933
  default?: any;
@@ -969,7 +964,6 @@ export declare const schemaInternal: import("zod").ZodObject<{
969
964
  columns: string[];
970
965
  }>;
971
966
  }, {
972
- schema?: string | undefined;
973
967
  uniqueConstraints?: Record<string, {
974
968
  name: string;
975
969
  columns: string[];
@@ -1059,10 +1053,7 @@ export declare const schemaInternal: import("zod").ZodObject<{
1059
1053
  } | undefined>;
1060
1054
  } | undefined>;
1061
1055
  } | undefined;
1062
- version: "5";
1063
- dialect: "mysql";
1064
1056
  tables: Record<string, {
1065
- schema?: string | undefined;
1066
1057
  name: string;
1067
1058
  columns: Record<string, {
1068
1059
  default?: any;
@@ -1099,6 +1090,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
1099
1090
  columns: string[];
1100
1091
  }>;
1101
1092
  }>;
1093
+ version: "5";
1094
+ dialect: "mysql";
1102
1095
  schemas: Record<string, string>;
1103
1096
  _meta: {
1104
1097
  columns: Record<string, string>;
@@ -1113,10 +1106,7 @@ export declare const schemaInternal: import("zod").ZodObject<{
1113
1106
  } | undefined>;
1114
1107
  } | undefined>;
1115
1108
  } | undefined;
1116
- version: "5";
1117
- dialect: "mysql";
1118
1109
  tables: Record<string, {
1119
- schema?: string | undefined;
1120
1110
  uniqueConstraints?: Record<string, {
1121
1111
  name: string;
1122
1112
  columns: string[];
@@ -1153,6 +1143,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
1153
1143
  columns: string[];
1154
1144
  }>;
1155
1145
  }>;
1146
+ version: "5";
1147
+ dialect: "mysql";
1156
1148
  schemas: Record<string, string>;
1157
1149
  _meta: {
1158
1150
  columns: Record<string, string>;
@@ -1160,8 +1152,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
1160
1152
  schemas: Record<string, string>;
1161
1153
  };
1162
1154
  }>;
1163
- export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
1164
- version: import("zod").ZodLiteral<"3">;
1155
+ export declare const schemaInternal: import("zod").ZodObject<{
1156
+ version: import("zod").ZodLiteral<"5">;
1165
1157
  dialect: import("zod").ZodLiteral<"mysql">;
1166
1158
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1167
1159
  name: import("zod").ZodString;
@@ -1237,6 +1229,26 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1237
1229
  tableTo: string;
1238
1230
  columnsTo: string[];
1239
1231
  }>>;
1232
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1233
+ name: import("zod").ZodString;
1234
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1235
+ }, "strict", import("zod").ZodTypeAny, {
1236
+ name: string;
1237
+ columns: string[];
1238
+ }, {
1239
+ name: string;
1240
+ columns: string[];
1241
+ }>>;
1242
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1243
+ name: import("zod").ZodString;
1244
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1245
+ }, "strict", import("zod").ZodTypeAny, {
1246
+ name: string;
1247
+ columns: string[];
1248
+ }, {
1249
+ name: string;
1250
+ columns: string[];
1251
+ }>>>;
1240
1252
  }, "strict", import("zod").ZodTypeAny, {
1241
1253
  name: string;
1242
1254
  columns: Record<string, {
@@ -1265,7 +1277,19 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1265
1277
  tableTo: string;
1266
1278
  columnsTo: string[];
1267
1279
  }>;
1280
+ compositePrimaryKeys: Record<string, {
1281
+ name: string;
1282
+ columns: string[];
1283
+ }>;
1284
+ uniqueConstraints: Record<string, {
1285
+ name: string;
1286
+ columns: string[];
1287
+ }>;
1268
1288
  }, {
1289
+ uniqueConstraints?: Record<string, {
1290
+ name: string;
1291
+ columns: string[];
1292
+ }> | undefined;
1269
1293
  name: string;
1270
1294
  columns: Record<string, {
1271
1295
  default?: any;
@@ -1293,15 +1317,60 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1293
1317
  tableTo: string;
1294
1318
  columnsTo: string[];
1295
1319
  }>;
1320
+ compositePrimaryKeys: Record<string, {
1321
+ name: string;
1322
+ columns: string[];
1323
+ }>;
1296
1324
  }>>;
1297
- }, {
1298
- id: import("zod").ZodString;
1299
- prevId: import("zod").ZodString;
1300
- }>, "strip", import("zod").ZodTypeAny, {
1301
- id: string;
1302
- prevId: string;
1303
- version: "3";
1304
- dialect: "mysql";
1325
+ _meta: import("zod").ZodObject<{
1326
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1327
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1328
+ }, "strip", import("zod").ZodTypeAny, {
1329
+ columns: Record<string, string>;
1330
+ tables: Record<string, string>;
1331
+ }, {
1332
+ columns: Record<string, string>;
1333
+ tables: Record<string, string>;
1334
+ }>;
1335
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
1336
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1337
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1338
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
1339
+ }, "strip", import("zod").ZodTypeAny, {
1340
+ isDefaultAnExpression?: boolean | undefined;
1341
+ }, {
1342
+ isDefaultAnExpression?: boolean | undefined;
1343
+ }>>>;
1344
+ }, "strip", import("zod").ZodTypeAny, {
1345
+ columns: Record<string, {
1346
+ isDefaultAnExpression?: boolean | undefined;
1347
+ } | undefined>;
1348
+ }, {
1349
+ columns: Record<string, {
1350
+ isDefaultAnExpression?: boolean | undefined;
1351
+ } | undefined>;
1352
+ }>>>;
1353
+ }, "strip", import("zod").ZodTypeAny, {
1354
+ tables: Record<string, {
1355
+ columns: Record<string, {
1356
+ isDefaultAnExpression?: boolean | undefined;
1357
+ } | undefined>;
1358
+ } | undefined>;
1359
+ }, {
1360
+ tables: Record<string, {
1361
+ columns: Record<string, {
1362
+ isDefaultAnExpression?: boolean | undefined;
1363
+ } | undefined>;
1364
+ } | undefined>;
1365
+ }>>;
1366
+ }, "strict", import("zod").ZodTypeAny, {
1367
+ internal?: {
1368
+ tables: Record<string, {
1369
+ columns: Record<string, {
1370
+ isDefaultAnExpression?: boolean | undefined;
1371
+ } | undefined>;
1372
+ } | undefined>;
1373
+ } | undefined;
1305
1374
  tables: Record<string, {
1306
1375
  name: string;
1307
1376
  columns: Record<string, {
@@ -1330,13 +1399,34 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1330
1399
  tableTo: string;
1331
1400
  columnsTo: string[];
1332
1401
  }>;
1402
+ compositePrimaryKeys: Record<string, {
1403
+ name: string;
1404
+ columns: string[];
1405
+ }>;
1406
+ uniqueConstraints: Record<string, {
1407
+ name: string;
1408
+ columns: string[];
1409
+ }>;
1333
1410
  }>;
1334
- }, {
1335
- id: string;
1336
- prevId: string;
1337
- version: "3";
1411
+ version: "5";
1338
1412
  dialect: "mysql";
1413
+ _meta: {
1414
+ columns: Record<string, string>;
1415
+ tables: Record<string, string>;
1416
+ };
1417
+ }, {
1418
+ internal?: {
1419
+ tables: Record<string, {
1420
+ columns: Record<string, {
1421
+ isDefaultAnExpression?: boolean | undefined;
1422
+ } | undefined>;
1423
+ } | undefined>;
1424
+ } | undefined;
1339
1425
  tables: Record<string, {
1426
+ uniqueConstraints?: Record<string, {
1427
+ name: string;
1428
+ columns: string[];
1429
+ }> | undefined;
1340
1430
  name: string;
1341
1431
  columns: Record<string, {
1342
1432
  default?: any;
@@ -1364,14 +1454,23 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1364
1454
  tableTo: string;
1365
1455
  columnsTo: string[];
1366
1456
  }>;
1457
+ compositePrimaryKeys: Record<string, {
1458
+ name: string;
1459
+ columns: string[];
1460
+ }>;
1367
1461
  }>;
1462
+ version: "5";
1463
+ dialect: "mysql";
1464
+ _meta: {
1465
+ columns: Record<string, string>;
1466
+ tables: Record<string, string>;
1467
+ };
1368
1468
  }>;
1369
- export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
1370
- version: import("zod").ZodLiteral<"4">;
1469
+ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
1470
+ version: import("zod").ZodLiteral<"3">;
1371
1471
  dialect: import("zod").ZodLiteral<"mysql">;
1372
1472
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1373
1473
  name: import("zod").ZodString;
1374
- schema: import("zod").ZodOptional<import("zod").ZodString>;
1375
1474
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1376
1475
  name: import("zod").ZodString;
1377
1476
  type: import("zod").ZodString;
@@ -1445,7 +1544,6 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1445
1544
  columnsTo: string[];
1446
1545
  }>>;
1447
1546
  }, "strict", import("zod").ZodTypeAny, {
1448
- schema?: string | undefined;
1449
1547
  name: string;
1450
1548
  columns: Record<string, {
1451
1549
  default?: any;
@@ -1474,7 +1572,6 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1474
1572
  columnsTo: string[];
1475
1573
  }>;
1476
1574
  }, {
1477
- schema?: string | undefined;
1478
1575
  name: string;
1479
1576
  columns: Record<string, {
1480
1577
  default?: any;
@@ -1503,17 +1600,11 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1503
1600
  columnsTo: string[];
1504
1601
  }>;
1505
1602
  }>>;
1506
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1507
1603
  }, {
1508
1604
  id: import("zod").ZodString;
1509
1605
  prevId: import("zod").ZodString;
1510
1606
  }>, "strip", import("zod").ZodTypeAny, {
1511
- id: string;
1512
- prevId: string;
1513
- version: "4";
1514
- dialect: "mysql";
1515
1607
  tables: Record<string, {
1516
- schema?: string | undefined;
1517
1608
  name: string;
1518
1609
  columns: Record<string, {
1519
1610
  default?: any;
@@ -1542,14 +1633,12 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1542
1633
  columnsTo: string[];
1543
1634
  }>;
1544
1635
  }>;
1545
- schemas: Record<string, string>;
1546
- }, {
1547
1636
  id: string;
1548
1637
  prevId: string;
1549
- version: "4";
1638
+ version: "3";
1550
1639
  dialect: "mysql";
1640
+ }, {
1551
1641
  tables: Record<string, {
1552
- schema?: string | undefined;
1553
1642
  name: string;
1554
1643
  columns: Record<string, {
1555
1644
  default?: any;
@@ -1578,11 +1667,14 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1578
1667
  columnsTo: string[];
1579
1668
  }>;
1580
1669
  }>;
1581
- schemas: Record<string, string>;
1670
+ id: string;
1671
+ prevId: string;
1672
+ version: "3";
1673
+ dialect: "mysql";
1582
1674
  }>;
1583
- export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1584
- version: import("zod").ZodLiteral<"5">;
1585
- dialect: import("zod").ZodLiteral<"mysql">;
1675
+ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
1676
+ version: import("zod").ZodLiteral<"4">;
1677
+ dialect: import("zod").ZodLiteral<"mysql">;
1586
1678
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1587
1679
  name: import("zod").ZodString;
1588
1680
  schema: import("zod").ZodOptional<import("zod").ZodString>;
@@ -1658,6 +1750,219 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1658
1750
  tableTo: string;
1659
1751
  columnsTo: string[];
1660
1752
  }>>;
1753
+ }, "strict", import("zod").ZodTypeAny, {
1754
+ schema?: string | undefined;
1755
+ name: string;
1756
+ columns: Record<string, {
1757
+ default?: any;
1758
+ onUpdate?: any;
1759
+ autoincrement?: boolean | undefined;
1760
+ name: string;
1761
+ type: string;
1762
+ primaryKey: boolean;
1763
+ notNull: boolean;
1764
+ }>;
1765
+ indexes: Record<string, {
1766
+ using?: "btree" | "hash" | undefined;
1767
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1768
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1769
+ name: string;
1770
+ columns: string[];
1771
+ isUnique: boolean;
1772
+ }>;
1773
+ foreignKeys: Record<string, {
1774
+ onUpdate?: string | undefined;
1775
+ onDelete?: string | undefined;
1776
+ name: string;
1777
+ tableFrom: string;
1778
+ columnsFrom: string[];
1779
+ tableTo: string;
1780
+ columnsTo: string[];
1781
+ }>;
1782
+ }, {
1783
+ schema?: string | undefined;
1784
+ name: string;
1785
+ columns: Record<string, {
1786
+ default?: any;
1787
+ onUpdate?: any;
1788
+ autoincrement?: boolean | undefined;
1789
+ name: string;
1790
+ type: string;
1791
+ primaryKey: boolean;
1792
+ notNull: boolean;
1793
+ }>;
1794
+ indexes: Record<string, {
1795
+ using?: "btree" | "hash" | undefined;
1796
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1797
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1798
+ name: string;
1799
+ columns: string[];
1800
+ isUnique: boolean;
1801
+ }>;
1802
+ foreignKeys: Record<string, {
1803
+ onUpdate?: string | undefined;
1804
+ onDelete?: string | undefined;
1805
+ name: string;
1806
+ tableFrom: string;
1807
+ columnsFrom: string[];
1808
+ tableTo: string;
1809
+ columnsTo: string[];
1810
+ }>;
1811
+ }>>;
1812
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1813
+ }, {
1814
+ id: import("zod").ZodString;
1815
+ prevId: import("zod").ZodString;
1816
+ }>, "strip", import("zod").ZodTypeAny, {
1817
+ tables: Record<string, {
1818
+ schema?: string | undefined;
1819
+ name: string;
1820
+ columns: Record<string, {
1821
+ default?: any;
1822
+ onUpdate?: any;
1823
+ autoincrement?: boolean | undefined;
1824
+ name: string;
1825
+ type: string;
1826
+ primaryKey: boolean;
1827
+ notNull: boolean;
1828
+ }>;
1829
+ indexes: Record<string, {
1830
+ using?: "btree" | "hash" | undefined;
1831
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1832
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1833
+ name: string;
1834
+ columns: string[];
1835
+ isUnique: boolean;
1836
+ }>;
1837
+ foreignKeys: Record<string, {
1838
+ onUpdate?: string | undefined;
1839
+ onDelete?: string | undefined;
1840
+ name: string;
1841
+ tableFrom: string;
1842
+ columnsFrom: string[];
1843
+ tableTo: string;
1844
+ columnsTo: string[];
1845
+ }>;
1846
+ }>;
1847
+ id: string;
1848
+ prevId: string;
1849
+ version: "4";
1850
+ dialect: "mysql";
1851
+ schemas: Record<string, string>;
1852
+ }, {
1853
+ tables: Record<string, {
1854
+ schema?: string | undefined;
1855
+ name: string;
1856
+ columns: Record<string, {
1857
+ default?: any;
1858
+ onUpdate?: any;
1859
+ autoincrement?: boolean | undefined;
1860
+ name: string;
1861
+ type: string;
1862
+ primaryKey: boolean;
1863
+ notNull: boolean;
1864
+ }>;
1865
+ indexes: Record<string, {
1866
+ using?: "btree" | "hash" | undefined;
1867
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1868
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1869
+ name: string;
1870
+ columns: string[];
1871
+ isUnique: boolean;
1872
+ }>;
1873
+ foreignKeys: Record<string, {
1874
+ onUpdate?: string | undefined;
1875
+ onDelete?: string | undefined;
1876
+ name: string;
1877
+ tableFrom: string;
1878
+ columnsFrom: string[];
1879
+ tableTo: string;
1880
+ columnsTo: string[];
1881
+ }>;
1882
+ }>;
1883
+ id: string;
1884
+ prevId: string;
1885
+ version: "4";
1886
+ dialect: "mysql";
1887
+ schemas: Record<string, string>;
1888
+ }>;
1889
+ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape<{
1890
+ version: import("zod").ZodLiteral<"5">;
1891
+ dialect: import("zod").ZodLiteral<"mysql">;
1892
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1893
+ name: import("zod").ZodString;
1894
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1895
+ name: import("zod").ZodString;
1896
+ type: import("zod").ZodString;
1897
+ primaryKey: import("zod").ZodBoolean;
1898
+ notNull: import("zod").ZodBoolean;
1899
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1900
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1901
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
1902
+ }, "strict", import("zod").ZodTypeAny, {
1903
+ default?: any;
1904
+ onUpdate?: any;
1905
+ autoincrement?: boolean | undefined;
1906
+ name: string;
1907
+ type: string;
1908
+ primaryKey: boolean;
1909
+ notNull: boolean;
1910
+ }, {
1911
+ default?: any;
1912
+ onUpdate?: any;
1913
+ autoincrement?: boolean | undefined;
1914
+ name: string;
1915
+ type: string;
1916
+ primaryKey: boolean;
1917
+ notNull: boolean;
1918
+ }>>;
1919
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1920
+ name: import("zod").ZodString;
1921
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1922
+ isUnique: import("zod").ZodBoolean;
1923
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
1924
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
1925
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
1926
+ }, "strict", import("zod").ZodTypeAny, {
1927
+ using?: "btree" | "hash" | undefined;
1928
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1929
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1930
+ name: string;
1931
+ columns: string[];
1932
+ isUnique: boolean;
1933
+ }, {
1934
+ using?: "btree" | "hash" | undefined;
1935
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1936
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1937
+ name: string;
1938
+ columns: string[];
1939
+ isUnique: boolean;
1940
+ }>>;
1941
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1942
+ name: import("zod").ZodString;
1943
+ tableFrom: import("zod").ZodString;
1944
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1945
+ tableTo: import("zod").ZodString;
1946
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1947
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1948
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1949
+ }, "strict", import("zod").ZodTypeAny, {
1950
+ onUpdate?: string | undefined;
1951
+ onDelete?: string | undefined;
1952
+ name: string;
1953
+ tableFrom: string;
1954
+ columnsFrom: string[];
1955
+ tableTo: string;
1956
+ columnsTo: string[];
1957
+ }, {
1958
+ onUpdate?: string | undefined;
1959
+ onDelete?: string | undefined;
1960
+ name: string;
1961
+ tableFrom: string;
1962
+ columnsFrom: string[];
1963
+ tableTo: string;
1964
+ columnsTo: string[];
1965
+ }>>;
1661
1966
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1662
1967
  name: import("zod").ZodString;
1663
1968
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
@@ -1679,7 +1984,6 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1679
1984
  columns: string[];
1680
1985
  }>>>;
1681
1986
  }, "strict", import("zod").ZodTypeAny, {
1682
- schema?: string | undefined;
1683
1987
  name: string;
1684
1988
  columns: Record<string, {
1685
1989
  default?: any;
@@ -1716,7 +2020,6 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1716
2020
  columns: string[];
1717
2021
  }>;
1718
2022
  }, {
1719
- schema?: string | undefined;
1720
2023
  uniqueConstraints?: Record<string, {
1721
2024
  name: string;
1722
2025
  columns: string[];
@@ -1809,12 +2112,7 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1809
2112
  } | undefined>;
1810
2113
  } | undefined>;
1811
2114
  } | undefined;
1812
- id: string;
1813
- prevId: string;
1814
- version: "5";
1815
- dialect: "mysql";
1816
2115
  tables: Record<string, {
1817
- schema?: string | undefined;
1818
2116
  name: string;
1819
2117
  columns: Record<string, {
1820
2118
  default?: any;
@@ -1851,6 +2149,10 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1851
2149
  columns: string[];
1852
2150
  }>;
1853
2151
  }>;
2152
+ id: string;
2153
+ prevId: string;
2154
+ version: "5";
2155
+ dialect: "mysql";
1854
2156
  schemas: Record<string, string>;
1855
2157
  _meta: {
1856
2158
  columns: Record<string, string>;
@@ -1865,12 +2167,7 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1865
2167
  } | undefined>;
1866
2168
  } | undefined>;
1867
2169
  } | undefined;
1868
- id: string;
1869
- prevId: string;
1870
- version: "5";
1871
- dialect: "mysql";
1872
2170
  tables: Record<string, {
1873
- schema?: string | undefined;
1874
2171
  uniqueConstraints?: Record<string, {
1875
2172
  name: string;
1876
2173
  columns: string[];
@@ -1907,6 +2204,10 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1907
2204
  columns: string[];
1908
2205
  }>;
1909
2206
  }>;
2207
+ id: string;
2208
+ prevId: string;
2209
+ version: "5";
2210
+ dialect: "mysql";
1910
2211
  schemas: Record<string, string>;
1911
2212
  _meta: {
1912
2213
  columns: Record<string, string>;
@@ -1914,253 +2215,11 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1914
2215
  schemas: Record<string, string>;
1915
2216
  };
1916
2217
  }>;
1917
- export declare const schemaSquashed: import("zod").ZodObject<{
2218
+ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1918
2219
  version: import("zod").ZodLiteral<"5">;
1919
2220
  dialect: import("zod").ZodLiteral<"mysql">;
1920
2221
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1921
2222
  name: import("zod").ZodString;
1922
- schema: import("zod").ZodOptional<import("zod").ZodString>;
1923
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1924
- name: import("zod").ZodString;
1925
- type: import("zod").ZodString;
1926
- primaryKey: import("zod").ZodBoolean;
1927
- notNull: import("zod").ZodBoolean;
1928
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1929
- default: import("zod").ZodOptional<import("zod").ZodAny>;
1930
- onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
1931
- }, "strict", import("zod").ZodTypeAny, {
1932
- default?: any;
1933
- onUpdate?: any;
1934
- autoincrement?: boolean | undefined;
1935
- name: string;
1936
- type: string;
1937
- primaryKey: boolean;
1938
- notNull: boolean;
1939
- }, {
1940
- default?: any;
1941
- onUpdate?: any;
1942
- autoincrement?: boolean | undefined;
1943
- name: string;
1944
- type: string;
1945
- primaryKey: boolean;
1946
- notNull: boolean;
1947
- }>>;
1948
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1949
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1950
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1951
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
1952
- }, "strict", import("zod").ZodTypeAny, {
1953
- schema?: string | undefined;
1954
- name: string;
1955
- columns: Record<string, {
1956
- default?: any;
1957
- onUpdate?: any;
1958
- autoincrement?: boolean | undefined;
1959
- name: string;
1960
- type: string;
1961
- primaryKey: boolean;
1962
- notNull: boolean;
1963
- }>;
1964
- indexes: Record<string, string>;
1965
- foreignKeys: Record<string, string>;
1966
- compositePrimaryKeys: Record<string, string>;
1967
- uniqueConstraints: Record<string, string>;
1968
- }, {
1969
- schema?: string | undefined;
1970
- uniqueConstraints?: Record<string, string> | undefined;
1971
- name: string;
1972
- columns: Record<string, {
1973
- default?: any;
1974
- onUpdate?: any;
1975
- autoincrement?: boolean | undefined;
1976
- name: string;
1977
- type: string;
1978
- primaryKey: boolean;
1979
- notNull: boolean;
1980
- }>;
1981
- indexes: Record<string, string>;
1982
- foreignKeys: Record<string, string>;
1983
- compositePrimaryKeys: Record<string, string>;
1984
- }>>;
1985
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1986
- }, "strict", import("zod").ZodTypeAny, {
1987
- version: "5";
1988
- dialect: "mysql";
1989
- tables: Record<string, {
1990
- schema?: string | undefined;
1991
- name: string;
1992
- columns: Record<string, {
1993
- default?: any;
1994
- onUpdate?: any;
1995
- autoincrement?: boolean | undefined;
1996
- name: string;
1997
- type: string;
1998
- primaryKey: boolean;
1999
- notNull: boolean;
2000
- }>;
2001
- indexes: Record<string, string>;
2002
- foreignKeys: Record<string, string>;
2003
- compositePrimaryKeys: Record<string, string>;
2004
- uniqueConstraints: Record<string, string>;
2005
- }>;
2006
- schemas: Record<string, string>;
2007
- }, {
2008
- version: "5";
2009
- dialect: "mysql";
2010
- tables: Record<string, {
2011
- schema?: string | undefined;
2012
- uniqueConstraints?: Record<string, string> | undefined;
2013
- name: string;
2014
- columns: Record<string, {
2015
- default?: any;
2016
- onUpdate?: any;
2017
- autoincrement?: boolean | undefined;
2018
- name: string;
2019
- type: string;
2020
- primaryKey: boolean;
2021
- notNull: boolean;
2022
- }>;
2023
- indexes: Record<string, string>;
2024
- foreignKeys: Record<string, string>;
2025
- compositePrimaryKeys: Record<string, string>;
2026
- }>;
2027
- schemas: Record<string, string>;
2028
- }>;
2029
- export declare const schemaSquashedV4: import("zod").ZodObject<{
2030
- version: import("zod").ZodLiteral<"4">;
2031
- dialect: import("zod").ZodLiteral<"mysql">;
2032
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2033
- name: import("zod").ZodString;
2034
- schema: import("zod").ZodOptional<import("zod").ZodString>;
2035
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2036
- name: import("zod").ZodString;
2037
- type: import("zod").ZodString;
2038
- primaryKey: import("zod").ZodBoolean;
2039
- notNull: import("zod").ZodBoolean;
2040
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2041
- default: import("zod").ZodOptional<import("zod").ZodAny>;
2042
- onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2043
- }, "strict", import("zod").ZodTypeAny, {
2044
- default?: any;
2045
- onUpdate?: any;
2046
- autoincrement?: boolean | undefined;
2047
- name: string;
2048
- type: string;
2049
- primaryKey: boolean;
2050
- notNull: boolean;
2051
- }, {
2052
- default?: any;
2053
- onUpdate?: any;
2054
- autoincrement?: boolean | undefined;
2055
- name: string;
2056
- type: string;
2057
- primaryKey: boolean;
2058
- notNull: boolean;
2059
- }>>;
2060
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2061
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2062
- }, "strict", import("zod").ZodTypeAny, {
2063
- schema?: string | undefined;
2064
- name: string;
2065
- columns: Record<string, {
2066
- default?: any;
2067
- onUpdate?: any;
2068
- autoincrement?: boolean | undefined;
2069
- name: string;
2070
- type: string;
2071
- primaryKey: boolean;
2072
- notNull: boolean;
2073
- }>;
2074
- indexes: Record<string, string>;
2075
- foreignKeys: Record<string, string>;
2076
- }, {
2077
- schema?: string | undefined;
2078
- name: string;
2079
- columns: Record<string, {
2080
- default?: any;
2081
- onUpdate?: any;
2082
- autoincrement?: boolean | undefined;
2083
- name: string;
2084
- type: string;
2085
- primaryKey: boolean;
2086
- notNull: boolean;
2087
- }>;
2088
- indexes: Record<string, string>;
2089
- foreignKeys: Record<string, string>;
2090
- }>>;
2091
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2092
- }, "strict", import("zod").ZodTypeAny, {
2093
- version: "4";
2094
- dialect: "mysql";
2095
- tables: Record<string, {
2096
- schema?: string | undefined;
2097
- name: string;
2098
- columns: Record<string, {
2099
- default?: any;
2100
- onUpdate?: any;
2101
- autoincrement?: boolean | undefined;
2102
- name: string;
2103
- type: string;
2104
- primaryKey: boolean;
2105
- notNull: boolean;
2106
- }>;
2107
- indexes: Record<string, string>;
2108
- foreignKeys: Record<string, string>;
2109
- }>;
2110
- schemas: Record<string, string>;
2111
- }, {
2112
- version: "4";
2113
- dialect: "mysql";
2114
- tables: Record<string, {
2115
- schema?: string | undefined;
2116
- name: string;
2117
- columns: Record<string, {
2118
- default?: any;
2119
- onUpdate?: any;
2120
- autoincrement?: boolean | undefined;
2121
- name: string;
2122
- type: string;
2123
- primaryKey: boolean;
2124
- notNull: boolean;
2125
- }>;
2126
- indexes: Record<string, string>;
2127
- foreignKeys: Record<string, string>;
2128
- }>;
2129
- schemas: Record<string, string>;
2130
- }>;
2131
- export type Dialect = TypeOf<typeof dialect>;
2132
- export type Column = TypeOf<typeof column>;
2133
- export type Table = TypeOf<typeof table>;
2134
- export type TableV4 = TypeOf<typeof tableV4>;
2135
- export type MySqlSchema = TypeOf<typeof schema>;
2136
- export type MySqlSchemaV3 = TypeOf<typeof schemaV3>;
2137
- export type MySqlSchemaV4 = TypeOf<typeof schemaV4>;
2138
- export type MySqlSchemaInternal = TypeOf<typeof schemaInternal>;
2139
- export type MySqlKitInternals = TypeOf<typeof kitInternals>;
2140
- export type MySqlSchemaSquashed = TypeOf<typeof schemaSquashed>;
2141
- export type MySqlSchemaSquashedV4 = TypeOf<typeof schemaSquashedV4>;
2142
- export type Index = TypeOf<typeof index>;
2143
- export type ForeignKey = TypeOf<typeof fk>;
2144
- export type PrimaryKey = TypeOf<typeof compositePK>;
2145
- export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
2146
- export declare const MySqlSquasher: {
2147
- squashIdx: (idx: Index) => string;
2148
- unsquashIdx: (input: string) => Index;
2149
- squashPK: (pk: PrimaryKey) => string;
2150
- unsquashPK: (pk: string) => PrimaryKey;
2151
- squashUnique: (unq: UniqueConstraint) => string;
2152
- unsquashUnique: (unq: string) => UniqueConstraint;
2153
- squashFK: (fk: ForeignKey) => string;
2154
- unsquashFK: (input: string) => ForeignKey;
2155
- };
2156
- export declare const squashMysqlSchemeV4: (json: MySqlSchemaV4) => MySqlSchemaSquashedV4;
2157
- export declare const squashMysqlScheme: (json: MySqlSchema) => MySqlSchemaSquashed;
2158
- export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendShape<{
2159
- version: import("zod").ZodLiteral<"5">;
2160
- dialect: import("zod").ZodLiteral<"mysql">;
2161
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2162
- name: import("zod").ZodString;
2163
- schema: import("zod").ZodOptional<import("zod").ZodString>;
2164
2223
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2165
2224
  name: import("zod").ZodString;
2166
2225
  type: import("zod").ZodString;
@@ -2254,7 +2313,6 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2254
2313
  columns: string[];
2255
2314
  }>>>;
2256
2315
  }, "strict", import("zod").ZodTypeAny, {
2257
- schema?: string | undefined;
2258
2316
  name: string;
2259
2317
  columns: Record<string, {
2260
2318
  default?: any;
@@ -2291,7 +2349,6 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2291
2349
  columns: string[];
2292
2350
  }>;
2293
2351
  }, {
2294
- schema?: string | undefined;
2295
2352
  uniqueConstraints?: Record<string, {
2296
2353
  name: string;
2297
2354
  columns: string[];
@@ -2328,19 +2385,15 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2328
2385
  columns: string[];
2329
2386
  }>;
2330
2387
  }>>;
2331
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2332
2388
  _meta: import("zod").ZodObject<{
2333
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2334
2389
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2335
2390
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2336
2391
  }, "strip", import("zod").ZodTypeAny, {
2337
2392
  columns: Record<string, string>;
2338
2393
  tables: Record<string, string>;
2339
- schemas: Record<string, string>;
2340
2394
  }, {
2341
2395
  columns: Record<string, string>;
2342
2396
  tables: Record<string, string>;
2343
- schemas: Record<string, string>;
2344
2397
  }>;
2345
2398
  internal: import("zod").ZodOptional<import("zod").ZodObject<{
2346
2399
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
@@ -2384,12 +2437,7 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2384
2437
  } | undefined>;
2385
2438
  } | undefined>;
2386
2439
  } | undefined;
2387
- id: string;
2388
- prevId: string;
2389
- version: "5";
2390
- dialect: "mysql";
2391
2440
  tables: Record<string, {
2392
- schema?: string | undefined;
2393
2441
  name: string;
2394
2442
  columns: Record<string, {
2395
2443
  default?: any;
@@ -2426,11 +2474,13 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2426
2474
  columns: string[];
2427
2475
  }>;
2428
2476
  }>;
2429
- schemas: Record<string, string>;
2477
+ id: string;
2478
+ prevId: string;
2479
+ version: "5";
2480
+ dialect: "mysql";
2430
2481
  _meta: {
2431
2482
  columns: Record<string, string>;
2432
2483
  tables: Record<string, string>;
2433
- schemas: Record<string, string>;
2434
2484
  };
2435
2485
  }, {
2436
2486
  internal?: {
@@ -2440,12 +2490,7 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2440
2490
  } | undefined>;
2441
2491
  } | undefined>;
2442
2492
  } | undefined;
2443
- id: string;
2444
- prevId: string;
2445
- version: "5";
2446
- dialect: "mysql";
2447
2493
  tables: Record<string, {
2448
- schema?: string | undefined;
2449
2494
  uniqueConstraints?: Record<string, {
2450
2495
  name: string;
2451
2496
  columns: string[];
@@ -2482,19 +2527,575 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2482
2527
  columns: string[];
2483
2528
  }>;
2484
2529
  }>;
2485
- schemas: Record<string, string>;
2530
+ id: string;
2531
+ prevId: string;
2532
+ version: "5";
2533
+ dialect: "mysql";
2486
2534
  _meta: {
2487
2535
  columns: Record<string, string>;
2488
2536
  tables: Record<string, string>;
2489
- schemas: Record<string, string>;
2490
2537
  };
2491
2538
  }>;
2492
- export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
2493
- version: import("zod").ZodLiteral<"4">;
2539
+ export declare const schemaSquashed: import("zod").ZodObject<{
2540
+ version: import("zod").ZodLiteral<"5">;
2541
+ dialect: import("zod").ZodLiteral<"mysql">;
2542
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2543
+ name: import("zod").ZodString;
2544
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2545
+ name: import("zod").ZodString;
2546
+ type: import("zod").ZodString;
2547
+ primaryKey: import("zod").ZodBoolean;
2548
+ notNull: import("zod").ZodBoolean;
2549
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2550
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2551
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2552
+ }, "strict", import("zod").ZodTypeAny, {
2553
+ default?: any;
2554
+ onUpdate?: any;
2555
+ autoincrement?: boolean | undefined;
2556
+ name: string;
2557
+ type: string;
2558
+ primaryKey: boolean;
2559
+ notNull: boolean;
2560
+ }, {
2561
+ default?: any;
2562
+ onUpdate?: any;
2563
+ autoincrement?: boolean | undefined;
2564
+ name: string;
2565
+ type: string;
2566
+ primaryKey: boolean;
2567
+ notNull: boolean;
2568
+ }>>;
2569
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2570
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2571
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2572
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
2573
+ }, "strict", import("zod").ZodTypeAny, {
2574
+ name: string;
2575
+ columns: Record<string, {
2576
+ default?: any;
2577
+ onUpdate?: any;
2578
+ autoincrement?: boolean | undefined;
2579
+ name: string;
2580
+ type: string;
2581
+ primaryKey: boolean;
2582
+ notNull: boolean;
2583
+ }>;
2584
+ indexes: Record<string, string>;
2585
+ foreignKeys: Record<string, string>;
2586
+ compositePrimaryKeys: Record<string, string>;
2587
+ uniqueConstraints: Record<string, string>;
2588
+ }, {
2589
+ uniqueConstraints?: Record<string, string> | undefined;
2590
+ name: string;
2591
+ columns: Record<string, {
2592
+ default?: any;
2593
+ onUpdate?: any;
2594
+ autoincrement?: boolean | undefined;
2595
+ name: string;
2596
+ type: string;
2597
+ primaryKey: boolean;
2598
+ notNull: boolean;
2599
+ }>;
2600
+ indexes: Record<string, string>;
2601
+ foreignKeys: Record<string, string>;
2602
+ compositePrimaryKeys: Record<string, string>;
2603
+ }>>;
2604
+ }, "strict", import("zod").ZodTypeAny, {
2605
+ tables: Record<string, {
2606
+ name: string;
2607
+ columns: Record<string, {
2608
+ default?: any;
2609
+ onUpdate?: any;
2610
+ autoincrement?: boolean | undefined;
2611
+ name: string;
2612
+ type: string;
2613
+ primaryKey: boolean;
2614
+ notNull: boolean;
2615
+ }>;
2616
+ indexes: Record<string, string>;
2617
+ foreignKeys: Record<string, string>;
2618
+ compositePrimaryKeys: Record<string, string>;
2619
+ uniqueConstraints: Record<string, string>;
2620
+ }>;
2621
+ version: "5";
2622
+ dialect: "mysql";
2623
+ }, {
2624
+ tables: Record<string, {
2625
+ uniqueConstraints?: Record<string, string> | undefined;
2626
+ name: string;
2627
+ columns: Record<string, {
2628
+ default?: any;
2629
+ onUpdate?: any;
2630
+ autoincrement?: boolean | undefined;
2631
+ name: string;
2632
+ type: string;
2633
+ primaryKey: boolean;
2634
+ notNull: boolean;
2635
+ }>;
2636
+ indexes: Record<string, string>;
2637
+ foreignKeys: Record<string, string>;
2638
+ compositePrimaryKeys: Record<string, string>;
2639
+ }>;
2640
+ version: "5";
2641
+ dialect: "mysql";
2642
+ }>;
2643
+ export declare const schemaSquashedV4: import("zod").ZodObject<{
2644
+ version: import("zod").ZodLiteral<"4">;
2645
+ dialect: import("zod").ZodLiteral<"mysql">;
2646
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2647
+ name: import("zod").ZodString;
2648
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
2649
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2650
+ name: import("zod").ZodString;
2651
+ type: import("zod").ZodString;
2652
+ primaryKey: import("zod").ZodBoolean;
2653
+ notNull: import("zod").ZodBoolean;
2654
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2655
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2656
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2657
+ }, "strict", import("zod").ZodTypeAny, {
2658
+ default?: any;
2659
+ onUpdate?: any;
2660
+ autoincrement?: boolean | undefined;
2661
+ name: string;
2662
+ type: string;
2663
+ primaryKey: boolean;
2664
+ notNull: boolean;
2665
+ }, {
2666
+ default?: any;
2667
+ onUpdate?: any;
2668
+ autoincrement?: boolean | undefined;
2669
+ name: string;
2670
+ type: string;
2671
+ primaryKey: boolean;
2672
+ notNull: boolean;
2673
+ }>>;
2674
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2675
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2676
+ }, "strict", import("zod").ZodTypeAny, {
2677
+ schema?: string | undefined;
2678
+ name: string;
2679
+ columns: Record<string, {
2680
+ default?: any;
2681
+ onUpdate?: any;
2682
+ autoincrement?: boolean | undefined;
2683
+ name: string;
2684
+ type: string;
2685
+ primaryKey: boolean;
2686
+ notNull: boolean;
2687
+ }>;
2688
+ indexes: Record<string, string>;
2689
+ foreignKeys: Record<string, string>;
2690
+ }, {
2691
+ schema?: string | undefined;
2692
+ name: string;
2693
+ columns: Record<string, {
2694
+ default?: any;
2695
+ onUpdate?: any;
2696
+ autoincrement?: boolean | undefined;
2697
+ name: string;
2698
+ type: string;
2699
+ primaryKey: boolean;
2700
+ notNull: boolean;
2701
+ }>;
2702
+ indexes: Record<string, string>;
2703
+ foreignKeys: Record<string, string>;
2704
+ }>>;
2705
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2706
+ }, "strict", import("zod").ZodTypeAny, {
2707
+ tables: Record<string, {
2708
+ schema?: string | undefined;
2709
+ name: string;
2710
+ columns: Record<string, {
2711
+ default?: any;
2712
+ onUpdate?: any;
2713
+ autoincrement?: boolean | undefined;
2714
+ name: string;
2715
+ type: string;
2716
+ primaryKey: boolean;
2717
+ notNull: boolean;
2718
+ }>;
2719
+ indexes: Record<string, string>;
2720
+ foreignKeys: Record<string, string>;
2721
+ }>;
2722
+ version: "4";
2723
+ dialect: "mysql";
2724
+ schemas: Record<string, string>;
2725
+ }, {
2726
+ tables: Record<string, {
2727
+ schema?: string | undefined;
2728
+ name: string;
2729
+ columns: Record<string, {
2730
+ default?: any;
2731
+ onUpdate?: any;
2732
+ autoincrement?: boolean | undefined;
2733
+ name: string;
2734
+ type: string;
2735
+ primaryKey: boolean;
2736
+ notNull: boolean;
2737
+ }>;
2738
+ indexes: Record<string, string>;
2739
+ foreignKeys: Record<string, string>;
2740
+ }>;
2741
+ version: "4";
2742
+ dialect: "mysql";
2743
+ schemas: Record<string, string>;
2744
+ }>;
2745
+ export type Dialect = TypeOf<typeof dialect>;
2746
+ export type Column = TypeOf<typeof column>;
2747
+ export type Table = TypeOf<typeof table>;
2748
+ export type TableV4 = TypeOf<typeof tableV4>;
2749
+ export type MySqlSchema = TypeOf<typeof schema>;
2750
+ export type MySqlSchemaV3 = TypeOf<typeof schemaV3>;
2751
+ export type MySqlSchemaV4 = TypeOf<typeof schemaV4>;
2752
+ export type MySqlSchemaV5 = TypeOf<typeof schemaV5>;
2753
+ export type MySqlSchemaInternal = TypeOf<typeof schemaInternal>;
2754
+ export type MySqlKitInternals = TypeOf<typeof kitInternals>;
2755
+ export type MySqlSchemaSquashed = TypeOf<typeof schemaSquashed>;
2756
+ export type MySqlSchemaSquashedV4 = TypeOf<typeof schemaSquashedV4>;
2757
+ export type Index = TypeOf<typeof index>;
2758
+ export type ForeignKey = TypeOf<typeof fk>;
2759
+ export type PrimaryKey = TypeOf<typeof compositePK>;
2760
+ export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
2761
+ export declare const MySqlSquasher: {
2762
+ squashIdx: (idx: Index) => string;
2763
+ unsquashIdx: (input: string) => Index;
2764
+ squashPK: (pk: PrimaryKey) => string;
2765
+ unsquashPK: (pk: string) => PrimaryKey;
2766
+ squashUnique: (unq: UniqueConstraint) => string;
2767
+ unsquashUnique: (unq: string) => UniqueConstraint;
2768
+ squashFK: (fk: ForeignKey) => string;
2769
+ unsquashFK: (input: string) => ForeignKey;
2770
+ };
2771
+ export declare const squashMysqlSchemeV4: (json: MySqlSchemaV4) => MySqlSchemaSquashedV4;
2772
+ export declare const squashMysqlScheme: (json: MySqlSchema) => MySqlSchemaSquashed;
2773
+ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendShape<{
2774
+ version: import("zod").ZodLiteral<"5">;
2775
+ dialect: import("zod").ZodLiteral<"mysql">;
2776
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2777
+ name: import("zod").ZodString;
2778
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2779
+ name: import("zod").ZodString;
2780
+ type: import("zod").ZodString;
2781
+ primaryKey: import("zod").ZodBoolean;
2782
+ notNull: import("zod").ZodBoolean;
2783
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2784
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2785
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2786
+ }, "strict", import("zod").ZodTypeAny, {
2787
+ default?: any;
2788
+ onUpdate?: any;
2789
+ autoincrement?: boolean | undefined;
2790
+ name: string;
2791
+ type: string;
2792
+ primaryKey: boolean;
2793
+ notNull: boolean;
2794
+ }, {
2795
+ default?: any;
2796
+ onUpdate?: any;
2797
+ autoincrement?: boolean | undefined;
2798
+ name: string;
2799
+ type: string;
2800
+ primaryKey: boolean;
2801
+ notNull: boolean;
2802
+ }>>;
2803
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2804
+ name: import("zod").ZodString;
2805
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2806
+ isUnique: import("zod").ZodBoolean;
2807
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2808
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2809
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2810
+ }, "strict", import("zod").ZodTypeAny, {
2811
+ using?: "btree" | "hash" | undefined;
2812
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2813
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2814
+ name: string;
2815
+ columns: string[];
2816
+ isUnique: boolean;
2817
+ }, {
2818
+ using?: "btree" | "hash" | undefined;
2819
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2820
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2821
+ name: string;
2822
+ columns: string[];
2823
+ isUnique: boolean;
2824
+ }>>;
2825
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2826
+ name: import("zod").ZodString;
2827
+ tableFrom: import("zod").ZodString;
2828
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2829
+ tableTo: import("zod").ZodString;
2830
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2831
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2832
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2833
+ }, "strict", import("zod").ZodTypeAny, {
2834
+ onUpdate?: string | undefined;
2835
+ onDelete?: string | undefined;
2836
+ name: string;
2837
+ tableFrom: string;
2838
+ columnsFrom: string[];
2839
+ tableTo: string;
2840
+ columnsTo: string[];
2841
+ }, {
2842
+ onUpdate?: string | undefined;
2843
+ onDelete?: string | undefined;
2844
+ name: string;
2845
+ tableFrom: string;
2846
+ columnsFrom: string[];
2847
+ tableTo: string;
2848
+ columnsTo: string[];
2849
+ }>>;
2850
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2851
+ name: import("zod").ZodString;
2852
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2853
+ }, "strict", import("zod").ZodTypeAny, {
2854
+ name: string;
2855
+ columns: string[];
2856
+ }, {
2857
+ name: string;
2858
+ columns: string[];
2859
+ }>>;
2860
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2861
+ name: import("zod").ZodString;
2862
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2863
+ }, "strict", import("zod").ZodTypeAny, {
2864
+ name: string;
2865
+ columns: string[];
2866
+ }, {
2867
+ name: string;
2868
+ columns: string[];
2869
+ }>>>;
2870
+ }, "strict", import("zod").ZodTypeAny, {
2871
+ name: string;
2872
+ columns: Record<string, {
2873
+ default?: any;
2874
+ onUpdate?: any;
2875
+ autoincrement?: boolean | undefined;
2876
+ name: string;
2877
+ type: string;
2878
+ primaryKey: boolean;
2879
+ notNull: boolean;
2880
+ }>;
2881
+ indexes: Record<string, {
2882
+ using?: "btree" | "hash" | undefined;
2883
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2884
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2885
+ name: string;
2886
+ columns: string[];
2887
+ isUnique: boolean;
2888
+ }>;
2889
+ foreignKeys: Record<string, {
2890
+ onUpdate?: string | undefined;
2891
+ onDelete?: string | undefined;
2892
+ name: string;
2893
+ tableFrom: string;
2894
+ columnsFrom: string[];
2895
+ tableTo: string;
2896
+ columnsTo: string[];
2897
+ }>;
2898
+ compositePrimaryKeys: Record<string, {
2899
+ name: string;
2900
+ columns: string[];
2901
+ }>;
2902
+ uniqueConstraints: Record<string, {
2903
+ name: string;
2904
+ columns: string[];
2905
+ }>;
2906
+ }, {
2907
+ uniqueConstraints?: Record<string, {
2908
+ name: string;
2909
+ columns: string[];
2910
+ }> | undefined;
2911
+ name: string;
2912
+ columns: Record<string, {
2913
+ default?: any;
2914
+ onUpdate?: any;
2915
+ autoincrement?: boolean | undefined;
2916
+ name: string;
2917
+ type: string;
2918
+ primaryKey: boolean;
2919
+ notNull: boolean;
2920
+ }>;
2921
+ indexes: Record<string, {
2922
+ using?: "btree" | "hash" | undefined;
2923
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2924
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2925
+ name: string;
2926
+ columns: string[];
2927
+ isUnique: boolean;
2928
+ }>;
2929
+ foreignKeys: Record<string, {
2930
+ onUpdate?: string | undefined;
2931
+ onDelete?: string | undefined;
2932
+ name: string;
2933
+ tableFrom: string;
2934
+ columnsFrom: string[];
2935
+ tableTo: string;
2936
+ columnsTo: string[];
2937
+ }>;
2938
+ compositePrimaryKeys: Record<string, {
2939
+ name: string;
2940
+ columns: string[];
2941
+ }>;
2942
+ }>>;
2943
+ _meta: import("zod").ZodObject<{
2944
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2945
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2946
+ }, "strip", import("zod").ZodTypeAny, {
2947
+ columns: Record<string, string>;
2948
+ tables: Record<string, string>;
2949
+ }, {
2950
+ columns: Record<string, string>;
2951
+ tables: Record<string, string>;
2952
+ }>;
2953
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
2954
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2955
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2956
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
2957
+ }, "strip", import("zod").ZodTypeAny, {
2958
+ isDefaultAnExpression?: boolean | undefined;
2959
+ }, {
2960
+ isDefaultAnExpression?: boolean | undefined;
2961
+ }>>>;
2962
+ }, "strip", import("zod").ZodTypeAny, {
2963
+ columns: Record<string, {
2964
+ isDefaultAnExpression?: boolean | undefined;
2965
+ } | undefined>;
2966
+ }, {
2967
+ columns: Record<string, {
2968
+ isDefaultAnExpression?: boolean | undefined;
2969
+ } | undefined>;
2970
+ }>>>;
2971
+ }, "strip", import("zod").ZodTypeAny, {
2972
+ tables: Record<string, {
2973
+ columns: Record<string, {
2974
+ isDefaultAnExpression?: boolean | undefined;
2975
+ } | undefined>;
2976
+ } | undefined>;
2977
+ }, {
2978
+ tables: Record<string, {
2979
+ columns: Record<string, {
2980
+ isDefaultAnExpression?: boolean | undefined;
2981
+ } | undefined>;
2982
+ } | undefined>;
2983
+ }>>;
2984
+ }, {
2985
+ id: import("zod").ZodString;
2986
+ prevId: import("zod").ZodString;
2987
+ }>, "strip", import("zod").ZodTypeAny, {
2988
+ internal?: {
2989
+ tables: Record<string, {
2990
+ columns: Record<string, {
2991
+ isDefaultAnExpression?: boolean | undefined;
2992
+ } | undefined>;
2993
+ } | undefined>;
2994
+ } | undefined;
2995
+ tables: Record<string, {
2996
+ name: string;
2997
+ columns: Record<string, {
2998
+ default?: any;
2999
+ onUpdate?: any;
3000
+ autoincrement?: boolean | undefined;
3001
+ name: string;
3002
+ type: string;
3003
+ primaryKey: boolean;
3004
+ notNull: boolean;
3005
+ }>;
3006
+ indexes: Record<string, {
3007
+ using?: "btree" | "hash" | undefined;
3008
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3009
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3010
+ name: string;
3011
+ columns: string[];
3012
+ isUnique: boolean;
3013
+ }>;
3014
+ foreignKeys: Record<string, {
3015
+ onUpdate?: string | undefined;
3016
+ onDelete?: string | undefined;
3017
+ name: string;
3018
+ tableFrom: string;
3019
+ columnsFrom: string[];
3020
+ tableTo: string;
3021
+ columnsTo: string[];
3022
+ }>;
3023
+ compositePrimaryKeys: Record<string, {
3024
+ name: string;
3025
+ columns: string[];
3026
+ }>;
3027
+ uniqueConstraints: Record<string, {
3028
+ name: string;
3029
+ columns: string[];
3030
+ }>;
3031
+ }>;
3032
+ id: string;
3033
+ prevId: string;
3034
+ version: "5";
3035
+ dialect: "mysql";
3036
+ _meta: {
3037
+ columns: Record<string, string>;
3038
+ tables: Record<string, string>;
3039
+ };
3040
+ }, {
3041
+ internal?: {
3042
+ tables: Record<string, {
3043
+ columns: Record<string, {
3044
+ isDefaultAnExpression?: boolean | undefined;
3045
+ } | undefined>;
3046
+ } | undefined>;
3047
+ } | undefined;
3048
+ tables: Record<string, {
3049
+ uniqueConstraints?: Record<string, {
3050
+ name: string;
3051
+ columns: string[];
3052
+ }> | undefined;
3053
+ name: string;
3054
+ columns: Record<string, {
3055
+ default?: any;
3056
+ onUpdate?: any;
3057
+ autoincrement?: boolean | undefined;
3058
+ name: string;
3059
+ type: string;
3060
+ primaryKey: boolean;
3061
+ notNull: boolean;
3062
+ }>;
3063
+ indexes: Record<string, {
3064
+ using?: "btree" | "hash" | undefined;
3065
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3066
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3067
+ name: string;
3068
+ columns: string[];
3069
+ isUnique: boolean;
3070
+ }>;
3071
+ foreignKeys: Record<string, {
3072
+ onUpdate?: string | undefined;
3073
+ onDelete?: string | undefined;
3074
+ name: string;
3075
+ tableFrom: string;
3076
+ columnsFrom: string[];
3077
+ tableTo: string;
3078
+ columnsTo: string[];
3079
+ }>;
3080
+ compositePrimaryKeys: Record<string, {
3081
+ name: string;
3082
+ columns: string[];
3083
+ }>;
3084
+ }>;
3085
+ id: string;
3086
+ prevId: string;
3087
+ version: "5";
3088
+ dialect: "mysql";
3089
+ _meta: {
3090
+ columns: Record<string, string>;
3091
+ tables: Record<string, string>;
3092
+ };
3093
+ }>;
3094
+ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
3095
+ version: import("zod").ZodLiteral<"3">;
2494
3096
  dialect: import("zod").ZodLiteral<"mysql">;
2495
3097
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2496
3098
  name: import("zod").ZodString;
2497
- schema: import("zod").ZodOptional<import("zod").ZodString>;
2498
3099
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2499
3100
  name: import("zod").ZodString;
2500
3101
  type: import("zod").ZodString;
@@ -2568,7 +3169,6 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2568
3169
  columnsTo: string[];
2569
3170
  }>>;
2570
3171
  }, "strict", import("zod").ZodTypeAny, {
2571
- schema?: string | undefined;
2572
3172
  name: string;
2573
3173
  columns: Record<string, {
2574
3174
  default?: any;
@@ -2597,7 +3197,6 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2597
3197
  columnsTo: string[];
2598
3198
  }>;
2599
3199
  }, {
2600
- schema?: string | undefined;
2601
3200
  name: string;
2602
3201
  columns: Record<string, {
2603
3202
  default?: any;
@@ -2626,17 +3225,11 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2626
3225
  columnsTo: string[];
2627
3226
  }>;
2628
3227
  }>>;
2629
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2630
3228
  }, {
2631
3229
  id: import("zod").ZodString;
2632
3230
  prevId: import("zod").ZodString;
2633
3231
  }>, "strip", import("zod").ZodTypeAny, {
2634
- id: string;
2635
- prevId: string;
2636
- version: "4";
2637
- dialect: "mysql";
2638
3232
  tables: Record<string, {
2639
- schema?: string | undefined;
2640
3233
  name: string;
2641
3234
  columns: Record<string, {
2642
3235
  default?: any;
@@ -2665,14 +3258,12 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2665
3258
  columnsTo: string[];
2666
3259
  }>;
2667
3260
  }>;
2668
- schemas: Record<string, string>;
2669
- }, {
2670
3261
  id: string;
2671
3262
  prevId: string;
2672
- version: "4";
3263
+ version: "3";
2673
3264
  dialect: "mysql";
3265
+ }, {
2674
3266
  tables: Record<string, {
2675
- schema?: string | undefined;
2676
3267
  name: string;
2677
3268
  columns: Record<string, {
2678
3269
  default?: any;
@@ -2701,13 +3292,17 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2701
3292
  columnsTo: string[];
2702
3293
  }>;
2703
3294
  }>;
2704
- schemas: Record<string, string>;
3295
+ id: string;
3296
+ prevId: string;
3297
+ version: "3";
3298
+ dialect: "mysql";
2705
3299
  }>;
2706
- export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
2707
- version: import("zod").ZodLiteral<"3">;
3300
+ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
3301
+ version: import("zod").ZodLiteral<"4">;
2708
3302
  dialect: import("zod").ZodLiteral<"mysql">;
2709
3303
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2710
3304
  name: import("zod").ZodString;
3305
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
2711
3306
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2712
3307
  name: import("zod").ZodString;
2713
3308
  type: import("zod").ZodString;
@@ -2781,6 +3376,7 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2781
3376
  columnsTo: string[];
2782
3377
  }>>;
2783
3378
  }, "strict", import("zod").ZodTypeAny, {
3379
+ schema?: string | undefined;
2784
3380
  name: string;
2785
3381
  columns: Record<string, {
2786
3382
  default?: any;
@@ -2809,6 +3405,7 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2809
3405
  columnsTo: string[];
2810
3406
  }>;
2811
3407
  }, {
3408
+ schema?: string | undefined;
2812
3409
  name: string;
2813
3410
  columns: Record<string, {
2814
3411
  default?: any;
@@ -2837,15 +3434,13 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2837
3434
  columnsTo: string[];
2838
3435
  }>;
2839
3436
  }>>;
3437
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2840
3438
  }, {
2841
3439
  id: import("zod").ZodString;
2842
3440
  prevId: import("zod").ZodString;
2843
3441
  }>, "strip", import("zod").ZodTypeAny, {
2844
- id: string;
2845
- prevId: string;
2846
- version: "3";
2847
- dialect: "mysql";
2848
3442
  tables: Record<string, {
3443
+ schema?: string | undefined;
2849
3444
  name: string;
2850
3445
  columns: Record<string, {
2851
3446
  default?: any;
@@ -2874,12 +3469,14 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2874
3469
  columnsTo: string[];
2875
3470
  }>;
2876
3471
  }>;
2877
- }, {
2878
3472
  id: string;
2879
3473
  prevId: string;
2880
- version: "3";
3474
+ version: "4";
2881
3475
  dialect: "mysql";
3476
+ schemas: Record<string, string>;
3477
+ }, {
2882
3478
  tables: Record<string, {
3479
+ schema?: string | undefined;
2883
3480
  name: string;
2884
3481
  columns: Record<string, {
2885
3482
  default?: any;
@@ -2908,121 +3505,14 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2908
3505
  columnsTo: string[];
2909
3506
  }>;
2910
3507
  }>;
2911
- }>;
2912
- export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
2913
- version: import("zod").ZodLiteral<"5">;
2914
- dialect: import("zod").ZodLiteral<"mysql">;
2915
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2916
- name: import("zod").ZodString;
2917
- schema: import("zod").ZodOptional<import("zod").ZodString>;
2918
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2919
- name: import("zod").ZodString;
2920
- type: import("zod").ZodString;
2921
- primaryKey: import("zod").ZodBoolean;
2922
- notNull: import("zod").ZodBoolean;
2923
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2924
- default: import("zod").ZodOptional<import("zod").ZodAny>;
2925
- onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2926
- }, "strict", import("zod").ZodTypeAny, {
2927
- default?: any;
2928
- onUpdate?: any;
2929
- autoincrement?: boolean | undefined;
2930
- name: string;
2931
- type: string;
2932
- primaryKey: boolean;
2933
- notNull: boolean;
2934
- }, {
2935
- default?: any;
2936
- onUpdate?: any;
2937
- autoincrement?: boolean | undefined;
2938
- name: string;
2939
- type: string;
2940
- primaryKey: boolean;
2941
- notNull: boolean;
2942
- }>>;
2943
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2944
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2945
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2946
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
2947
- }, "strict", import("zod").ZodTypeAny, {
2948
- schema?: string | undefined;
2949
- name: string;
2950
- columns: Record<string, {
2951
- default?: any;
2952
- onUpdate?: any;
2953
- autoincrement?: boolean | undefined;
2954
- name: string;
2955
- type: string;
2956
- primaryKey: boolean;
2957
- notNull: boolean;
2958
- }>;
2959
- indexes: Record<string, string>;
2960
- foreignKeys: Record<string, string>;
2961
- compositePrimaryKeys: Record<string, string>;
2962
- uniqueConstraints: Record<string, string>;
2963
- }, {
2964
- schema?: string | undefined;
2965
- uniqueConstraints?: Record<string, string> | undefined;
2966
- name: string;
2967
- columns: Record<string, {
2968
- default?: any;
2969
- onUpdate?: any;
2970
- autoincrement?: boolean | undefined;
2971
- name: string;
2972
- type: string;
2973
- primaryKey: boolean;
2974
- notNull: boolean;
2975
- }>;
2976
- indexes: Record<string, string>;
2977
- foreignKeys: Record<string, string>;
2978
- compositePrimaryKeys: Record<string, string>;
2979
- }>>;
2980
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2981
- }, "strict", import("zod").ZodTypeAny, {
2982
- version: "5";
2983
- dialect: "mysql";
2984
- tables: Record<string, {
2985
- schema?: string | undefined;
2986
- name: string;
2987
- columns: Record<string, {
2988
- default?: any;
2989
- onUpdate?: any;
2990
- autoincrement?: boolean | undefined;
2991
- name: string;
2992
- type: string;
2993
- primaryKey: boolean;
2994
- notNull: boolean;
2995
- }>;
2996
- indexes: Record<string, string>;
2997
- foreignKeys: Record<string, string>;
2998
- compositePrimaryKeys: Record<string, string>;
2999
- uniqueConstraints: Record<string, string>;
3000
- }>;
3001
- schemas: Record<string, string>;
3002
- }, {
3003
- version: "5";
3508
+ id: string;
3509
+ prevId: string;
3510
+ version: "4";
3004
3511
  dialect: "mysql";
3005
- tables: Record<string, {
3006
- schema?: string | undefined;
3007
- uniqueConstraints?: Record<string, string> | undefined;
3008
- name: string;
3009
- columns: Record<string, {
3010
- default?: any;
3011
- onUpdate?: any;
3012
- autoincrement?: boolean | undefined;
3013
- name: string;
3014
- type: string;
3015
- primaryKey: boolean;
3016
- notNull: boolean;
3017
- }>;
3018
- indexes: Record<string, string>;
3019
- foreignKeys: Record<string, string>;
3020
- compositePrimaryKeys: Record<string, string>;
3021
- }>;
3022
3512
  schemas: Record<string, string>;
3023
3513
  }>;
3024
- export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
3025
- version: import("zod").ZodLiteral<"3">;
3514
+ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
3515
+ version: import("zod").ZodLiteral<"5">;
3026
3516
  dialect: import("zod").ZodLiteral<"mysql">;
3027
3517
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3028
3518
  name: import("zod").ZodString;
@@ -3098,6 +3588,26 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3098
3588
  tableTo: string;
3099
3589
  columnsTo: string[];
3100
3590
  }>>;
3591
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3592
+ name: import("zod").ZodString;
3593
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3594
+ }, "strict", import("zod").ZodTypeAny, {
3595
+ name: string;
3596
+ columns: string[];
3597
+ }, {
3598
+ name: string;
3599
+ columns: string[];
3600
+ }>>;
3601
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3602
+ name: import("zod").ZodString;
3603
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3604
+ }, "strict", import("zod").ZodTypeAny, {
3605
+ name: string;
3606
+ columns: string[];
3607
+ }, {
3608
+ name: string;
3609
+ columns: string[];
3610
+ }>>>;
3101
3611
  }, "strict", import("zod").ZodTypeAny, {
3102
3612
  name: string;
3103
3613
  columns: Record<string, {
@@ -3126,7 +3636,167 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3126
3636
  tableTo: string;
3127
3637
  columnsTo: string[];
3128
3638
  }>;
3639
+ compositePrimaryKeys: Record<string, {
3640
+ name: string;
3641
+ columns: string[];
3642
+ }>;
3643
+ uniqueConstraints: Record<string, {
3644
+ name: string;
3645
+ columns: string[];
3646
+ }>;
3647
+ }, {
3648
+ uniqueConstraints?: Record<string, {
3649
+ name: string;
3650
+ columns: string[];
3651
+ }> | undefined;
3652
+ name: string;
3653
+ columns: Record<string, {
3654
+ default?: any;
3655
+ onUpdate?: any;
3656
+ autoincrement?: boolean | undefined;
3657
+ name: string;
3658
+ type: string;
3659
+ primaryKey: boolean;
3660
+ notNull: boolean;
3661
+ }>;
3662
+ indexes: Record<string, {
3663
+ using?: "btree" | "hash" | undefined;
3664
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3665
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3666
+ name: string;
3667
+ columns: string[];
3668
+ isUnique: boolean;
3669
+ }>;
3670
+ foreignKeys: Record<string, {
3671
+ onUpdate?: string | undefined;
3672
+ onDelete?: string | undefined;
3673
+ name: string;
3674
+ tableFrom: string;
3675
+ columnsFrom: string[];
3676
+ tableTo: string;
3677
+ columnsTo: string[];
3678
+ }>;
3679
+ compositePrimaryKeys: Record<string, {
3680
+ name: string;
3681
+ columns: string[];
3682
+ }>;
3683
+ }>>;
3684
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3685
+ _meta: import("zod").ZodObject<{
3686
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3687
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3688
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3689
+ }, "strip", import("zod").ZodTypeAny, {
3690
+ columns: Record<string, string>;
3691
+ tables: Record<string, string>;
3692
+ schemas: Record<string, string>;
3693
+ }, {
3694
+ columns: Record<string, string>;
3695
+ tables: Record<string, string>;
3696
+ schemas: Record<string, string>;
3697
+ }>;
3698
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
3699
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
3700
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
3701
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
3702
+ }, "strip", import("zod").ZodTypeAny, {
3703
+ isDefaultAnExpression?: boolean | undefined;
3704
+ }, {
3705
+ isDefaultAnExpression?: boolean | undefined;
3706
+ }>>>;
3707
+ }, "strip", import("zod").ZodTypeAny, {
3708
+ columns: Record<string, {
3709
+ isDefaultAnExpression?: boolean | undefined;
3710
+ } | undefined>;
3711
+ }, {
3712
+ columns: Record<string, {
3713
+ isDefaultAnExpression?: boolean | undefined;
3714
+ } | undefined>;
3715
+ }>>>;
3716
+ }, "strip", import("zod").ZodTypeAny, {
3717
+ tables: Record<string, {
3718
+ columns: Record<string, {
3719
+ isDefaultAnExpression?: boolean | undefined;
3720
+ } | undefined>;
3721
+ } | undefined>;
3129
3722
  }, {
3723
+ tables: Record<string, {
3724
+ columns: Record<string, {
3725
+ isDefaultAnExpression?: boolean | undefined;
3726
+ } | undefined>;
3727
+ } | undefined>;
3728
+ }>>;
3729
+ }, {
3730
+ id: import("zod").ZodString;
3731
+ prevId: import("zod").ZodString;
3732
+ }>, "strip", import("zod").ZodTypeAny, {
3733
+ internal?: {
3734
+ tables: Record<string, {
3735
+ columns: Record<string, {
3736
+ isDefaultAnExpression?: boolean | undefined;
3737
+ } | undefined>;
3738
+ } | undefined>;
3739
+ } | undefined;
3740
+ tables: Record<string, {
3741
+ name: string;
3742
+ columns: Record<string, {
3743
+ default?: any;
3744
+ onUpdate?: any;
3745
+ autoincrement?: boolean | undefined;
3746
+ name: string;
3747
+ type: string;
3748
+ primaryKey: boolean;
3749
+ notNull: boolean;
3750
+ }>;
3751
+ indexes: Record<string, {
3752
+ using?: "btree" | "hash" | undefined;
3753
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3754
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3755
+ name: string;
3756
+ columns: string[];
3757
+ isUnique: boolean;
3758
+ }>;
3759
+ foreignKeys: Record<string, {
3760
+ onUpdate?: string | undefined;
3761
+ onDelete?: string | undefined;
3762
+ name: string;
3763
+ tableFrom: string;
3764
+ columnsFrom: string[];
3765
+ tableTo: string;
3766
+ columnsTo: string[];
3767
+ }>;
3768
+ compositePrimaryKeys: Record<string, {
3769
+ name: string;
3770
+ columns: string[];
3771
+ }>;
3772
+ uniqueConstraints: Record<string, {
3773
+ name: string;
3774
+ columns: string[];
3775
+ }>;
3776
+ }>;
3777
+ id: string;
3778
+ prevId: string;
3779
+ version: "5";
3780
+ dialect: "mysql";
3781
+ schemas: Record<string, string>;
3782
+ _meta: {
3783
+ columns: Record<string, string>;
3784
+ tables: Record<string, string>;
3785
+ schemas: Record<string, string>;
3786
+ };
3787
+ }, {
3788
+ internal?: {
3789
+ tables: Record<string, {
3790
+ columns: Record<string, {
3791
+ isDefaultAnExpression?: boolean | undefined;
3792
+ } | undefined>;
3793
+ } | undefined>;
3794
+ } | undefined;
3795
+ tables: Record<string, {
3796
+ uniqueConstraints?: Record<string, {
3797
+ name: string;
3798
+ columns: string[];
3799
+ }> | undefined;
3130
3800
  name: string;
3131
3801
  columns: Record<string, {
3132
3802
  default?: any;
@@ -3149,20 +3819,93 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3149
3819
  onUpdate?: string | undefined;
3150
3820
  onDelete?: string | undefined;
3151
3821
  name: string;
3152
- tableFrom: string;
3153
- columnsFrom: string[];
3154
- tableTo: string;
3155
- columnsTo: string[];
3822
+ tableFrom: string;
3823
+ columnsFrom: string[];
3824
+ tableTo: string;
3825
+ columnsTo: string[];
3826
+ }>;
3827
+ compositePrimaryKeys: Record<string, {
3828
+ name: string;
3829
+ columns: string[];
3830
+ }>;
3831
+ }>;
3832
+ id: string;
3833
+ prevId: string;
3834
+ version: "5";
3835
+ dialect: "mysql";
3836
+ schemas: Record<string, string>;
3837
+ _meta: {
3838
+ columns: Record<string, string>;
3839
+ tables: Record<string, string>;
3840
+ schemas: Record<string, string>;
3841
+ };
3842
+ }>;
3843
+ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
3844
+ version: import("zod").ZodLiteral<"5">;
3845
+ dialect: import("zod").ZodLiteral<"mysql">;
3846
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3847
+ name: import("zod").ZodString;
3848
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3849
+ name: import("zod").ZodString;
3850
+ type: import("zod").ZodString;
3851
+ primaryKey: import("zod").ZodBoolean;
3852
+ notNull: import("zod").ZodBoolean;
3853
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
3854
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
3855
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3856
+ }, "strict", import("zod").ZodTypeAny, {
3857
+ default?: any;
3858
+ onUpdate?: any;
3859
+ autoincrement?: boolean | undefined;
3860
+ name: string;
3861
+ type: string;
3862
+ primaryKey: boolean;
3863
+ notNull: boolean;
3864
+ }, {
3865
+ default?: any;
3866
+ onUpdate?: any;
3867
+ autoincrement?: boolean | undefined;
3868
+ name: string;
3869
+ type: string;
3870
+ primaryKey: boolean;
3871
+ notNull: boolean;
3872
+ }>>;
3873
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3874
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3875
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3876
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
3877
+ }, "strict", import("zod").ZodTypeAny, {
3878
+ name: string;
3879
+ columns: Record<string, {
3880
+ default?: any;
3881
+ onUpdate?: any;
3882
+ autoincrement?: boolean | undefined;
3883
+ name: string;
3884
+ type: string;
3885
+ primaryKey: boolean;
3886
+ notNull: boolean;
3887
+ }>;
3888
+ indexes: Record<string, string>;
3889
+ foreignKeys: Record<string, string>;
3890
+ compositePrimaryKeys: Record<string, string>;
3891
+ uniqueConstraints: Record<string, string>;
3892
+ }, {
3893
+ uniqueConstraints?: Record<string, string> | undefined;
3894
+ name: string;
3895
+ columns: Record<string, {
3896
+ default?: any;
3897
+ onUpdate?: any;
3898
+ autoincrement?: boolean | undefined;
3899
+ name: string;
3900
+ type: string;
3901
+ primaryKey: boolean;
3902
+ notNull: boolean;
3156
3903
  }>;
3904
+ indexes: Record<string, string>;
3905
+ foreignKeys: Record<string, string>;
3906
+ compositePrimaryKeys: Record<string, string>;
3157
3907
  }>>;
3158
- }, {
3159
- id: import("zod").ZodString;
3160
- prevId: import("zod").ZodString;
3161
- }>, "strip", import("zod").ZodTypeAny, {
3162
- id: string;
3163
- prevId: string;
3164
- version: "3";
3165
- dialect: "mysql";
3908
+ }, "strict", import("zod").ZodTypeAny, {
3166
3909
  tables: Record<string, {
3167
3910
  name: string;
3168
3911
  columns: Record<string, {
@@ -3174,30 +3917,16 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3174
3917
  primaryKey: boolean;
3175
3918
  notNull: boolean;
3176
3919
  }>;
3177
- indexes: Record<string, {
3178
- using?: "btree" | "hash" | undefined;
3179
- algorithm?: "default" | "inplace" | "copy" | undefined;
3180
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3181
- name: string;
3182
- columns: string[];
3183
- isUnique: boolean;
3184
- }>;
3185
- foreignKeys: Record<string, {
3186
- onUpdate?: string | undefined;
3187
- onDelete?: string | undefined;
3188
- name: string;
3189
- tableFrom: string;
3190
- columnsFrom: string[];
3191
- tableTo: string;
3192
- columnsTo: string[];
3193
- }>;
3920
+ indexes: Record<string, string>;
3921
+ foreignKeys: Record<string, string>;
3922
+ compositePrimaryKeys: Record<string, string>;
3923
+ uniqueConstraints: Record<string, string>;
3194
3924
  }>;
3195
- }, {
3196
- id: string;
3197
- prevId: string;
3198
- version: "3";
3925
+ version: "5";
3199
3926
  dialect: "mysql";
3927
+ }, {
3200
3928
  tables: Record<string, {
3929
+ uniqueConstraints?: Record<string, string> | undefined;
3201
3930
  name: string;
3202
3931
  columns: Record<string, {
3203
3932
  default?: any;
@@ -3208,30 +3937,18 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3208
3937
  primaryKey: boolean;
3209
3938
  notNull: boolean;
3210
3939
  }>;
3211
- indexes: Record<string, {
3212
- using?: "btree" | "hash" | undefined;
3213
- algorithm?: "default" | "inplace" | "copy" | undefined;
3214
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3215
- name: string;
3216
- columns: string[];
3217
- isUnique: boolean;
3218
- }>;
3219
- foreignKeys: Record<string, {
3220
- onUpdate?: string | undefined;
3221
- onDelete?: string | undefined;
3222
- name: string;
3223
- tableFrom: string;
3224
- columnsFrom: string[];
3225
- tableTo: string;
3226
- columnsTo: string[];
3227
- }>;
3940
+ indexes: Record<string, string>;
3941
+ foreignKeys: Record<string, string>;
3942
+ compositePrimaryKeys: Record<string, string>;
3228
3943
  }>;
3229
- }>, import("zod").ZodObject<import("zod").extendShape<{
3230
- version: import("zod").ZodLiteral<"4">;
3944
+ version: "5";
3945
+ dialect: "mysql";
3946
+ }>;
3947
+ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
3948
+ version: import("zod").ZodLiteral<"5">;
3231
3949
  dialect: import("zod").ZodLiteral<"mysql">;
3232
3950
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3233
3951
  name: import("zod").ZodString;
3234
- schema: import("zod").ZodOptional<import("zod").ZodString>;
3235
3952
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3236
3953
  name: import("zod").ZodString;
3237
3954
  type: import("zod").ZodString;
@@ -3304,8 +4021,27 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3304
4021
  tableTo: string;
3305
4022
  columnsTo: string[];
3306
4023
  }>>;
4024
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4025
+ name: import("zod").ZodString;
4026
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
4027
+ }, "strict", import("zod").ZodTypeAny, {
4028
+ name: string;
4029
+ columns: string[];
4030
+ }, {
4031
+ name: string;
4032
+ columns: string[];
4033
+ }>>;
4034
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4035
+ name: import("zod").ZodString;
4036
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
4037
+ }, "strict", import("zod").ZodTypeAny, {
4038
+ name: string;
4039
+ columns: string[];
4040
+ }, {
4041
+ name: string;
4042
+ columns: string[];
4043
+ }>>>;
3307
4044
  }, "strict", import("zod").ZodTypeAny, {
3308
- schema?: string | undefined;
3309
4045
  name: string;
3310
4046
  columns: Record<string, {
3311
4047
  default?: any;
@@ -3333,8 +4069,19 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3333
4069
  tableTo: string;
3334
4070
  columnsTo: string[];
3335
4071
  }>;
4072
+ compositePrimaryKeys: Record<string, {
4073
+ name: string;
4074
+ columns: string[];
4075
+ }>;
4076
+ uniqueConstraints: Record<string, {
4077
+ name: string;
4078
+ columns: string[];
4079
+ }>;
3336
4080
  }, {
3337
- schema?: string | undefined;
4081
+ uniqueConstraints?: Record<string, {
4082
+ name: string;
4083
+ columns: string[];
4084
+ }> | undefined;
3338
4085
  name: string;
3339
4086
  columns: Record<string, {
3340
4087
  default?: any;
@@ -3362,18 +4109,68 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3362
4109
  tableTo: string;
3363
4110
  columnsTo: string[];
3364
4111
  }>;
4112
+ compositePrimaryKeys: Record<string, {
4113
+ name: string;
4114
+ columns: string[];
4115
+ }>;
3365
4116
  }>>;
3366
4117
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4118
+ _meta: import("zod").ZodObject<{
4119
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4120
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4121
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4122
+ }, "strip", import("zod").ZodTypeAny, {
4123
+ columns: Record<string, string>;
4124
+ tables: Record<string, string>;
4125
+ schemas: Record<string, string>;
4126
+ }, {
4127
+ columns: Record<string, string>;
4128
+ tables: Record<string, string>;
4129
+ schemas: Record<string, string>;
4130
+ }>;
4131
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
4132
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4133
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4134
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
4135
+ }, "strip", import("zod").ZodTypeAny, {
4136
+ isDefaultAnExpression?: boolean | undefined;
4137
+ }, {
4138
+ isDefaultAnExpression?: boolean | undefined;
4139
+ }>>>;
4140
+ }, "strip", import("zod").ZodTypeAny, {
4141
+ columns: Record<string, {
4142
+ isDefaultAnExpression?: boolean | undefined;
4143
+ } | undefined>;
4144
+ }, {
4145
+ columns: Record<string, {
4146
+ isDefaultAnExpression?: boolean | undefined;
4147
+ } | undefined>;
4148
+ }>>>;
4149
+ }, "strip", import("zod").ZodTypeAny, {
4150
+ tables: Record<string, {
4151
+ columns: Record<string, {
4152
+ isDefaultAnExpression?: boolean | undefined;
4153
+ } | undefined>;
4154
+ } | undefined>;
4155
+ }, {
4156
+ tables: Record<string, {
4157
+ columns: Record<string, {
4158
+ isDefaultAnExpression?: boolean | undefined;
4159
+ } | undefined>;
4160
+ } | undefined>;
4161
+ }>>;
3367
4162
  }, {
3368
4163
  id: import("zod").ZodString;
3369
4164
  prevId: import("zod").ZodString;
3370
4165
  }>, "strip", import("zod").ZodTypeAny, {
3371
- id: string;
3372
- prevId: string;
3373
- version: "4";
3374
- dialect: "mysql";
4166
+ internal?: {
4167
+ tables: Record<string, {
4168
+ columns: Record<string, {
4169
+ isDefaultAnExpression?: boolean | undefined;
4170
+ } | undefined>;
4171
+ } | undefined>;
4172
+ } | undefined;
3375
4173
  tables: Record<string, {
3376
- schema?: string | undefined;
3377
4174
  name: string;
3378
4175
  columns: Record<string, {
3379
4176
  default?: any;
@@ -3401,15 +4198,38 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3401
4198
  tableTo: string;
3402
4199
  columnsTo: string[];
3403
4200
  }>;
4201
+ compositePrimaryKeys: Record<string, {
4202
+ name: string;
4203
+ columns: string[];
4204
+ }>;
4205
+ uniqueConstraints: Record<string, {
4206
+ name: string;
4207
+ columns: string[];
4208
+ }>;
3404
4209
  }>;
3405
- schemas: Record<string, string>;
3406
- }, {
3407
4210
  id: string;
3408
4211
  prevId: string;
3409
- version: "4";
4212
+ version: "5";
3410
4213
  dialect: "mysql";
4214
+ schemas: Record<string, string>;
4215
+ _meta: {
4216
+ columns: Record<string, string>;
4217
+ tables: Record<string, string>;
4218
+ schemas: Record<string, string>;
4219
+ };
4220
+ }, {
4221
+ internal?: {
4222
+ tables: Record<string, {
4223
+ columns: Record<string, {
4224
+ isDefaultAnExpression?: boolean | undefined;
4225
+ } | undefined>;
4226
+ } | undefined>;
4227
+ } | undefined;
3411
4228
  tables: Record<string, {
3412
- schema?: string | undefined;
4229
+ uniqueConstraints?: Record<string, {
4230
+ name: string;
4231
+ columns: string[];
4232
+ }> | undefined;
3413
4233
  name: string;
3414
4234
  columns: Record<string, {
3415
4235
  default?: any;
@@ -3437,14 +4257,26 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3437
4257
  tableTo: string;
3438
4258
  columnsTo: string[];
3439
4259
  }>;
4260
+ compositePrimaryKeys: Record<string, {
4261
+ name: string;
4262
+ columns: string[];
4263
+ }>;
3440
4264
  }>;
4265
+ id: string;
4266
+ prevId: string;
4267
+ version: "5";
4268
+ dialect: "mysql";
3441
4269
  schemas: Record<string, string>;
4270
+ _meta: {
4271
+ columns: Record<string, string>;
4272
+ tables: Record<string, string>;
4273
+ schemas: Record<string, string>;
4274
+ };
3442
4275
  }>, import("zod").ZodObject<import("zod").extendShape<{
3443
4276
  version: import("zod").ZodLiteral<"5">;
3444
4277
  dialect: import("zod").ZodLiteral<"mysql">;
3445
4278
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3446
4279
  name: import("zod").ZodString;
3447
- schema: import("zod").ZodOptional<import("zod").ZodString>;
3448
4280
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3449
4281
  name: import("zod").ZodString;
3450
4282
  type: import("zod").ZodString;
@@ -3538,7 +4370,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3538
4370
  columns: string[];
3539
4371
  }>>>;
3540
4372
  }, "strict", import("zod").ZodTypeAny, {
3541
- schema?: string | undefined;
3542
4373
  name: string;
3543
4374
  columns: Record<string, {
3544
4375
  default?: any;
@@ -3575,7 +4406,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3575
4406
  columns: string[];
3576
4407
  }>;
3577
4408
  }, {
3578
- schema?: string | undefined;
3579
4409
  uniqueConstraints?: Record<string, {
3580
4410
  name: string;
3581
4411
  columns: string[];
@@ -3612,19 +4442,15 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3612
4442
  columns: string[];
3613
4443
  }>;
3614
4444
  }>>;
3615
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3616
4445
  _meta: import("zod").ZodObject<{
3617
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3618
4446
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3619
4447
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3620
4448
  }, "strip", import("zod").ZodTypeAny, {
3621
4449
  columns: Record<string, string>;
3622
4450
  tables: Record<string, string>;
3623
- schemas: Record<string, string>;
3624
4451
  }, {
3625
4452
  columns: Record<string, string>;
3626
4453
  tables: Record<string, string>;
3627
- schemas: Record<string, string>;
3628
4454
  }>;
3629
4455
  internal: import("zod").ZodOptional<import("zod").ZodObject<{
3630
4456
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
@@ -3668,12 +4494,7 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3668
4494
  } | undefined>;
3669
4495
  } | undefined>;
3670
4496
  } | undefined;
3671
- id: string;
3672
- prevId: string;
3673
- version: "5";
3674
- dialect: "mysql";
3675
4497
  tables: Record<string, {
3676
- schema?: string | undefined;
3677
4498
  name: string;
3678
4499
  columns: Record<string, {
3679
4500
  default?: any;
@@ -3710,11 +4531,13 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3710
4531
  columns: string[];
3711
4532
  }>;
3712
4533
  }>;
3713
- schemas: Record<string, string>;
4534
+ id: string;
4535
+ prevId: string;
4536
+ version: "5";
4537
+ dialect: "mysql";
3714
4538
  _meta: {
3715
4539
  columns: Record<string, string>;
3716
4540
  tables: Record<string, string>;
3717
- schemas: Record<string, string>;
3718
4541
  };
3719
4542
  }, {
3720
4543
  internal?: {
@@ -3724,12 +4547,7 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3724
4547
  } | undefined>;
3725
4548
  } | undefined>;
3726
4549
  } | undefined;
3727
- id: string;
3728
- prevId: string;
3729
- version: "5";
3730
- dialect: "mysql";
3731
4550
  tables: Record<string, {
3732
- schema?: string | undefined;
3733
4551
  uniqueConstraints?: Record<string, {
3734
4552
  name: string;
3735
4553
  columns: string[];
@@ -3766,11 +4584,13 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3766
4584
  columns: string[];
3767
4585
  }>;
3768
4586
  }>;
3769
- schemas: Record<string, string>;
4587
+ id: string;
4588
+ prevId: string;
4589
+ version: "5";
4590
+ dialect: "mysql";
3770
4591
  _meta: {
3771
4592
  columns: Record<string, string>;
3772
4593
  tables: Record<string, string>;
3773
- schemas: Record<string, string>;
3774
4594
  };
3775
4595
  }>]>;
3776
4596
  export declare const dryMySql: {
@@ -3781,12 +4601,7 @@ export declare const dryMySql: {
3781
4601
  } | undefined>;
3782
4602
  } | undefined>;
3783
4603
  } | undefined;
3784
- id: string;
3785
- prevId: string;
3786
- version: "5";
3787
- dialect: "mysql";
3788
4604
  tables: Record<string, {
3789
- schema?: string | undefined;
3790
4605
  name: string;
3791
4606
  columns: Record<string, {
3792
4607
  default?: any;
@@ -3823,11 +4638,13 @@ export declare const dryMySql: {
3823
4638
  columns: string[];
3824
4639
  }>;
3825
4640
  }>;
3826
- schemas: Record<string, string>;
4641
+ id: string;
4642
+ prevId: string;
4643
+ version: "5";
4644
+ dialect: "mysql";
3827
4645
  _meta: {
3828
4646
  columns: Record<string, string>;
3829
4647
  tables: Record<string, string>;
3830
- schemas: Record<string, string>;
3831
4648
  };
3832
4649
  };
3833
4650
  export {};