drizzle-kit 0.20.14-d8f1e46 → 0.20.14-e8e7ed6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (50) hide show
  1. package/bin.cjs +21878 -21519
  2. package/cli/commands/migrate.d.ts +121 -97
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -14
  4. package/cli/commands/mysqlPushUtils.d.ts +2 -2
  5. package/cli/commands/pgConnect.d.ts +1 -1
  6. package/cli/commands/pgIntrospect.d.ts +18 -11
  7. package/cli/commands/pgPushUtils.d.ts +2 -2
  8. package/cli/commands/sqliteIntrospect.d.ts +9 -9
  9. package/cli/commands/sqlitePushUtils.d.ts +3 -3
  10. package/cli/commands/utils.d.ts +15 -259
  11. package/cli/validations/cli.d.ts +107 -0
  12. package/cli/validations/common.d.ts +205 -7
  13. package/cli/validations/mysql.d.ts +6 -1
  14. package/cli/validations/pg.d.ts +6 -1
  15. package/cli/validations/sqlite.d.ts +382 -0
  16. package/cli/views.d.ts +7 -5
  17. package/global.d.ts +3 -1
  18. package/index.d.mts +8 -6
  19. package/index.d.ts +8 -6
  20. package/index.js +1 -0
  21. package/introspect-mysql.d.ts +1 -1
  22. package/introspect-pg.d.ts +5 -2
  23. package/introspect-sqlite.d.ts +1 -1
  24. package/jsonDiffer.d.ts +14 -29
  25. package/jsonStatements.d.ts +38 -11
  26. package/package.json +18 -51
  27. package/payload.d.mts +18 -988
  28. package/payload.d.ts +18 -988
  29. package/payload.js +18030 -7175
  30. package/payload.mjs +9020 -9305
  31. package/schemaValidator.d.ts +73 -70
  32. package/serializer/mysqlImports.d.ts +3 -7
  33. package/serializer/mysqlSchema.d.ts +1624 -493
  34. package/serializer/mysqlSerializer.d.ts +4 -4
  35. package/serializer/pgImports.d.ts +2 -2
  36. package/serializer/pgSchema.d.ts +1260 -801
  37. package/serializer/sqliteImports.d.ts +2 -4
  38. package/serializer/sqliteSchema.d.ts +144 -570
  39. package/serializer/sqliteSerializer.d.ts +3 -3
  40. package/snapshotsDiffer.d.ts +1908 -1050
  41. package/utils/words.d.ts +1 -1
  42. package/utils-studio.js +4147 -83
  43. package/utils-studio.mjs +4147 -83
  44. package/utils.d.ts +6 -140
  45. package/utils.js +3903 -7064
  46. package/utils.mjs +3982 -7143
  47. package/cli/commands/mysqlUp.d.ts +0 -4
  48. package/cli/commands/pgUp.d.ts +0 -4
  49. package/cli/commands/sqliteUtils.d.ts +0 -162
  50. package/cli/commands/upFolders.d.ts +0 -27
package/serializer/mysqlSchema.d.ts CHANGED
@@ -227,7 +227,6 @@ declare const tableV4: import("zod").ZodObject<{
227
227
  }>;
228
228
  declare const table: import("zod").ZodObject<{
229
229
  name: import("zod").ZodString;
230
- schema: import("zod").ZodOptional<import("zod").ZodString>;
231
230
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
232
231
  name: import("zod").ZodString;
233
232
  type: import("zod").ZodString;
@@ -321,7 +320,6 @@ declare const table: import("zod").ZodObject<{
321
320
  columns: string[];
322
321
  }>>>;
323
322
  }, "strict", import("zod").ZodTypeAny, {
324
- schema?: string | undefined;
325
323
  name: string;
326
324
  columns: Record<string, {
327
325
  default?: any;
@@ -358,7 +356,6 @@ declare const table: import("zod").ZodObject<{
358
356
  columns: string[];
359
357
  }>;
360
358
  }, {
361
- schema?: string | undefined;
362
359
  uniqueConstraints?: Record<string, {
363
360
  name: string;
364
361
  columns: string[];
@@ -395,6 +392,37 @@ declare const table: import("zod").ZodObject<{
395
392
  columns: string[];
396
393
  }>;
397
394
  }>;
395
+ export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
396
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
397
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
398
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
399
+ }, "strip", import("zod").ZodTypeAny, {
400
+ isDefaultAnExpression?: boolean | undefined;
401
+ }, {
402
+ isDefaultAnExpression?: boolean | undefined;
403
+ }>>>;
404
+ }, "strip", import("zod").ZodTypeAny, {
405
+ columns: Record<string, {
406
+ isDefaultAnExpression?: boolean | undefined;
407
+ } | undefined>;
408
+ }, {
409
+ columns: Record<string, {
410
+ isDefaultAnExpression?: boolean | undefined;
411
+ } | undefined>;
412
+ }>>>;
413
+ }, "strip", import("zod").ZodTypeAny, {
414
+ tables: Record<string, {
415
+ columns: Record<string, {
416
+ isDefaultAnExpression?: boolean | undefined;
417
+ } | undefined>;
418
+ } | undefined>;
419
+ }, {
420
+ tables: Record<string, {
421
+ columns: Record<string, {
422
+ isDefaultAnExpression?: boolean | undefined;
423
+ } | undefined>;
424
+ } | undefined>;
425
+ }>>;
398
426
  declare const dialect: import("zod").ZodLiteral<"mysql">;
399
427
  export declare const schemaInternalV3: import("zod").ZodObject<{
400
428
  version: import("zod").ZodLiteral<"3">;
@@ -531,8 +559,6 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
531
559
  }>;
532
560
  }>>;
533
561
  }, "strict", import("zod").ZodTypeAny, {
534
- version: "3";
535
- dialect: "mysql";
536
562
  tables: Record<string, {
537
563
  name: string;
538
564
  columns: Record<string, {
@@ -562,9 +588,9 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
562
588
  columnsTo: string[];
563
589
  }>;
564
590
  }>;
565
- }, {
566
591
  version: "3";
567
592
  dialect: "mysql";
593
+ }, {
568
594
  tables: Record<string, {
569
595
  name: string;
570
596
  columns: Record<string, {
@@ -594,6 +620,8 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
594
620
  columnsTo: string[];
595
621
  }>;
596
622
  }>;
623
+ version: "3";
624
+ dialect: "mysql";
597
625
  }>;
598
626
  export declare const schemaInternalV4: import("zod").ZodObject<{
599
627
  version: import("zod").ZodLiteral<"4">;
@@ -734,8 +762,6 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
734
762
  }>>;
735
763
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
736
764
  }, "strict", import("zod").ZodTypeAny, {
737
- version: "4";
738
- dialect: "mysql";
739
765
  tables: Record<string, {
740
766
  schema?: string | undefined;
741
767
  name: string;
@@ -766,10 +792,10 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
766
792
  columnsTo: string[];
767
793
  }>;
768
794
  }>;
769
- schemas: Record<string, string>;
770
- }, {
771
795
  version: "4";
772
796
  dialect: "mysql";
797
+ schemas: Record<string, string>;
798
+ }, {
773
799
  tables: Record<string, {
774
800
  schema?: string | undefined;
775
801
  name: string;
@@ -800,45 +826,15 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
800
826
  columnsTo: string[];
801
827
  }>;
802
828
  }>;
829
+ version: "4";
830
+ dialect: "mysql";
803
831
  schemas: Record<string, string>;
804
832
  }>;
805
- export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
806
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
807
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
808
- isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
809
- }, "strip", import("zod").ZodTypeAny, {
810
- isDefaultAnExpression?: boolean | undefined;
811
- }, {
812
- isDefaultAnExpression?: boolean | undefined;
813
- }>>>;
814
- }, "strip", import("zod").ZodTypeAny, {
815
- columns: Record<string, {
816
- isDefaultAnExpression?: boolean | undefined;
817
- } | undefined>;
818
- }, {
819
- columns: Record<string, {
820
- isDefaultAnExpression?: boolean | undefined;
821
- } | undefined>;
822
- }>>>;
823
- }, "strip", import("zod").ZodTypeAny, {
824
- tables: Record<string, {
825
- columns: Record<string, {
826
- isDefaultAnExpression?: boolean | undefined;
827
- } | undefined>;
828
- } | undefined>;
829
- }, {
830
- tables: Record<string, {
831
- columns: Record<string, {
832
- isDefaultAnExpression?: boolean | undefined;
833
- } | undefined>;
834
- } | undefined>;
835
- }>>;
836
- export declare const schemaInternal: import("zod").ZodObject<{
833
+ export declare const schemaInternalV5: import("zod").ZodObject<{
837
834
  version: import("zod").ZodLiteral<"5">;
838
835
  dialect: import("zod").ZodLiteral<"mysql">;
839
836
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
840
837
  name: import("zod").ZodString;
841
- schema: import("zod").ZodOptional<import("zod").ZodString>;
842
838
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
843
839
  name: import("zod").ZodString;
844
840
  type: import("zod").ZodString;
@@ -932,7 +928,6 @@ export declare const schemaInternal: import("zod").ZodObject<{
932
928
  columns: string[];
933
929
  }>>>;
934
930
  }, "strict", import("zod").ZodTypeAny, {
935
- schema?: string | undefined;
936
931
  name: string;
937
932
  columns: Record<string, {
938
933
  default?: any;
@@ -969,7 +964,6 @@ export declare const schemaInternal: import("zod").ZodObject<{
969
964
  columns: string[];
970
965
  }>;
971
966
  }, {
972
- schema?: string | undefined;
973
967
  uniqueConstraints?: Record<string, {
974
968
  name: string;
975
969
  columns: string[];
@@ -1059,10 +1053,7 @@ export declare const schemaInternal: import("zod").ZodObject<{
1059
1053
  } | undefined>;
1060
1054
  } | undefined>;
1061
1055
  } | undefined;
1062
- version: "5";
1063
- dialect: "mysql";
1064
1056
  tables: Record<string, {
1065
- schema?: string | undefined;
1066
1057
  name: string;
1067
1058
  columns: Record<string, {
1068
1059
  default?: any;
@@ -1099,6 +1090,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
1099
1090
  columns: string[];
1100
1091
  }>;
1101
1092
  }>;
1093
+ version: "5";
1094
+ dialect: "mysql";
1102
1095
  schemas: Record<string, string>;
1103
1096
  _meta: {
1104
1097
  columns: Record<string, string>;
@@ -1113,10 +1106,7 @@ export declare const schemaInternal: import("zod").ZodObject<{
1113
1106
  } | undefined>;
1114
1107
  } | undefined>;
1115
1108
  } | undefined;
1116
- version: "5";
1117
- dialect: "mysql";
1118
1109
  tables: Record<string, {
1119
- schema?: string | undefined;
1120
1110
  uniqueConstraints?: Record<string, {
1121
1111
  name: string;
1122
1112
  columns: string[];
@@ -1153,6 +1143,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
1153
1143
  columns: string[];
1154
1144
  }>;
1155
1145
  }>;
1146
+ version: "5";
1147
+ dialect: "mysql";
1156
1148
  schemas: Record<string, string>;
1157
1149
  _meta: {
1158
1150
  columns: Record<string, string>;
@@ -1160,8 +1152,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
1160
1152
  schemas: Record<string, string>;
1161
1153
  };
1162
1154
  }>;
1163
- export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
1164
- version: import("zod").ZodLiteral<"3">;
1155
+ export declare const schemaInternalV6: import("zod").ZodObject<{
1156
+ version: import("zod").ZodLiteral<"6">;
1165
1157
  dialect: import("zod").ZodLiteral<"mysql">;
1166
1158
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1167
1159
  name: import("zod").ZodString;
@@ -1237,6 +1229,26 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1237
1229
  tableTo: string;
1238
1230
  columnsTo: string[];
1239
1231
  }>>;
