drizzle-kit 0.20.14-a77266f → 0.20.14-c82ab68

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 +7311 -7010
  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 +12 -9
  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/upFolders.d.ts +1 -1
  13. package/cli/commands/utils.d.ts +14 -259
  14. package/cli/validations/cli.d.ts +104 -0
  15. package/cli/validations/common.d.ts +205 -7
  16. package/cli/validations/mysql.d.ts +6 -1
  17. package/cli/validations/pg.d.ts +6 -1
  18. package/cli/validations/sqlite.d.ts +382 -0
  19. package/cli/views.d.ts +1 -1
  20. package/global.d.ts +1 -1
  21. package/index.d.mts +8 -6
  22. package/index.d.ts +8 -6
  23. package/index.js +1 -0
  24. package/introspect-mysql.d.ts +1 -1
  25. package/introspect-pg.d.ts +5 -2
  26. package/introspect-sqlite.d.ts +1 -1
  27. package/jsonStatements.d.ts +1 -1
  28. package/package.json +3 -1
  29. package/payload.js +2574 -1898
  30. package/payload.mjs +2570 -1895
  31. package/schemaValidator.d.ts +40 -40
  32. package/serializer/mysqlSchema.d.ts +1991 -753
  33. package/serializer/mysqlSerializer.d.ts +2 -2
  34. package/serializer/pgSchema.d.ts +1113 -788
  35. package/serializer/sqliteSchema.d.ts +144 -570
  36. package/serializer/sqliteSerializer.d.ts +2 -2
  37. package/snapshotsDiffer.d.ts +24 -20
  38. package/utils-studio.js +390 -15
  39. package/utils-studio.mjs +389 -15
  40. package/utils.d.ts +12 -12
  41. package/utils.js +849 -735
  42. package/utils.mjs +849 -736
  43. package/cli/commands/sqliteUtils.d.ts +0 -162
package/serializer/mysqlSchema.d.ts CHANGED
@@ -395,6 +395,37 @@ 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
+ }>>;
398
429
  declare const dialect: import("zod").ZodLiteral<"mysql">;
399
430
  export declare const schemaInternalV3: import("zod").ZodObject<{
400
431
  version: import("zod").ZodLiteral<"3">;
@@ -531,8 +562,6 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
531
562
  }>;
532
563
  }>>;
533
564
  }, "strict", import("zod").ZodTypeAny, {
534
- version: "3";
535
- dialect: "mysql";
536
565
  tables: Record<string, {
537
566
  name: string;
538
567
  columns: Record<string, {
@@ -562,9 +591,9 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
562
591
  columnsTo: string[];
563
592
  }>;
564
593
  }>;
565
- }, {
566
594
  version: "3";
567
595
  dialect: "mysql";
596
+ }, {
568
597
  tables: Record<string, {
569
598
  name: string;
570
599
  columns: Record<string, {
@@ -594,6 +623,8 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
594
623
  columnsTo: string[];
595
624
  }>;
596
625
  }>;
626
+ version: "3";
627
+ dialect: "mysql";
597
628
  }>;
598
629
  export declare const schemaInternalV4: import("zod").ZodObject<{
599
630
  version: import("zod").ZodLiteral<"4">;
@@ -734,8 +765,6 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
734
765
  }>>;
735
766
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
736
767
  }, "strict", import("zod").ZodTypeAny, {
737
- version: "4";
738
- dialect: "mysql";
739
768
  tables: Record<string, {
740
769
  schema?: string | undefined;
741
770
  name: string;
@@ -766,10 +795,10 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
766
795
  columnsTo: string[];
767
796
  }>;
768
797
  }>;
769
- schemas: Record<string, string>;
770
- }, {
771
798
  version: "4";
772
799
  dialect: "mysql";
800
+ schemas: Record<string, string>;
801
+ }, {
773
802
  tables: Record<string, {
774
803
  schema?: string | undefined;
775
804
  name: string;
@@ -800,40 +829,11 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
800
829
  columnsTo: string[];
801
830
  }>;
802
831
  }>;
832
+ version: "4";
833
+ dialect: "mysql";
803
834
  schemas: Record<string, string>;
804
835
  }>;
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<{
836
+ export declare const schemaInternalV5: 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,8 +1059,6 @@ export declare const schemaInternal: import("zod").ZodObject<{
1059
1059
  } | undefined>;
1060
1060
  } | undefined>;
1061
1061
  } | undefined;
1062
- version: "5";
1063
- dialect: "mysql";
1064
1062
  tables: Record<string, {
1065
1063
  schema?: string | undefined;
1066
1064
  name: string;
@@ -1099,6 +1097,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
1099
1097
  columns: string[];
1100
1098
  }>;
1101
1099
  }>;
1100
+ version: "5";
1101
+ dialect: "mysql";
1102
1102
  schemas: Record<string, string>;
1103
1103
  _meta: {
1104
1104
  columns: Record<string, string>;
@@ -1113,8 +1113,6 @@ export declare const schemaInternal: import("zod").ZodObject<{
1113
1113
  } | undefined>;
1114
1114
  } | undefined>;
1115
1115
  } | undefined;
1116
- version: "5";
1117
- dialect: "mysql";
1118
1116
  tables: Record<string, {
1119
1117
  schema?: string | undefined;
1120
1118
  uniqueConstraints?: Record<string, {
@@ -1153,6 +1151,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
1153
1151
  columns: string[];
1154
1152
  }>;
1155
1153
  }>;
1154
+ version: "5";
1155
+ dialect: "mysql";
1156
1156
  schemas: Record<string, string>;
1157
1157
  _meta: {
1158
1158
  columns: Record<string, string>;
@@ -1160,11 +1160,12 @@ export declare const schemaInternal: import("zod").ZodObject<{
1160
1160
  schemas: Record<string, string>;
1161
1161
  };
1162
1162
  }>;
1163
- export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
1164
- version: import("zod").ZodLiteral<"3">;
1163
+ export declare const schemaInternalV6: import("zod").ZodObject<{
1164
+ version: import("zod").ZodLiteral<"6">;
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>;
1168
1169
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1169
1170
  name: import("zod").ZodString;
1170
1171
  type: import("zod").ZodString;
@@ -1237,7 +1238,28 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1237
1238
  tableTo: string;
1238
1239
  columnsTo: string[];
1239
1240
  }>>;
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
+ }>>>;
1240
1261
  }, "strict", import("zod").ZodTypeAny, {
1262
+ schema?: string | undefined;
1241
1263
  name: string;
1242
1264
  columns: Record<string, {
1243
1265
  default?: any;
@@ -1265,7 +1287,20 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1265
1287
  tableTo: string;
1266
1288
  columnsTo: string[];
1267
1289
  }>;
1290
+ compositePrimaryKeys: Record<string, {
1291
+ name: string;
1292
+ columns: string[];
1293
+ }>;
1294
+ uniqueConstraints: Record<string, {
1295
+ name: string;
1296
+ columns: string[];
1297
+ }>;
1268
1298
  }, {
1299
+ schema?: string | undefined;
1300
+ uniqueConstraints?: Record<string, {
1301
+ name: string;
1302
+ columns: string[];
1303
+ }> | undefined;
1269
1304
  name: string;
1270
1305
  columns: Record<string, {
1271
1306
  default?: any;
@@ -1293,16 +1328,66 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1293
1328
  tableTo: string;
1294
1329
  columnsTo: string[];
1295
1330
  }>;
1331
+ compositePrimaryKeys: Record<string, {
1332
+ name: string;
1333
+ columns: string[];
1334
+ }>;
1296
1335
  }>>;
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";
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
+ }>>;
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;
1305
1389
  tables: Record<string, {
1390
+ schema?: string | undefined;
1306
1391
  name: string;
1307
1392
  columns: Record<string, {
1308
1393
  default?: any;
@@ -1330,13 +1415,37 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1330
1415
  tableTo: string;
1331
1416
  columnsTo: string[];
1332
1417
  }>;
1418
+ compositePrimaryKeys: Record<string, {
1419
+ name: string;
1420
+ columns: string[];
1421
+ }>;
1422
+ uniqueConstraints: Record<string, {
1423
+ name: string;
1424
+ columns: string[];
1425
+ }>;
1333
1426
  }>;
