drizzle-kit 0.20.14-c82ab68 → 0.20.14-d8f1e46

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (45) hide show
  1. package/bin.cjs +7142 -7442
  2. package/cli/commands/migrate.d.ts +24 -24
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -8
  4. package/cli/commands/mysqlPushUtils.d.ts +2 -2
  5. package/cli/commands/mysqlUp.d.ts +2 -2
  6. package/cli/commands/pgConnect.d.ts +1 -1
  7. package/cli/commands/pgIntrospect.d.ts +9 -12
  8. package/cli/commands/pgPushUtils.d.ts +2 -2
  9. package/cli/commands/pgUp.d.ts +2 -2
  10. package/cli/commands/sqliteIntrospect.d.ts +9 -9
  11. package/cli/commands/sqlitePushUtils.d.ts +3 -3
  12. package/cli/commands/sqliteUtils.d.ts +162 -0
  13. package/cli/commands/upFolders.d.ts +1 -1
  14. package/cli/commands/utils.d.ts +259 -14
  15. package/cli/validations/common.d.ts +7 -205
  16. package/cli/validations/mysql.d.ts +1 -6
  17. package/cli/validations/pg.d.ts +1 -6
  18. package/cli/views.d.ts +1 -1
  19. package/global.d.ts +1 -1
  20. package/index.d.mts +6 -8
  21. package/index.d.ts +6 -8
  22. package/index.js +0 -1
  23. package/introspect-mysql.d.ts +1 -1
  24. package/introspect-pg.d.ts +2 -5
  25. package/introspect-sqlite.d.ts +1 -1
  26. package/jsonStatements.d.ts +1 -1
  27. package/package.json +2 -3
  28. package/payload.d.mts +988 -18
  29. package/payload.d.ts +988 -18
  30. package/payload.js +1616 -13426
  31. package/payload.mjs +1538 -2213
  32. package/schemaValidator.d.ts +40 -40
  33. package/serializer/mysqlSchema.d.ts +616 -1854
  34. package/serializer/mysqlSerializer.d.ts +2 -2
  35. package/serializer/pgSchema.d.ts +684 -1009
  36. package/serializer/sqliteSchema.d.ts +570 -144
  37. package/serializer/sqliteSerializer.d.ts +2 -2
  38. package/snapshotsDiffer.d.ts +20 -24
  39. package/utils-studio.js +15 -390
  40. package/utils-studio.mjs +15 -389
  41. package/utils.d.ts +12 -12
  42. package/utils.js +735 -849
  43. package/utils.mjs +736 -849
  44. package/cli/validations/cli.d.ts +0 -104
  45. package/cli/validations/sqlite.d.ts +0 -382
package/serializer/mysqlSchema.d.ts CHANGED
@@ -395,37 +395,6 @@ declare const table: import("zod").ZodObject<{
395
395
  columns: string[];
396
396
  }>;
397
397
  }>;
398
- export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
399
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
400
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
401
- isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
402
- }, "strip", import("zod").ZodTypeAny, {
403
- isDefaultAnExpression?: boolean | undefined;
404
- }, {
405
- isDefaultAnExpression?: boolean | undefined;
406
- }>>>;
407
- }, "strip", import("zod").ZodTypeAny, {
408
- columns: Record<string, {
409
- isDefaultAnExpression?: boolean | undefined;
410
- } | undefined>;
411
- }, {
412
- columns: Record<string, {
413
- isDefaultAnExpression?: boolean | undefined;
414
- } | undefined>;
415
- }>>>;
416
- }, "strip", import("zod").ZodTypeAny, {
417
- tables: Record<string, {
418
- columns: Record<string, {
419
- isDefaultAnExpression?: boolean | undefined;
420
- } | undefined>;
421
- } | undefined>;
422
- }, {
423
- tables: Record<string, {
424
- columns: Record<string, {
425
- isDefaultAnExpression?: boolean | undefined;
426
- } | undefined>;
427
- } | undefined>;
428
- }>>;
429
398
  declare const dialect: import("zod").ZodLiteral<"mysql">;
430
399
  export declare const schemaInternalV3: import("zod").ZodObject<{
431
400
  version: import("zod").ZodLiteral<"3">;
@@ -562,6 +531,8 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
562
531
  }>;
563
532
  }>>;
564
533
  }, "strict", import("zod").ZodTypeAny, {
534
+ version: "3";
535
+ dialect: "mysql";
565
536
  tables: Record<string, {
566
537
  name: string;
567
538
  columns: Record<string, {
@@ -591,9 +562,9 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
591
562
  columnsTo: string[];
592
563
  }>;
593
564
  }>;
565
+ }, {
594
566
  version: "3";
595
567
  dialect: "mysql";
596
- }, {
597
568
  tables: Record<string, {
598
569
  name: string;
599
570
  columns: Record<string, {
@@ -623,8 +594,6 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
623
594
  columnsTo: string[];
624
595
  }>;
625
596
  }>;
626
- version: "3";
627
- dialect: "mysql";
628
597
  }>;
629
598
  export declare const schemaInternalV4: import("zod").ZodObject<{
630
599
  version: import("zod").ZodLiteral<"4">;
@@ -765,6 +734,8 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
765
734
  }>>;
766
735
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
767
736
  }, "strict", import("zod").ZodTypeAny, {
737
+ version: "4";
738
+ dialect: "mysql";
768
739
  tables: Record<string, {
769
740
  schema?: string | undefined;
770
741
  name: string;
@@ -795,10 +766,10 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
795
766
  columnsTo: string[];
796
767
  }>;
797
768
  }>;
798
- version: "4";
799
- dialect: "mysql";
800
769
  schemas: Record<string, string>;
801
770
  }, {
771
+ version: "4";
772
+ dialect: "mysql";
802
773
  tables: Record<string, {
803
774
  schema?: string | undefined;
804
775
  name: string;
@@ -829,11 +800,40 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
829
800
  columnsTo: string[];
830
801
  }>;
831
802
  }>;
832
- version: "4";
833
- dialect: "mysql";
834
803
  schemas: Record<string, string>;
835
804
  }>;
836
- export declare const schemaInternalV5: import("zod").ZodObject<{
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<{
837
837
  version: import("zod").ZodLiteral<"5">;
838
838
  dialect: import("zod").ZodLiteral<"mysql">;
839
839
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1059,6 +1059,8 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
1059
1059
  } | undefined>;
1060
1060
  } | undefined>;
1061
1061
  } | undefined;
1062
+ version: "5";
1063
+ dialect: "mysql";
1062
1064
  tables: Record<string, {
1063
1065
  schema?: string | undefined;
1064
1066
  name: string;
@@ -1097,8 +1099,6 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
1097
1099
  columns: string[];
1098
1100
  }>;
1099
1101
  }>;
1100
- version: "5";
1101
- dialect: "mysql";
1102
1102
  schemas: Record<string, string>;
1103
1103
  _meta: {
1104
1104
  columns: Record<string, string>;
@@ -1113,6 +1113,8 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
1113
1113
  } | undefined>;
1114
1114
  } | undefined>;
1115
1115
  } | undefined;
1116
+ version: "5";
1117
+ dialect: "mysql";
1116
1118
  tables: Record<string, {
1117
1119
  schema?: string | undefined;
1118
1120
  uniqueConstraints?: Record<string, {
@@ -1151,8 +1153,6 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
1151
1153
  columns: string[];
1152
1154
  }>;
1153
1155
  }>;
1154
- version: "5";
1155
- dialect: "mysql";
1156
1156
  schemas: Record<string, string>;
1157
1157
  _meta: {
1158
1158
  columns: Record<string, string>;
@@ -1160,12 +1160,11 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
1160
1160
  schemas: Record<string, string>;
1161
1161
  };
1162
1162
  }>;
1163
- export declare const schemaInternalV6: import("zod").ZodObject<{
1164
- version: import("zod").ZodLiteral<"6">;
1163
+ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
1164
+ version: import("zod").ZodLiteral<"3">;
1165
1165
  dialect: import("zod").ZodLiteral<"mysql">;
1166
1166
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1167
1167
  name: import("zod").ZodString;
1168
- schema: import("zod").ZodOptional<import("zod").ZodString>;
1169
1168
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1170
1169
  name: import("zod").ZodString;
1171
1170
  type: import("zod").ZodString;
@@ -1238,28 +1237,7 @@ export declare const schemaInternalV6: import("zod").ZodObject<{
1238
1237
  tableTo: string;
1239
1238
  columnsTo: string[];
1240
1239
  }>>;
1241
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1242
- name: import("zod").ZodString;
1243
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1244
- }, "strict", import("zod").ZodTypeAny, {
1245
- name: string;
1246
- columns: string[];
1247
- }, {
1248
- name: string;
1249
- columns: string[];
1250
- }>>;
1251
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1252
- name: import("zod").ZodString;
1253
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1254
- }, "strict", import("zod").ZodTypeAny, {
1255
- name: string;
1256
- columns: string[];
1257
- }, {
1258
- name: string;
1259
- columns: string[];
1260
- }>>>;
1261
1240
  }, "strict", import("zod").ZodTypeAny, {
1262
- schema?: string | undefined;
1263
1241
  name: string;
1264
1242
  columns: Record<string, {
1265
1243
  default?: any;
@@ -1287,20 +1265,7 @@ export declare const schemaInternalV6: import("zod").ZodObject<{
1287
1265
  tableTo: string;
1288
1266
  columnsTo: string[];
1289
1267
  }>;
1290
- compositePrimaryKeys: Record<string, {
1291
- name: string;
1292
- columns: string[];
1293
- }>;
1294
- uniqueConstraints: Record<string, {
1295
- name: string;
1296
- columns: string[];
1297
- }>;
1298
1268
  }, {
1299
- schema?: string | undefined;
1300
- uniqueConstraints?: Record<string, {
1301
- name: string;
1302
- columns: string[];
1303
- }> | undefined;
1304
1269
  name: string;
1305
1270
  columns: Record<string, {
1306
1271
  default?: any;
@@ -1328,66 +1293,16 @@ export declare const schemaInternalV6: import("zod").ZodObject<{
1328
1293
  tableTo: string;
1329
1294
  columnsTo: string[];
1330
1295
  }>;
1331
- compositePrimaryKeys: Record<string, {
1332
- name: string;
1333
- columns: string[];
1334
- }>;
1335
- }>>;
1336
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1337
- _meta: import("zod").ZodObject<{
1338
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1339
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1340
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1341
- }, "strip", import("zod").ZodTypeAny, {
1342
- columns: Record<string, string>;
1343
- tables: Record<string, string>;
1344
- schemas: Record<string, string>;
1345
- }, {
1346
- columns: Record<string, string>;
1347
- tables: Record<string, string>;
1348
- schemas: Record<string, string>;
1349
- }>;
1350
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
1351
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1352
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1353
- isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
1354
- }, "strip", import("zod").ZodTypeAny, {
1355
- isDefaultAnExpression?: boolean | undefined;
1356
- }, {
1357
- isDefaultAnExpression?: boolean | undefined;
1358
- }>>>;
1359
- }, "strip", import("zod").ZodTypeAny, {
1360
- columns: Record<string, {
1361
- isDefaultAnExpression?: boolean | undefined;
1362
- } | undefined>;
1363
- }, {
1364
- columns: Record<string, {
1365
- isDefaultAnExpression?: boolean | undefined;
1366
- } | undefined>;
1367
- }>>>;
1368
- }, "strip", import("zod").ZodTypeAny, {
1369
- tables: Record<string, {
1370
- columns: Record<string, {
1371
- isDefaultAnExpression?: boolean | undefined;
1372
- } | undefined>;
1373
- } | undefined>;
1374
- }, {
1375
- tables: Record<string, {
1376
- columns: Record<string, {
1377
- isDefaultAnExpression?: boolean | undefined;
1378
- } | undefined>;
1379
- } | undefined>;
1380
1296
  }>>;