1232
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1233
+ name: import("zod").ZodString;
1234
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1235
+ }, "strict", import("zod").ZodTypeAny, {
1236
+ name: string;
1237
+ columns: string[];
1238
+ }, {
1239
+ name: string;
1240
+ columns: string[];
1241
+ }>>;
1242
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1243
+ name: import("zod").ZodString;
1244
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1245
+ }, "strict", import("zod").ZodTypeAny, {
1246
+ name: string;
1247
+ columns: string[];
1248
+ }, {
1249
+ name: string;
1250
+ columns: string[];
1251
+ }>>>;
1240
1252
  }, "strict", import("zod").ZodTypeAny, {
1241
1253
  name: string;
1242
1254
  columns: Record<string, {
@@ -1265,7 +1277,19 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1265
1277
  tableTo: string;
1266
1278
  columnsTo: string[];
1267
1279
  }>;
1280
+ compositePrimaryKeys: Record<string, {
1281
+ name: string;
1282
+ columns: string[];
1283
+ }>;
1284
+ uniqueConstraints: Record<string, {
1285
+ name: string;
1286
+ columns: string[];
1287
+ }>;
1268
1288
  }, {
1289
+ uniqueConstraints?: Record<string, {
1290
+ name: string;
1291
+ columns: string[];
1292
+ }> | undefined;
1269
1293
  name: string;
1270
1294
  columns: Record<string, {
1271
1295
  default?: any;
@@ -1293,15 +1317,60 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1293
1317
  tableTo: string;
1294
1318
  columnsTo: string[];
1295
1319
  }>;
1320
+ compositePrimaryKeys: Record<string, {
1321
+ name: string;
1322
+ columns: string[];
1323
+ }>;
1296
1324
  }>>;
1297
- }, {
1298
- id: import("zod").ZodString;
1299
- prevId: import("zod").ZodString;
1300
- }>, "strip", import("zod").ZodTypeAny, {
1301
- id: string;
1302
- prevId: string;
1303
- version: "3";
1304
- dialect: "mysql";
1325
+ _meta: import("zod").ZodObject<{
1326
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1327
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1328
+ }, "strip", import("zod").ZodTypeAny, {
1329
+ columns: Record<string, string>;
1330
+ tables: Record<string, string>;
1331
+ }, {
1332
+ columns: Record<string, string>;
1333
+ tables: Record<string, string>;
1334
+ }>;
1335
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
1336
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1337
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1338
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
1339
+ }, "strip", import("zod").ZodTypeAny, {
1340
+ isDefaultAnExpression?: boolean | undefined;
1341
+ }, {
1342
+ isDefaultAnExpression?: boolean | undefined;
1343
+ }>>>;
1344
+ }, "strip", import("zod").ZodTypeAny, {
1345
+ columns: Record<string, {
1346
+ isDefaultAnExpression?: boolean | undefined;
1347
+ } | undefined>;
1348
+ }, {
1349
+ columns: Record<string, {
1350
+ isDefaultAnExpression?: boolean | undefined;
1351
+ } | undefined>;
1352
+ }>>>;
1353
+ }, "strip", import("zod").ZodTypeAny, {
1354
+ tables: Record<string, {
1355
+ columns: Record<string, {
1356
+ isDefaultAnExpression?: boolean | undefined;
1357
+ } | undefined>;
1358
+ } | undefined>;
1359
+ }, {
1360
+ tables: Record<string, {
1361
+ columns: Record<string, {
1362
+ isDefaultAnExpression?: boolean | undefined;
1363
+ } | undefined>;
1364
+ } | undefined>;
1365
+ }>>;
1366
+ }, "strict", import("zod").ZodTypeAny, {
1367
+ internal?: {
1368
+ tables: Record<string, {
1369
+ columns: Record<string, {
1370
+ isDefaultAnExpression?: boolean | undefined;
1371
+ } | undefined>;
1372
+ } | undefined>;
1373
+ } | undefined;
1305
1374
  tables: Record<string, {
1306
1375
  name: string;
1307
1376
  columns: Record<string, {
@@ -1330,13 +1399,34 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1330
1399
  tableTo: string;
1331
1400
  columnsTo: string[];
1332
1401
  }>;
1402
+ compositePrimaryKeys: Record<string, {
1403
+ name: string;
1404
+ columns: string[];
1405
+ }>;
1406
+ uniqueConstraints: Record<string, {
1407
+ name: string;
1408
+ columns: string[];
1409
+ }>;
1333
1410
  }>;
1334
- }, {
1335
- id: string;
1336
- prevId: string;
1337
- version: "3";
1411
+ version: "6";
1338
1412
  dialect: "mysql";
1413
+ _meta: {
1414
+ columns: Record<string, string>;
1415
+ tables: Record<string, string>;
1416
+ };
1417
+ }, {
1418
+ internal?: {
1419
+ tables: Record<string, {
1420
+ columns: Record<string, {
1421
+ isDefaultAnExpression?: boolean | undefined;
1422
+ } | undefined>;
1423
+ } | undefined>;
1424
+ } | undefined;
1339
1425
  tables: Record<string, {
1426
+ uniqueConstraints?: Record<string, {
1427
+ name: string;
1428
+ columns: string[];
1429
+ }> | undefined;
1340
1430
  name: string;
1341
1431
  columns: Record<string, {
1342
1432
  default?: any;
@@ -1364,14 +1454,23 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1364
1454
  tableTo: string;
1365
1455
  columnsTo: string[];
1366
1456
  }>;
1457
+ compositePrimaryKeys: Record<string, {
1458
+ name: string;
1459
+ columns: string[];
1460
+ }>;
1367
1461
  }>;
1462
+ version: "6";
1463
+ dialect: "mysql";
1464
+ _meta: {
1465
+ columns: Record<string, string>;
1466
+ tables: Record<string, string>;
1467
+ };
1368
1468
  }>;
1369
- export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
1370
- version: import("zod").ZodLiteral<"4">;
1469
+ export declare const schemaInternal: import("zod").ZodObject<{
1470
+ version: import("zod").ZodLiteral<"6">;
1371
1471
  dialect: import("zod").ZodLiteral<"mysql">;
1372
1472
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1373
1473
  name: import("zod").ZodString;
1374
- schema: import("zod").ZodOptional<import("zod").ZodString>;
1375
1474
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1376
1475
  name: import("zod").ZodString;
1377
1476
  type: import("zod").ZodString;
@@ -1444,8 +1543,27 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1444
1543
  tableTo: string;
1445
1544
  columnsTo: string[];
1446
1545
  }>>;
1546
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1547
+ name: import("zod").ZodString;
1548
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1549
+ }, "strict", import("zod").ZodTypeAny, {
1550
+ name: string;
1551
+ columns: string[];
1552
+ }, {
1553
+ name: string;
1554
+ columns: string[];
1555
+ }>>;
1556
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1557
+ name: import("zod").ZodString;
1558
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1559
+ }, "strict", import("zod").ZodTypeAny, {
1560
+ name: string;
1561
+ columns: string[];
1562
+ }, {
1563
+ name: string;
1564
+ columns: string[];
1565
+ }>>>;
1447
1566
  }, "strict", import("zod").ZodTypeAny, {
1448
- schema?: string | undefined;
1449
1567
  name: string;
1450
1568
  columns: Record<string, {
1451
1569
  default?: any;
@@ -1473,12 +1591,23 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1473
1591
  tableTo: string;
1474
1592
  columnsTo: string[];
1475
1593
  }>;
1476
- }, {
1477
- schema?: string | undefined;
1478
- name: string;
1479
- columns: Record<string, {
1480
- default?: any;
1481
- onUpdate?: any;
1594
+ compositePrimaryKeys: Record<string, {
1595
+ name: string;
1596
+ columns: string[];
1597
+ }>;
1598
+ uniqueConstraints: Record<string, {
1599
+ name: string;
1600
+ columns: string[];
1601
+ }>;
1602
+ }, {
1603
+ uniqueConstraints?: Record<string, {
1604
+ name: string;
1605
+ columns: string[];
1606
+ }> | undefined;
1607
+ name: string;
1608
+ columns: Record<string, {
1609
+ default?: any;
1610
+ onUpdate?: any;
1482
1611
  autoincrement?: boolean | undefined;
1483
1612
  name: string;
1484
1613
  type: string;
@@ -1502,18 +1631,61 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1502
1631
  tableTo: string;
1503
1632
  columnsTo: string[];
1504
1633
  }>;
1634
+ compositePrimaryKeys: Record<string, {
1635
+ name: string;
1636
+ columns: string[];
1637
+ }>;
1505
1638
  }>>;
1506
- 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";
1639
+ _meta: import("zod").ZodObject<{
1640
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1641
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1642
+ }, "strip", import("zod").ZodTypeAny, {
1643
+ columns: Record<string, string>;
1644
+ tables: Record<string, string>;
1645
+ }, {
1646
+ columns: Record<string, string>;
1647
+ tables: Record<string, string>;
1648
+ }>;
1649
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
1650
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1651
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1652
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
1653
+ }, "strip", import("zod").ZodTypeAny, {
1654
+ isDefaultAnExpression?: boolean | undefined;
1655
+ }, {
1656
+ isDefaultAnExpression?: boolean | undefined;
1657
+ }>>>;
1658
+ }, "strip", import("zod").ZodTypeAny, {
1659
+ columns: Record<string, {
1660
+ isDefaultAnExpression?: boolean | undefined;
1661
+ } | undefined>;
1662
+ }, {
1663
+ columns: Record<string, {
1664
+ isDefaultAnExpression?: boolean | undefined;
1665
+ } | undefined>;
1666
+ }>>>;
1667
+ }, "strip", import("zod").ZodTypeAny, {
1668
+ tables: Record<string, {
1669
+ columns: Record<string, {
1670
+ isDefaultAnExpression?: boolean | undefined;
1671
+ } | undefined>;
1672
+ } | undefined>;
1673
+ }, {
1674
+ tables: Record<string, {
1675
+ columns: Record<string, {
1676
+ isDefaultAnExpression?: boolean | undefined;
1677
+ } | undefined>;
1678
+ } | undefined>;
1679
+ }>>;
1680
+ }, "strict", import("zod").ZodTypeAny, {
1681
+ internal?: {
1682
+ tables: Record<string, {
1683
+ columns: Record<string, {
1684
+ isDefaultAnExpression?: boolean | undefined;
1685
+ } | undefined>;
1686
+ } | undefined>;
1687
+ } | undefined;
1515
1688
  tables: Record<string, {
1516
- schema?: string | undefined;
1517
1689
  name: string;
1518
1690
  columns: Record<string, {
1519
1691
  default?: any;
@@ -1541,15 +1713,34 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1541
1713
  tableTo: string;
1542
1714
  columnsTo: string[];
1543
1715
  }>;
1716
+ compositePrimaryKeys: Record<string, {
1717
+ name: string;
1718
+ columns: string[];
1719
+ }>;
1720
+ uniqueConstraints: Record<string, {
1721
+ name: string;
1722
+ columns: string[];
1723
+ }>;
1544
1724
  }>;
1545
- schemas: Record<string, string>;
1546
- }, {
1547
- id: string;
1548
- prevId: string;
1549
- version: "4";
1725
+ version: "6";
1550
1726
  dialect: "mysql";
1727
+ _meta: {
1728
+ columns: Record<string, string>;
1729
+ tables: Record<string, string>;
1730
+ };
1731
+ }, {
1732
+ internal?: {
1733
+ tables: Record<string, {
1734
+ columns: Record<string, {
1735
+ isDefaultAnExpression?: boolean | undefined;
1736
+ } | undefined>;
1737
+ } | undefined>;
1738
+ } | undefined;
1551
1739
  tables: Record<string, {
1552
- schema?: string | undefined;
1740
+ uniqueConstraints?: Record<string, {
1741
+ name: string;
1742
+ columns: string[];
1743
+ }> | undefined;
1553
1744
  name: string;
1554
1745
  columns: Record<string, {
1555
1746
  default?: any;
@@ -1577,15 +1768,23 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1577
1768
  tableTo: string;
1578
1769
  columnsTo: string[];
1579
1770
  }>;
1771
+ compositePrimaryKeys: Record<string, {
1772
+ name: string;
1773
+ columns: string[];
1774
+ }>;
1580
1775
  }>;
1581
- schemas: Record<string, string>;
1776
+ version: "6";
1777
+ dialect: "mysql";
1778
+ _meta: {
1779
+ columns: Record<string, string>;
1780
+ tables: Record<string, string>;
1781
+ };
1582
1782
  }>;