1334
- }, {
1335
- id: string;
1336
- prevId: string;
1337
- version: "3";
1427
+ version: "6";
1338
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
+ }, {
1436
+ internal?: {
1437
+ tables: Record<string, {
1438
+ columns: Record<string, {
1439
+ isDefaultAnExpression?: boolean | undefined;
1440
+ } | undefined>;
1441
+ } | undefined>;
1442
+ } | undefined;
1339
1443
  tables: Record<string, {
1444
+ schema?: string | undefined;
1445
+ uniqueConstraints?: Record<string, {
1446
+ name: string;
1447
+ columns: string[];
1448
+ }> | undefined;
1340
1449
  name: string;
1341
1450
  columns: Record<string, {
1342
1451
  default?: any;
@@ -1364,10 +1473,22 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1364
1473
  tableTo: string;
1365
1474
  columnsTo: string[];
1366
1475
  }>;
1476
+ compositePrimaryKeys: Record<string, {
1477
+ name: string;
1478
+ columns: string[];
1479
+ }>;
1367
1480
  }>;
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
+ };
1368
1489
  }>;
1369
- export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
1370
- version: import("zod").ZodLiteral<"4">;
1490
+ export declare const schemaInternal: import("zod").ZodObject<{
1491
+ version: import("zod").ZodLiteral<"6">;
1371
1492
  dialect: import("zod").ZodLiteral<"mysql">;
1372
1493
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1373
1494
  name: import("zod").ZodString;
@@ -1444,6 +1565,26 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1444
1565
  tableTo: string;
1445
1566
  columnsTo: string[];
1446
1567
  }>>;
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
+ }>>>;
1447
1588
  }, "strict", import("zod").ZodTypeAny, {
1448
1589
  schema?: string | undefined;
1449
1590
  name: string;
@@ -1473,9 +1614,21 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1473
1614
  tableTo: string;
1474
1615
  columnsTo: string[];
1475
1616
  }>;
1476
- }, {
1477
- schema?: string | undefined;
1478
- name: string;
1617
+ compositePrimaryKeys: Record<string, {
1618
+ name: string;
1619
+ columns: string[];
1620
+ }>;
1621
+ uniqueConstraints: Record<string, {
1622
+ name: string;
1623
+ columns: string[];
1624
+ }>;
1625
+ }, {
1626
+ schema?: string | undefined;
1627
+ uniqueConstraints?: Record<string, {
1628
+ name: string;
1629
+ columns: string[];
1630
+ }> | undefined;
1631
+ name: string;
1479
1632
  columns: Record<string, {
1480
1633
  default?: any;
1481
1634
  onUpdate?: any;
@@ -1502,16 +1655,64 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1502
1655
  tableTo: string;
1503
1656
  columnsTo: string[];
1504
1657
  }>;
1658
+ compositePrimaryKeys: Record<string, {
1659
+ name: string;
1660
+ columns: string[];
1661
+ }>;
1505
1662
  }>>;
1506
1663
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
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";
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;
1515
1716
  tables: Record<string, {
1516
1717
  schema?: string | undefined;
1517
1718
  name: string;
@@ -1541,15 +1742,37 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1541
1742
  tableTo: string;
1542
1743
  columnsTo: string[];
1543
1744
  }>;
1745
+ compositePrimaryKeys: Record<string, {
1746
+ name: string;
1747
+ columns: string[];
1748
+ }>;
1749
+ uniqueConstraints: Record<string, {
1750
+ name: string;
1751
+ columns: string[];
1752
+ }>;
1544
1753
  }>;
1754
+ version: "6";
1755
+ dialect: "mysql";
1545
1756
  schemas: Record<string, string>;
1757
+ _meta: {
1758
+ columns: Record<string, string>;
1759
+ tables: Record<string, string>;
1760
+ schemas: Record<string, string>;
1761
+ };
1546
1762
  }, {
1547
- id: string;
1548
- prevId: string;
1549
- version: "4";
1550
- dialect: "mysql";
1763
+ internal?: {
1764
+ tables: Record<string, {
1765
+ columns: Record<string, {
1766
+ isDefaultAnExpression?: boolean | undefined;
1767
+ } | undefined>;
1768
+ } | undefined>;
1769
+ } | undefined;
1551
1770
  tables: Record<string, {
1552
1771
  schema?: string | undefined;
1772
+ uniqueConstraints?: Record<string, {
1773
+ name: string;
1774
+ columns: string[];
1775
+ }> | undefined;
1553
1776
  name: string;
1554
1777
  columns: Record<string, {
1555
1778
  default?: any;
@@ -1577,15 +1800,25 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1577
1800
  tableTo: string;
1578
1801
  columnsTo: string[];
1579
1802
  }>;
1803
+ compositePrimaryKeys: Record<string, {
1804
+ name: string;
1805
+ columns: string[];
1806
+ }>;
1580
1807
  }>;
1808
+ version: "6";
1809
+ dialect: "mysql";
1581
1810
  schemas: Record<string, string>;
1811
+ _meta: {
1812
+ columns: Record<string, string>;
1813
+ tables: Record<string, string>;
1814
+ schemas: Record<string, string>;
1815
+ };
1582
1816
  }>;
1583
- export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1584
- version: import("zod").ZodLiteral<"5">;
1817
+ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
1818
+ version: import("zod").ZodLiteral<"3">;
1585
1819
  dialect: import("zod").ZodLiteral<"mysql">;
1586
1820
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1587
1821
  name: import("zod").ZodString;
1588
- schema: import("zod").ZodOptional<import("zod").ZodString>;
1589
1822
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1590
1823
  name: import("zod").ZodString;
1591
1824
  type: import("zod").ZodString;
@@ -1658,28 +1891,7 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1658
1891
  tableTo: string;
1659
1892
  columnsTo: string[];
1660
1893
  }>>;
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
- }>>>;
1681
1894
  }, "strict", import("zod").ZodTypeAny, {
1682
- schema?: string | undefined;
1683
1895
  name: string;
1684
1896
  columns: Record<string, {
1685
1897
  default?: any;
@@ -1707,20 +1919,7 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1707
1919
  tableTo: string;
1708
1920
  columnsTo: string[];
1709
1921
  }>;
1710
- compositePrimaryKeys: Record<string, {
1711
- name: string;
1712
- columns: string[];
1713
- }>;
1714
- uniqueConstraints: Record<string, {
1715
- name: string;
1716
- columns: string[];
1717
- }>;
1718
1922
  }, {
1719
- schema?: string | undefined;
1720
- uniqueConstraints?: Record<string, {
1721
- name: string;
1722
- columns: string[];
1723
- }> | undefined;
1724
1923
  name: string;
1725
1924
  columns: Record<string, {
1726
1925
  default?: any;
@@ -1748,73 +1947,12 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1748
1947
  tableTo: string;
1749
1948
  columnsTo: string[];
1750
1949
  }>;
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>;
1800
1950
  }>>;