1381
- }, "strict", import("zod").ZodTypeAny, {
1382
- internal?: {
1383
- tables: Record<string, {
1384
- columns: Record<string, {
1385
- isDefaultAnExpression?: boolean | undefined;
1386
- } | undefined>;
1387
- } | undefined>;
1388
- } | undefined;
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";
1389
1305
  tables: Record<string, {
1390
- schema?: string | undefined;
1391
1306
  name: string;
1392
1307
  columns: Record<string, {
1393
1308
  default?: any;
@@ -1415,37 +1330,13 @@ export declare const schemaInternalV6: import("zod").ZodObject<{
1415
1330
  tableTo: string;
1416
1331
  columnsTo: string[];
1417
1332
  }>;
1418
- compositePrimaryKeys: Record<string, {
1419
- name: string;
1420
- columns: string[];
1421
- }>;
1422
- uniqueConstraints: Record<string, {
1423
- name: string;
1424
- columns: string[];
1425
- }>;
1426
1333
  }>;
1427
- version: "6";
1428
- dialect: "mysql";
1429
- schemas: Record<string, string>;
1430
- _meta: {
1431
- columns: Record<string, string>;
1432
- tables: Record<string, string>;
1433
- schemas: Record<string, string>;
1434
- };
1435
1334
  }, {
1436
- internal?: {
1437
- tables: Record<string, {
1438
- columns: Record<string, {
1439
- isDefaultAnExpression?: boolean | undefined;
1440
- } | undefined>;
1441
- } | undefined>;
1442
- } | undefined;
1335
+ id: string;
1336
+ prevId: string;
1337
+ version: "3";
1338
+ dialect: "mysql";
1443
1339
  tables: Record<string, {
1444
- schema?: string | undefined;
1445
- uniqueConstraints?: Record<string, {
1446
- name: string;
1447
- columns: string[];
1448
- }> | undefined;
1449
1340
  name: string;
1450
1341
  columns: Record<string, {
1451
1342
  default?: any;
@@ -1473,22 +1364,10 @@ export declare const schemaInternalV6: import("zod").ZodObject<{
1473
1364
  tableTo: string;
1474
1365
  columnsTo: string[];
1475
1366
  }>;
1476
- compositePrimaryKeys: Record<string, {
1477
- name: string;
1478
- columns: string[];
1479
- }>;
1480
1367
  }>;
1481
- version: "6";
1482
- dialect: "mysql";
1483
- schemas: Record<string, string>;
1484
- _meta: {
1485
- columns: Record<string, string>;
1486
- tables: Record<string, string>;
1487
- schemas: Record<string, string>;
1488
- };
1489
1368
  }>;
1490
- export declare const schemaInternal: import("zod").ZodObject<{
1491
- version: import("zod").ZodLiteral<"6">;
1369
+ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
1370
+ version: import("zod").ZodLiteral<"4">;
1492
1371
  dialect: import("zod").ZodLiteral<"mysql">;
1493
1372
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1494
1373
  name: import("zod").ZodString;
@@ -1565,26 +1444,6 @@ export declare const schemaInternal: import("zod").ZodObject<{
1565
1444
  tableTo: string;
1566
1445
  columnsTo: string[];
1567
1446
  }>>;
1568
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1569
- name: import("zod").ZodString;
1570
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1571
- }, "strict", import("zod").ZodTypeAny, {
1572
- name: string;
1573
- columns: string[];
1574
- }, {
1575
- name: string;
1576
- columns: string[];
1577
- }>>;
1578
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1579
- name: import("zod").ZodString;
1580
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1581
- }, "strict", import("zod").ZodTypeAny, {
1582
- name: string;
1583
- columns: string[];
1584
- }, {
1585
- name: string;
1586
- columns: string[];
1587
- }>>>;
1588
1447
  }, "strict", import("zod").ZodTypeAny, {
1589
1448
  schema?: string | undefined;
1590
1449
  name: string;
@@ -1614,20 +1473,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
1614
1473
  tableTo: string;
1615
1474
  columnsTo: string[];
1616
1475
  }>;
1617
- compositePrimaryKeys: Record<string, {
1618
- name: string;
1619
- columns: string[];
1620
- }>;
1621
- uniqueConstraints: Record<string, {
1622
- name: string;
1623
- columns: string[];
1624
- }>;
1625
1476
  }, {
1626
1477
  schema?: string | undefined;
1627
- uniqueConstraints?: Record<string, {
1628
- name: string;
1629
- columns: string[];
1630
- }> | undefined;
1631
1478
  name: string;
1632
1479
  columns: Record<string, {
1633
1480
  default?: any;
@@ -1655,64 +1502,16 @@ export declare const schemaInternal: import("zod").ZodObject<{
1655
1502
  tableTo: string;
1656
1503
  columnsTo: string[];
1657
1504
  }>;
1658
- compositePrimaryKeys: Record<string, {
1659
- name: string;
1660
- columns: string[];
1661
- }>;
1662
1505
  }>>;
1663
1506
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1664
- _meta: import("zod").ZodObject<{
1665
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1666
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1667
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1668
- }, "strip", import("zod").ZodTypeAny, {
1669
- columns: Record<string, string>;
1670
- tables: Record<string, string>;
1671
- schemas: Record<string, string>;
1672
- }, {
1673
- columns: Record<string, string>;
1674
- tables: Record<string, string>;
1675
- schemas: Record<string, string>;
1676
- }>;
1677
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
1678
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1679
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1680
- isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
1681
- }, "strip", import("zod").ZodTypeAny, {
1682
- isDefaultAnExpression?: boolean | undefined;
1683
- }, {
1684
- isDefaultAnExpression?: boolean | undefined;
1685
- }>>>;
1686
- }, "strip", import("zod").ZodTypeAny, {
1687
- columns: Record<string, {
1688
- isDefaultAnExpression?: boolean | undefined;
1689
- } | undefined>;
1690
- }, {
1691
- columns: Record<string, {
1692
- isDefaultAnExpression?: boolean | undefined;
1693
- } | undefined>;
1694
- }>>>;
1695
- }, "strip", import("zod").ZodTypeAny, {
1696
- tables: Record<string, {
1697
- columns: Record<string, {
1698
- isDefaultAnExpression?: boolean | undefined;
1699
- } | undefined>;
1700
- } | undefined>;
1701
- }, {
1702
- tables: Record<string, {
1703
- columns: Record<string, {
1704
- isDefaultAnExpression?: boolean | undefined;
1705
- } | undefined>;
1706
- } | undefined>;
1707
- }>>;
1708
- }, "strict", import("zod").ZodTypeAny, {
1709
- internal?: {
1710
- tables: Record<string, {
1711
- columns: Record<string, {
1712
- isDefaultAnExpression?: boolean | undefined;
1713
- } | undefined>;
1714
- } | undefined>;
1715
- } | undefined;
1507
+ }, {
1508
+ id: import("zod").ZodString;
1509
+ prevId: import("zod").ZodString;
1510
+ }>, "strip", import("zod").ZodTypeAny, {
1511
+ id: string;
1512
+ prevId: string;
1513
+ version: "4";
1514
+ dialect: "mysql";
1716
1515
  tables: Record<string, {
1717
1516
  schema?: string | undefined;
1718
1517
  name: string;
@@ -1742,37 +1541,15 @@ export declare const schemaInternal: import("zod").ZodObject<{
1742
1541
  tableTo: string;
1743
1542
  columnsTo: string[];
1744
1543
  }>;
1745
- compositePrimaryKeys: Record<string, {
1746
- name: string;
1747
- columns: string[];
1748
- }>;
1749
- uniqueConstraints: Record<string, {
1750
- name: string;
1751
- columns: string[];
1752
- }>;
1753
1544
  }>;
1754
- version: "6";
1755
- dialect: "mysql";
1756
1545
  schemas: Record<string, string>;
1757
- _meta: {
1758
- columns: Record<string, string>;
1759
- tables: Record<string, string>;
1760
- schemas: Record<string, string>;
1761
- };
1762
1546
  }, {
1763
- internal?: {
1764
- tables: Record<string, {
1765
- columns: Record<string, {
1766
- isDefaultAnExpression?: boolean | undefined;
1767
- } | undefined>;
1768
- } | undefined>;
1769
- } | undefined;
1547
+ id: string;
1548
+ prevId: string;
1549
+ version: "4";
1550
+ dialect: "mysql";
1770
1551
  tables: Record<string, {
1771
1552
  schema?: string | undefined;
1772
- uniqueConstraints?: Record<string, {
1773
- name: string;
1774
- columns: string[];
1775
- }> | undefined;
1776
1553
  name: string;
1777
1554
  columns: Record<string, {
1778
1555
  default?: any;
@@ -1800,25 +1577,15 @@ export declare const schemaInternal: import("zod").ZodObject<{
1800
1577
  tableTo: string;
1801
1578
  columnsTo: string[];
1802
1579
  }>;
1803
- compositePrimaryKeys: Record<string, {
1804
- name: string;
1805
- columns: string[];
1806
- }>;
1807
1580
  }>;
1808
- version: "6";
1809
- dialect: "mysql";
1810
1581
  schemas: Record<string, string>;
1811
- _meta: {
1812
- columns: Record<string, string>;
1813
- tables: Record<string, string>;
1814
- schemas: Record<string, string>;
1815
- };
1816
1582
  }>;
1817
- export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
1818
- version: import("zod").ZodLiteral<"3">;
1583
+ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1584
+ version: import("zod").ZodLiteral<"5">;
1819
1585
  dialect: import("zod").ZodLiteral<"mysql">;
1820
1586
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1821
1587
  name: import("zod").ZodString;
1588
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
1822
1589
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1823
1590
  name: import("zod").ZodString;
1824
1591
  type: import("zod").ZodString;
@@ -1891,7 +1658,28 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1891
1658
  tableTo: string;
1892
1659
  columnsTo: string[];
1893
1660
  }>>;
1661
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1662
+ name: import("zod").ZodString;
1663
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1664
+ }, "strict", import("zod").ZodTypeAny, {
1665
+ name: string;
1666
+ columns: string[];
1667
+ }, {
1668
+ name: string;
1669
+ columns: string[];
1670
+ }>>;
1671
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1672
+ name: import("zod").ZodString;
1673
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1674
+ }, "strict", import("zod").ZodTypeAny, {
1675
+ name: string;
1676
+ columns: string[];
1677
+ }, {
1678
+ name: string;
1679
+ columns: string[];
1680
+ }>>>;
1894
1681
  }, "strict", import("zod").ZodTypeAny, {
1682
+ schema?: string | undefined;
1895
1683
  name: string;
1896
1684
  columns: Record<string, {
1897
1685
  default?: any;
@@ -1919,7 +1707,20 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1919
1707
  tableTo: string;
1920
1708
  columnsTo: string[];
1921
1709
  }>;
1710
+ compositePrimaryKeys: Record<string, {
1711
+ name: string;
1712
+ columns: string[];
1713
+ }>;
1714
+ uniqueConstraints: Record<string, {
1715
+ name: string;
1716
+ columns: string[];
1717
+ }>;
1922
1718
  }, {
1719
+ schema?: string | undefined;
1720
+ uniqueConstraints?: Record<string, {
1721
+ name: string;
1722
+ columns: string[];
1723
+ }> | undefined;
1923
1724
  name: string;
1924
1725
  columns: Record<string, {
1925
1726
  default?: any;
@@ -1947,12 +1748,73 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1947
1748
  tableTo: string;
1948
1749
  columnsTo: string[];
1949
1750
  }>;
1751
+ compositePrimaryKeys: Record<string, {
1752
+ name: string;
1753
+ columns: string[];
1754
+ }>;
1755
+ }>>;
1756
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1757
+ _meta: import("zod").ZodObject<{
1758
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1759
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1760
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1761
+ }, "strip", import("zod").ZodTypeAny, {
1762
+ columns: Record<string, string>;
1763
+ tables: Record<string, string>;
1764
+ schemas: Record<string, string>;
1765
+ }, {
1766
+ columns: Record<string, string>;
1767
+ tables: Record<string, string>;
1768
+ schemas: Record<string, string>;
1769
+ }>;
1770
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
1771
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1772
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1773
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
1774
+ }, "strip", import("zod").ZodTypeAny, {
1775
+ isDefaultAnExpression?: boolean | undefined;
1776
+ }, {
1777
+ isDefaultAnExpression?: boolean | undefined;
1778
+ }>>>;
1779
+ }, "strip", import("zod").ZodTypeAny, {
1780
+ columns: Record<string, {
1781
+ isDefaultAnExpression?: boolean | undefined;
1782
+ } | undefined>;
1783
+ }, {
1784
+ columns: Record<string, {
1785
+ isDefaultAnExpression?: boolean | undefined;
1786
+ } | undefined>;
1787
+ }>>>;
1788
+ }, "strip", import("zod").ZodTypeAny, {
1789
+ tables: Record<string, {
1790
+ columns: Record<string, {
1791
+ isDefaultAnExpression?: boolean | undefined;
1792
+ } | undefined>;
1793
+ } | undefined>;
1794
+ }, {
1795
+ tables: Record<string, {
1796
+ columns: Record<string, {
1797
+ isDefaultAnExpression?: boolean | undefined;
1798
+ } | undefined>;
1799
+ } | undefined>;
1950
1800
  }>>;