1583
- export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1584
- version: import("zod").ZodLiteral<"5">;
1783
+ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
1784
+ version: import("zod").ZodLiteral<"3">;
1585
1785
  dialect: import("zod").ZodLiteral<"mysql">;
1586
1786
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1587
1787
  name: import("zod").ZodString;
1588
- schema: import("zod").ZodOptional<import("zod").ZodString>;
1589
1788
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1590
1789
  name: import("zod").ZodString;
1591
1790
  type: import("zod").ZodString;
@@ -1658,28 +1857,7 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1658
1857
  tableTo: string;
1659
1858
  columnsTo: string[];
1660
1859
  }>>;
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
1860
  }, "strict", import("zod").ZodTypeAny, {
1682
- schema?: string | undefined;
1683
1861
  name: string;
1684
1862
  columns: Record<string, {
1685
1863
  default?: any;
@@ -1707,20 +1885,7 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1707
1885
  tableTo: string;
1708
1886
  columnsTo: string[];
1709
1887
  }>;
1710
- compositePrimaryKeys: Record<string, {
1711
- name: string;
1712
- columns: string[];
1713
- }>;
1714
- uniqueConstraints: Record<string, {
1715
- name: string;
1716
- columns: string[];
1717
- }>;
1718
1888
  }, {
1719
- schema?: string | undefined;
1720
- uniqueConstraints?: Record<string, {
1721
- name: string;
1722
- columns: string[];
1723
- }> | undefined;
1724
1889
  name: string;
1725
1890
  columns: Record<string, {
1726
1891
  default?: any;
@@ -1748,73 +1913,12 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1748
1913
  tableTo: string;
1749
1914
  columnsTo: string[];
1750
1915
  }>;
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
1916
  }>>;
1801
1917
  }, {
1802
1918
  id: import("zod").ZodString;
1803
1919
  prevId: import("zod").ZodString;
1804
1920
  }>, "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
1921
  tables: Record<string, {
1817
- schema?: string | undefined;
1818
1922
  name: string;
1819
1923
  columns: Record<string, {
1820
1924
  default?: any;
@@ -1842,39 +1946,13 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1842
1946
  tableTo: string;
1843
1947
  columnsTo: string[];
1844
1948
  }>;
1845
- compositePrimaryKeys: Record<string, {
1846
- name: string;
1847
- columns: string[];
1848
- }>;
1849
- uniqueConstraints: Record<string, {
1850
- name: string;
1851
- columns: string[];
1852
- }>;
1853
1949
  }>;
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
1950
  id: string;
1869
1951
  prevId: string;
1870
- version: "5";
1952
+ version: "3";
1871
1953
  dialect: "mysql";