1801
1951
  }, {
1802
1952
  id: import("zod").ZodString;
1803
1953
  prevId: import("zod").ZodString;
1804
1954
  }>, "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";
1816
1955
  tables: Record<string, {
1817
- schema?: string | undefined;
1818
1956
  name: string;
1819
1957
  columns: Record<string, {
1820
1958
  default?: any;
@@ -1842,39 +1980,13 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1842
1980
  tableTo: string;
1843
1981
  columnsTo: string[];
1844
1982
  }>;
1845
- compositePrimaryKeys: Record<string, {
1846
- name: string;
1847
- columns: string[];
1848
- }>;
1849
- uniqueConstraints: Record<string, {
1850
- name: string;
1851
- columns: string[];
1852
- }>;
1853
1983
  }>;
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;
1868
1984
  id: string;
1869
1985
  prevId: string;
1870
- version: "5";
1986
+ version: "3";
1871
1987
  dialect: "mysql";
1988
+ }, {
1872
1989
  tables: Record<string, {
1873
- schema?: string | undefined;
1874
- uniqueConstraints?: Record<string, {
1875
- name: string;
1876
- columns: string[];
1877
- }> | undefined;
1878
1990
  name: string;
1879
1991
  columns: Record<string, {
1880
1992
  default?: any;
@@ -1902,20 +2014,14 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1902
2014
  tableTo: string;
1903
2015
  columnsTo: string[];
1904
2016
  }>;
1905
- compositePrimaryKeys: Record<string, {
1906
- name: string;
1907
- columns: string[];
1908
- }>;
1909
2017
  }>;
1910
- schemas: Record<string, string>;
1911
- _meta: {
1912
- columns: Record<string, string>;
1913
- tables: Record<string, string>;
1914
- schemas: Record<string, string>;
1915
- };
2018
+ id: string;
2019
+ prevId: string;
2020
+ version: "3";
2021
+ dialect: "mysql";
1916
2022
  }>;
1917
- export declare const schemaSquashed: import("zod").ZodObject<{
1918
- version: import("zod").ZodLiteral<"5">;
2023
+ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
2024
+ version: import("zod").ZodLiteral<"4">;
1919
2025
  dialect: import("zod").ZodLiteral<"mysql">;
1920
2026
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1921
2027
  name: import("zod").ZodString;
@@ -1945,10 +2051,53 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1945
2051
  primaryKey: boolean;
1946
2052
  notNull: boolean;
1947
2053
  }>>;
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>>;
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
+ }>>;
1952
2101
  }, "strict", import("zod").ZodTypeAny, {
1953
2102
  schema?: string | undefined;
1954
2103
  name: string;
@@ -1961,13 +2110,25 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1961
2110
  primaryKey: boolean;
1962
2111
  notNull: boolean;
1963
2112
  }>;
1964
- indexes: Record<string, string>;
1965
- foreignKeys: Record<string, string>;
1966
- compositePrimaryKeys: Record<string, string>;
1967
- uniqueConstraints: Record<string, string>;
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
+ }>;
1968
2130
  }, {
1969
2131
  schema?: string | undefined;
1970
- uniqueConstraints?: Record<string, string> | undefined;
1971
2132
  name: string;
1972
2133
  columns: Record<string, {
1973
2134
  default?: any;
@@ -1978,14 +2139,29 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1978
2139
  primaryKey: boolean;
1979
2140
  notNull: boolean;
1980
2141
  }>;
1981
- indexes: Record<string, string>;
1982
- foreignKeys: Record<string, string>;
1983
- compositePrimaryKeys: Record<string, string>;
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
+ }>;
1984
2159
  }>>;
1985
2160
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1986
- }, "strict", import("zod").ZodTypeAny, {
1987
- version: "5";
1988
- dialect: "mysql";
2161
+ }, {
2162
+ id: import("zod").ZodString;
2163
+ prevId: import("zod").ZodString;
2164
+ }>, "strip", import("zod").ZodTypeAny, {
1989
2165
  tables: Record<string, {
1990
2166
  schema?: string | undefined;
1991
2167
  name: string;
@@ -1998,18 +2174,32 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1998
2174
  primaryKey: boolean;
1999
2175
  notNull: boolean;
2000
2176
  }>;
2001
- indexes: Record<string, string>;
2002
- foreignKeys: Record<string, string>;
2003
- compositePrimaryKeys: Record<string, string>;
2004
- uniqueConstraints: Record<string, string>;
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
+ }>;
2005
2194
  }>;
2195
+ id: string;
2196
+ prevId: string;
2197
+ version: "4";
2198
+ dialect: "mysql";
2006
2199
  schemas: Record<string, string>;
2007
2200
  }, {
2008
- version: "5";
2009
- dialect: "mysql";
2010
2201
  tables: Record<string, {
2011
2202
  schema?: string | undefined;
2012
- uniqueConstraints?: Record<string, string> | undefined;
2013
2203
  name: string;
2014
2204
  columns: Record<string, {
2015
2205
  default?: any;
@@ -2020,14 +2210,32 @@ export declare const schemaSquashed: import("zod").ZodObject<{
2020
2210
  primaryKey: boolean;
2021
2211
  notNull: boolean;
2022
2212
  }>;
2023
- indexes: Record<string, string>;
2024
- foreignKeys: Record<string, string>;
2025
- compositePrimaryKeys: Record<string, string>;
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
+ }>;
2026
2230
  }>;
2231
+ id: string;
2232
+ prevId: string;
2233
+ version: "4";
2234
+ dialect: "mysql";
2027
2235
  schemas: Record<string, string>;
2028
2236
  }>;
2029
- export declare const schemaSquashedV4: import("zod").ZodObject<{
2030
- version: import("zod").ZodLiteral<"4">;
2237
+ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape<{
2238
+ version: import("zod").ZodLiteral<"5">;
2031
2239
  dialect: import("zod").ZodLiteral<"mysql">;
2032
2240
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2033
2241
  name: import("zod").ZodString;
@@ -2057,8 +2265,73 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
2057
2265
  primaryKey: boolean;
2058
2266
  notNull: boolean;
2059
2267
  }>>;
2060
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2061
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
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
+ }>>>;
2062
2335
  }, "strict", import("zod").ZodTypeAny, {
2063
2336
  schema?: string | undefined;
2064
2337
  name: string;
@@ -2071,27 +2344,125 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
2071
2344
  primaryKey: boolean;
2072
2345
  notNull: boolean;
2073
2346
  }>;
