drizzle-kit 0.20.14-c82ab68 → 0.20.14-dc0459e

Sign up to get free protection for your applications and to get access to all the features.
Files changed (43) hide show
  1. package/bin.cjs +36904 -34432
  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 +8 -7
  28. package/payload.js +1534 -2210
  29. package/payload.mjs +1538 -2213
  30. package/schemaValidator.d.ts +40 -40
  31. package/serializer/mysqlSchema.d.ts +616 -1854
  32. package/serializer/mysqlSerializer.d.ts +2 -2
  33. package/serializer/pgSchema.d.ts +684 -1009
  34. package/serializer/sqliteSchema.d.ts +570 -144
  35. package/serializer/sqliteSerializer.d.ts +2 -2
  36. package/snapshotsDiffer.d.ts +20 -24
  37. package/utils-studio.js +15 -390
  38. package/utils-studio.mjs +15 -389
  39. package/utils.d.ts +12 -12
  40. package/utils.js +735 -849
  41. package/utils.mjs +736 -849
  42. package/cli/validations/cli.d.ts +0 -104
  43. 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>;