1954
+ }, {
1872
1955
  tables: Record<string, {
1873
- schema?: string | undefined;
1874
- uniqueConstraints?: Record<string, {
1875
- name: string;
1876
- columns: string[];
1877
- }> | undefined;
1878
1956
  name: string;
1879
1957
  columns: Record<string, {
1880
1958
  default?: any;
@@ -1902,16 +1980,874 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1902
1980
  tableTo: string;
1903
1981
  columnsTo: string[];
1904
1982
  }>;
1905
- compositePrimaryKeys: Record<string, {
1906
- name: string;
1907
- columns: string[];
1908
- }>;
1909
1983
  }>;
1910
- schemas: Record<string, string>;
1911
- _meta: {
1984
+ id: string;
1985
+ prevId: string;
1986
+ version: "3";
1987
+ dialect: "mysql";
1988
+ }>;
1989
+ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
1990
+ version: import("zod").ZodLiteral<"4">;
1991
+ dialect: import("zod").ZodLiteral<"mysql">;
1992
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1993
+ name: import("zod").ZodString;
1994
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
1995
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1996
+ name: import("zod").ZodString;
1997
+ type: import("zod").ZodString;
1998
+ primaryKey: import("zod").ZodBoolean;
1999
+ notNull: import("zod").ZodBoolean;
2000
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2001
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2002
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2003
+ }, "strict", import("zod").ZodTypeAny, {
2004
+ default?: any;
2005
+ onUpdate?: any;
2006
+ autoincrement?: boolean | undefined;
2007
+ name: string;
2008
+ type: string;
2009
+ primaryKey: boolean;
2010
+ notNull: boolean;
2011
+ }, {
2012
+ default?: any;
2013
+ onUpdate?: any;
2014
+ autoincrement?: boolean | undefined;
2015
+ name: string;
2016
+ type: string;
2017
+ primaryKey: boolean;
2018
+ notNull: boolean;
2019
+ }>>;
2020
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2021
+ name: import("zod").ZodString;
2022
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2023
+ isUnique: import("zod").ZodBoolean;
2024
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2025
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2026
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2027
+ }, "strict", import("zod").ZodTypeAny, {
2028
+ using?: "btree" | "hash" | undefined;
2029
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2030
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2031
+ name: string;
2032
+ columns: string[];
2033
+ isUnique: boolean;
2034
+ }, {
2035
+ using?: "btree" | "hash" | undefined;
2036
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2037
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2038
+ name: string;
2039
+ columns: string[];
2040
+ isUnique: boolean;
2041
+ }>>;
2042
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2043
+ name: import("zod").ZodString;
2044
+ tableFrom: import("zod").ZodString;
2045
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2046
+ tableTo: import("zod").ZodString;
2047
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2048
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2049
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2050
+ }, "strict", import("zod").ZodTypeAny, {
2051
+ onUpdate?: string | undefined;
2052
+ onDelete?: string | undefined;
2053
+ name: string;
2054
+ tableFrom: string;
2055
+ columnsFrom: string[];
2056
+ tableTo: string;
2057
+ columnsTo: string[];
2058
+ }, {
2059
+ onUpdate?: string | undefined;
2060
+ onDelete?: string | undefined;
2061
+ name: string;
2062
+ tableFrom: string;
2063
+ columnsFrom: string[];
2064
+ tableTo: string;
2065
+ columnsTo: string[];
2066
+ }>>;
2067
+ }, "strict", import("zod").ZodTypeAny, {
2068
+ schema?: string | undefined;
2069
+ name: string;
2070
+ columns: Record<string, {
2071
+ default?: any;
2072
+ onUpdate?: any;
2073
+ autoincrement?: boolean | undefined;
2074
+ name: string;
2075
+ type: string;
2076
+ primaryKey: boolean;
2077
+ notNull: boolean;
2078
+ }>;
2079
+ indexes: Record<string, {
2080
+ using?: "btree" | "hash" | undefined;
2081
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2082
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2083
+ name: string;
2084
+ columns: string[];
2085
+ isUnique: boolean;
2086
+ }>;
2087
+ foreignKeys: Record<string, {
2088
+ onUpdate?: string | undefined;
2089
+ onDelete?: string | undefined;
2090
+ name: string;
2091
+ tableFrom: string;
2092
+ columnsFrom: string[];
2093
+ tableTo: string;
2094
+ columnsTo: string[];
2095
+ }>;
2096
+ }, {
2097
+ schema?: string | undefined;
2098
+ name: string;
2099
+ columns: Record<string, {
2100
+ default?: any;
2101
+ onUpdate?: any;
2102
+ autoincrement?: boolean | undefined;
2103
+ name: string;
2104
+ type: string;
2105
+ primaryKey: boolean;
2106
+ notNull: boolean;
2107
+ }>;
2108
+ indexes: Record<string, {
2109
+ using?: "btree" | "hash" | undefined;
2110
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2111
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2112
+ name: string;
2113
+ columns: string[];
2114
+ isUnique: boolean;
2115
+ }>;
2116
+ foreignKeys: Record<string, {
2117
+ onUpdate?: string | undefined;
2118
+ onDelete?: string | undefined;
2119
+ name: string;
2120
+ tableFrom: string;
2121
+ columnsFrom: string[];
2122
+ tableTo: string;
2123
+ columnsTo: string[];
2124
+ }>;
2125
+ }>>;
2126
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2127
+ }, {
2128
+ id: import("zod").ZodString;
2129
+ prevId: import("zod").ZodString;
2130
+ }>, "strip", import("zod").ZodTypeAny, {
2131
+ tables: Record<string, {
2132
+ schema?: string | undefined;
2133
+ name: string;
2134
+ columns: Record<string, {
2135
+ default?: any;
2136
+ onUpdate?: any;
2137
+ autoincrement?: boolean | undefined;
2138
+ name: string;
2139
+ type: string;
2140
+ primaryKey: boolean;
2141
+ notNull: boolean;
2142
+ }>;
2143
+ indexes: Record<string, {
2144
+ using?: "btree" | "hash" | undefined;
2145
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2146
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2147
+ name: string;
2148
+ columns: string[];
2149
+ isUnique: boolean;
2150
+ }>;
2151
+ foreignKeys: Record<string, {
2152
+ onUpdate?: string | undefined;
2153
+ onDelete?: string | undefined;
2154
+ name: string;
2155
+ tableFrom: string;
2156
+ columnsFrom: string[];
2157
+ tableTo: string;
2158
+ columnsTo: string[];
2159
+ }>;
2160
+ }>;
2161
+ id: string;
2162
+ prevId: string;
2163
+ version: "4";
2164
+ dialect: "mysql";
2165
+ schemas: Record<string, string>;
2166
+ }, {
2167
+ tables: Record<string, {
2168
+ schema?: string | undefined;
2169
+ name: string;
2170
+ columns: Record<string, {
2171
+ default?: any;
2172
+ onUpdate?: any;
2173
+ autoincrement?: boolean | undefined;
2174
+ name: string;
2175
+ type: string;
2176
+ primaryKey: boolean;
2177
+ notNull: boolean;
2178
+ }>;
2179
+ indexes: Record<string, {
2180
+ using?: "btree" | "hash" | undefined;
2181
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2182
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2183
+ name: string;
2184
+ columns: string[];
2185
+ isUnique: boolean;
2186
+ }>;
2187
+ foreignKeys: Record<string, {
2188
+ onUpdate?: string | undefined;
2189
+ onDelete?: string | undefined;
2190
+ name: string;
2191
+ tableFrom: string;
2192
+ columnsFrom: string[];
2193
+ tableTo: string;
2194
+ columnsTo: string[];
2195
+ }>;
2196
+ }>;
2197
+ id: string;
2198
+ prevId: string;
2199
+ version: "4";
2200
+ dialect: "mysql";
2201
+ schemas: Record<string, string>;
2202
+ }>;
2203
+ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape<{
2204
+ version: import("zod").ZodLiteral<"5">;
2205
+ dialect: import("zod").ZodLiteral<"mysql">;
2206
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2207
+ name: import("zod").ZodString;
2208
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2209
+ name: import("zod").ZodString;
2210
+ type: import("zod").ZodString;
2211
+ primaryKey: import("zod").ZodBoolean;
2212
+ notNull: import("zod").ZodBoolean;
2213
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2214
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2215
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2216
+ }, "strict", import("zod").ZodTypeAny, {
2217
+ default?: any;
2218
+ onUpdate?: any;
2219
+ autoincrement?: boolean | undefined;
2220
+ name: string;
2221
+ type: string;
2222
+ primaryKey: boolean;
2223
+ notNull: boolean;
2224
+ }, {
2225
+ default?: any;
2226
+ onUpdate?: any;
2227
+ autoincrement?: boolean | undefined;
2228
+ name: string;
2229
+ type: string;
2230
+ primaryKey: boolean;
2231
+ notNull: boolean;
2232
+ }>>;
2233
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2234
+ name: import("zod").ZodString;
2235
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2236
+ isUnique: import("zod").ZodBoolean;
2237
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2238
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2239
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2240
+ }, "strict", import("zod").ZodTypeAny, {
2241
+ using?: "btree" | "hash" | undefined;
2242
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2243
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2244
+ name: string;
2245
+ columns: string[];
2246
+ isUnique: boolean;
2247
+ }, {
2248
+ using?: "btree" | "hash" | undefined;
2249
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2250
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2251
+ name: string;
2252
+ columns: string[];
2253
+ isUnique: boolean;
2254
+ }>>;
2255
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2256
+ name: import("zod").ZodString;
2257
+ tableFrom: import("zod").ZodString;
2258
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2259
+ tableTo: import("zod").ZodString;
2260
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2261
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2262
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2263
+ }, "strict", import("zod").ZodTypeAny, {
2264
+ onUpdate?: string | undefined;
2265
+ onDelete?: string | undefined;
2266
+ name: string;
2267
+ tableFrom: string;
2268
+ columnsFrom: string[];
2269
+ tableTo: string;
2270
+ columnsTo: string[];
2271
+ }, {
2272
+ onUpdate?: string | undefined;
2273
+ onDelete?: string | undefined;
2274
+ name: string;
2275
+ tableFrom: string;
2276
+ columnsFrom: string[];
2277
+ tableTo: string;
2278
+ columnsTo: string[];
2279
+ }>>;
2280
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2281
+ name: import("zod").ZodString;
2282
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2283
+ }, "strict", import("zod").ZodTypeAny, {
2284
+ name: string;
2285
+ columns: string[];
2286
+ }, {
2287
+ name: string;
2288
+ columns: string[];
2289
+ }>>;
2290
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2291
+ name: import("zod").ZodString;
2292
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2293
+ }, "strict", import("zod").ZodTypeAny, {
2294
+ name: string;
2295
+ columns: string[];
2296
+ }, {
2297
+ name: string;
2298
+ columns: string[];
2299
+ }>>>;
2300
+ }, "strict", import("zod").ZodTypeAny, {
2301
+ name: string;
2302
+ columns: Record<string, {
2303
+ default?: any;
2304
+ onUpdate?: any;
2305
+ autoincrement?: boolean | undefined;
2306
+ name: string;
2307
+ type: string;
2308
+ primaryKey: boolean;
2309
+ notNull: boolean;
2310
+ }>;
2311
+ indexes: Record<string, {
2312
+ using?: "btree" | "hash" | undefined;
2313
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2314
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2315
+ name: string;
2316
+ columns: string[];
2317
+ isUnique: boolean;
2318
+ }>;
2319
+ foreignKeys: Record<string, {
2320
+ onUpdate?: string | undefined;
2321
+ onDelete?: string | undefined;
2322
+ name: string;
2323
+ tableFrom: string;
2324
+ columnsFrom: string[];
2325
+ tableTo: string;
2326
+ columnsTo: string[];
2327
+ }>;
2328
+ compositePrimaryKeys: Record<string, {
2329
+ name: string;
2330
+ columns: string[];
2331
+ }>;
2332
+ uniqueConstraints: Record<string, {
2333
+ name: string;
2334
+ columns: string[];
2335
+ }>;
2336
+ }, {
2337
+ uniqueConstraints?: Record<string, {
2338
+ name: string;
2339
+ columns: string[];
2340
+ }> | undefined;
2341
+ name: string;
2342
+ columns: Record<string, {
2343
+ default?: any;
2344
+ onUpdate?: any;
2345
+ autoincrement?: boolean | undefined;
2346
+ name: string;
2347
+ type: string;
2348
+ primaryKey: boolean;
2349
+ notNull: boolean;
2350
+ }>;
2351
+ indexes: Record<string, {
2352
+ using?: "btree" | "hash" | undefined;
2353
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2354
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2355
+ name: string;
2356
+ columns: string[];
2357
+ isUnique: boolean;
2358
+ }>;
2359
+ foreignKeys: Record<string, {
2360
+ onUpdate?: string | undefined;
2361
+ onDelete?: string | undefined;
2362
+ name: string;
2363
+ tableFrom: string;
2364
+ columnsFrom: string[];
2365
+ tableTo: string;
2366
+ columnsTo: string[];
2367
+ }>;
2368
+ compositePrimaryKeys: Record<string, {
2369
+ name: string;
2370
+ columns: string[];
2371
+ }>;
2372
+ }>>;
2373
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2374
+ _meta: import("zod").ZodObject<{
2375
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2376
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2377
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2378
+ }, "strip", import("zod").ZodTypeAny, {
2379
+ columns: Record<string, string>;
2380
+ tables: Record<string, string>;
2381
+ schemas: Record<string, string>;
2382
+ }, {
2383
+ columns: Record<string, string>;
2384
+ tables: Record<string, string>;
2385
+ schemas: Record<string, string>;
2386
+ }>;
2387
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
2388
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2389
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2390
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
2391
+ }, "strip", import("zod").ZodTypeAny, {
2392
+ isDefaultAnExpression?: boolean | undefined;
2393
+ }, {
2394
+ isDefaultAnExpression?: boolean | undefined;
2395
+ }>>>;
2396
+ }, "strip", import("zod").ZodTypeAny, {
2397
+ columns: Record<string, {
2398
+ isDefaultAnExpression?: boolean | undefined;
2399
+ } | undefined>;
2400
+ }, {
2401
+ columns: Record<string, {
2402
+ isDefaultAnExpression?: boolean | undefined;
2403
+ } | undefined>;
2404
+ }>>>;
2405
+ }, "strip", import("zod").ZodTypeAny, {
2406
+ tables: Record<string, {
2407
+ columns: Record<string, {
2408
+ isDefaultAnExpression?: boolean | undefined;
2409
+ } | undefined>;
2410
+ } | undefined>;
2411
+ }, {
2412
+ tables: Record<string, {
2413
+ columns: Record<string, {
2414
+ isDefaultAnExpression?: boolean | undefined;
2415
+ } | undefined>;
2416
+ } | undefined>;
2417
+ }>>;
2418
+ }, {
2419
+ id: import("zod").ZodString;
2420
+ prevId: import("zod").ZodString;
2421
+ }>, "strip", import("zod").ZodTypeAny, {
2422
+ internal?: {
2423
+ tables: Record<string, {
2424
+ columns: Record<string, {
2425
+ isDefaultAnExpression?: boolean | undefined;
2426
+ } | undefined>;
2427
+ } | undefined>;
2428
+ } | undefined;
2429
+ tables: Record<string, {
2430
+ name: string;
2431
+ columns: Record<string, {
2432
+ default?: any;
2433
+ onUpdate?: any;
2434
+ autoincrement?: boolean | undefined;
2435
+ name: string;
2436
+ type: string;
2437
+ primaryKey: boolean;
2438
+ notNull: boolean;
2439
+ }>;
2440
+ indexes: Record<string, {
2441
+ using?: "btree" | "hash" | undefined;
2442
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2443
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2444
+ name: string;
2445
+ columns: string[];
2446
+ isUnique: boolean;
2447
+ }>;
2448
+ foreignKeys: Record<string, {
2449
+ onUpdate?: string | undefined;
2450
+ onDelete?: string | undefined;
2451
+ name: string;
2452
+ tableFrom: string;
2453
+ columnsFrom: string[];
2454
+ tableTo: string;
2455
+ columnsTo: string[];
2456
+ }>;
2457
+ compositePrimaryKeys: Record<string, {
2458
+ name: string;
2459
+ columns: string[];
2460
+ }>;
2461
+ uniqueConstraints: Record<string, {
2462
+ name: string;
2463
+ columns: string[];
2464
+ }>;
2465
+ }>;
2466
+ id: string;
2467
+ prevId: string;
2468
+ version: "5";
2469
+ dialect: "mysql";
2470
+ schemas: Record<string, string>;
2471
+ _meta: {
2472
+ columns: Record<string, string>;
2473
+ tables: Record<string, string>;
2474
+ schemas: Record<string, string>;
2475
+ };
2476
+ }, {
2477
+ internal?: {
2478
+ tables: Record<string, {
2479
+ columns: Record<string, {
2480
+ isDefaultAnExpression?: boolean | undefined;
2481
+ } | undefined>;
2482
+ } | undefined>;
2483
+ } | undefined;
2484
+ tables: Record<string, {
2485
+ uniqueConstraints?: Record<string, {
2486
+ name: string;
2487
+ columns: string[];
2488
+ }> | undefined;
2489
+ name: string;
2490
+ columns: Record<string, {
2491
+ default?: any;
2492
+ onUpdate?: any;
2493
+ autoincrement?: boolean | undefined;
2494
+ name: string;
2495
+ type: string;
2496
+ primaryKey: boolean;
2497
+ notNull: boolean;
2498
+ }>;
2499
+ indexes: Record<string, {
2500
+ using?: "btree" | "hash" | undefined;
2501
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2502
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2503
+ name: string;
2504
+ columns: string[];
2505
+ isUnique: boolean;
2506
+ }>;
2507
+ foreignKeys: Record<string, {
2508
+ onUpdate?: string | undefined;
2509
+ onDelete?: string | undefined;
2510
+ name: string;
2511
+ tableFrom: string;
2512
+ columnsFrom: string[];
2513
+ tableTo: string;
2514
+ columnsTo: string[];
2515
+ }>;
2516
+ compositePrimaryKeys: Record<string, {
2517
+ name: string;
2518
+ columns: string[];
2519
+ }>;
2520
+ }>;
2521
+ id: string;
2522
+ prevId: string;
2523
+ version: "5";
2524
+ dialect: "mysql";
2525
+ schemas: Record<string, string>;
2526
+ _meta: {
2527
+ columns: Record<string, string>;
2528
+ tables: Record<string, string>;
2529
+ schemas: Record<string, string>;
2530
+ };
2531
+ }>;
2532
+ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2533
+ version: import("zod").ZodLiteral<"6">;
2534
+ dialect: import("zod").ZodLiteral<"mysql">;
2535
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2536
+ name: import("zod").ZodString;
2537
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2538
+ name: import("zod").ZodString;
2539
+ type: import("zod").ZodString;
2540
+ primaryKey: import("zod").ZodBoolean;
2541
+ notNull: import("zod").ZodBoolean;
2542
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2543
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2544
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2545
+ }, "strict", import("zod").ZodTypeAny, {
2546
+ default?: any;
2547
+ onUpdate?: any;
2548
+ autoincrement?: boolean | undefined;
2549
+ name: string;
2550
+ type: string;
2551
+ primaryKey: boolean;
2552
+ notNull: boolean;
2553
+ }, {
2554
+ default?: any;
2555
+ onUpdate?: any;
2556
+ autoincrement?: boolean | undefined;
2557
+ name: string;
2558
+ type: string;
2559
+ primaryKey: boolean;
2560
+ notNull: boolean;
2561
+ }>>;
2562
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2563
+ name: import("zod").ZodString;
2564
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2565
+ isUnique: import("zod").ZodBoolean;
2566
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2567
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2568
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2569
+ }, "strict", import("zod").ZodTypeAny, {
2570
+ using?: "btree" | "hash" | undefined;
2571
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2572
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2573
+ name: string;
2574
+ columns: string[];
2575
+ isUnique: boolean;
2576
+ }, {
2577
+ using?: "btree" | "hash" | undefined;
2578
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2579
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2580
+ name: string;
2581
+ columns: string[];
2582
+ isUnique: boolean;
2583
+ }>>;
2584
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2585
+ name: import("zod").ZodString;
2586
+ tableFrom: import("zod").ZodString;
2587
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2588
+ tableTo: import("zod").ZodString;
2589
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2590
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2591
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2592
+ }, "strict", import("zod").ZodTypeAny, {
2593
+ onUpdate?: string | undefined;
2594
+ onDelete?: string | undefined;
2595
+ name: string;
2596
+ tableFrom: string;
2597
+ columnsFrom: string[];
2598
+ tableTo: string;
2599
+ columnsTo: string[];
2600
+ }, {
2601
+ onUpdate?: string | undefined;
2602
+ onDelete?: string | undefined;
2603
+ name: string;
2604
+ tableFrom: string;
2605
+ columnsFrom: string[];
2606
+ tableTo: string;
2607
+ columnsTo: string[];
2608
+ }>>;
2609
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2610
+ name: import("zod").ZodString;
2611
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2612
+ }, "strict", import("zod").ZodTypeAny, {
2613
+ name: string;
2614
+ columns: string[];
2615
+ }, {
2616
+ name: string;
2617
+ columns: string[];
2618
+ }>>;
2619
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2620
+ name: import("zod").ZodString;
2621
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2622
+ }, "strict", import("zod").ZodTypeAny, {
2623
+ name: string;
2624
+ columns: string[];
2625
+ }, {
2626
+ name: string;
2627
+ columns: string[];
2628
+ }>>>;
2629
+ }, "strict", import("zod").ZodTypeAny, {
2630
+ name: string;
2631
+ columns: Record<string, {
2632
+ default?: any;
2633
+ onUpdate?: any;
2634
+ autoincrement?: boolean | undefined;
2635
+ name: string;
2636
+ type: string;
2637
+ primaryKey: boolean;
2638
+ notNull: boolean;
2639
+ }>;
2640
+ indexes: Record<string, {
2641
+ using?: "btree" | "hash" | undefined;
2642
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2643
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2644
+ name: string;
2645
+ columns: string[];
2646
+ isUnique: boolean;
2647
+ }>;
2648
+ foreignKeys: Record<string, {
2649
+ onUpdate?: string | undefined;
2650
+ onDelete?: string | undefined;
2651
+ name: string;
2652
+ tableFrom: string;
2653
+ columnsFrom: string[];
2654
+ tableTo: string;
2655
+ columnsTo: string[];
2656
+ }>;
2657
+ compositePrimaryKeys: Record<string, {
2658
+ name: string;
2659
+ columns: string[];
2660
+ }>;
2661
+ uniqueConstraints: Record<string, {
2662
+ name: string;
2663
+ columns: string[];
2664
+ }>;
2665
+ }, {
2666
+ uniqueConstraints?: Record<string, {
2667
+ name: string;
2668
+ columns: string[];
2669
+ }> | undefined;
2670
+ name: string;
2671
+ columns: Record<string, {
2672
+ default?: any;
2673
+ onUpdate?: any;
2674
+ autoincrement?: boolean | undefined;
2675
+ name: string;
2676
+ type: string;
2677
+ primaryKey: boolean;
2678
+ notNull: boolean;
2679
+ }>;
2680
+ indexes: Record<string, {
2681
+ using?: "btree" | "hash" | undefined;
2682
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2683
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2684
+ name: string;
2685
+ columns: string[];
2686
+ isUnique: boolean;
2687
+ }>;
2688
+ foreignKeys: Record<string, {
2689
+ onUpdate?: string | undefined;
2690
+ onDelete?: string | undefined;
2691
+ name: string;
2692
+ tableFrom: string;
2693
+ columnsFrom: string[];
2694
+ tableTo: string;
2695
+ columnsTo: string[];
2696
+ }>;
2697
+ compositePrimaryKeys: Record<string, {
2698
+ name: string;
2699
+ columns: string[];
2700
+ }>;
2701
+ }>>;
2702
+ _meta: import("zod").ZodObject<{
2703
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2704
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2705
+ }, "strip", import("zod").ZodTypeAny, {
2706
+ columns: Record<string, string>;
2707
+ tables: Record<string, string>;
2708
+ }, {
2709
+ columns: Record<string, string>;
2710
+ tables: Record<string, string>;
2711
+ }>;
2712
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
2713
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2714
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2715
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
2716
+ }, "strip", import("zod").ZodTypeAny, {
2717
+ isDefaultAnExpression?: boolean | undefined;
2718
+ }, {
2719
+ isDefaultAnExpression?: boolean | undefined;
2720
+ }>>>;
2721
+ }, "strip", import("zod").ZodTypeAny, {
2722
+ columns: Record<string, {
2723
+ isDefaultAnExpression?: boolean | undefined;
2724
+ } | undefined>;
2725
+ }, {
2726
+ columns: Record<string, {
2727
+ isDefaultAnExpression?: boolean | undefined;
2728
+ } | undefined>;
2729
+ }>>>;
2730
+ }, "strip", import("zod").ZodTypeAny, {
2731
+ tables: Record<string, {
2732
+ columns: Record<string, {
2733
+ isDefaultAnExpression?: boolean | undefined;
2734
+ } | undefined>;
2735
+ } | undefined>;
2736
+ }, {
2737
+ tables: Record<string, {
2738
+ columns: Record<string, {
2739
+ isDefaultAnExpression?: boolean | undefined;
2740
+ } | undefined>;
2741
+ } | undefined>;
2742
+ }>>;
2743
+ }, {
2744
+ id: import("zod").ZodString;
2745
+ prevId: import("zod").ZodString;
2746
+ }>, "strip", import("zod").ZodTypeAny, {
2747
+ internal?: {
2748
+ tables: Record<string, {
2749
+ columns: Record<string, {
2750
+ isDefaultAnExpression?: boolean | undefined;
2751
+ } | undefined>;
2752
+ } | undefined>;
2753
+ } | undefined;
2754
+ tables: Record<string, {
2755
+ name: string;
2756
+ columns: Record<string, {
2757
+ default?: any;
2758
+ onUpdate?: any;
2759
+ autoincrement?: boolean | undefined;
2760
+ name: string;
2761
+ type: string;
2762
+ primaryKey: boolean;
2763
+ notNull: boolean;
2764
+ }>;
2765
+ indexes: Record<string, {
2766
+ using?: "btree" | "hash" | undefined;
2767
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2768
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2769
+ name: string;
2770
+ columns: string[];
2771
+ isUnique: boolean;
2772
+ }>;
2773
+ foreignKeys: Record<string, {
2774
+ onUpdate?: string | undefined;
2775
+ onDelete?: string | undefined;
2776
+ name: string;
2777
+ tableFrom: string;
2778
+ columnsFrom: string[];
2779
+ tableTo: string;
2780
+ columnsTo: string[];
2781
+ }>;
2782
+ compositePrimaryKeys: Record<string, {
2783
+ name: string;
2784
+ columns: string[];
2785
+ }>;
2786
+ uniqueConstraints: Record<string, {
2787
+ name: string;
2788
+ columns: string[];
2789
+ }>;
2790
+ }>;
2791
+ id: string;
2792
+ prevId: string;
2793
+ version: "6";
2794
+ dialect: "mysql";
2795
+ _meta: {
2796
+ columns: Record<string, string>;
2797
+ tables: Record<string, string>;
2798
+ };
2799
+ }, {
2800
+ internal?: {
2801
+ tables: Record<string, {
2802
+ columns: Record<string, {
2803
+ isDefaultAnExpression?: boolean | undefined;
2804
+ } | undefined>;
2805
+ } | undefined>;
2806
+ } | undefined;
2807
+ tables: Record<string, {
2808
+ uniqueConstraints?: Record<string, {
2809
+ name: string;
2810
+ columns: string[];
2811
+ }> | undefined;
2812
+ name: string;
2813
+ columns: Record<string, {
2814
+ default?: any;
2815
+ onUpdate?: any;
2816
+ autoincrement?: boolean | undefined;
2817
+ name: string;
2818
+ type: string;
2819
+ primaryKey: boolean;
2820
+ notNull: boolean;
2821
+ }>;
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
+ }>;
2839
+ compositePrimaryKeys: Record<string, {
2840
+ name: string;
2841
+ columns: string[];
2842
+ }>;
2843
+ }>;
2844
+ id: string;
2845
+ prevId: string;
2846
+ version: "6";
2847
+ dialect: "mysql";
2848
+ _meta: {
1912
2849
  columns: Record<string, string>;
1913
2850
  tables: Record<string, string>;
1914
- schemas: Record<string, string>;
1915
2851
  };