2074
- indexes: Record<string, string>;
2075
- foreignKeys: Record<string, string>;
2076
- }, {
2077
- schema?: string | undefined;
2078
- name: string;
2079
- columns: Record<string, {
2080
- default?: any;
2081
- onUpdate?: any;
2082
- autoincrement?: boolean | undefined;
2347
+ indexes: Record<string, {
2348
+ using?: "btree" | "hash" | undefined;
2349
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2350
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2083
2351
  name: string;
2084
- type: string;
2085
- primaryKey: boolean;
2086
- notNull: boolean;
2352
+ columns: string[];
2353
+ isUnique: boolean;
2087
2354
  }>;
2088
- indexes: Record<string, string>;
2089
- foreignKeys: Record<string, string>;
2090
- }>>;
2091
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2092
- }, "strict", import("zod").ZodTypeAny, {
2093
- version: "4";
2094
- dialect: "mysql";
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
+ }>;
2372
+ }, {
2373
+ schema?: string | undefined;
2374
+ uniqueConstraints?: Record<string, {
2375
+ name: string;
2376
+ columns: string[];
2377
+ }> | undefined;
2378
+ name: string;
2379
+ columns: Record<string, {
2380
+ default?: any;
2381
+ onUpdate?: any;
2382
+ autoincrement?: boolean | undefined;
2383
+ name: string;
2384
+ type: string;
2385
+ primaryKey: boolean;
2386
+ notNull: boolean;
2387
+ }>;
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
+ }>;
2409
+ }>>;
2410
+ 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;
2095
2466
  tables: Record<string, {
2096
2467
  schema?: string | undefined;
2097
2468
  name: string;
@@ -2104,15 +2475,56 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
2104
2475
  primaryKey: boolean;
2105
2476
  notNull: boolean;
2106
2477
  }>;
2107
- indexes: Record<string, string>;
2108
- foreignKeys: Record<string, string>;
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
+ }>;
2109
2503
  }>;
2504
+ id: string;
2505
+ prevId: string;
2506
+ version: "5";
2507
+ dialect: "mysql";
2110
2508
  schemas: Record<string, string>;
2509
+ _meta: {
2510
+ columns: Record<string, string>;
2511
+ tables: Record<string, string>;
2512
+ schemas: Record<string, string>;
2513
+ };
2111
2514
  }, {
2112
- version: "4";
2113
- dialect: "mysql";
2515
+ internal?: {
2516
+ tables: Record<string, {
2517
+ columns: Record<string, {
2518
+ isDefaultAnExpression?: boolean | undefined;
2519
+ } | undefined>;
2520
+ } | undefined>;
2521
+ } | undefined;
2114
2522
  tables: Record<string, {
2115
2523
  schema?: string | undefined;
2524
+ uniqueConstraints?: Record<string, {
2525
+ name: string;
2526
+ columns: string[];
2527
+ }> | undefined;
2116
2528
  name: string;
2117
2529
  columns: Record<string, {
2118
2530
  default?: any;
@@ -2123,40 +2535,41 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
2123
2535
  primaryKey: boolean;
2124
2536
  notNull: boolean;
2125
2537
  }>;
2126
- indexes: Record<string, string>;
2127
- foreignKeys: Record<string, string>;
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
+ }>;
2128
2559
  }>;
2560
+ id: string;
2561
+ prevId: string;
2562
+ version: "5";
2563
+ dialect: "mysql";
2129
2564
  schemas: Record<string, string>;
2565
+ _meta: {
2566
+ columns: Record<string, string>;
2567
+ tables: Record<string, string>;
2568
+ schemas: Record<string, string>;
2569
+ };
2130
2570
  }>;
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">;
2571
+ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2572
+ version: import("zod").ZodLiteral<"6">;
2160
2573
  dialect: import("zod").ZodLiteral<"mysql">;
2161
2574
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2162
2575
  name: import("zod").ZodString;
@@ -2384,10 +2797,6 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2384
2797
  } | undefined>;
2385
2798
  } | undefined>;
2386
2799
  } | undefined;
2387
- id: string;
2388
- prevId: string;
2389
- version: "5";
2390
- dialect: "mysql";
2391
2800
  tables: Record<string, {
2392
2801
  schema?: string | undefined;
2393
2802
  name: string;
@@ -2426,6 +2835,10 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2426
2835
  columns: string[];
2427
2836
  }>;
2428
2837
  }>;
2838
+ id: string;
2839
+ prevId: string;
2840
+ version: "6";
2841
+ dialect: "mysql";
2429
2842
  schemas: Record<string, string>;
2430
2843
  _meta: {
2431
2844
  columns: Record<string, string>;
@@ -2440,10 +2853,6 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2440
2853
  } | undefined>;
2441
2854
  } | undefined>;
2442
2855
  } | undefined;
2443
- id: string;
2444
- prevId: string;
2445
- version: "5";
2446
- dialect: "mysql";
2447
2856
  tables: Record<string, {
2448
2857
  schema?: string | undefined;
2449
2858
  uniqueConstraints?: Record<string, {
@@ -2482,6 +2891,10 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2482
2891
  columns: string[];
2483
2892
  }>;
2484
2893
  }>;
2894
+ id: string;
2895
+ prevId: string;
2896
+ version: "6";
2897
+ dialect: "mysql";
2485
2898
  schemas: Record<string, string>;
2486
2899
  _meta: {
2487
2900
  columns: Record<string, string>;
@@ -2489,8 +2902,8 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2489
2902
  schemas: Record<string, string>;
2490
2903
  };
2491
2904
  }>;
2492
- export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
2493
- version: import("zod").ZodLiteral<"4">;
2905
+ export declare const schemaSquashed: import("zod").ZodObject<{
2906
+ version: import("zod").ZodLiteral<"5">;
2494
2907
  dialect: import("zod").ZodLiteral<"mysql">;
2495
2908
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2496
2909
  name: import("zod").ZodString;
@@ -2520,53 +2933,10 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2520
2933
  primaryKey: boolean;
2521
2934
  notNull: boolean;
2522
2935
  }>>;
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;
2534
- name: string;
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;
2541
- name: string;
2542
- columns: string[];
2543
- isUnique: boolean;
2544
- }>>;
2545
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2546
- name: import("zod").ZodString;
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>;
2553
- }, "strict", import("zod").ZodTypeAny, {
2554
- onUpdate?: string | undefined;
2555
- onDelete?: string | undefined;
2556
- name: string;
2557
- tableFrom: string;
2558
- columnsFrom: string[];
2559
- tableTo: string;
2560
- columnsTo: string[];
2561
- }, {
2562
- onUpdate?: string | undefined;
2563
- onDelete?: string | undefined;
2564
- name: string;
2565
- tableFrom: string;
2566
- columnsFrom: string[];
2567
- tableTo: string;
2568
- columnsTo: string[];
2569
- }>>;
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>>;
2570
2940
  }, "strict", import("zod").ZodTypeAny, {
2571
2941
  schema?: string | undefined;
2572
2942
  name: string;
@@ -2579,25 +2949,13 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2579
2949
  primaryKey: boolean;
2580
2950
  notNull: boolean;
2581
2951
  }>;
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
- }>;
2952
+ indexes: Record<string, string>;
2953
+ foreignKeys: Record<string, string>;
2954
+ compositePrimaryKeys: Record<string, string>;
2955
+ uniqueConstraints: Record<string, string>;
2599
2956
  }, {
2600
2957
  schema?: string | undefined;
2958
+ uniqueConstraints?: Record<string, string> | undefined;
2601
2959
  name: string;
2602
2960
  columns: Record<string, {
2603
2961
  default?: any;
@@ -2608,33 +2966,12 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2608
2966
  primaryKey: boolean;
2609
2967
  notNull: boolean;
2610
2968
  }>;
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
- }>;
2969
+ indexes: Record<string, string>;
2970
+ foreignKeys: Record<string, string>;
2971
+ compositePrimaryKeys: Record<string, string>;
2628
2972
  }>>;