1951
1801
  }, {
1952
1802
  id: import("zod").ZodString;
1953
1803
  prevId: import("zod").ZodString;
1954
1804
  }>, "strip", import("zod").ZodTypeAny, {
1805
+ internal?: {
1806
+ tables: Record<string, {
1807
+ columns: Record<string, {
1808
+ isDefaultAnExpression?: boolean | undefined;
1809
+ } | undefined>;
1810
+ } | undefined>;
1811
+ } | undefined;
1812
+ id: string;
1813
+ prevId: string;
1814
+ version: "5";
1815
+ dialect: "mysql";
1955
1816
  tables: Record<string, {
1817
+ schema?: string | undefined;
1956
1818
  name: string;
1957
1819
  columns: Record<string, {
1958
1820
  default?: any;
@@ -1980,13 +1842,39 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1980
1842
  tableTo: string;
1981
1843
  columnsTo: string[];
1982
1844
  }>;
1845
+ compositePrimaryKeys: Record<string, {
1846
+ name: string;
1847
+ columns: string[];
1848
+ }>;
1849
+ uniqueConstraints: Record<string, {
1850
+ name: string;
1851
+ columns: string[];
1852
+ }>;
1983
1853
  }>;
1854
+ schemas: Record<string, string>;
1855
+ _meta: {
1856
+ columns: Record<string, string>;
1857
+ tables: Record<string, string>;
1858
+ schemas: Record<string, string>;
1859
+ };
1860
+ }, {
1861
+ internal?: {
1862
+ tables: Record<string, {
1863
+ columns: Record<string, {
1864
+ isDefaultAnExpression?: boolean | undefined;
1865
+ } | undefined>;
1866
+ } | undefined>;
1867
+ } | undefined;
1984
1868
  id: string;
1985
1869
  prevId: string;
1986
- version: "3";
1870
+ version: "5";
1987
1871
  dialect: "mysql";
1988
- }, {
1989
1872
  tables: Record<string, {
1873
+ schema?: string | undefined;
1874
+ uniqueConstraints?: Record<string, {
1875
+ name: string;
1876
+ columns: string[];
1877
+ }> | undefined;
1990
1878
  name: string;
1991
1879
  columns: Record<string, {
1992
1880
  default?: any;
@@ -2014,14 +1902,20 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
2014
1902
  tableTo: string;
2015
1903
  columnsTo: string[];
2016
1904
  }>;
1905
+ compositePrimaryKeys: Record<string, {
1906
+ name: string;
1907
+ columns: string[];
1908
+ }>;
2017
1909
  }>;
2018
- id: string;
2019
- prevId: string;
2020
- version: "3";
2021
- dialect: "mysql";
1910
+ schemas: Record<string, string>;
1911
+ _meta: {
1912
+ columns: Record<string, string>;
1913
+ tables: Record<string, string>;
1914
+ schemas: Record<string, string>;
1915
+ };
2022
1916
  }>;
2023
- export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
2024
- version: import("zod").ZodLiteral<"4">;
1917
+ export declare const schemaSquashed: import("zod").ZodObject<{
1918
+ version: import("zod").ZodLiteral<"5">;
2025
1919
  dialect: import("zod").ZodLiteral<"mysql">;
2026
1920
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2027
1921
  name: import("zod").ZodString;
@@ -2051,53 +1945,10 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
2051
1945
  primaryKey: boolean;
2052
1946
  notNull: boolean;
2053
1947
  }>>;
2054
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2055
- name: import("zod").ZodString;
2056
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2057
- isUnique: import("zod").ZodBoolean;
2058
- using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2059
- algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2060
- lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2061
- }, "strict", import("zod").ZodTypeAny, {
2062
- using?: "btree" | "hash" | undefined;
2063
- algorithm?: "default" | "inplace" | "copy" | undefined;
2064
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2065
- name: string;
2066
- columns: string[];
2067
- isUnique: boolean;
2068
- }, {
2069
- using?: "btree" | "hash" | undefined;
2070
- algorithm?: "default" | "inplace" | "copy" | undefined;
2071
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2072
- name: string;
2073
- columns: string[];
2074
- isUnique: boolean;
2075
- }>>;
2076
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2077
- name: import("zod").ZodString;
2078
- tableFrom: import("zod").ZodString;
2079
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2080
- tableTo: import("zod").ZodString;
2081
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2082
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2083
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2084
- }, "strict", import("zod").ZodTypeAny, {
2085
- onUpdate?: string | undefined;
2086
- onDelete?: string | undefined;
2087
- name: string;
2088
- tableFrom: string;
2089
- columnsFrom: string[];
2090
- tableTo: string;
2091
- columnsTo: string[];
2092
- }, {
2093
- onUpdate?: string | undefined;
2094
- onDelete?: string | undefined;
2095
- name: string;
2096
- tableFrom: string;
2097
- columnsFrom: string[];
2098
- tableTo: string;
2099
- columnsTo: string[];
2100
- }>>;
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>>;
2101
1952
  }, "strict", import("zod").ZodTypeAny, {
2102
1953
  schema?: string | undefined;
2103
1954
  name: string;
@@ -2110,25 +1961,13 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
2110
1961
  primaryKey: boolean;
2111
1962
  notNull: boolean;
2112
1963
  }>;
2113
- indexes: Record<string, {
2114
- using?: "btree" | "hash" | undefined;
2115
- algorithm?: "default" | "inplace" | "copy" | undefined;
2116
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2117
- name: string;
2118
- columns: string[];
2119
- isUnique: boolean;
2120
- }>;
2121
- foreignKeys: Record<string, {
2122
- onUpdate?: string | undefined;
2123
- onDelete?: string | undefined;
2124
- name: string;
2125
- tableFrom: string;
2126
- columnsFrom: string[];
2127
- tableTo: string;
2128
- columnsTo: string[];
2129
- }>;
1964
+ indexes: Record<string, string>;
1965
+ foreignKeys: Record<string, string>;
1966
+ compositePrimaryKeys: Record<string, string>;
1967
+ uniqueConstraints: Record<string, string>;
2130
1968
  }, {
2131
1969
  schema?: string | undefined;
1970
+ uniqueConstraints?: Record<string, string> | undefined;
2132
1971
  name: string;
2133
1972
  columns: Record<string, {
2134
1973
  default?: any;
@@ -2139,29 +1978,14 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
2139
1978
  primaryKey: boolean;
2140
1979
  notNull: boolean;
2141
1980
  }>;
2142
- indexes: Record<string, {
2143
- using?: "btree" | "hash" | undefined;
2144
- algorithm?: "default" | "inplace" | "copy" | undefined;
2145
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2146
- name: string;
2147
- columns: string[];
2148
- isUnique: boolean;
2149
- }>;
2150
- foreignKeys: Record<string, {
2151
- onUpdate?: string | undefined;
2152
- onDelete?: string | undefined;
2153
- name: string;
2154
- tableFrom: string;
2155
- columnsFrom: string[];
2156
- tableTo: string;
2157
- columnsTo: string[];
2158
- }>;
1981
+ indexes: Record<string, string>;
1982
+ foreignKeys: Record<string, string>;
1983
+ compositePrimaryKeys: Record<string, string>;
2159
1984
  }>>;
2160
1985
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2161
- }, {
2162
- id: import("zod").ZodString;
2163
- prevId: import("zod").ZodString;
2164
- }>, "strip", import("zod").ZodTypeAny, {
1986
+ }, "strict", import("zod").ZodTypeAny, {
1987
+ version: "5";
1988
+ dialect: "mysql";
2165
1989
  tables: Record<string, {
2166
1990
  schema?: string | undefined;
2167
1991
  name: string;
@@ -2174,32 +1998,18 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
2174
1998
  primaryKey: boolean;
2175
1999
  notNull: boolean;
2176
2000
  }>;
2177
- indexes: Record<string, {
2178
- using?: "btree" | "hash" | undefined;
2179
- algorithm?: "default" | "inplace" | "copy" | undefined;
2180
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2181
- name: string;
2182
- columns: string[];
2183
- isUnique: boolean;
2184
- }>;
2185
- foreignKeys: Record<string, {
2186
- onUpdate?: string | undefined;
2187
- onDelete?: string | undefined;
2188
- name: string;
2189
- tableFrom: string;
2190
- columnsFrom: string[];
2191
- tableTo: string;
2192
- columnsTo: string[];
2193
- }>;
2001
+ indexes: Record<string, string>;
2002
+ foreignKeys: Record<string, string>;
2003
+ compositePrimaryKeys: Record<string, string>;
2004
+ uniqueConstraints: Record<string, string>;
2194
2005
  }>;
2195
- id: string;
2196
- prevId: string;
2197
- version: "4";
2198
- dialect: "mysql";
2199
2006
  schemas: Record<string, string>;
2200
2007
  }, {
2008
+ version: "5";
2009
+ dialect: "mysql";
2201
2010
  tables: Record<string, {
2202
2011
  schema?: string | undefined;
2012
+ uniqueConstraints?: Record<string, string> | undefined;
2203
2013
  name: string;
2204
2014
  columns: Record<string, {
2205
2015
  default?: any;
@@ -2210,32 +2020,14 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
2210
2020
  primaryKey: boolean;
2211
2021
  notNull: boolean;
2212
2022
  }>;
2213
- indexes: Record<string, {
2214
- using?: "btree" | "hash" | undefined;
2215
- algorithm?: "default" | "inplace" | "copy" | undefined;
2216
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2217
- name: string;
2218
- columns: string[];
2219
- isUnique: boolean;
2220
- }>;
2221
- foreignKeys: Record<string, {
2222
- onUpdate?: string | undefined;
2223
- onDelete?: string | undefined;
2224
- name: string;
2225
- tableFrom: string;
2226
- columnsFrom: string[];
2227
- tableTo: string;
2228
- columnsTo: string[];
2229
- }>;
2023
+ indexes: Record<string, string>;
2024
+ foreignKeys: Record<string, string>;
2025
+ compositePrimaryKeys: Record<string, string>;
2230
2026
  }>;
2231
- id: string;
2232
- prevId: string;
2233
- version: "4";
2234
- dialect: "mysql";
2235
2027
  schemas: Record<string, string>;
2236
2028
  }>;
2237
- export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape<{
2238
- version: import("zod").ZodLiteral<"5">;
2029
+ export declare const schemaSquashedV4: import("zod").ZodObject<{
2030
+ version: import("zod").ZodLiteral<"4">;
2239
2031
  dialect: import("zod").ZodLiteral<"mysql">;
2240
2032
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2241
2033
  name: import("zod").ZodString;
@@ -2265,73 +2057,8 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
2265
2057
  primaryKey: boolean;
2266
2058
  notNull: boolean;
2267
2059
  }>>;
2268
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2269
- name: import("zod").ZodString;
2270
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2271
- isUnique: import("zod").ZodBoolean;
2272
- using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2273
- algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2274
- lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2275
- }, "strict", import("zod").ZodTypeAny, {
2276
- using?: "btree" | "hash" | undefined;
2277
- algorithm?: "default" | "inplace" | "copy" | undefined;
2278
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2279
- name: string;
2280
- columns: string[];
2281
- isUnique: boolean;
2282
- }, {
2283
- using?: "btree" | "hash" | undefined;
2284
- algorithm?: "default" | "inplace" | "copy" | undefined;
2285
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2286
- name: string;
2287
- columns: string[];
2288
- isUnique: boolean;
2289
- }>>;
2290
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2291
- name: import("zod").ZodString;
2292
- tableFrom: import("zod").ZodString;
2293
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2294
- tableTo: import("zod").ZodString;
2295
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2296
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2297
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2298
- }, "strict", import("zod").ZodTypeAny, {
2299
- onUpdate?: string | undefined;
2300
- onDelete?: string | undefined;
2301
- name: string;
2302
- tableFrom: string;
2303
- columnsFrom: string[];
2304
- tableTo: string;
2305
- columnsTo: string[];
2306
- }, {
2307
- onUpdate?: string | undefined;
2308
- onDelete?: string | undefined;
2309
- name: string;
2310
- tableFrom: string;
2311
- columnsFrom: string[];
2312
- tableTo: string;
2313
- columnsTo: string[];
2314
- }>>;
2315
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2316
- name: import("zod").ZodString;
2317
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2318
- }, "strict", import("zod").ZodTypeAny, {
2319
- name: string;
2320
- columns: string[];
2321
- }, {
2322
- name: string;
2323
- columns: string[];
2324
- }>>;
2325
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2326
- name: import("zod").ZodString;
2327
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2328
- }, "strict", import("zod").ZodTypeAny, {
2329
- name: string;
2330
- columns: string[];
2331
- }, {
2332
- name: string;
2333
- columns: string[];
2334
- }>>>;
2060
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2061
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2335
2062
  }, "strict", import("zod").ZodTypeAny, {
2336
2063
  schema?: string | undefined;
2337
2064
  name: string;
@@ -2344,37 +2071,10 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
2344
2071
  primaryKey: boolean;
2345
2072
  notNull: boolean;
2346
2073
  }>;
