drizzle-kit 0.20.14-6ce9d1f → 0.20.14-730d763

Sign up to get free protection for your applications and to get access to all the features.
Files changed (54) hide show
  1. package/bin.cjs +20593 -20020
  2. package/cli/commands/migrate.d.ts +114 -90
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -14
  4. package/cli/commands/pgIntrospect.d.ts +17 -10
  5. package/cli/commands/sqliteIntrospect.d.ts +9 -9
  6. package/cli/commands/utils.d.ts +8 -261
  7. package/cli/validations/cli.d.ts +107 -0
  8. package/cli/validations/common.d.ts +205 -7
  9. package/cli/validations/mysql.d.ts +6 -1
  10. package/cli/validations/pg.d.ts +6 -1
  11. package/cli/validations/sqlite.d.ts +165 -3
  12. package/cli/views.d.ts +6 -4
  13. package/global.d.ts +3 -1
  14. package/index.js +1 -0
  15. package/introspect-mysql.d.ts +1 -1
  16. package/introspect-pg.d.ts +5 -2
  17. package/introspect-sqlite.d.ts +1 -1
  18. package/jsonDiffer.d.ts +14 -29
  19. package/jsonStatements.d.ts +38 -11
  20. package/package.json +18 -50
  21. package/payload.js +8130 -8617
  22. package/payload.mjs +8252 -8745
  23. package/schemaValidator.d.ts +72 -69
  24. package/serializer/mysqlImports.d.ts +3 -7
  25. package/serializer/mysqlSchema.d.ts +1624 -493
  26. package/serializer/mysqlSerializer.d.ts +2 -2
  27. package/serializer/pgImports.d.ts +2 -2
  28. package/serializer/pgSchema.d.ts +1260 -801
  29. package/serializer/sqliteImports.d.ts +2 -4
  30. package/serializer/sqliteSchema.d.ts +144 -570
  31. package/serializer/sqliteSerializer.d.ts +1 -1
  32. package/snapshotsDiffer.d.ts +1908 -1050
  33. package/utils/words.d.ts +1 -1
  34. package/utils-studio.js +4144 -85
  35. package/utils-studio.mjs +4144 -85
  36. package/utils.d.ts +6 -140
  37. package/utils.js +3906 -7081
  38. package/utils.mjs +3983 -7158
  39. package/cli/commands/check.d.ts +0 -2
  40. package/cli/commands/drop.d.ts +0 -4
  41. package/cli/commands/mysqlUp.d.ts +0 -4
  42. package/cli/commands/pgUp.d.ts +0 -4
  43. package/cli/commands/push.d.ts +0 -6
  44. package/cli/commands/sqliteUp.d.ts +0 -2
  45. package/cli/commands/sqliteUtils.d.ts +0 -162
  46. package/cli/commands/upFolders.d.ts +0 -27
  47. package/cli/index.d.ts +0 -71
  48. package/cli/utils.d.ts +0 -12
  49. package/cli/validations/studio.d.ts +0 -593
  50. package/orm-extenstions/d1-driver/driver.d.ts +0 -8
  51. package/orm-extenstions/d1-driver/session.d.ts +0 -51
  52. package/orm-extenstions/d1-driver/wrangler-client.d.ts +0 -3
  53. package/serializer/studioUtils.d.ts +0 -65
  54. package/utils/certs.d.ts +0 -4
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 {};