2629
2973
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
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";
2974
+ }, "strict", import("zod").ZodTypeAny, {
2638
2975
  tables: Record<string, {
2639
2976
  schema?: string | undefined;
2640
2977
  name: string;
@@ -2647,32 +2984,18 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2647
2984
  primaryKey: boolean;
2648
2985
  notNull: boolean;
2649
2986
  }>;
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
- }>;
2987
+ indexes: Record<string, string>;
2988
+ foreignKeys: Record<string, string>;
2989
+ compositePrimaryKeys: Record<string, string>;
2990
+ uniqueConstraints: Record<string, string>;
2667
2991
  }>;
2992
+ version: "5";
2993
+ dialect: "mysql";
2668
2994
  schemas: Record<string, string>;
2669
2995
  }, {
2670
- id: string;
2671
- prevId: string;
2672
- version: "4";
2673
- dialect: "mysql";
2674
2996
  tables: Record<string, {
2675
2997
  schema?: string | undefined;
2998
+ uniqueConstraints?: Record<string, string> | undefined;
2676
2999
  name: string;
2677
3000
  columns: Record<string, {
2678
3001
  default?: any;
@@ -2683,31 +3006,20 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2683
3006
  primaryKey: boolean;
2684
3007
  notNull: boolean;
2685
3008
  }>;
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
- }>;
3009
+ indexes: Record<string, string>;
3010
+ foreignKeys: Record<string, string>;
3011
+ compositePrimaryKeys: Record<string, string>;
2703
3012
  }>;
3013
+ version: "5";
3014
+ dialect: "mysql";
2704
3015
  schemas: Record<string, string>;
2705
3016
  }>;
2706
- export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
2707
- version: import("zod").ZodLiteral<"3">;
3017
+ export declare const schemaSquashedV4: import("zod").ZodObject<{
3018
+ version: import("zod").ZodLiteral<"4">;
2708
3019
  dialect: import("zod").ZodLiteral<"mysql">;
2709
3020
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2710
3021
  name: import("zod").ZodString;
3022
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
2711
3023
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2712
3024
  name: import("zod").ZodString;
2713
3025
  type: import("zod").ZodString;
@@ -2733,54 +3045,10 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2733
3045
  primaryKey: boolean;
2734
3046
  notNull: boolean;
2735
3047
  }>>;
2736
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2737
- name: import("zod").ZodString;
2738
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2739
- isUnique: import("zod").ZodBoolean;
2740
- using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2741
- algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2742
- lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2743
- }, "strict", import("zod").ZodTypeAny, {
2744
- using?: "btree" | "hash" | undefined;
2745
- algorithm?: "default" | "inplace" | "copy" | undefined;
2746
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2747
- name: string;
2748
- columns: string[];
2749
- isUnique: boolean;
2750
- }, {
2751
- using?: "btree" | "hash" | undefined;
2752
- algorithm?: "default" | "inplace" | "copy" | undefined;
2753
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2754
- name: string;
2755
- columns: string[];
2756
- isUnique: boolean;
2757
- }>>;
2758
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2759
- name: import("zod").ZodString;
2760
- tableFrom: import("zod").ZodString;
2761
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2762
- tableTo: import("zod").ZodString;
2763
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2764
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2765
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2766
- }, "strict", import("zod").ZodTypeAny, {
2767
- onUpdate?: string | undefined;
2768
- onDelete?: string | undefined;
2769
- name: string;
2770
- tableFrom: string;
2771
- columnsFrom: string[];
2772
- tableTo: string;
2773
- columnsTo: string[];
2774
- }, {
2775
- onUpdate?: string | undefined;
2776
- onDelete?: string | undefined;
2777
- name: string;
2778
- tableFrom: string;
2779
- columnsFrom: string[];
2780
- tableTo: string;
2781
- columnsTo: string[];
2782
- }>>;
3048
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3049
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2783
3050
  }, "strict", import("zod").ZodTypeAny, {
3051
+ schema?: string | undefined;
2784
3052
  name: string;
2785
3053
  columns: Record<string, {
2786
3054
  default?: any;
@@ -2791,24 +3059,10 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2791
3059
  primaryKey: boolean;
2792
3060
  notNull: boolean;
2793
3061
  }>;
2794
- indexes: Record<string, {
2795
- using?: "btree" | "hash" | undefined;
2796
- algorithm?: "default" | "inplace" | "copy" | undefined;
2797
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2798
- name: string;
2799
- columns: string[];
2800
- isUnique: boolean;
2801
- }>;
2802
- foreignKeys: Record<string, {
2803
- onUpdate?: string | undefined;
2804
- onDelete?: string | undefined;
2805
- name: string;
2806
- tableFrom: string;
2807
- columnsFrom: string[];
2808
- tableTo: string;
2809
- columnsTo: string[];
2810
- }>;
3062
+ indexes: Record<string, string>;
3063
+ foreignKeys: Record<string, string>;
2811
3064
  }, {
3065
+ schema?: string | undefined;
2812
3066
  name: string;
2813
3067
  columns: Record<string, {
2814
3068
  default?: any;
@@ -2819,170 +3073,13 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2819
3073
  primaryKey: boolean;
2820
3074
  notNull: boolean;
2821
3075
  }>;
2822
- indexes: Record<string, {
2823
- using?: "btree" | "hash" | undefined;
2824
- algorithm?: "default" | "inplace" | "copy" | undefined;
2825
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2826
- name: string;
2827
- columns: string[];
2828
- isUnique: boolean;
2829
- }>;
2830
- foreignKeys: Record<string, {
2831
- onUpdate?: string | undefined;
2832
- onDelete?: string | undefined;
2833
- name: string;
2834
- tableFrom: string;
2835
- columnsFrom: string[];
2836
- tableTo: string;
2837
- columnsTo: string[];
2838
- }>;
3076
+ indexes: Record<string, string>;
3077
+ foreignKeys: Record<string, string>;
2839
3078
  }>>;