2347
- indexes: Record<string, {
2348
- using?: "btree" | "hash" | undefined;
2349
- algorithm?: "default" | "inplace" | "copy" | undefined;
2350
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2351
- name: string;
2352
- columns: string[];
2353
- isUnique: boolean;
2354
- }>;
2355
- foreignKeys: Record<string, {
2356
- onUpdate?: string | undefined;
2357
- onDelete?: string | undefined;
2358
- name: string;
2359
- tableFrom: string;
2360
- columnsFrom: string[];
2361
- tableTo: string;
2362
- columnsTo: string[];
2363
- }>;
2364
- compositePrimaryKeys: Record<string, {
2365
- name: string;
2366
- columns: string[];
2367
- }>;
2368
- uniqueConstraints: Record<string, {
2369
- name: string;
2370
- columns: string[];
2371
- }>;
2074
+ indexes: Record<string, string>;
2075
+ foreignKeys: Record<string, string>;
2372
2076
  }, {
2373
2077
  schema?: string | undefined;
2374
- uniqueConstraints?: Record<string, {
2375
- name: string;
2376
- columns: string[];
2377
- }> | undefined;
2378
2078
  name: string;
2379
2079
  columns: Record<string, {
2380
2080
  default?: any;
@@ -2385,84 +2085,13 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
2385
2085
  primaryKey: boolean;
2386
2086
  notNull: boolean;
2387
2087
  }>;
2388
- indexes: Record<string, {
2389
- using?: "btree" | "hash" | undefined;
2390
- algorithm?: "default" | "inplace" | "copy" | undefined;
2391
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2392
- name: string;
2393
- columns: string[];
2394
- isUnique: boolean;
2395
- }>;
2396
- foreignKeys: Record<string, {
2397
- onUpdate?: string | undefined;
2398
- onDelete?: string | undefined;
2399
- name: string;
2400
- tableFrom: string;
2401
- columnsFrom: string[];
2402
- tableTo: string;
2403
- columnsTo: string[];
2404
- }>;
2405
- compositePrimaryKeys: Record<string, {
2406
- name: string;
2407
- columns: string[];
2408
- }>;
2088
+ indexes: Record<string, string>;
2089
+ foreignKeys: Record<string, string>;
2409
2090
  }>>;
2410
2091
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2411
- _meta: import("zod").ZodObject<{
2412
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2413
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2414
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2415
- }, "strip", import("zod").ZodTypeAny, {
2416
- columns: Record<string, string>;
2417
- tables: Record<string, string>;
2418
- schemas: Record<string, string>;
2419
- }, {
2420
- columns: Record<string, string>;
2421
- tables: Record<string, string>;
2422
- schemas: Record<string, string>;
2423
- }>;
2424
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
2425
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2426
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2427
- isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
2428
- }, "strip", import("zod").ZodTypeAny, {
2429
- isDefaultAnExpression?: boolean | undefined;
2430
- }, {
2431
- isDefaultAnExpression?: boolean | undefined;
2432
- }>>>;
2433
- }, "strip", import("zod").ZodTypeAny, {
2434
- columns: Record<string, {
2435
- isDefaultAnExpression?: boolean | undefined;
2436
- } | undefined>;
2437
- }, {
2438
- columns: Record<string, {
2439
- isDefaultAnExpression?: boolean | undefined;
2440
- } | undefined>;
2441
- }>>>;
2442
- }, "strip", import("zod").ZodTypeAny, {
2443
- tables: Record<string, {
2444
- columns: Record<string, {
2445
- isDefaultAnExpression?: boolean | undefined;
2446
- } | undefined>;
2447
- } | undefined>;
2448
- }, {
2449
- tables: Record<string, {
2450
- columns: Record<string, {
2451
- isDefaultAnExpression?: boolean | undefined;
2452
- } | undefined>;
2453
- } | undefined>;
2454
- }>>;
2455
- }, {
2456
- id: import("zod").ZodString;
2457
- prevId: import("zod").ZodString;
2458
- }>, "strip", import("zod").ZodTypeAny, {
2459
- internal?: {
2460
- tables: Record<string, {
2461
- columns: Record<string, {
2462
- isDefaultAnExpression?: boolean | undefined;
2463
- } | undefined>;
2464
- } | undefined>;
2465
- } | undefined;
2092
+ }, "strict", import("zod").ZodTypeAny, {
2093
+ version: "4";
2094
+ dialect: "mysql";
2466
2095
  tables: Record<string, {
2467
2096
  schema?: string | undefined;
2468
2097
  name: string;
@@ -2475,56 +2104,15 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
2475
2104
  primaryKey: boolean;
2476
2105
  notNull: boolean;
2477
2106
  }>;
2478
- indexes: Record<string, {
2479
- using?: "btree" | "hash" | undefined;
2480
- algorithm?: "default" | "inplace" | "copy" | undefined;
2481
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2482
- name: string;
2483
- columns: string[];
2484
- isUnique: boolean;
2485
- }>;
2486
- foreignKeys: Record<string, {
2487
- onUpdate?: string | undefined;
2488
- onDelete?: string | undefined;
2489
- name: string;
2490
- tableFrom: string;
2491
- columnsFrom: string[];
2492
- tableTo: string;
2493
- columnsTo: string[];
2494
- }>;
2495
- compositePrimaryKeys: Record<string, {
2496
- name: string;
2497
- columns: string[];
2498
- }>;
2499
- uniqueConstraints: Record<string, {
2500
- name: string;
2501
- columns: string[];
2502
- }>;
2107
+ indexes: Record<string, string>;
2108
+ foreignKeys: Record<string, string>;
2503
2109
  }>;
2504
- id: string;
2505
- prevId: string;
2506
- version: "5";
2507
- dialect: "mysql";
2508
2110
  schemas: Record<string, string>;
2509
- _meta: {
2510
- columns: Record<string, string>;
2511
- tables: Record<string, string>;
2512
- schemas: Record<string, string>;
2513
- };
2514
2111
  }, {
2515
- internal?: {
2516
- tables: Record<string, {
2517
- columns: Record<string, {
2518
- isDefaultAnExpression?: boolean | undefined;
2519
- } | undefined>;
2520
- } | undefined>;
2521
- } | undefined;
2112
+ version: "4";
2113
+ dialect: "mysql";
2522
2114
  tables: Record<string, {
2523
2115
  schema?: string | undefined;
2524
- uniqueConstraints?: Record<string, {
2525
- name: string;
2526
- columns: string[];
2527
- }> | undefined;
2528
2116
  name: string;
2529
2117
  columns: Record<string, {
2530
2118
  default?: any;
@@ -2535,41 +2123,40 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
2535
2123
  primaryKey: boolean;
2536
2124
  notNull: boolean;
2537
2125
  }>;
2538
- indexes: Record<string, {
2539
- using?: "btree" | "hash" | undefined;
2540
- algorithm?: "default" | "inplace" | "copy" | undefined;
2541
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2542
- name: string;
2543
- columns: string[];
2544
- isUnique: boolean;
2545
- }>;
2546
- foreignKeys: Record<string, {
2547
- onUpdate?: string | undefined;
2548
- onDelete?: string | undefined;
2549
- name: string;
2550
- tableFrom: string;
2551
- columnsFrom: string[];
2552
- tableTo: string;
2553
- columnsTo: string[];
2554
- }>;
2555
- compositePrimaryKeys: Record<string, {
2556
- name: string;
2557
- columns: string[];
2558
- }>;
2126
+ indexes: Record<string, string>;
2127
+ foreignKeys: Record<string, string>;
2559
2128
  }>;
2560
- id: string;
2561
- prevId: string;
2562
- version: "5";
2563
- dialect: "mysql";
2564
2129
  schemas: Record<string, string>;
2565
- _meta: {
2566
- columns: Record<string, string>;
2567
- tables: Record<string, string>;
2568
- schemas: Record<string, string>;
2569
- };
2570
2130
  }>;
2571
- export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2572
- version: import("zod").ZodLiteral<"6">;
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">;
2573
2160
  dialect: import("zod").ZodLiteral<"mysql">;
2574
2161
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2575
2162
  name: import("zod").ZodString;
@@ -2797,6 +2384,10 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2797
2384
  } | undefined>;
2798
2385
  } | undefined>;
2799
2386
  } | undefined;
2387
+ id: string;
2388
+ prevId: string;
2389
+ version: "5";
2390
+ dialect: "mysql";
2800
2391
  tables: Record<string, {
2801
2392
  schema?: string | undefined;
2802
2393
  name: string;
@@ -2835,10 +2426,6 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2835
2426
  columns: string[];
2836
2427
  }>;
2837
2428
  }>;
2838
- id: string;
2839
- prevId: string;
2840
- version: "6";
2841
- dialect: "mysql";
2842
2429
  schemas: Record<string, string>;
2843
2430
  _meta: {
2844
2431
  columns: Record<string, string>;
@@ -2853,6 +2440,10 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2853
2440
  } | undefined>;
2854
2441
  } | undefined>;
2855
2442
  } | undefined;
2443
+ id: string;
2444
+ prevId: string;
2445
+ version: "5";
2446
+ dialect: "mysql";
2856
2447
  tables: Record<string, {
2857
2448
  schema?: string | undefined;
2858
2449
  uniqueConstraints?: Record<string, {
@@ -2891,10 +2482,6 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2891
2482
  columns: string[];
2892
2483
  }>;
2893
2484
  }>;
2894
- id: string;
2895
- prevId: string;
2896
- version: "6";
2897
- dialect: "mysql";
2898
2485
  schemas: Record<string, string>;
2899
2486
  _meta: {
2900
2487
  columns: Record<string, string>;
@@ -2902,8 +2489,8 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2902
2489
  schemas: Record<string, string>;
2903
2490
  };
2904
2491
  }>;
2905
- export declare const schemaSquashed: import("zod").ZodObject<{
2906
- version: import("zod").ZodLiteral<"5">;
2492
+ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
2493
+ version: import("zod").ZodLiteral<"4">;
2907
2494
  dialect: import("zod").ZodLiteral<"mysql">;
2908
2495
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2909
2496
  name: import("zod").ZodString;
@@ -2933,120 +2520,53 @@ export declare const schemaSquashed: import("zod").ZodObject<{
2933
2520
  primaryKey: boolean;
2934
2521
  notNull: boolean;
2935
2522
  }>>;
2936
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2937
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2938
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2939
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
2940
- }, "strict", import("zod").ZodTypeAny, {
2941
- schema?: string | undefined;
2942
- name: string;
2943
- columns: Record<string, {
2944
- default?: any;
2945
- onUpdate?: any;
2946
- autoincrement?: boolean | undefined;
2947
- name: string;
2948
- type: string;
2949
- primaryKey: boolean;
2950
- notNull: boolean;
2951
- }>;
2952
- indexes: Record<string, string>;
2953
- foreignKeys: Record<string, string>;
2954
- compositePrimaryKeys: Record<string, string>;
2955
- uniqueConstraints: Record<string, string>;
2956
- }, {
2957
- schema?: string | undefined;
2958
- uniqueConstraints?: Record<string, string> | undefined;
2959
- name: string;
2960
- columns: Record<string, {
2961
- default?: any;
2962
- onUpdate?: any;
2963
- autoincrement?: boolean | undefined;
2523
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2524
+ name: import("zod").ZodString;
2525
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2526
+ isUnique: import("zod").ZodBoolean;
2527
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2528
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2529
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2530
+ }, "strict", import("zod").ZodTypeAny, {
2531
+ using?: "btree" | "hash" | undefined;
2532
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2533
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2964
2534
  name: string;
2965
- type: string;
2966
- primaryKey: boolean;
2967
- notNull: boolean;
2968
- }>;
2969
- indexes: Record<string, string>;
2970
- foreignKeys: Record<string, string>;
2971
- compositePrimaryKeys: Record<string, string>;
2972
- }>>;
2973
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2974
- }, "strict", import("zod").ZodTypeAny, {
2975
- tables: Record<string, {
2976
- schema?: string | undefined;
2977
- name: string;
2978
- columns: Record<string, {
2979
- default?: any;
2980
- onUpdate?: any;
2981
- autoincrement?: boolean | undefined;
2982
- name: string;
2983
- type: string;
2984
- primaryKey: boolean;
2985
- notNull: boolean;
2986
- }>;
2987
- indexes: Record<string, string>;
2988
- foreignKeys: Record<string, string>;
2989
- compositePrimaryKeys: Record<string, string>;
2990
- uniqueConstraints: Record<string, string>;
2991
- }>;
2992
- version: "5";
2993
- dialect: "mysql";
2994
- schemas: Record<string, string>;
2995
- }, {
2996
- tables: Record<string, {
2997
- schema?: string | undefined;
2998
- uniqueConstraints?: Record<string, string> | undefined;
2999
- name: string;
3000
- columns: Record<string, {
3001
- default?: any;
3002
- onUpdate?: any;
3003
- autoincrement?: boolean | undefined;
2535
+ columns: string[];
2536
+ isUnique: boolean;
2537
+ }, {
2538
+ using?: "btree" | "hash" | undefined;
2539
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2540
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3004
2541
  name: string;
3005
- type: string;
3006
- primaryKey: boolean;
3007
- notNull: boolean;
3008
- }>;
3009
- indexes: Record<string, string>;
3010
- foreignKeys: Record<string, string>;
3011
- compositePrimaryKeys: Record<string, string>;
3012
- }>;
3013
- version: "5";
3014
- dialect: "mysql";
3015
- schemas: Record<string, string>;
3016
- }>;
3017
- export declare const schemaSquashedV4: import("zod").ZodObject<{
3018
- version: import("zod").ZodLiteral<"4">;
3019
- dialect: import("zod").ZodLiteral<"mysql">;
3020
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3021
- name: import("zod").ZodString;
3022
- schema: import("zod").ZodOptional<import("zod").ZodString>;
3023
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2542
+ columns: string[];
2543
+ isUnique: boolean;
2544
+ }>>;
2545
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3024
2546
  name: import("zod").ZodString;