1916
2852
  }>;
1917
2853
  export declare const schemaSquashed: import("zod").ZodObject<{
@@ -1919,7 +2855,6 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1919
2855
  dialect: import("zod").ZodLiteral<"mysql">;
1920
2856
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1921
2857
  name: import("zod").ZodString;
1922
- schema: import("zod").ZodOptional<import("zod").ZodString>;
1923
2858
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1924
2859
  name: import("zod").ZodString;
1925
2860
  type: import("zod").ZodString;
@@ -1950,7 +2885,6 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1950
2885
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1951
2886
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
1952
2887
  }, "strict", import("zod").ZodTypeAny, {
1953
- schema?: string | undefined;
1954
2888
  name: string;
1955
2889
  columns: Record<string, {
1956
2890
  default?: any;
@@ -1966,7 +2900,6 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1966
2900
  compositePrimaryKeys: Record<string, string>;
1967
2901
  uniqueConstraints: Record<string, string>;
1968
2902
  }, {
1969
- schema?: string | undefined;
1970
2903
  uniqueConstraints?: Record<string, string> | undefined;
1971
2904
  name: string;
1972
2905
  columns: Record<string, {
@@ -1982,12 +2915,8 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1982
2915
  foreignKeys: Record<string, string>;
1983
2916
  compositePrimaryKeys: Record<string, string>;
1984
2917
  }>>;
1985
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1986
2918
  }, "strict", import("zod").ZodTypeAny, {
1987
- version: "5";
1988
- dialect: "mysql";
1989
2919
  tables: Record<string, {
1990
- schema?: string | undefined;
1991
2920
  name: string;
1992
2921
  columns: Record<string, {
1993
2922
  default?: any;
@@ -2003,12 +2932,10 @@ export declare const schemaSquashed: import("zod").ZodObject<{
2003
2932
  compositePrimaryKeys: Record<string, string>;
2004
2933
  uniqueConstraints: Record<string, string>;
2005
2934
  }>;
2006
- schemas: Record<string, string>;
2007
- }, {
2008
2935
  version: "5";
2009
2936
  dialect: "mysql";
2937
+ }, {
2010
2938
  tables: Record<string, {
2011
- schema?: string | undefined;
2012
2939
  uniqueConstraints?: Record<string, string> | undefined;
2013
2940
  name: string;
2014
2941
  columns: Record<string, {
@@ -2024,7 +2951,8 @@ export declare const schemaSquashed: import("zod").ZodObject<{
2024
2951
  foreignKeys: Record<string, string>;
2025
2952
  compositePrimaryKeys: Record<string, string>;
2026
2953
  }>;
2027
- schemas: Record<string, string>;
2954
+ version: "5";
2955
+ dialect: "mysql";
2028
2956
  }>;
2029
2957
  export declare const schemaSquashedV4: import("zod").ZodObject<{
2030
2958
  version: import("zod").ZodLiteral<"4">;
@@ -2090,8 +3018,6 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
2090
3018
  }>>;
2091
3019
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2092
3020
  }, "strict", import("zod").ZodTypeAny, {
2093
- version: "4";
2094
- dialect: "mysql";
2095
3021
  tables: Record<string, {
2096
3022
  schema?: string | undefined;
2097
3023
  name: string;
@@ -2107,10 +3033,10 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
2107
3033
  indexes: Record<string, string>;
2108
3034
  foreignKeys: Record<string, string>;
2109
3035
  }>;
2110
- schemas: Record<string, string>;
2111
- }, {
2112
3036
  version: "4";
2113
3037
  dialect: "mysql";
3038
+ schemas: Record<string, string>;
3039
+ }, {
2114
3040
  tables: Record<string, {
2115
3041
  schema?: string | undefined;
2116
3042
  name: string;
@@ -2126,6 +3052,8 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
2126
3052
  indexes: Record<string, string>;
2127
3053
  foreignKeys: Record<string, string>;
2128
3054
  }>;
3055
+ version: "4";
3056
+ dialect: "mysql";
2129
3057
  schemas: Record<string, string>;
2130
3058
  }>;
2131
3059
  export type Dialect = TypeOf<typeof dialect>;
@@ -2135,6 +3063,7 @@ export type TableV4 = TypeOf<typeof tableV4>;
2135
3063
  export type MySqlSchema = TypeOf<typeof schema>;
2136
3064
  export type MySqlSchemaV3 = TypeOf<typeof schemaV3>;
2137
3065
  export type MySqlSchemaV4 = TypeOf<typeof schemaV4>;
3066
+ export type MySqlSchemaV5 = TypeOf<typeof schemaV5>;
2138
3067
  export type MySqlSchemaInternal = TypeOf<typeof schemaInternal>;
2139
3068
  export type MySqlKitInternals = TypeOf<typeof kitInternals>;
2140
3069
  export type MySqlSchemaSquashed = TypeOf<typeof schemaSquashed>;
@@ -2156,11 +3085,10 @@ export declare const MySqlSquasher: {
2156
3085
  export declare const squashMysqlSchemeV4: (json: MySqlSchemaV4) => MySqlSchemaSquashedV4;
2157
3086
  export declare const squashMysqlScheme: (json: MySqlSchema) => MySqlSchemaSquashed;
2158
3087
  export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendShape<{
2159
- version: import("zod").ZodLiteral<"5">;
3088
+ version: import("zod").ZodLiteral<"6">;
2160
3089
  dialect: import("zod").ZodLiteral<"mysql">;
2161
3090
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2162
3091
  name: import("zod").ZodString;
2163
- schema: import("zod").ZodOptional<import("zod").ZodString>;
2164
3092
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2165
3093
  name: import("zod").ZodString;
2166
3094
  type: import("zod").ZodString;
@@ -2254,7 +3182,6 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2254
3182
  columns: string[];
2255
3183
  }>>>;
2256
3184
  }, "strict", import("zod").ZodTypeAny, {
2257
- schema?: string | undefined;
2258
3185
  name: string;
2259
3186
  columns: Record<string, {
2260
3187
  default?: any;
@@ -2291,7 +3218,6 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2291
3218
  columns: string[];
2292
3219
  }>;
2293
3220
  }, {
2294
- schema?: string | undefined;
2295
3221
  uniqueConstraints?: Record<string, {
2296
3222
  name: string;
2297
3223
  columns: string[];
@@ -2328,19 +3254,15 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2328
3254
  columns: string[];
2329
3255
  }>;
2330
3256
  }>>;
2331
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2332
3257
  _meta: import("zod").ZodObject<{
2333
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2334
3258
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2335
3259
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2336
3260
  }, "strip", import("zod").ZodTypeAny, {
2337
3261
  columns: Record<string, string>;
2338
3262
  tables: Record<string, string>;
2339
- schemas: Record<string, string>;
2340
3263
  }, {
2341
3264
  columns: Record<string, string>;
2342
3265
  tables: Record<string, string>;
2343
- schemas: Record<string, string>;
2344
3266
  }>;
2345
3267
  internal: import("zod").ZodOptional<import("zod").ZodObject<{
2346
3268
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
@@ -2384,12 +3306,7 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2384
3306
  } | undefined>;
2385
3307
  } | undefined>;
2386
3308
  } | undefined;
2387
- id: string;
2388
- prevId: string;
2389
- version: "5";
2390
- dialect: "mysql";
2391
3309
  tables: Record<string, {
2392
- schema?: string | undefined;
2393
3310
  name: string;
2394
3311
  columns: Record<string, {
2395
3312
  default?: any;
@@ -2426,11 +3343,13 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2426
3343
  columns: string[];
2427
3344
  }>;
2428
3345
  }>;
2429
- schemas: Record<string, string>;
3346
+ id: string;
3347
+ prevId: string;
3348
+ version: "6";
3349
+ dialect: "mysql";
2430
3350
  _meta: {
2431
3351
  columns: Record<string, string>;
2432
3352
  tables: Record<string, string>;
2433
- schemas: Record<string, string>;
2434
3353
  };
2435
3354
  }, {
2436
3355
  internal?: {
@@ -2440,12 +3359,7 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2440
3359
  } | undefined>;
2441
3360
  } | undefined>;
2442
3361
  } | undefined;