2840
- }, {
2841
- id: import("zod").ZodString;
2842
- prevId: import("zod").ZodString;
2843
- }>, "strip", import("zod").ZodTypeAny, {
2844
- id: string;
2845
- prevId: string;
2846
- version: "3";
2847
- dialect: "mysql";
3079
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3080
+ }, "strict", import("zod").ZodTypeAny, {
2848
3081
  tables: Record<string, {
2849
- name: string;
2850
- columns: Record<string, {
2851
- default?: any;
2852
- onUpdate?: any;
2853
- autoincrement?: boolean | undefined;
2854
- name: string;
2855
- type: string;
2856
- primaryKey: boolean;
2857
- notNull: boolean;
2858
- }>;
2859
- indexes: Record<string, {
2860
- using?: "btree" | "hash" | undefined;
2861
- algorithm?: "default" | "inplace" | "copy" | undefined;
2862
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2863
- name: string;
2864
- columns: string[];
2865
- isUnique: boolean;
2866
- }>;
2867
- foreignKeys: Record<string, {
2868
- onUpdate?: string | undefined;
2869
- onDelete?: string | undefined;
2870
- name: string;
2871
- tableFrom: string;
2872
- columnsFrom: string[];
2873
- tableTo: string;
2874
- columnsTo: string[];
2875
- }>;
2876
- }>;
2877
- }, {
2878
- id: string;
2879
- prevId: string;
2880
- version: "3";
2881
- dialect: "mysql";
2882
- tables: Record<string, {
2883
- name: string;
2884
- columns: Record<string, {
2885
- default?: any;
2886
- onUpdate?: any;
2887
- autoincrement?: boolean | undefined;
2888
- name: string;
2889
- type: string;
2890
- primaryKey: boolean;
2891
- notNull: boolean;
2892
- }>;
2893
- indexes: Record<string, {
2894
- using?: "btree" | "hash" | undefined;
2895
- algorithm?: "default" | "inplace" | "copy" | undefined;
2896
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2897
- name: string;
2898
- columns: string[];
2899
- isUnique: boolean;
2900
- }>;
2901
- foreignKeys: Record<string, {
2902
- onUpdate?: string | undefined;
2903
- onDelete?: string | undefined;
2904
- name: string;
2905
- tableFrom: string;
2906
- columnsFrom: string[];
2907
- tableTo: string;
2908
- columnsTo: string[];
2909
- }>;
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;
2930
- name: string;
2931
- type: string;
2932
- primaryKey: boolean;
2933
- notNull: boolean;
2934
- }, {
2935
- default?: any;
2936
- onUpdate?: any;
2937
- autoincrement?: boolean | undefined;
2938
- name: string;
2939
- type: string;
2940
- primaryKey: boolean;
2941
- notNull: boolean;
2942
- }>>;
2943
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2944
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2945
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2946
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
2947
- }, "strict", import("zod").ZodTypeAny, {
2948
- schema?: string | undefined;
2949
- name: string;
2950
- columns: Record<string, {
2951
- default?: any;
2952
- onUpdate?: any;
2953
- autoincrement?: boolean | undefined;
2954
- name: string;
2955
- type: string;
2956
- primaryKey: boolean;
2957
- notNull: boolean;
2958
- }>;
2959
- indexes: Record<string, string>;
2960
- foreignKeys: Record<string, string>;
2961
- compositePrimaryKeys: Record<string, string>;
2962
- uniqueConstraints: Record<string, string>;
2963
- }, {
2964
- schema?: string | undefined;
2965
- uniqueConstraints?: Record<string, string> | undefined;
2966
- name: string;
2967
- columns: Record<string, {
2968
- default?: any;
2969
- onUpdate?: any;
2970
- autoincrement?: boolean | undefined;
2971
- name: string;
2972
- type: string;
2973
- primaryKey: boolean;
2974
- notNull: boolean;
2975
- }>;
2976
- indexes: Record<string, string>;
2977
- foreignKeys: Record<string, string>;
2978
- compositePrimaryKeys: Record<string, string>;
2979
- }>>;
2980
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2981
- }, "strict", import("zod").ZodTypeAny, {
2982
- version: "5";
2983
- dialect: "mysql";
2984
- tables: Record<string, {
2985
- schema?: string | undefined;
3082
+ schema?: string | undefined;
2986
3083
  name: string;
2987
3084
  columns: Record<string, {
2988
3085
  default?: any;
@@ -2995,16 +3092,13 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
2995
3092
  }>;
2996
3093
  indexes: Record<string, string>;
2997
3094
  foreignKeys: Record<string, string>;
2998
- compositePrimaryKeys: Record<string, string>;
2999
- uniqueConstraints: Record<string, string>;
3000
3095
  }>;
3096
+ version: "4";
3097
+ dialect: "mysql";
3001
3098
  schemas: Record<string, string>;
3002
3099
  }, {
3003
- version: "5";
3004
- dialect: "mysql";
3005
3100
  tables: Record<string, {
3006
3101
  schema?: string | undefined;
3007
- uniqueConstraints?: Record<string, string> | undefined;
3008
3102
  name: string;
3009
3103
  columns: Record<string, {
3010
3104
  default?: any;
@@ -3017,15 +3111,45 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
3017
3111
  }>;
3018
3112
  indexes: Record<string, string>;
3019
3113
  foreignKeys: Record<string, string>;
3020
- compositePrimaryKeys: Record<string, string>;
3021
3114
  }>;
3115
+ version: "4";
3116
+ dialect: "mysql";
3022
3117
  schemas: Record<string, string>;
3023
3118
  }>;
3024
- export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
3025
- version: import("zod").ZodLiteral<"3">;
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">;
3026
3149
  dialect: import("zod").ZodLiteral<"mysql">;
3027
3150
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3028
3151
  name: import("zod").ZodString;
3152
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
3029
3153
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3030
3154
  name: import("zod").ZodString;
3031
3155
  type: import("zod").ZodString;
@@ -3098,7 +3222,69 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3098
3222
  tableTo: string;
3099
3223
  columnsTo: string[];