3025
- type: import("zod").ZodString;
3026
- primaryKey: import("zod").ZodBoolean;
3027
- notNull: import("zod").ZodBoolean;
3028
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
3029
- default: import("zod").ZodOptional<import("zod").ZodAny>;
3030
- onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2547
+ tableFrom: import("zod").ZodString;
2548
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2549
+ tableTo: import("zod").ZodString;
2550
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2551
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2552
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3031
2553
  }, "strict", import("zod").ZodTypeAny, {
3032
- default?: any;
3033
- onUpdate?: any;
3034
- autoincrement?: boolean | undefined;
2554
+ onUpdate?: string | undefined;
2555
+ onDelete?: string | undefined;
3035
2556
  name: string;
3036
- type: string;
3037
- primaryKey: boolean;
3038
- notNull: boolean;
2557
+ tableFrom: string;
2558
+ columnsFrom: string[];
2559
+ tableTo: string;
2560
+ columnsTo: string[];
3039
2561
  }, {
3040
- default?: any;
3041
- onUpdate?: any;
3042
- autoincrement?: boolean | undefined;
2562
+ onUpdate?: string | undefined;
2563
+ onDelete?: string | undefined;
3043
2564
  name: string;
3044
- type: string;
3045
- primaryKey: boolean;
3046
- notNull: boolean;
2565
+ tableFrom: string;
2566
+ columnsFrom: string[];
2567
+ tableTo: string;
2568
+ columnsTo: string[];
3047
2569
  }>>;
3048
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3049
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3050
2570
  }, "strict", import("zod").ZodTypeAny, {
3051
2571
  schema?: string | undefined;
3052
2572
  name: string;
@@ -3059,8 +2579,23 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
3059
2579
  primaryKey: boolean;
3060
2580
  notNull: boolean;
3061
2581
  }>;
3062
- indexes: Record<string, string>;
3063
- foreignKeys: Record<string, string>;
2582
+ indexes: Record<string, {
2583
+ using?: "btree" | "hash" | undefined;
2584
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2585
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2586
+ name: string;
2587
+ columns: string[];
2588
+ isUnique: boolean;
2589
+ }>;
2590
+ foreignKeys: Record<string, {
2591
+ onUpdate?: string | undefined;
2592
+ onDelete?: string | undefined;
2593
+ name: string;
2594
+ tableFrom: string;
2595
+ columnsFrom: string[];
2596
+ tableTo: string;
2597
+ columnsTo: string[];
2598
+ }>;
3064
2599
  }, {
3065
2600
  schema?: string | undefined;
3066
2601
  name: string;
@@ -3073,11 +2608,33 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
3073
2608
  primaryKey: boolean;
3074
2609
  notNull: boolean;
3075
2610
  }>;
3076
- indexes: Record<string, string>;
3077
- foreignKeys: Record<string, string>;
2611
+ indexes: Record<string, {
2612
+ using?: "btree" | "hash" | undefined;
2613
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2614
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2615
+ name: string;
2616
+ columns: string[];
2617
+ isUnique: boolean;
2618
+ }>;
2619
+ foreignKeys: Record<string, {
2620
+ onUpdate?: string | undefined;
2621
+ onDelete?: string | undefined;
2622
+ name: string;
2623
+ tableFrom: string;
2624
+ columnsFrom: string[];
2625
+ tableTo: string;
2626
+ columnsTo: string[];
2627
+ }>;
3078
2628
  }>>;
3079
2629
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3080
- }, "strict", import("zod").ZodTypeAny, {
2630
+ }, {
2631
+ id: import("zod").ZodString;
2632
+ prevId: import("zod").ZodString;
2633
+ }>, "strip", import("zod").ZodTypeAny, {
2634
+ id: string;
2635
+ prevId: string;
2636
+ version: "4";
2637
+ dialect: "mysql";
3081
2638
  tables: Record<string, {
3082
2639
  schema?: string | undefined;
3083
2640
  name: string;
@@ -3090,13 +2647,30 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
3090
2647
  primaryKey: boolean;
3091
2648
  notNull: boolean;
3092
2649
  }>;
3093
- indexes: Record<string, string>;
3094
- foreignKeys: Record<string, string>;
2650
+ indexes: Record<string, {
2651
+ using?: "btree" | "hash" | undefined;
2652
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2653
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2654
+ name: string;
2655
+ columns: string[];
2656
+ isUnique: boolean;
2657
+ }>;
2658
+ foreignKeys: Record<string, {
2659
+ onUpdate?: string | undefined;
2660
+ onDelete?: string | undefined;
2661
+ name: string;
2662
+ tableFrom: string;
2663
+ columnsFrom: string[];
2664
+ tableTo: string;
2665
+ columnsTo: string[];
2666
+ }>;
3095
2667
  }>;
3096
- version: "4";
3097
- dialect: "mysql";
3098
2668
  schemas: Record<string, string>;
3099
2669
  }, {
2670
+ id: string;
2671
+ prevId: string;
2672
+ version: "4";
2673
+ dialect: "mysql";
3100
2674
  tables: Record<string, {
3101
2675
  schema?: string | undefined;
3102
2676
  name: string;
@@ -3109,47 +2683,31 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
3109
2683
  primaryKey: boolean;
3110
2684
  notNull: boolean;
3111
2685
  }>;
3112
- indexes: Record<string, string>;
3113
- foreignKeys: Record<string, string>;
2686
+ indexes: Record<string, {
2687
+ using?: "btree" | "hash" | undefined;
2688
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2689
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2690
+ name: string;
2691
+ columns: string[];
2692
+ isUnique: boolean;
2693
+ }>;
2694
+ foreignKeys: Record<string, {
2695
+ onUpdate?: string | undefined;
2696
+ onDelete?: string | undefined;
2697
+ name: string;
2698
+ tableFrom: string;
2699
+ columnsFrom: string[];
2700
+ tableTo: string;
2701
+ columnsTo: string[];
2702
+ }>;
3114
2703
  }>;
3115
- version: "4";
3116
- dialect: "mysql";
3117
2704
  schemas: Record<string, string>;
3118
2705
  }>;
3119
- export type Dialect = TypeOf<typeof dialect>;
3120
- export type Column = TypeOf<typeof column>;
3121
- export type Table = TypeOf<typeof table>;
3122
- export type TableV4 = TypeOf<typeof tableV4>;
3123
- export type MySqlSchema = TypeOf<typeof schema>;
3124
- export type MySqlSchemaV3 = TypeOf<typeof schemaV3>;
3125
- export type MySqlSchemaV4 = TypeOf<typeof schemaV4>;
3126
- export type MySqlSchemaV5 = TypeOf<typeof schemaV5>;
3127
- export type MySqlSchemaInternal = TypeOf<typeof schemaInternal>;
3128
- export type MySqlKitInternals = TypeOf<typeof kitInternals>;
3129
- export type MySqlSchemaSquashed = TypeOf<typeof schemaSquashed>;
3130
- export type MySqlSchemaSquashedV4 = TypeOf<typeof schemaSquashedV4>;
3131
- export type Index = TypeOf<typeof index>;
3132
- export type ForeignKey = TypeOf<typeof fk>;
3133
- export type PrimaryKey = TypeOf<typeof compositePK>;
3134
- export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
3135
- export declare const MySqlSquasher: {
3136
- squashIdx: (idx: Index) => string;
3137
- unsquashIdx: (input: string) => Index;
3138
- squashPK: (pk: PrimaryKey) => string;
3139
- unsquashPK: (pk: string) => PrimaryKey;
3140
- squashUnique: (unq: UniqueConstraint) => string;
3141
- unsquashUnique: (unq: string) => UniqueConstraint;
3142
- squashFK: (fk: ForeignKey) => string;
3143
- unsquashFK: (input: string) => ForeignKey;
3144
- };
3145
- export declare const squashMysqlSchemeV4: (json: MySqlSchemaV4) => MySqlSchemaSquashedV4;
3146
- export declare const squashMysqlScheme: (json: MySqlSchema) => MySqlSchemaSquashed;
3147
- export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendShape<{
3148
- version: import("zod").ZodLiteral<"6">;
2706
+ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
2707
+ version: import("zod").ZodLiteral<"3">;
3149
2708
  dialect: import("zod").ZodLiteral<"mysql">;
3150
2709
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3151
2710
  name: import("zod").ZodString;
3152
- schema: import("zod").ZodOptional<import("zod").ZodString>;
3153
2711
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3154
2712
  name: import("zod").ZodString;
3155
2713
  type: import("zod").ZodString;
@@ -3222,28 +2780,7 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
3222
2780
  tableTo: string;
3223
2781
  columnsTo: string[];
3224
2782
  }>>;
3225
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3226
- name: import("zod").ZodString;
3227
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3228
- }, "strict", import("zod").ZodTypeAny, {
3229
- name: string;
3230
- columns: string[];
3231
- }, {
3232
- name: string;
3233
- columns: string[];
3234
- }>>;
3235
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3236
- name: import("zod").ZodString;
3237
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3238
- }, "strict", import("zod").ZodTypeAny, {
3239
- name: string;
3240
- columns: string[];
3241
- }, {
3242
- name: string;
3243
- columns: string[];
3244
- }>>>;
3245
2783
  }, "strict", import("zod").ZodTypeAny, {
3246
- schema?: string | undefined;
3247
2784
  name: string;
3248
2785
  columns: Record<string, {
3249
2786
  default?: any;
@@ -3271,20 +2808,7 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
3271
2808
  tableTo: string;
3272
2809
  columnsTo: string[];
3273
2810
  }>;
3274
- compositePrimaryKeys: Record<string, {
3275
- name: string;
3276
- columns: string[];
3277
- }>;
3278
- uniqueConstraints: Record<string, {
3279
- name: string;
3280
- columns: string[];
3281
- }>;
3282
2811
  }, {
3283
- schema?: string | undefined;
3284
- uniqueConstraints?: Record<string, {
3285
- name: string;
3286
- columns: string[];
3287
- }> | undefined;
3288
2812
  name: string;
3289
2813
  columns: Record<string, {
3290
2814
  default?: any;
@@ -3312,69 +2836,16 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
3312
2836
  tableTo: string;
3313
2837
  columnsTo: string[];
3314
2838
  }>;
3315
- compositePrimaryKeys: Record<string, {
3316
- name: string;
3317
- columns: string[];
3318
- }>;
3319
- }>>;
3320
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3321
- _meta: import("zod").ZodObject<{
3322
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3323
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3324
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3325
- }, "strip", import("zod").ZodTypeAny, {
3326
- columns: Record<string, string>;
3327
- tables: Record<string, string>;
3328
- schemas: Record<string, string>;
3329
- }, {
3330
- columns: Record<string, string>;
3331
- tables: Record<string, string>;
3332
- schemas: Record<string, string>;
3333
- }>;
3334
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
3335
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
3336
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
3337
- isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
3338
- }, "strip", import("zod").ZodTypeAny, {
3339
- isDefaultAnExpression?: boolean | undefined;
3340
- }, {
3341
- isDefaultAnExpression?: boolean | undefined;
3342
- }>>>;
3343
- }, "strip", import("zod").ZodTypeAny, {
3344
- columns: Record<string, {
3345
- isDefaultAnExpression?: boolean | undefined;
3346
- } | undefined>;
3347
- }, {
3348
- columns: Record<string, {
3349
- isDefaultAnExpression?: boolean | undefined;
3350
- } | undefined>;
3351
- }>>>;
3352
- }, "strip", import("zod").ZodTypeAny, {
3353
- tables: Record<string, {
3354
- columns: Record<string, {
3355
- isDefaultAnExpression?: boolean | undefined;
3356
- } | undefined>;
3357
- } | undefined>;
3358
- }, {
3359
- tables: Record<string, {
3360
- columns: Record<string, {
3361
- isDefaultAnExpression?: boolean | undefined;
3362
- } | undefined>;
3363
- } | undefined>;
3364
2839
  }>>;