2443
- id: string;
2444
- prevId: string;
2445
- version: "5";
2446
- dialect: "mysql";
2447
3362
  tables: Record<string, {
2448
- schema?: string | undefined;
2449
3363
  uniqueConstraints?: Record<string, {
2450
3364
  name: string;
2451
3365
  columns: string[];
@@ -2482,19 +3396,20 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2482
3396
  columns: string[];
2483
3397
  }>;
2484
3398
  }>;
2485
- schemas: Record<string, string>;
3399
+ id: string;
3400
+ prevId: string;
3401
+ version: "6";
3402
+ dialect: "mysql";
2486
3403
  _meta: {
2487
3404
  columns: Record<string, string>;
2488
3405
  tables: Record<string, string>;
2489
- schemas: Record<string, string>;
2490
3406
  };
2491
3407
  }>;
2492
- export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
2493
- version: import("zod").ZodLiteral<"4">;
3408
+ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
3409
+ version: import("zod").ZodLiteral<"3">;
2494
3410
  dialect: import("zod").ZodLiteral<"mysql">;
2495
3411
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2496
3412
  name: import("zod").ZodString;
2497
- schema: import("zod").ZodOptional<import("zod").ZodString>;
2498
3413
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2499
3414
  name: import("zod").ZodString;
2500
3415
  type: import("zod").ZodString;
@@ -2568,7 +3483,6 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2568
3483
  columnsTo: string[];
2569
3484
  }>>;
2570
3485
  }, "strict", import("zod").ZodTypeAny, {
2571
- schema?: string | undefined;
2572
3486
  name: string;
2573
3487
  columns: Record<string, {
2574
3488
  default?: any;
@@ -2597,7 +3511,6 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2597
3511
  columnsTo: string[];
2598
3512
  }>;
2599
3513
  }, {
2600
- schema?: string | undefined;
2601
3514
  name: string;
2602
3515
  columns: Record<string, {
2603
3516
  default?: any;
@@ -2626,17 +3539,11 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2626
3539
  columnsTo: string[];
2627
3540
  }>;
2628
3541
  }>>;
2629
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2630
3542
  }, {
2631
3543
  id: import("zod").ZodString;
2632
3544
  prevId: import("zod").ZodString;
2633
3545
  }>, "strip", import("zod").ZodTypeAny, {
2634
- id: string;
2635
- prevId: string;
2636
- version: "4";
2637
- dialect: "mysql";
2638
3546
  tables: Record<string, {
2639
- schema?: string | undefined;
2640
3547
  name: string;
2641
3548
  columns: Record<string, {
2642
3549
  default?: any;
@@ -2665,14 +3572,12 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2665
3572
  columnsTo: string[];
2666
3573
  }>;
2667
3574
  }>;
2668
- schemas: Record<string, string>;
2669
- }, {
2670
3575
  id: string;
2671
3576
  prevId: string;
2672
- version: "4";
3577
+ version: "3";
2673
3578
  dialect: "mysql";
3579
+ }, {
2674
3580
  tables: Record<string, {
2675
- schema?: string | undefined;
2676
3581
  name: string;
2677
3582
  columns: Record<string, {
2678
3583
  default?: any;
@@ -2701,13 +3606,17 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
2701
3606
  columnsTo: string[];
2702
3607
  }>;
2703
3608
  }>;
2704
- schemas: Record<string, string>;
3609
+ id: string;
3610
+ prevId: string;
3611
+ version: "3";
3612
+ dialect: "mysql";
2705
3613
  }>;
2706
- export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
2707
- version: import("zod").ZodLiteral<"3">;
3614
+ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
3615
+ version: import("zod").ZodLiteral<"4">;
2708
3616
  dialect: import("zod").ZodLiteral<"mysql">;
2709
3617
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2710
3618
  name: import("zod").ZodString;
3619
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
2711
3620
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2712
3621
  name: import("zod").ZodString;
2713
3622
  type: import("zod").ZodString;
@@ -2781,6 +3690,7 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2781
3690
  columnsTo: string[];
2782
3691
  }>>;
2783
3692
  }, "strict", import("zod").ZodTypeAny, {
3693
+ schema?: string | undefined;
2784
3694
  name: string;
2785
3695
  columns: Record<string, {
2786
3696
  default?: any;
@@ -2809,6 +3719,7 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2809
3719
  columnsTo: string[];
2810
3720
  }>;
2811
3721
  }, {
3722
+ schema?: string | undefined;
2812
3723
  name: string;
2813
3724
  columns: Record<string, {
2814
3725
  default?: any;
@@ -2837,15 +3748,13 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2837
3748
  columnsTo: string[];
2838
3749
  }>;
2839
3750
  }>>;
3751
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2840
3752
  }, {
2841
3753
  id: import("zod").ZodString;
2842
3754
  prevId: import("zod").ZodString;
2843
3755
  }>, "strip", import("zod").ZodTypeAny, {
2844
- id: string;
2845
- prevId: string;
2846
- version: "3";
2847
- dialect: "mysql";
2848
3756
  tables: Record<string, {
3757
+ schema?: string | undefined;
2849
3758
  name: string;
2850
3759
  columns: Record<string, {
2851
3760
  default?: any;
@@ -2874,137 +3783,14 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
2874
3783
  columnsTo: string[];
2875
3784
  }>;
2876
3785
  }>;
2877
- }, {
2878
3786
  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;
2986
- name: string;
2987
- columns: Record<string, {
2988
- default?: any;
2989
- onUpdate?: any;
2990
- autoincrement?: boolean | undefined;
2991
- name: string;
2992
- type: string;
2993
- primaryKey: boolean;
2994
- notNull: boolean;
2995
- }>;
2996
- indexes: Record<string, string>;
2997
- foreignKeys: Record<string, string>;
2998
- compositePrimaryKeys: Record<string, string>;
2999
- uniqueConstraints: Record<string, string>;
3000
- }>;
3787
+ prevId: string;
3788
+ version: "4";
3789
+ dialect: "mysql";
3001
3790
  schemas: Record<string, string>;
3002
3791
  }, {
3003
- version: "5";
3004
- dialect: "mysql";
3005
3792
  tables: Record<string, {
3006
3793
  schema?: string | undefined;
3007
- uniqueConstraints?: Record<string, string> | undefined;
3008
3794
  name: string;
3009
3795
  columns: Record<string, {
3010
3796
  default?: any;
@@ -3015,14 +3801,32 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
3015
3801
  primaryKey: boolean;
3016
3802
  notNull: boolean;
3017
3803
  }>;
3018
- indexes: Record<string, string>;
3019
- foreignKeys: Record<string, string>;
3020
- compositePrimaryKeys: Record<string, string>;
3804
+ indexes: Record<string, {
3805
+ using?: "btree" | "hash" | undefined;
3806
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3807
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3808
+ name: string;
3809
+ columns: string[];
3810
+ isUnique: boolean;
3811
+ }>;
3812
+ foreignKeys: Record<string, {
3813
+ onUpdate?: string | undefined;
3814
+ onDelete?: string | undefined;
3815
+ name: string;
3816
+ tableFrom: string;
3817
+ columnsFrom: string[];
3818
+ tableTo: string;
3819
+ columnsTo: string[];
3820
+ }>;
3021
3821
  }>;
3822
+ id: string;
3823
+ prevId: string;
3824
+ version: "4";
3825
+ dialect: "mysql";
3022
3826
  schemas: Record<string, string>;
3023
3827
  }>;