3100
3224
  }>>;
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
+ }>>>;
3101
3245
  }, "strict", import("zod").ZodTypeAny, {
3246
+ schema?: string | undefined;
3247
+ name: string;
3248
+ columns: Record<string, {
3249
+ default?: any;
3250
+ onUpdate?: any;
3251
+ autoincrement?: boolean | undefined;
3252
+ name: string;
3253
+ type: string;
3254
+ primaryKey: boolean;
3255
+ notNull: boolean;
3256
+ }>;
3257
+ indexes: Record<string, {
3258
+ using?: "btree" | "hash" | undefined;
3259
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3260
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3261
+ name: string;
3262
+ columns: string[];
3263
+ isUnique: boolean;
3264
+ }>;
3265
+ foreignKeys: Record<string, {
3266
+ onUpdate?: string | undefined;
3267
+ onDelete?: string | undefined;
3268
+ name: string;
3269
+ tableFrom: string;
3270
+ columnsFrom: string[];
3271
+ tableTo: string;
3272
+ columnsTo: string[];
3273
+ }>;
3274
+ compositePrimaryKeys: Record<string, {
3275
+ name: string;
3276
+ columns: string[];
3277
+ }>;
3278
+ uniqueConstraints: Record<string, {
3279
+ name: string;
3280
+ columns: string[];
3281
+ }>;
3282
+ }, {
3283
+ schema?: string | undefined;
3284
+ uniqueConstraints?: Record<string, {
3285
+ name: string;
3286
+ columns: string[];
3287
+ }> | undefined;
3102
3288
  name: string;
3103
3289
  columns: Record<string, {
3104
3290
  default?: any;
@@ -3126,7 +3312,980 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3126
3312
  tableTo: string;
3127
3313
  columnsTo: string[];
3128
3314
  }>;
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
+ }>>;
3365
+ }, {
3366
+ id: import("zod").ZodString;
3367
+ prevId: import("zod").ZodString;
3368
+ }>, "strip", import("zod").ZodTypeAny, {
3369
+ internal?: {
3370
+ tables: Record<string, {
3371
+ columns: Record<string, {
3372
+ isDefaultAnExpression?: boolean | undefined;
3373
+ } | undefined>;
3374
+ } | undefined>;
3375
+ } | undefined;
3376
+ tables: Record<string, {
3377
+ schema?: string | undefined;
3378
+ name: string;
3379
+ columns: Record<string, {
3380
+ default?: any;
3381
+ onUpdate?: any;
3382
+ autoincrement?: boolean | undefined;
3383
+ name: string;
3384
+ type: string;
3385
+ primaryKey: boolean;
3386
+ notNull: boolean;
3387
+ }>;
3388
+ indexes: Record<string, {
3389
+ using?: "btree" | "hash" | undefined;
3390
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3391
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3392
+ name: string;
3393
+ columns: string[];
3394
+ isUnique: boolean;
3395
+ }>;
3396
+ foreignKeys: Record<string, {
3397
+ onUpdate?: string | undefined;
3398
+ onDelete?: string | undefined;
3399
+ name: string;
3400
+ tableFrom: string;
3401
+ columnsFrom: string[];
3402
+ tableTo: string;
3403
+ columnsTo: string[];
3404
+ }>;
3405
+ compositePrimaryKeys: Record<string, {
3406
+ name: string;
3407
+ columns: string[];
3408
+ }>;
3409
+ uniqueConstraints: Record<string, {
3410
+ name: string;
3411
+ columns: string[];
3412
+ }>;
3413
+ }>;
3414
+ id: string;
3415
+ prevId: string;
3416
+ version: "6";
3417
+ 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
+ tables: Record<string, {
3433
+ schema?: string | undefined;
3434
+ uniqueConstraints?: Record<string, {
3435
+ name: string;
3436
+ columns: string[];
3437
+ }> | undefined;
3438
+ name: string;
3439
+ columns: Record<string, {
3440
+ default?: any;
3441
+ onUpdate?: any;
3442
+ autoincrement?: boolean | undefined;
3443
+ name: string;
3444
+ type: string;
3445
+ primaryKey: boolean;
3446
+ notNull: boolean;
3447
+ }>;
3448
+ indexes: Record<string, {
3449
+ using?: "btree" | "hash" | undefined;
3450
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3451
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3452
+ name: string;
3453
+ columns: string[];
3454
+ isUnique: boolean;
3455
+ }>;
3456
+ foreignKeys: Record<string, {
3457
+ onUpdate?: string | undefined;
3458
+ onDelete?: string | undefined;
3459
+ name: string;
3460
+ tableFrom: string;
3461
+ columnsFrom: string[];
3462
+ tableTo: string;
3463
+ columnsTo: string[];
3464
+ }>;
3465
+ compositePrimaryKeys: Record<string, {
3466
+ name: string;
3467
+ columns: string[];
3468
+ }>;
3469
+ }>;
3470
+ id: string;
3471
+ prevId: string;
3472
+ version: "6";
3473
+ dialect: "mysql";
3474
+ schemas: Record<string, string>;
3475
+ _meta: {
3476
+ columns: Record<string, string>;
3477
+ tables: Record<string, string>;
3478
+ schemas: Record<string, string>;
3479
+ };
3480
+ }>;
3481
+ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
3482
+ version: import("zod").ZodLiteral<"3">;
3483
+ dialect: import("zod").ZodLiteral<"mysql">;
3484
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3485
+ name: import("zod").ZodString;
3486
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3487
+ name: import("zod").ZodString;
3488
+ type: import("zod").ZodString;
3489
+ primaryKey: import("zod").ZodBoolean;
3490
+ notNull: import("zod").ZodBoolean;
3491
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
3492
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
3493
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3494
+ }, "strict", import("zod").ZodTypeAny, {
3495
+ default?: any;
3496
+ onUpdate?: any;
3497
+ autoincrement?: boolean | undefined;
3498
+ name: string;
3499
+ type: string;
3500
+ primaryKey: boolean;
3501
+ notNull: boolean;
3502
+ }, {
3503
+ default?: any;
3504
+ onUpdate?: any;
3505
+ autoincrement?: boolean | undefined;
3506
+ name: string;
3507
+ type: string;
3508
+ primaryKey: boolean;
3509
+ notNull: boolean;
3510
+ }>>;
3511
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3512
+ name: import("zod").ZodString;
3513
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3514
+ isUnique: import("zod").ZodBoolean;
3515
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
3516
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
3517
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
3518
+ }, "strict", import("zod").ZodTypeAny, {
3519
+ using?: "btree" | "hash" | undefined;
3520
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3521
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3522
+ name: string;
3523
+ columns: string[];
3524
+ isUnique: boolean;
3525
+ }, {
3526
+ using?: "btree" | "hash" | undefined;
3527
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3528
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3529
+ name: string;
3530
+ columns: string[];
3531
+ isUnique: boolean;
3532
+ }>>;
3533
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3534
+ name: import("zod").ZodString;
3535
+ tableFrom: import("zod").ZodString;
3536
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3537
+ tableTo: import("zod").ZodString;
3538
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3539
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3540
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3541
+ }, "strict", import("zod").ZodTypeAny, {
3542
+ onUpdate?: string | undefined;
3543
+ onDelete?: string | undefined;
3544
+ name: string;
3545
+ tableFrom: string;
3546
+ columnsFrom: string[];
3547
+ tableTo: string;
3548
+ columnsTo: string[];
3549
+ }, {
3550
+ onUpdate?: string | undefined;
3551
+ onDelete?: string | undefined;
3552
+ name: string;
3553
+ tableFrom: string;
3554
+ columnsFrom: string[];
3555
+ tableTo: string;
3556
+ columnsTo: string[];
3557
+ }>>;
3558
+ }, "strict", import("zod").ZodTypeAny, {
3559
+ name: string;
3560
+ columns: Record<string, {
3561
+ default?: any;
3562
+ onUpdate?: any;
3563
+ autoincrement?: boolean | undefined;
3564
+ name: string;
3565
+ type: string;
3566
+ primaryKey: boolean;
3567
+ notNull: boolean;
3568
+ }>;
3569
+ indexes: Record<string, {
3570
+ using?: "btree" | "hash" | undefined;
3571
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3572
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3573
+ name: string;
3574
+ columns: string[];
3575
+ isUnique: boolean;
3576
+ }>;
3577
+ foreignKeys: Record<string, {
3578
+ onUpdate?: string | undefined;
3579
+ 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;
4281
+ }>;
4282
+ indexes: Record<string, string>;
4283
+ foreignKeys: Record<string, string>;
4284
+ compositePrimaryKeys: Record<string, string>;
4285
+ uniqueConstraints: Record<string, string>;
3129
4286
  }, {
4287
+ schema?: string | undefined;
4288
+ uniqueConstraints?: Record<string, string> | undefined;
3130
4289
  name: string;
3131
4290
  columns: Record<string, {
3132
4291
  default?: any;
@@ -3137,33 +4296,14 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3137
4296
  primaryKey: boolean;
3138
4297
  notNull: boolean;
3139
4298
  }>;
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
- }>;
4299
+ indexes: Record<string, string>;
4300
+ foreignKeys: Record<string, string>;
4301
+ compositePrimaryKeys: Record<string, string>;
3157
4302
  }>>;
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";
4303
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4304
+ }, "strict", import("zod").ZodTypeAny, {
3166
4305
  tables: Record<string, {
4306
+ schema?: string | undefined;
3167
4307
  name: string;
3168
4308
  columns: Record<string, {
3169
4309
  default?: any;
@@ -3174,30 +4314,18 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3174
4314
  primaryKey: boolean;
3175
4315
  notNull: boolean;
3176
4316
  }>;
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
- }>;
4317
+ indexes: Record<string, string>;
4318
+ foreignKeys: Record<string, string>;
4319
+ compositePrimaryKeys: Record<string, string>;
4320
+ uniqueConstraints: Record<string, string>;
3194
4321
  }>;