3365
2840
  }, {
3366
2841
  id: import("zod").ZodString;
3367
2842
  prevId: import("zod").ZodString;
3368
2843
  }>, "strip", import("zod").ZodTypeAny, {
3369
- internal?: {
3370
- tables: Record<string, {
3371
- columns: Record<string, {
3372
- isDefaultAnExpression?: boolean | undefined;
3373
- } | undefined>;
3374
- } | undefined>;
3375
- } | undefined;
2844
+ id: string;
2845
+ prevId: string;
2846
+ version: "3";
2847
+ dialect: "mysql";
3376
2848
  tables: Record<string, {
3377
- schema?: string | undefined;
3378
2849
  name: string;
3379
2850
  columns: Record<string, {
3380
2851
  default?: any;
@@ -3402,39 +2873,13 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
3402
2873
  tableTo: string;
3403
2874
  columnsTo: string[];
3404
2875
  }>;
3405
- compositePrimaryKeys: Record<string, {
3406
- name: string;
3407
- columns: string[];
3408
- }>;
3409
- uniqueConstraints: Record<string, {
3410
- name: string;
3411
- columns: string[];
3412
- }>;
3413
2876
  }>;
2877
+ }, {
3414
2878
  id: string;
3415
2879
  prevId: string;
3416
- version: "6";
2880
+ version: "3";
3417
2881
  dialect: "mysql";
3418
- schemas: Record<string, string>;
3419
- _meta: {
3420
- columns: Record<string, string>;
3421
- tables: Record<string, string>;
3422
- schemas: Record<string, string>;
3423
- };
3424
- }, {
3425
- internal?: {
3426
- tables: Record<string, {
3427
- columns: Record<string, {
3428
- isDefaultAnExpression?: boolean | undefined;
3429
- } | undefined>;
3430
- } | undefined>;
3431
- } | undefined;
3432
2882
  tables: Record<string, {
3433
- schema?: string | undefined;
3434
- uniqueConstraints?: Record<string, {
3435
- name: string;
3436
- columns: string[];
3437
- }> | undefined;
3438
2883
  name: string;
3439
2884
  columns: Record<string, {
3440
2885
  default?: any;
@@ -3462,23 +2907,121 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
3462
2907
  tableTo: string;
3463
2908
  columnsTo: string[];
3464
2909
  }>;
3465
- compositePrimaryKeys: Record<string, {
2910
+ }>;
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;
3466
2930
  name: string;
3467
- columns: 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;
3468
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>;
3469
3000
  }>;
3470
- id: string;
3471
- prevId: string;
3472
- version: "6";
3001
+ schemas: Record<string, string>;
3002
+ }, {
3003
+ version: "5";
3473
3004
  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
+ }>;
3474
3022
  schemas: Record<string, string>;
3475
- _meta: {
3476
- columns: Record<string, string>;
3477
- tables: Record<string, string>;
3478
- schemas: Record<string, string>;
3479
- };
3480
3023
  }>;
3481
- export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
3024
+ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
3482
3025
  version: import("zod").ZodLiteral<"3">;
3483
3026
  dialect: import("zod").ZodLiteral<"mysql">;