3024
- export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
3025
- version: import("zod").ZodLiteral<"3">;
3828
+ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
3829
+ version: import("zod").ZodLiteral<"5">;
3026
3830
  dialect: import("zod").ZodLiteral<"mysql">;
3027
3831
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3028
3832
  name: import("zod").ZodString;
@@ -3098,6 +3902,26 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3098
3902
  tableTo: string;
3099
3903
  columnsTo: string[];
3100
3904
  }>>;
3905
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3906
+ name: import("zod").ZodString;
3907
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3908
+ }, "strict", import("zod").ZodTypeAny, {
3909
+ name: string;
3910
+ columns: string[];
3911
+ }, {
3912
+ name: string;
3913
+ columns: string[];
3914
+ }>>;
3915
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3916
+ name: import("zod").ZodString;
3917
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3918
+ }, "strict", import("zod").ZodTypeAny, {
3919
+ name: string;
3920
+ columns: string[];
3921
+ }, {
3922
+ name: string;
3923
+ columns: string[];
3924
+ }>>>;
3101
3925
  }, "strict", import("zod").ZodTypeAny, {
3102
3926
  name: string;
3103
3927
  columns: Record<string, {
@@ -3126,7 +3950,19 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3126
3950
  tableTo: string;
3127
3951
  columnsTo: string[];
3128
3952
  }>;
3953
+ compositePrimaryKeys: Record<string, {
3954
+ name: string;
3955
+ columns: string[];
3956
+ }>;
3957
+ uniqueConstraints: Record<string, {
3958
+ name: string;
3959
+ columns: string[];
3960
+ }>;
3129
3961
  }, {
3962
+ uniqueConstraints?: Record<string, {
3963
+ name: string;
3964
+ columns: string[];
3965
+ }> | undefined;
3130
3966
  name: string;
3131
3967
  columns: Record<string, {
3132
3968
  default?: any;
@@ -3154,16 +3990,205 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3154
3990
  tableTo: string;
3155
3991
  columnsTo: string[];
3156
3992
  }>;
3993
+ compositePrimaryKeys: Record<string, {
3994
+ name: string;
3995
+ columns: string[];
3996
+ }>;
3997
+ }>>;
3998
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3999
+ _meta: import("zod").ZodObject<{
4000
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4001
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4002
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4003
+ }, "strip", import("zod").ZodTypeAny, {
4004
+ columns: Record<string, string>;
4005
+ tables: Record<string, string>;
4006
+ schemas: Record<string, string>;
4007
+ }, {
4008
+ columns: Record<string, string>;
4009
+ tables: Record<string, string>;
4010
+ schemas: Record<string, string>;
4011
+ }>;
4012
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
4013
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4014
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4015
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
4016
+ }, "strip", import("zod").ZodTypeAny, {
4017
+ isDefaultAnExpression?: boolean | undefined;
4018
+ }, {
4019
+ isDefaultAnExpression?: boolean | undefined;
4020
+ }>>>;
4021
+ }, "strip", import("zod").ZodTypeAny, {
4022
+ columns: Record<string, {
4023
+ isDefaultAnExpression?: boolean | undefined;
4024
+ } | undefined>;
4025
+ }, {
4026
+ columns: Record<string, {
4027
+ isDefaultAnExpression?: boolean | undefined;
4028
+ } | undefined>;
4029
+ }>>>;
4030
+ }, "strip", import("zod").ZodTypeAny, {
4031
+ tables: Record<string, {
4032
+ columns: Record<string, {
4033
+ isDefaultAnExpression?: boolean | undefined;
4034
+ } | undefined>;
4035
+ } | undefined>;
4036
+ }, {
4037
+ tables: Record<string, {
4038
+ columns: Record<string, {
4039
+ isDefaultAnExpression?: boolean | undefined;
4040
+ } | undefined>;
4041
+ } | undefined>;
3157
4042
  }>>;
3158
4043
  }, {
3159
4044
  id: import("zod").ZodString;
3160
4045
  prevId: import("zod").ZodString;
3161
4046
  }>, "strip", import("zod").ZodTypeAny, {
4047
+ internal?: {
4048
+ tables: Record<string, {
4049
+ columns: Record<string, {
4050
+ isDefaultAnExpression?: boolean | undefined;
4051
+ } | undefined>;
4052
+ } | undefined>;
4053
+ } | undefined;
4054
+ tables: Record<string, {
4055
+ name: string;
4056
+ columns: Record<string, {
4057
+ default?: any;
4058
+ onUpdate?: any;
4059
+ autoincrement?: boolean | undefined;
4060
+ name: string;
4061
+ type: string;
4062
+ primaryKey: boolean;
4063
+ notNull: boolean;
4064
+ }>;
4065
+ indexes: Record<string, {
4066
+ using?: "btree" | "hash" | undefined;
4067
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4068
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4069
+ name: string;
4070
+ columns: string[];
4071
+ isUnique: boolean;
4072
+ }>;
4073
+ foreignKeys: Record<string, {
4074
+ onUpdate?: string | undefined;
4075
+ onDelete?: string | undefined;
4076
+ name: string;
4077
+ tableFrom: string;
4078
+ columnsFrom: string[];
4079
+ tableTo: string;
4080
+ columnsTo: string[];
4081
+ }>;
4082
+ compositePrimaryKeys: Record<string, {
4083
+ name: string;
4084
+ columns: string[];
4085
+ }>;
4086
+ uniqueConstraints: Record<string, {
4087
+ name: string;
4088
+ columns: string[];
4089
+ }>;
4090
+ }>;
3162
4091
  id: string;
3163
4092
  prevId: string;
3164
- version: "3";
4093
+ version: "5";
3165
4094
  dialect: "mysql";
4095
+ schemas: Record<string, string>;
4096
+ _meta: {
4097
+ columns: Record<string, string>;
4098
+ tables: Record<string, string>;
4099
+ schemas: Record<string, string>;
4100
+ };
4101
+ }, {
4102
+ internal?: {
4103
+ tables: Record<string, {
4104
+ columns: Record<string, {
4105
+ isDefaultAnExpression?: boolean | undefined;
4106
+ } | undefined>;
4107
+ } | undefined>;
4108
+ } | undefined;
3166
4109
  tables: Record<string, {
4110
+ uniqueConstraints?: Record<string, {
4111
+ name: string;
4112
+ columns: string[];
4113
+ }> | undefined;
4114
+ name: string;
4115
+ columns: Record<string, {
4116
+ default?: any;
4117
+ onUpdate?: any;
4118
+ autoincrement?: boolean | undefined;
4119
+ name: string;
4120
+ type: string;
4121
+ primaryKey: boolean;
4122
+ notNull: boolean;
4123
+ }>;
4124
+ indexes: Record<string, {
4125
+ using?: "btree" | "hash" | undefined;
4126
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4127
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4128
+ name: string;
4129
+ columns: string[];
4130
+ isUnique: boolean;
4131
+ }>;
4132
+ foreignKeys: Record<string, {
4133
+ onUpdate?: string | undefined;
4134
+ onDelete?: string | undefined;
4135
+ name: string;
4136
+ tableFrom: string;
4137
+ columnsFrom: string[];
4138
+ tableTo: string;
4139
+ columnsTo: string[];
4140
+ }>;
4141
+ compositePrimaryKeys: Record<string, {
4142
+ name: string;
4143
+ columns: string[];
4144
+ }>;
4145
+ }>;
4146
+ id: string;
4147
+ prevId: string;
4148
+ version: "5";
4149
+ dialect: "mysql";
4150
+ schemas: Record<string, string>;
4151
+ _meta: {
4152
+ columns: Record<string, string>;
4153
+ tables: Record<string, string>;
4154
+ schemas: Record<string, string>;
4155
+ };
4156
+ }>;
4157
+ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
4158
+ version: import("zod").ZodLiteral<"5">;
4159
+ dialect: import("zod").ZodLiteral<"mysql">;
4160
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4161
+ name: import("zod").ZodString;
4162
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4163
+ name: import("zod").ZodString;
4164
+ type: import("zod").ZodString;
4165
+ primaryKey: import("zod").ZodBoolean;
4166
+ notNull: import("zod").ZodBoolean;
4167
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
4168
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
4169
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
4170
+ }, "strict", import("zod").ZodTypeAny, {
4171
+ default?: any;
4172
+ onUpdate?: any;
4173
+ autoincrement?: boolean | undefined;
4174
+ name: string;
4175
+ type: string;
4176
+ primaryKey: boolean;
4177
+ notNull: boolean;
4178
+ }, {
4179
+ default?: any;
4180
+ onUpdate?: any;
4181
+ autoincrement?: boolean | undefined;
4182
+ name: string;
4183
+ type: string;
4184
+ primaryKey: boolean;
4185
+ notNull: boolean;
4186
+ }>>;
4187
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4188
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4189
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4190
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
4191
+ }, "strict", import("zod").ZodTypeAny, {
3167
4192
  name: string;
3168
4193
  columns: Record<string, {
3169
4194
  default?: any;
@@ -3174,30 +4199,48 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3174
4199
  primaryKey: boolean;
3175
4200
  notNull: boolean;
3176
4201
  }>;
3177
- indexes: Record<string, {
3178
- using?: "btree" | "hash" | undefined;
3179
- algorithm?: "default" | "inplace" | "copy" | undefined;
3180
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4202
+ indexes: Record<string, string>;
4203
+ foreignKeys: Record<string, string>;
4204
+ compositePrimaryKeys: Record<string, string>;
4205
+ uniqueConstraints: Record<string, string>;
4206
+ }, {
4207
+ uniqueConstraints?: Record<string, string> | undefined;
4208
+ name: string;
4209
+ columns: Record<string, {
4210
+ default?: any;
4211
+ onUpdate?: any;
4212
+ autoincrement?: boolean | undefined;
3181
4213
  name: string;
3182
- columns: string[];
3183
- isUnique: boolean;
4214
+ type: string;
4215
+ primaryKey: boolean;
4216
+ notNull: boolean;
3184
4217
  }>;
3185
- foreignKeys: Record<string, {
3186
- onUpdate?: string | undefined;
3187
- onDelete?: string | undefined;
4218
+ indexes: Record<string, string>;
4219
+ foreignKeys: Record<string, string>;
4220
+ compositePrimaryKeys: Record<string, string>;
4221
+ }>>;
4222
+ }, "strict", import("zod").ZodTypeAny, {
4223
+ tables: Record<string, {
4224
+ name: string;
4225
+ columns: Record<string, {
4226
+ default?: any;
4227
+ onUpdate?: any;
4228
+ autoincrement?: boolean | undefined;
3188
4229
  name: string;
3189
- tableFrom: string;
3190
- columnsFrom: string[];
3191
- tableTo: string;
3192
- columnsTo: string[];
4230
+ type: string;
4231
+ primaryKey: boolean;
4232
+ notNull: boolean;
3193
4233
  }>;
4234
+ indexes: Record<string, string>;
4235
+ foreignKeys: Record<string, string>;
4236
+ compositePrimaryKeys: Record<string, string>;
4237
+ uniqueConstraints: Record<string, string>;
3194
4238
  }>;
3195
- }, {
3196
- id: string;
3197
- prevId: string;
3198
- version: "3";
4239
+ version: "5";
3199
4240
  dialect: "mysql";
4241
+ }, {
3200
4242
  tables: Record<string, {
4243
+ uniqueConstraints?: Record<string, string> | undefined;
3201
4244
  name: string;
3202
4245
  columns: Record<string, {
3203
4246
  default?: any;
@@ -3208,30 +4251,18 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3208
4251
  primaryKey: boolean;
3209
4252
  notNull: boolean;
3210
4253
  }>;
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
- }>;
4254
+ indexes: Record<string, string>;
4255
+ foreignKeys: Record<string, string>;
4256
+ compositePrimaryKeys: Record<string, string>;
3228
4257
  }>;
3229
- }>, import("zod").ZodObject<import("zod").extendShape<{
3230
- version: import("zod").ZodLiteral<"4">;
4258
+ version: "5";
4259
+ dialect: "mysql";
4260
+ }>;
4261
+ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
4262
+ version: import("zod").ZodLiteral<"5">;
3231
4263
  dialect: import("zod").ZodLiteral<"mysql">;