3195
- }, {
3196
- id: string;
3197
- prevId: string;
3198
- version: "3";
4322
+ version: "5";
3199
4323
  dialect: "mysql";
4324
+ schemas: Record<string, string>;
4325
+ }, {
3200
4326
  tables: Record<string, {
4327
+ schema?: string | undefined;
4328
+ uniqueConstraints?: Record<string, string> | undefined;
3201
4329
  name: string;
3202
4330
  columns: Record<string, {
3203
4331
  default?: any;
@@ -3208,26 +4336,16 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3208
4336
  primaryKey: boolean;
3209
4337
  notNull: boolean;
3210
4338
  }>;
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
- }>;
4339
+ indexes: Record<string, string>;
4340
+ foreignKeys: Record<string, string>;
4341
+ compositePrimaryKeys: Record<string, string>;
3228
4342
  }>;
3229
- }>, import("zod").ZodObject<import("zod").extendShape<{
3230
- version: import("zod").ZodLiteral<"4">;
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">;
3231
4349
  dialect: import("zod").ZodLiteral<"mysql">;
3232
4350
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3233
4351
  name: import("zod").ZodString;
@@ -3304,6 +4422,26 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3304
4422
  tableTo: string;
3305
4423
  columnsTo: string[];
3306
4424
  }>>;
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
+ }>>>;
3307
4445
  }, "strict", import("zod").ZodTypeAny, {
3308
4446
  schema?: string | undefined;
3309
4447
  name: string;
@@ -3333,8 +4471,20 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3333
4471
  tableTo: string;
3334
4472
  columnsTo: string[];
3335
4473
  }>;
4474
+ compositePrimaryKeys: Record<string, {
4475
+ name: string;
4476
+ columns: string[];
4477
+ }>;
4478
+ uniqueConstraints: Record<string, {
4479
+ name: string;
4480
+ columns: string[];
4481
+ }>;
3336
4482
  }, {
3337
4483
  schema?: string | undefined;
4484
+ uniqueConstraints?: Record<string, {
4485
+ name: string;
4486
+ columns: string[];
4487
+ }> | undefined;
3338
4488
  name: string;
3339
4489
  columns: Record<string, {
3340
4490
  default?: any;
@@ -3362,16 +4512,67 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3362
4512
  tableTo: string;
3363
4513
  columnsTo: string[];
3364
4514
  }>;
4515
+ compositePrimaryKeys: Record<string, {
4516
+ name: string;
4517
+ columns: string[];
4518
+ }>;
3365
4519
  }>>;
3366
4520
  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
+ }>>;
3367
4565
  }, {
3368
4566
  id: import("zod").ZodString;
3369
4567
  prevId: import("zod").ZodString;
3370
4568
  }>, "strip", import("zod").ZodTypeAny, {
3371
- id: string;
3372
- prevId: string;
3373
- version: "4";
3374
- dialect: "mysql";
4569
+ internal?: {
4570
+ tables: Record<string, {
4571
+ columns: Record<string, {
4572
+ isDefaultAnExpression?: boolean | undefined;
4573
+ } | undefined>;
4574
+ } | undefined>;
4575
+ } | undefined;
3375
4576
  tables: Record<string, {
3376
4577
  schema?: string | undefined;
3377
4578
  name: string;
@@ -3401,15 +4602,39 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3401
4602
  tableTo: string;
3402
4603
  columnsTo: string[];
3403
4604
  }>;
4605
+ compositePrimaryKeys: Record<string, {
4606
+ name: string;
4607
+ columns: string[];
4608
+ }>;
4609
+ uniqueConstraints: Record<string, {
4610
+ name: string;
4611
+ columns: string[];
4612
+ }>;
3404
4613
  }>;
3405
- schemas: Record<string, string>;
3406
- }, {
3407
4614
  id: string;
3408
4615
  prevId: string;
3409
- version: "4";
4616
+ version: "5";
3410
4617
  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;
3411
4632
  tables: Record<string, {
3412
4633
  schema?: string | undefined;
4634
+ uniqueConstraints?: Record<string, {
4635
+ name: string;
4636
+ columns: string[];
4637
+ }> | undefined;
3413
4638
  name: string;
3414
4639
  columns: Record<string, {
3415
4640
  default?: any;
@@ -3437,10 +4662,23 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3437
4662
  tableTo: string;
3438
4663
  columnsTo: string[];
3439
4664
  }>;
4665
+ compositePrimaryKeys: Record<string, {
4666
+ name: string;
4667
+ columns: string[];
4668
+ }>;
3440
4669
  }>;
4670
+ id: string;
4671
+ prevId: string;
4672
+ version: "5";
4673
+ dialect: "mysql";
3441
4674
  schemas: Record<string, string>;
4675
+ _meta: {
4676
+ columns: Record<string, string>;
4677
+ tables: Record<string, string>;
4678
+ schemas: Record<string, string>;
4679
+ };
3442
4680
  }>, import("zod").ZodObject<import("zod").extendShape<{
3443
- version: import("zod").ZodLiteral<"5">;
4681
+ version: import("zod").ZodLiteral<"6">;
3444
4682
  dialect: import("zod").ZodLiteral<"mysql">;
3445
4683
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3446
4684
  name: import("zod").ZodString;
@@ -3668,10 +4906,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3668
4906
  } | undefined>;
3669
4907
  } | undefined>;
3670
4908
  } | undefined;
3671
- id: string;
3672
- prevId: string;
3673
- version: "5";
3674
- dialect: "mysql";
3675
4909
  tables: Record<string, {
3676
4910
  schema?: string | undefined;
3677
4911
  name: string;
@@ -3710,6 +4944,10 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3710
4944
  columns: string[];
3711
4945
  }>;
3712
4946
  }>;
4947
+ id: string;
4948
+ prevId: string;
4949
+ version: "6";
4950
+ dialect: "mysql";
3713
4951
  schemas: Record<string, string>;
3714
4952
  _meta: {
3715
4953
  columns: Record<string, string>;
@@ -3724,10 +4962,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3724
4962
  } | undefined>;
3725
4963
  } | undefined>;
3726
4964
  } | undefined;
3727
- id: string;
3728
- prevId: string;
3729
- version: "5";
3730
- dialect: "mysql";
3731
4965
  tables: Record<string, {
3732
4966
  schema?: string | undefined;
3733
4967
  uniqueConstraints?: Record<string, {
@@ -3766,6 +5000,10 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3766
5000
  columns: string[];
3767
5001
  }>;
3768
5002
  }>;
5003
+ id: string;
5004
+ prevId: string;
5005
+ version: "6";
5006
+ dialect: "mysql";
3769
5007
  schemas: Record<string, string>;
3770
5008
  _meta: {
3771
5009
  columns: Record<string, string>;
@@ -3781,10 +5019,6 @@ export declare const dryMySql: {
3781
5019
  } | undefined>;
3782
5020
  } | undefined>;
3783
5021
  } | undefined;
3784
- id: string;
3785
- prevId: string;
3786
- version: "5";
3787
- dialect: "mysql";
3788
5022
  tables: Record<string, {
3789
5023
  schema?: string | undefined;
3790
5024
  name: string;
@@ -3823,6 +5057,10 @@ export declare const dryMySql: {
3823
5057
  columns: string[];
3824
5058
  }>;
3825
5059
  }>;
5060
+ id: string;
5061
+ prevId: string;
5062
+ version: "6";
5063
+ dialect: "mysql";
3826
5064
  schemas: Record<string, string>;
3827
5065
  _meta: {
3828
5066
  columns: Record<string, string>;