3484
3027
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3577,715 +3120,13 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
3577
3120
  foreignKeys: Record<string, {
3578
3121
  onUpdate?: string | undefined;
3579
3122
  onDelete?: string | undefined;
3580
- name: string;
3581
- tableFrom: string;
3582
- columnsFrom: string[];
3583
- tableTo: string;
3584
- columnsTo: string[];
3585
- }>;
3586
- }, {
3587
- name: string;
3588
- columns: Record<string, {
3589
- default?: any;
3590
- onUpdate?: any;
3591
- autoincrement?: boolean | undefined;
3592
- name: string;
3593
- type: string;
3594
- primaryKey: boolean;
3595
- notNull: boolean;
3596
- }>;
3597
- indexes: Record<string, {
3598
- using?: "btree" | "hash" | undefined;
3599
- algorithm?: "default" | "inplace" | "copy" | undefined;
3600
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3601
- name: string;
3602
- columns: string[];
3603
- isUnique: boolean;
3604
- }>;
3605
- foreignKeys: Record<string, {
3606
- onUpdate?: string | undefined;
3607
- onDelete?: string | undefined;
3608
- name: string;
3609
- tableFrom: string;
3610
- columnsFrom: string[];
3611
- tableTo: string;
3612
- columnsTo: string[];
3613
- }>;
3614
- }>>;
3615
- }, {
3616
- id: import("zod").ZodString;
3617
- prevId: import("zod").ZodString;
3618
- }>, "strip", import("zod").ZodTypeAny, {
3619
- tables: Record<string, {
3620
- name: string;
3621
- columns: Record<string, {
3622
- default?: any;
3623
- onUpdate?: any;
3624
- autoincrement?: boolean | undefined;
3625
- name: string;
3626
- type: string;
3627
- primaryKey: boolean;
3628
- notNull: boolean;
3629
- }>;
3630
- indexes: Record<string, {
3631
- using?: "btree" | "hash" | undefined;
3632
- algorithm?: "default" | "inplace" | "copy" | undefined;
3633
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3634
- name: string;
3635
- columns: string[];
3636
- isUnique: boolean;
3637
- }>;
3638
- foreignKeys: Record<string, {
3639
- onUpdate?: string | undefined;
3640
- onDelete?: string | undefined;
3641
- name: string;
3642
- tableFrom: string;
3643
- columnsFrom: string[];
3644
- tableTo: string;
3645
- columnsTo: string[];
3646
- }>;
3647
- }>;
3648
- id: string;
3649
- prevId: string;
3650
- version: "3";
3651
- dialect: "mysql";
3652
- }, {
3653
- tables: Record<string, {
3654
- name: string;
3655
- columns: Record<string, {
3656
- default?: any;
3657
- onUpdate?: any;
3658
- autoincrement?: boolean | undefined;
3659
- name: string;
3660
- type: string;
3661
- primaryKey: boolean;
3662
- notNull: boolean;
3663
- }>;
3664
- indexes: Record<string, {
3665
- using?: "btree" | "hash" | undefined;
3666
- algorithm?: "default" | "inplace" | "copy" | undefined;
3667
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3668
- name: string;
3669
- columns: string[];
3670
- isUnique: boolean;
3671
- }>;
3672
- foreignKeys: Record<string, {
3673
- onUpdate?: string | undefined;
3674
- onDelete?: string | undefined;
3675
- name: string;
3676
- tableFrom: string;
3677
- columnsFrom: string[];
3678
- tableTo: string;
3679
- columnsTo: string[];
3680
- }>;
3681
- }>;
3682
- id: string;
3683
- prevId: string;
3684
- version: "3";
3685
- dialect: "mysql";
3686
- }>;
3687
- export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
3688
- version: import("zod").ZodLiteral<"4">;
3689
- dialect: import("zod").ZodLiteral<"mysql">;
3690
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3691
- name: import("zod").ZodString;
3692
- schema: import("zod").ZodOptional<import("zod").ZodString>;
3693
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3694
- name: import("zod").ZodString;
3695
- type: import("zod").ZodString;
3696
- primaryKey: import("zod").ZodBoolean;
3697
- notNull: import("zod").ZodBoolean;
3698
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
3699
- default: import("zod").ZodOptional<import("zod").ZodAny>;
3700
- onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3701
- }, "strict", import("zod").ZodTypeAny, {
3702
- default?: any;
3703
- onUpdate?: any;
3704
- autoincrement?: boolean | undefined;
3705
- name: string;
3706
- type: string;
3707
- primaryKey: boolean;
3708
- notNull: boolean;
3709
- }, {
3710
- default?: any;
3711
- onUpdate?: any;
3712
- autoincrement?: boolean | undefined;
3713
- name: string;
3714
- type: string;
3715
- primaryKey: boolean;
3716
- notNull: boolean;
3717
- }>>;
3718
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3719
- name: import("zod").ZodString;
3720
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3721
- isUnique: import("zod").ZodBoolean;
3722
- using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
3723
- algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
3724
- lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
3725
- }, "strict", import("zod").ZodTypeAny, {
3726
- using?: "btree" | "hash" | undefined;
3727
- algorithm?: "default" | "inplace" | "copy" | undefined;
3728
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3729
- name: string;
3730
- columns: string[];
3731
- isUnique: boolean;
3732
- }, {
3733
- using?: "btree" | "hash" | undefined;
3734
- algorithm?: "default" | "inplace" | "copy" | undefined;
3735
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3736
- name: string;
3737
- columns: string[];
3738
- isUnique: boolean;
3739
- }>>;
3740
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3741
- name: import("zod").ZodString;
3742
- tableFrom: import("zod").ZodString;
3743
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3744
- tableTo: import("zod").ZodString;
3745
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3746
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3747
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3748
- }, "strict", import("zod").ZodTypeAny, {
3749
- onUpdate?: string | undefined;
3750
- onDelete?: string | undefined;
3751
- name: string;
3752
- tableFrom: string;
3753
- columnsFrom: string[];
3754
- tableTo: string;
3755
- columnsTo: string[];
3756
- }, {
3757
- onUpdate?: string | undefined;
3758
- onDelete?: string | undefined;
3759
- name: string;
3760
- tableFrom: string;
3761
- columnsFrom: string[];
3762
- tableTo: string;
3763
- columnsTo: string[];
3764
- }>>;
3765
- }, "strict", import("zod").ZodTypeAny, {
3766
- schema?: string | undefined;
3767
- name: string;
3768
- columns: Record<string, {
3769
- default?: any;
3770
- onUpdate?: any;
3771
- autoincrement?: boolean | undefined;
3772
- name: string;
3773
- type: string;
3774
- primaryKey: boolean;
3775
- notNull: boolean;
3776
- }>;
3777
- indexes: Record<string, {
3778
- using?: "btree" | "hash" | undefined;
3779
- algorithm?: "default" | "inplace" | "copy" | undefined;
3780
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3781
- name: string;
3782
- columns: string[];
3783
- isUnique: boolean;
3784
- }>;
3785
- foreignKeys: Record<string, {
3786
- onUpdate?: string | undefined;
3787
- onDelete?: string | undefined;
3788
- name: string;
3789
- tableFrom: string;
3790
- columnsFrom: string[];
3791
- tableTo: string;
3792
- columnsTo: string[];
3793
- }>;
3794
- }, {
3795
- schema?: string | undefined;
3796
- name: string;
3797
- columns: Record<string, {
3798
- default?: any;
3799
- onUpdate?: any;
3800
- autoincrement?: boolean | undefined;
3801
- name: string;
3802
- type: string;
3803
- primaryKey: boolean;
3804
- notNull: boolean;
3805
- }>;
3806
- indexes: Record<string, {
3807
- using?: "btree" | "hash" | undefined;
3808
- algorithm?: "default" | "inplace" | "copy" | undefined;
3809
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3810
- name: string;
3811
- columns: string[];
3812
- isUnique: boolean;
3813
- }>;
3814
- foreignKeys: Record<string, {
3815
- onUpdate?: string | undefined;
3816
- onDelete?: string | undefined;
3817
- name: string;
3818
- tableFrom: string;
3819
- columnsFrom: string[];
3820
- tableTo: string;
3821
- columnsTo: string[];
3822
- }>;
3823
- }>>;
3824
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3825
- }, {
3826
- id: import("zod").ZodString;
3827
- prevId: import("zod").ZodString;
3828
- }>, "strip", import("zod").ZodTypeAny, {
3829
- tables: Record<string, {
3830
- schema?: string | undefined;
3831
- name: string;
3832
- columns: Record<string, {
3833
- default?: any;
3834
- onUpdate?: any;
3835
- autoincrement?: boolean | undefined;
3836
- name: string;
3837
- type: string;
3838
- primaryKey: boolean;
3839
- notNull: boolean;
3840
- }>;
3841
- indexes: Record<string, {
3842
- using?: "btree" | "hash" | undefined;
3843
- algorithm?: "default" | "inplace" | "copy" | undefined;
3844
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3845
- name: string;
3846
- columns: string[];
3847
- isUnique: boolean;
3848
- }>;
3849
- foreignKeys: Record<string, {
3850
- onUpdate?: string | undefined;
3851
- onDelete?: string | undefined;
3852
- name: string;
3853
- tableFrom: string;
3854
- columnsFrom: string[];
3855
- tableTo: string;
3856
- columnsTo: string[];
3857
- }>;
3858
- }>;
3859
- id: string;
3860
- prevId: string;
3861
- version: "4";
3862
- dialect: "mysql";
3863
- schemas: Record<string, string>;
3864
- }, {
3865
- tables: Record<string, {
3866
- schema?: string | undefined;
3867
- name: string;
3868
- columns: Record<string, {
3869
- default?: any;
3870
- onUpdate?: any;
3871
- autoincrement?: boolean | undefined;
3872
- name: string;
3873
- type: string;
3874
- primaryKey: boolean;
3875
- notNull: boolean;
3876
- }>;
3877
- indexes: Record<string, {
3878
- using?: "btree" | "hash" | undefined;
3879
- algorithm?: "default" | "inplace" | "copy" | undefined;
3880
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3881
- name: string;
3882
- columns: string[];
3883
- isUnique: boolean;
3884
- }>;
3885
- foreignKeys: Record<string, {
3886
- onUpdate?: string | undefined;
3887
- onDelete?: string | undefined;
3888
- name: string;
3889
- tableFrom: string;
3890
- columnsFrom: string[];
3891
- tableTo: string;
3892
- columnsTo: string[];
3893
- }>;
3894
- }>;
3895
- id: string;
3896
- prevId: string;
3897
- version: "4";
3898
- dialect: "mysql";
3899
- schemas: Record<string, string>;
3900
- }>;
3901
- export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
3902
- version: import("zod").ZodLiteral<"5">;
3903
- dialect: import("zod").ZodLiteral<"mysql">;
3904
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3905
- name: import("zod").ZodString;
3906
- schema: import("zod").ZodOptional<import("zod").ZodString>;
3907
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3908
- name: import("zod").ZodString;
3909
- type: import("zod").ZodString;
3910
- primaryKey: import("zod").ZodBoolean;
3911
- notNull: import("zod").ZodBoolean;
3912
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
3913
- default: import("zod").ZodOptional<import("zod").ZodAny>;
3914
- onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3915
- }, "strict", import("zod").ZodTypeAny, {
3916
- default?: any;
3917
- onUpdate?: any;
3918
- autoincrement?: boolean | undefined;
3919
- name: string;
3920
- type: string;
3921
- primaryKey: boolean;
3922
- notNull: boolean;
3923
- }, {
3924
- default?: any;
3925
- onUpdate?: any;
3926
- autoincrement?: boolean | undefined;
3927
- name: string;
3928
- type: string;
3929
- primaryKey: boolean;
3930
- notNull: boolean;
3931
- }>>;
3932
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3933
- name: import("zod").ZodString;
3934
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3935
- isUnique: import("zod").ZodBoolean;
3936
- using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
3937
- algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
3938
- lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
3939
- }, "strict", import("zod").ZodTypeAny, {
3940
- using?: "btree" | "hash" | undefined;
3941
- algorithm?: "default" | "inplace" | "copy" | undefined;
3942
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3943
- name: string;
3944
- columns: string[];
3945
- isUnique: boolean;
3946
- }, {
3947
- using?: "btree" | "hash" | undefined;
3948
- algorithm?: "default" | "inplace" | "copy" | undefined;
3949
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3950
- name: string;
3951
- columns: string[];
3952
- isUnique: boolean;
3953
- }>>;
3954
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3955
- name: import("zod").ZodString;
3956
- tableFrom: import("zod").ZodString;
3957
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3958
- tableTo: import("zod").ZodString;
3959
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3960
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3961
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3962
- }, "strict", import("zod").ZodTypeAny, {
3963
- onUpdate?: string | undefined;
3964
- onDelete?: string | undefined;
3965
- name: string;
3966
- tableFrom: string;
3967
- columnsFrom: string[];
3968
- tableTo: string;
3969
- columnsTo: string[];
3970
- }, {
3971
- onUpdate?: string | undefined;
3972
- onDelete?: string | undefined;
3973
- name: string;
3974
- tableFrom: string;
3975
- columnsFrom: string[];
3976
- tableTo: string;
3977
- columnsTo: string[];
3978
- }>>;
3979
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3980
- name: import("zod").ZodString;
3981
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3982
- }, "strict", import("zod").ZodTypeAny, {
3983
- name: string;
3984
- columns: string[];
3985
- }, {
3986
- name: string;
3987
- columns: string[];
3988
- }>>;
3989
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3990
- name: import("zod").ZodString;
3991
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3992
- }, "strict", import("zod").ZodTypeAny, {
3993
- name: string;
3994
- columns: string[];
3995
- }, {
3996
- name: string;
3997
- columns: string[];
3998
- }>>>;
3999
- }, "strict", import("zod").ZodTypeAny, {
4000
- schema?: string | undefined;
4001
- name: string;
4002
- columns: Record<string, {
4003
- default?: any;
4004
- onUpdate?: any;
4005
- autoincrement?: boolean | undefined;
4006
- name: string;
4007
- type: string;
4008
- primaryKey: boolean;
4009
- notNull: boolean;
4010
- }>;
4011
- indexes: Record<string, {
4012
- using?: "btree" | "hash" | undefined;
4013
- algorithm?: "default" | "inplace" | "copy" | undefined;
4014
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4015
- name: string;
4016
- columns: string[];
4017
- isUnique: boolean;
4018
- }>;
4019
- foreignKeys: Record<string, {
4020
- onUpdate?: string | undefined;
4021
- onDelete?: string | undefined;
4022
- name: string;
4023
- tableFrom: string;
4024
- columnsFrom: string[];
4025
- tableTo: string;
4026
- columnsTo: string[];
4027
- }>;
4028
- compositePrimaryKeys: Record<string, {
4029
- name: string;
4030
- columns: string[];
4031
- }>;
4032
- uniqueConstraints: Record<string, {
4033
- name: string;
4034
- columns: string[];
4035
- }>;
4036
- }, {
4037
- schema?: string | undefined;
4038
- uniqueConstraints?: Record<string, {
4039
- name: string;
4040
- columns: string[];
4041
- }> | undefined;
4042
- name: string;
4043
- columns: Record<string, {
4044
- default?: any;
4045
- onUpdate?: any;
4046
- autoincrement?: boolean | undefined;
4047
- name: string;
4048
- type: string;
4049
- primaryKey: boolean;
4050
- notNull: boolean;
4051
- }>;
4052
- indexes: Record<string, {
4053
- using?: "btree" | "hash" | undefined;
4054
- algorithm?: "default" | "inplace" | "copy" | undefined;
4055
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4056
- name: string;
4057
- columns: string[];
4058
- isUnique: boolean;
4059
- }>;
4060
- foreignKeys: Record<string, {
4061
- onUpdate?: string | undefined;
4062
- onDelete?: string | undefined;
4063
- name: string;
4064
- tableFrom: string;
4065
- columnsFrom: string[];
4066
- tableTo: string;
4067
- columnsTo: string[];
4068
- }>;
4069
- compositePrimaryKeys: Record<string, {
4070
- name: string;
4071
- columns: string[];
4072
- }>;
4073
- }>>;
4074
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4075
- _meta: import("zod").ZodObject<{
4076
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4077
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4078
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4079
- }, "strip", import("zod").ZodTypeAny, {
4080
- columns: Record<string, string>;
4081
- tables: Record<string, string>;
4082
- schemas: Record<string, string>;
4083
- }, {
4084
- columns: Record<string, string>;
4085
- tables: Record<string, string>;
4086
- schemas: Record<string, string>;
4087
- }>;
4088
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
4089
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4090
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4091
- isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
4092
- }, "strip", import("zod").ZodTypeAny, {
4093
- isDefaultAnExpression?: boolean | undefined;
4094
- }, {
4095
- isDefaultAnExpression?: boolean | undefined;
4096
- }>>>;
4097
- }, "strip", import("zod").ZodTypeAny, {
4098
- columns: Record<string, {
4099
- isDefaultAnExpression?: boolean | undefined;
4100
- } | undefined>;
4101
- }, {
4102
- columns: Record<string, {
4103
- isDefaultAnExpression?: boolean | undefined;
4104
- } | undefined>;
4105
- }>>>;
4106
- }, "strip", import("zod").ZodTypeAny, {
4107
- tables: Record<string, {
4108
- columns: Record<string, {
4109
- isDefaultAnExpression?: boolean | undefined;
4110
- } | undefined>;
4111
- } | undefined>;
4112
- }, {
4113
- tables: Record<string, {
4114
- columns: Record<string, {
4115
- isDefaultAnExpression?: boolean | undefined;
4116
- } | undefined>;
4117
- } | undefined>;
4118
- }>>;
4119
- }, {
4120
- id: import("zod").ZodString;
4121
- prevId: import("zod").ZodString;
4122
- }>, "strip", import("zod").ZodTypeAny, {
4123
- internal?: {
4124
- tables: Record<string, {
4125
- columns: Record<string, {
4126
- isDefaultAnExpression?: boolean | undefined;
4127
- } | undefined>;
4128
- } | undefined>;
4129
- } | undefined;
4130
- tables: Record<string, {
4131
- schema?: string | undefined;
4132
- name: string;
4133
- columns: Record<string, {
4134
- default?: any;
4135
- onUpdate?: any;
4136
- autoincrement?: boolean | undefined;
4137
- name: string;
4138
- type: string;
4139
- primaryKey: boolean;
4140
- notNull: boolean;
4141
- }>;
4142
- indexes: Record<string, {
4143
- using?: "btree" | "hash" | undefined;
4144
- algorithm?: "default" | "inplace" | "copy" | undefined;
4145
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4146
- name: string;
4147
- columns: string[];
4148
- isUnique: boolean;
4149
- }>;
4150
- foreignKeys: Record<string, {
4151
- onUpdate?: string | undefined;
4152
- onDelete?: string | undefined;
4153
- name: string;
4154
- tableFrom: string;
4155
- columnsFrom: string[];
4156
- tableTo: string;
4157
- columnsTo: string[];
4158
- }>;
4159
- compositePrimaryKeys: Record<string, {
4160
- name: string;
4161
- columns: string[];
4162
- }>;
4163
- uniqueConstraints: Record<string, {
4164
- name: string;
4165
- columns: string[];
4166
- }>;
4167
- }>;
4168
- id: string;
4169
- prevId: string;
4170
- version: "5";
4171
- dialect: "mysql";
4172
- schemas: Record<string, string>;
4173
- _meta: {
4174
- columns: Record<string, string>;
4175
- tables: Record<string, string>;
4176
- schemas: Record<string, string>;
4177
- };
4178
- }, {
4179
- internal?: {
4180
- tables: Record<string, {
4181
- columns: Record<string, {
4182
- isDefaultAnExpression?: boolean | undefined;
4183
- } | undefined>;
4184
- } | undefined>;
4185
- } | undefined;
4186
- tables: Record<string, {
4187
- schema?: string | undefined;
4188
- uniqueConstraints?: Record<string, {
4189
- name: string;
4190
- columns: string[];
4191
- }> | undefined;
4192
- name: string;
4193
- columns: Record<string, {
4194
- default?: any;
4195
- onUpdate?: any;
4196
- autoincrement?: boolean | undefined;
4197
- name: string;
4198
- type: string;
4199
- primaryKey: boolean;
4200
- notNull: boolean;
4201
- }>;
4202
- indexes: Record<string, {
4203
- using?: "btree" | "hash" | undefined;
4204
- algorithm?: "default" | "inplace" | "copy" | undefined;
4205
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4206
- name: string;
4207
- columns: string[];
4208
- isUnique: boolean;
4209
- }>;
4210
- foreignKeys: Record<string, {
4211
- onUpdate?: string | undefined;
4212
- onDelete?: string | undefined;
4213
- name: string;
4214
- tableFrom: string;
4215
- columnsFrom: string[];
4216
- tableTo: string;
4217
- columnsTo: string[];
4218
- }>;
4219
- compositePrimaryKeys: Record<string, {
4220
- name: string;
4221
- columns: string[];
4222
- }>;
4223
- }>;
4224
- id: string;
4225
- prevId: string;
4226
- version: "5";
4227
- dialect: "mysql";
4228
- schemas: Record<string, string>;
4229
- _meta: {
4230
- columns: Record<string, string>;
4231
- tables: Record<string, string>;
4232
- schemas: Record<string, string>;
4233
- };
4234
- }>;
4235
- export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
4236
- version: import("zod").ZodLiteral<"5">;
4237
- dialect: import("zod").ZodLiteral<"mysql">;
4238
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4239
- name: import("zod").ZodString;
4240
- schema: import("zod").ZodOptional<import("zod").ZodString>;
4241
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4242
- name: import("zod").ZodString;
4243
- type: import("zod").ZodString;
4244
- primaryKey: import("zod").ZodBoolean;
4245
- notNull: import("zod").ZodBoolean;
4246
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
4247
- default: import("zod").ZodOptional<import("zod").ZodAny>;
4248
- onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
4249
- }, "strict", import("zod").ZodTypeAny, {
4250
- default?: any;
4251
- onUpdate?: any;
4252
- autoincrement?: boolean | undefined;
4253
- name: string;
4254
- type: string;
4255
- primaryKey: boolean;
4256
- notNull: boolean;
4257
- }, {
4258
- default?: any;
4259
- onUpdate?: any;
4260
- autoincrement?: boolean | undefined;
4261
- name: string;
4262
- type: string;
4263
- primaryKey: boolean;
4264
- notNull: boolean;
4265
- }>>;
4266
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4267
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4268
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4269
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
4270
- }, "strict", import("zod").ZodTypeAny, {
4271
- schema?: string | undefined;
4272
- name: string;
4273
- columns: Record<string, {
4274
- default?: any;
4275
- onUpdate?: any;
4276
- autoincrement?: boolean | undefined;
4277
- name: string;
4278
- type: string;
4279
- primaryKey: boolean;
4280
- notNull: boolean;
3123
+ name: string;
3124
+ tableFrom: string;
3125
+ columnsFrom: string[];
3126
+ tableTo: string;
3127
+ columnsTo: string[];
4281
3128
  }>;
4282
- indexes: Record<string, string>;
4283
- foreignKeys: Record<string, string>;
4284
- compositePrimaryKeys: Record<string, string>;
4285
- uniqueConstraints: Record<string, string>;
4286
3129
  }, {
4287
- schema?: string | undefined;
4288
- uniqueConstraints?: Record<string, string> | undefined;
4289
3130
  name: string;
4290
3131
  columns: Record<string, {
4291
3132
  default?: any;
@@ -4296,14 +3137,33 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
4296
3137
  primaryKey: boolean;
4297
3138
  notNull: boolean;
4298
3139
  }>;
4299
- indexes: Record<string, string>;
4300
- foreignKeys: Record<string, string>;
4301
- compositePrimaryKeys: Record<string, string>;
3140
+ indexes: Record<string, {
3141
+ using?: "btree" | "hash" | undefined;
3142
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3143
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3144
+ name: string;
3145
+ columns: string[];
3146
+ isUnique: boolean;
3147
+ }>;
3148
+ foreignKeys: Record<string, {
3149
+ onUpdate?: string | undefined;
3150
+ onDelete?: string | undefined;
3151
+ name: string;
3152
+ tableFrom: string;
3153
+ columnsFrom: string[];
3154
+ tableTo: string;
3155
+ columnsTo: string[];
3156
+ }>;
4302
3157
  }>>;