3232
4264
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3233
4265
  name: import("zod").ZodString;
3234
- schema: import("zod").ZodOptional<import("zod").ZodString>;
3235
4266
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3236
4267
  name: import("zod").ZodString;
3237
4268
  type: import("zod").ZodString;
@@ -3304,8 +4335,27 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3304
4335
  tableTo: string;
3305
4336
  columnsTo: string[];
3306
4337
  }>>;
4338
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4339
+ name: import("zod").ZodString;
4340
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
4341
+ }, "strict", import("zod").ZodTypeAny, {
4342
+ name: string;
4343
+ columns: string[];
4344
+ }, {
4345
+ name: string;
4346
+ columns: string[];
4347
+ }>>;
4348
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4349
+ name: import("zod").ZodString;
4350
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
4351
+ }, "strict", import("zod").ZodTypeAny, {
4352
+ name: string;
4353
+ columns: string[];
4354
+ }, {
4355
+ name: string;
4356
+ columns: string[];
4357
+ }>>>;
3307
4358
  }, "strict", import("zod").ZodTypeAny, {
3308
- schema?: string | undefined;
3309
4359
  name: string;
3310
4360
  columns: Record<string, {
3311
4361
  default?: any;
@@ -3333,8 +4383,19 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3333
4383
  tableTo: string;
3334
4384
  columnsTo: string[];
3335
4385
  }>;
4386
+ compositePrimaryKeys: Record<string, {
4387
+ name: string;
4388
+ columns: string[];
4389
+ }>;
4390
+ uniqueConstraints: Record<string, {
4391
+ name: string;
4392
+ columns: string[];
4393
+ }>;
3336
4394
  }, {
3337
- schema?: string | undefined;
4395
+ uniqueConstraints?: Record<string, {
4396
+ name: string;
4397
+ columns: string[];
4398
+ }> | undefined;
3338
4399
  name: string;
3339
4400
  columns: Record<string, {
3340
4401
  default?: any;
@@ -3362,18 +4423,68 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3362
4423
  tableTo: string;
3363
4424
  columnsTo: string[];
3364
4425
  }>;
4426
+ compositePrimaryKeys: Record<string, {
4427
+ name: string;
4428
+ columns: string[];
4429
+ }>;
3365
4430
  }>>;
3366
4431
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4432
+ _meta: import("zod").ZodObject<{
4433
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4434
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4435
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4436
+ }, "strip", import("zod").ZodTypeAny, {
4437
+ columns: Record<string, string>;
4438
+ tables: Record<string, string>;
4439
+ schemas: Record<string, string>;
4440
+ }, {
4441
+ columns: Record<string, string>;
4442
+ tables: Record<string, string>;
4443
+ schemas: Record<string, string>;
4444
+ }>;
4445
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
4446
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4447
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4448
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
4449
+ }, "strip", import("zod").ZodTypeAny, {
4450
+ isDefaultAnExpression?: boolean | undefined;
4451
+ }, {
4452
+ isDefaultAnExpression?: boolean | undefined;
4453
+ }>>>;
4454
+ }, "strip", import("zod").ZodTypeAny, {
4455
+ columns: Record<string, {
4456
+ isDefaultAnExpression?: boolean | undefined;
4457
+ } | undefined>;
4458
+ }, {
4459
+ columns: Record<string, {
4460
+ isDefaultAnExpression?: boolean | undefined;
4461
+ } | undefined>;
4462
+ }>>>;
4463
+ }, "strip", import("zod").ZodTypeAny, {
4464
+ tables: Record<string, {
4465
+ columns: Record<string, {
4466
+ isDefaultAnExpression?: boolean | undefined;
4467
+ } | undefined>;
4468
+ } | undefined>;
4469
+ }, {
4470
+ tables: Record<string, {
4471
+ columns: Record<string, {
4472
+ isDefaultAnExpression?: boolean | undefined;
4473
+ } | undefined>;
4474
+ } | undefined>;
4475
+ }>>;
3367
4476
  }, {
3368
4477
  id: import("zod").ZodString;
3369
4478
  prevId: import("zod").ZodString;
3370
4479
  }>, "strip", import("zod").ZodTypeAny, {
3371
- id: string;
3372
- prevId: string;
3373
- version: "4";
3374
- dialect: "mysql";
4480
+ internal?: {
4481
+ tables: Record<string, {
4482
+ columns: Record<string, {
4483
+ isDefaultAnExpression?: boolean | undefined;
4484
+ } | undefined>;
4485
+ } | undefined>;
4486
+ } | undefined;
3375
4487
  tables: Record<string, {
3376
- schema?: string | undefined;
3377
4488
  name: string;
3378
4489
  columns: Record<string, {
3379
4490
  default?: any;
@@ -3401,15 +4512,38 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3401
4512
  tableTo: string;
3402
4513
  columnsTo: string[];
3403
4514
  }>;
4515
+ compositePrimaryKeys: Record<string, {
4516
+ name: string;
4517
+ columns: string[];
4518
+ }>;
4519
+ uniqueConstraints: Record<string, {
4520
+ name: string;
4521
+ columns: string[];
4522
+ }>;
3404
4523
  }>;
3405
- schemas: Record<string, string>;
3406
- }, {
3407
4524
  id: string;
3408
4525
  prevId: string;
3409
- version: "4";
4526
+ version: "5";
3410
4527
  dialect: "mysql";
4528
+ schemas: Record<string, string>;
4529
+ _meta: {
4530
+ columns: Record<string, string>;
4531
+ tables: Record<string, string>;
4532
+ schemas: Record<string, string>;
4533
+ };
4534
+ }, {
4535
+ internal?: {
4536
+ tables: Record<string, {
4537
+ columns: Record<string, {
4538
+ isDefaultAnExpression?: boolean | undefined;
4539
+ } | undefined>;
4540
+ } | undefined>;
4541
+ } | undefined;
3411
4542
  tables: Record<string, {
3412
- schema?: string | undefined;
4543
+ uniqueConstraints?: Record<string, {
4544
+ name: string;
4545
+ columns: string[];
4546
+ }> | undefined;
3413
4547
  name: string;
3414
4548
  columns: Record<string, {
3415
4549
  default?: any;
@@ -3437,14 +4571,26 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3437
4571
  tableTo: string;
3438
4572
  columnsTo: string[];
3439
4573
  }>;
4574
+ compositePrimaryKeys: Record<string, {
4575
+ name: string;
4576
+ columns: string[];
4577
+ }>;
3440
4578
  }>;
4579
+ id: string;
4580
+ prevId: string;
4581
+ version: "5";
4582
+ dialect: "mysql";
3441
4583
  schemas: Record<string, string>;
4584
+ _meta: {
4585
+ columns: Record<string, string>;
4586
+ tables: Record<string, string>;
4587
+ schemas: Record<string, string>;
4588
+ };
3442
4589
  }>, import("zod").ZodObject<import("zod").extendShape<{
3443
- version: import("zod").ZodLiteral<"5">;
4590
+ version: import("zod").ZodLiteral<"6">;
3444
4591
  dialect: import("zod").ZodLiteral<"mysql">;
3445
4592
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3446
4593
  name: import("zod").ZodString;
3447
- schema: import("zod").ZodOptional<import("zod").ZodString>;
3448
4594
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3449
4595
  name: import("zod").ZodString;
3450
4596
  type: import("zod").ZodString;
@@ -3538,7 +4684,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3538
4684
  columns: string[];
3539
4685
  }>>>;
3540
4686
  }, "strict", import("zod").ZodTypeAny, {
3541
- schema?: string | undefined;
3542
4687
  name: string;
3543
4688
  columns: Record<string, {
3544
4689
  default?: any;
@@ -3575,7 +4720,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3575
4720
  columns: string[];
3576
4721
  }>;
3577
4722
  }, {
3578
- schema?: string | undefined;
3579
4723
  uniqueConstraints?: Record<string, {
3580
4724
  name: string;
3581
4725
  columns: string[];
@@ -3612,19 +4756,15 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3612
4756
  columns: string[];
3613
4757
  }>;
3614
4758
  }>>;
3615
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3616
4759
  _meta: import("zod").ZodObject<{
3617
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3618
4760
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3619
4761
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3620
4762
  }, "strip", import("zod").ZodTypeAny, {
3621
4763
  columns: Record<string, string>;
3622
4764
  tables: Record<string, string>;
3623
- schemas: Record<string, string>;
3624
4765
  }, {
3625
4766
  columns: Record<string, string>;
3626
4767
  tables: Record<string, string>;
3627
- schemas: Record<string, string>;
3628
4768
  }>;
3629
4769
  internal: import("zod").ZodOptional<import("zod").ZodObject<{
3630
4770
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
@@ -3668,12 +4808,7 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3668
4808
  } | undefined>;
3669
4809
  } | undefined>;
3670
4810
  } | undefined;
3671
- id: string;
3672
- prevId: string;
3673
- version: "5";
3674
- dialect: "mysql";
3675
4811
  tables: Record<string, {
3676
- schema?: string | undefined;
3677
4812
  name: string;
3678
4813
  columns: Record<string, {
3679
4814
  default?: any;
@@ -3710,11 +4845,13 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3710
4845
  columns: string[];
3711
4846
  }>;
3712
4847
  }>;
3713
- schemas: Record<string, string>;
4848
+ id: string;
4849
+ prevId: string;
4850
+ version: "6";
4851
+ dialect: "mysql";
3714
4852
  _meta: {
3715
4853
  columns: Record<string, string>;
3716
4854
  tables: Record<string, string>;
3717
- schemas: Record<string, string>;
3718
4855
  };
3719
4856
  }, {
3720
4857
  internal?: {
@@ -3724,12 +4861,7 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3724
4861
  } | undefined>;
3725
4862
  } | undefined>;
3726
4863
  } | undefined;
3727
- id: string;
3728
- prevId: string;
3729
- version: "5";
3730
- dialect: "mysql";
3731
4864
  tables: Record<string, {
3732
- schema?: string | undefined;
3733
4865
  uniqueConstraints?: Record<string, {
3734
4866
  name: string;
3735
4867
  columns: string[];
@@ -3766,11 +4898,13 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3766
4898
  columns: string[];
3767
4899
  }>;
3768
4900
  }>;
3769
- schemas: Record<string, string>;
4901
+ id: string;
4902
+ prevId: string;
4903
+ version: "6";
4904
+ dialect: "mysql";
3770
4905
  _meta: {
3771
4906
  columns: Record<string, string>;
3772
4907
  tables: Record<string, string>;
3773
- schemas: Record<string, string>;
3774
4908
  };
3775
4909
  }>]>;
3776
4910
  export declare const dryMySql: {
@@ -3781,12 +4915,7 @@ export declare const dryMySql: {
3781
4915
  } | undefined>;
3782
4916
  } | undefined>;
3783
4917
  } | undefined;
3784
- id: string;
3785
- prevId: string;
3786
- version: "5";
3787
- dialect: "mysql";
3788
4918
  tables: Record<string, {
3789
- schema?: string | undefined;
3790
4919
  name: string;
3791
4920
  columns: Record<string, {
3792
4921
  default?: any;
@@ -3823,11 +4952,13 @@ export declare const dryMySql: {
3823
4952
  columns: string[];
3824
4953
  }>;
3825
4954
  }>;
3826
- schemas: Record<string, string>;
4955
+ id: string;
4956
+ prevId: string;
4957
+ version: "6";
4958
+ dialect: "mysql";
3827
4959
  _meta: {
3828
4960
  columns: Record<string, string>;
3829
4961
  tables: Record<string, string>;
3830
- schemas: Record<string, string>;
3831
4962
  };
3832
4963
  };
3833
4964
  export {};