4303
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4304
- }, "strict", import("zod").ZodTypeAny, {
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";
4305
3166
  tables: Record<string, {
4306
- schema?: string | undefined;
4307
3167
  name: string;
4308
3168
  columns: Record<string, {
4309
3169
  default?: any;
@@ -4314,18 +3174,30 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
4314
3174
  primaryKey: boolean;
4315
3175
  notNull: boolean;
4316
3176
  }>;
4317
- indexes: Record<string, string>;
4318
- foreignKeys: Record<string, string>;
4319
- compositePrimaryKeys: Record<string, string>;
4320
- uniqueConstraints: Record<string, string>;
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
+ }>;
4321
3194
  }>;
4322
- version: "5";
4323
- dialect: "mysql";
4324
- schemas: Record<string, string>;
4325
3195
  }, {
3196
+ id: string;
3197
+ prevId: string;
3198
+ version: "3";
3199
+ dialect: "mysql";
4326
3200
  tables: Record<string, {
4327
- schema?: string | undefined;
4328
- uniqueConstraints?: Record<string, string> | undefined;
4329
3201
  name: string;
4330
3202
  columns: Record<string, {
4331
3203
  default?: any;
@@ -4336,16 +3208,26 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
4336
3208
  primaryKey: boolean;
4337
3209
  notNull: boolean;
4338
3210
  }>;
4339
- indexes: Record<string, string>;
4340
- foreignKeys: Record<string, string>;
4341
- compositePrimaryKeys: Record<string, string>;
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
+ }>;
4342
3228
  }>;
4343
- version: "5";
4344
- dialect: "mysql";
4345
- schemas: Record<string, string>;
4346
- }>;
4347
- export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
4348
- version: import("zod").ZodLiteral<"5">;
3229
+ }>, import("zod").ZodObject<import("zod").extendShape<{
3230
+ version: import("zod").ZodLiteral<"4">;
4349
3231
  dialect: import("zod").ZodLiteral<"mysql">;
4350
3232
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4351
3233
  name: import("zod").ZodString;
@@ -4422,26 +3304,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4422
3304
  tableTo: string;
4423
3305
  columnsTo: string[];
4424
3306
  }>>;
4425
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4426
- name: import("zod").ZodString;
4427
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
4428
- }, "strict", import("zod").ZodTypeAny, {
4429
- name: string;
4430
- columns: string[];
4431
- }, {
4432
- name: string;
4433
- columns: string[];
4434
- }>>;
4435
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4436
- name: import("zod").ZodString;
4437
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
4438
- }, "strict", import("zod").ZodTypeAny, {
4439
- name: string;
4440
- columns: string[];
4441
- }, {
4442
- name: string;
4443
- columns: string[];
4444
- }>>>;
4445
3307
  }, "strict", import("zod").ZodTypeAny, {
4446
3308
  schema?: string | undefined;
4447
3309
  name: string;
@@ -4471,20 +3333,8 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4471
3333
  tableTo: string;
4472
3334
  columnsTo: string[];
4473
3335
  }>;
4474
- compositePrimaryKeys: Record<string, {
4475
- name: string;
4476
- columns: string[];
4477
- }>;
4478
- uniqueConstraints: Record<string, {
4479
- name: string;
4480
- columns: string[];
4481
- }>;
4482
3336
  }, {
4483
3337
  schema?: string | undefined;
4484
- uniqueConstraints?: Record<string, {
4485
- name: string;
4486
- columns: string[];
4487
- }> | undefined;
4488
3338
  name: string;
4489
3339
  columns: Record<string, {
4490
3340
  default?: any;
@@ -4512,67 +3362,16 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4512
3362
  tableTo: string;
4513
3363
  columnsTo: string[];
4514
3364
  }>;
4515
- compositePrimaryKeys: Record<string, {
4516
- name: string;
4517
- columns: string[];
4518
- }>;
4519
3365
  }>>;
4520
3366
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4521
- _meta: import("zod").ZodObject<{
4522
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4523
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4524
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4525
- }, "strip", import("zod").ZodTypeAny, {
4526
- columns: Record<string, string>;
4527
- tables: Record<string, string>;
4528
- schemas: Record<string, string>;
4529
- }, {
4530
- columns: Record<string, string>;
4531
- tables: Record<string, string>;
4532
- schemas: Record<string, string>;
4533
- }>;
4534
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
4535
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4536
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4537
- isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
4538
- }, "strip", import("zod").ZodTypeAny, {
4539
- isDefaultAnExpression?: boolean | undefined;
4540
- }, {
4541
- isDefaultAnExpression?: boolean | undefined;
4542
- }>>>;
4543
- }, "strip", import("zod").ZodTypeAny, {
4544
- columns: Record<string, {
4545
- isDefaultAnExpression?: boolean | undefined;
4546
- } | undefined>;
4547
- }, {
4548
- columns: Record<string, {
4549
- isDefaultAnExpression?: boolean | undefined;
4550
- } | undefined>;
4551
- }>>>;
4552
- }, "strip", import("zod").ZodTypeAny, {
4553
- tables: Record<string, {
4554
- columns: Record<string, {
4555
- isDefaultAnExpression?: boolean | undefined;
4556
- } | undefined>;
4557
- } | undefined>;
4558
- }, {
4559
- tables: Record<string, {
4560
- columns: Record<string, {
4561
- isDefaultAnExpression?: boolean | undefined;
4562
- } | undefined>;
4563
- } | undefined>;
4564
- }>>;
4565
3367
  }, {
4566
3368
  id: import("zod").ZodString;
4567
3369
  prevId: import("zod").ZodString;
4568
3370
  }>, "strip", import("zod").ZodTypeAny, {
4569
- internal?: {
4570
- tables: Record<string, {
4571
- columns: Record<string, {
4572
- isDefaultAnExpression?: boolean | undefined;
4573
- } | undefined>;
4574
- } | undefined>;
4575
- } | undefined;
3371
+ id: string;
3372
+ prevId: string;
3373
+ version: "4";
3374
+ dialect: "mysql";
4576
3375
  tables: Record<string, {
4577
3376
  schema?: string | undefined;
4578
3377
  name: string;
@@ -4602,39 +3401,15 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4602
3401
  tableTo: string;
4603
3402
  columnsTo: string[];
4604
3403
  }>;
4605
- compositePrimaryKeys: Record<string, {
4606
- name: string;
4607
- columns: string[];
4608
- }>;
4609
- uniqueConstraints: Record<string, {
4610
- name: string;
4611
- columns: string[];
4612
- }>;
4613
3404
  }>;
3405
+ schemas: Record<string, string>;
3406
+ }, {
4614
3407
  id: string;
4615
3408
  prevId: string;
4616
- version: "5";
3409
+ version: "4";
4617
3410
  dialect: "mysql";
4618
- schemas: Record<string, string>;
4619
- _meta: {
4620
- columns: Record<string, string>;
4621
- tables: Record<string, string>;
4622
- schemas: Record<string, string>;
4623
- };
4624
- }, {
4625
- internal?: {
4626
- tables: Record<string, {
4627
- columns: Record<string, {
4628
- isDefaultAnExpression?: boolean | undefined;
4629
- } | undefined>;
4630
- } | undefined>;
4631
- } | undefined;
4632
3411
  tables: Record<string, {
4633
3412
  schema?: string | undefined;
4634
- uniqueConstraints?: Record<string, {
4635
- name: string;
4636
- columns: string[];
4637
- }> | undefined;
4638
3413
  name: string;
4639
3414
  columns: Record<string, {
4640
3415
  default?: any;
@@ -4662,23 +3437,10 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4662
3437
  tableTo: string;
4663
3438
  columnsTo: string[];
4664
3439
  }>;
4665
- compositePrimaryKeys: Record<string, {
4666
- name: string;
4667
- columns: string[];
4668
- }>;
4669
3440
  }>;
4670
- id: string;
4671
- prevId: string;
4672
- version: "5";
4673
- dialect: "mysql";
4674
3441
  schemas: Record<string, string>;
4675
- _meta: {
4676
- columns: Record<string, string>;
4677
- tables: Record<string, string>;
4678
- schemas: Record<string, string>;
4679
- };
4680
3442
  }>, import("zod").ZodObject<import("zod").extendShape<{
4681
- version: import("zod").ZodLiteral<"6">;
3443
+ version: import("zod").ZodLiteral<"5">;
4682
3444
  dialect: import("zod").ZodLiteral<"mysql">;
4683
3445
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4684
3446
  name: import("zod").ZodString;
@@ -4906,6 +3668,10 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4906
3668
  } | undefined>;
4907
3669
  } | undefined>;
4908
3670
  } | undefined;
3671
+ id: string;
3672
+ prevId: string;
3673
+ version: "5";
3674
+ dialect: "mysql";
4909
3675
  tables: Record<string, {
4910
3676
  schema?: string | undefined;
4911
3677
  name: string;
@@ -4944,10 +3710,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4944
3710
  columns: string[];
4945
3711
  }>;
4946
3712
  }>;
4947
- id: string;
4948
- prevId: string;
4949
- version: "6";
4950
- dialect: "mysql";
4951
3713
  schemas: Record<string, string>;
4952
3714
  _meta: {
4953
3715
  columns: Record<string, string>;
@@ -4962,6 +3724,10 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4962
3724
  } | undefined>;
4963
3725
  } | undefined>;
4964
3726
  } | undefined;
3727
+ id: string;
3728
+ prevId: string;
3729
+ version: "5";
3730
+ dialect: "mysql";
4965
3731
  tables: Record<string, {
4966
3732
  schema?: string | undefined;
4967
3733
  uniqueConstraints?: Record<string, {
@@ -5000,10 +3766,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
5000
3766
  columns: string[];
5001
3767
  }>;
5002
3768
  }>;
5003
- id: string;
5004
- prevId: string;
5005
- version: "6";
5006
- dialect: "mysql";
5007
3769
  schemas: Record<string, string>;
5008
3770
  _meta: {
5009
3771
  columns: Record<string, string>;
@@ -5019,6 +3781,10 @@ export declare const dryMySql: {
5019
3781
  } | undefined>;
5020
3782
  } | undefined>;
5021
3783
  } | undefined;
3784
+ id: string;
3785
+ prevId: string;
3786
+ version: "5";
3787
+ dialect: "mysql";
5022
3788
  tables: Record<string, {
5023
3789
  schema?: string | undefined;
5024
3790
  name: string;
@@ -5057,10 +3823,6 @@ export declare const dryMySql: {
5057
3823
  columns: string[];
5058
3824
  }>;
5059
3825
  }>;
5060
- id: string;
5061
- prevId: string;
5062
- version: "6";
5063
- dialect: "mysql";
5064
3826
  schemas: Record<string, string>;
5065
3827
  _meta: {
5066
3828
  columns: Record<string, string>;