drizzle-kit 0.20.14-c82ab68 → 0.20.14-d8f1e46

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (45) hide show
  1. package/bin.cjs +7142 -7442
  2. package/cli/commands/migrate.d.ts +24 -24
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -8
  4. package/cli/commands/mysqlPushUtils.d.ts +2 -2
  5. package/cli/commands/mysqlUp.d.ts +2 -2
  6. package/cli/commands/pgConnect.d.ts +1 -1
  7. package/cli/commands/pgIntrospect.d.ts +9 -12
  8. package/cli/commands/pgPushUtils.d.ts +2 -2
  9. package/cli/commands/pgUp.d.ts +2 -2
  10. package/cli/commands/sqliteIntrospect.d.ts +9 -9
  11. package/cli/commands/sqlitePushUtils.d.ts +3 -3
  12. package/cli/commands/sqliteUtils.d.ts +162 -0
  13. package/cli/commands/upFolders.d.ts +1 -1
  14. package/cli/commands/utils.d.ts +259 -14
  15. package/cli/validations/common.d.ts +7 -205
  16. package/cli/validations/mysql.d.ts +1 -6
  17. package/cli/validations/pg.d.ts +1 -6
  18. package/cli/views.d.ts +1 -1
  19. package/global.d.ts +1 -1
  20. package/index.d.mts +6 -8
  21. package/index.d.ts +6 -8
  22. package/index.js +0 -1
  23. package/introspect-mysql.d.ts +1 -1
  24. package/introspect-pg.d.ts +2 -5
  25. package/introspect-sqlite.d.ts +1 -1
  26. package/jsonStatements.d.ts +1 -1
  27. package/package.json +2 -3
  28. package/payload.d.mts +988 -18
  29. package/payload.d.ts +988 -18
  30. package/payload.js +1616 -13426
  31. package/payload.mjs +1538 -2213
  32. package/schemaValidator.d.ts +40 -40
  33. package/serializer/mysqlSchema.d.ts +616 -1854
  34. package/serializer/mysqlSerializer.d.ts +2 -2
  35. package/serializer/pgSchema.d.ts +684 -1009
  36. package/serializer/sqliteSchema.d.ts +570 -144
  37. package/serializer/sqliteSerializer.d.ts +2 -2
  38. package/snapshotsDiffer.d.ts +20 -24
  39. package/utils-studio.js +15 -390
  40. package/utils-studio.mjs +15 -389
  41. package/utils.d.ts +12 -12
  42. package/utils.js +735 -849
  43. package/utils.mjs +736 -849
  44. package/cli/validations/cli.d.ts +0 -104
  45. package/cli/validations/sqlite.d.ts +0 -382
package/serializer/pgSchema.d.ts CHANGED
@@ -104,6 +104,7 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
104
104
  values: Record<string, string>;
105
105
  }>>;
106
106
  }, "strict", import("zod").ZodTypeAny, {
107
+ version: "2";
107
108
  tables: Record<string, {
108
109
  name: string;
109
110
  columns: Record<string, {
@@ -122,12 +123,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
122
123
  isUnique: boolean;
123
124
  }>;
124
125
  }>;
125
- version: "2";
126
126
  enums: Record<string, {
127
127
  name: string;
128
128
  values: Record<string, string>;
129
129
  }>;
130
130
  }, {
131
+ version: "2";
131
132
  tables: Record<string, {
132
133
  name: string;
133
134
  columns: Record<string, {
@@ -146,7 +147,6 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
146
147
  isUnique: boolean;
147
148
  }>;
148
149
  }>;
149
- version: "2";
150
150
  enums: Record<string, {
151
151
  name: string;
152
152
  values: Record<string, string>;
@@ -289,6 +289,7 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
289
289
  values: Record<string, string>;
290
290
  }>>;
291
291
  }, "strict", import("zod").ZodTypeAny, {
292
+ version: "1";
292
293
  tables: Record<string, {
293
294
  name: string;
294
295
  columns: Record<string, {
@@ -313,12 +314,12 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
313
314
  isUnique: boolean;
314
315
  }>;
315
316
  }>;
316
- version: "1";
317
317
  enums: Record<string, {
318
318
  name: string;
319
319
  values: Record<string, string>;
320
320
  }>;
321
321
  }, {
322
+ version: "1";
322
323
  tables: Record<string, {
323
324
  name: string;
324
325
  columns: Record<string, {
@@ -343,7 +344,6 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
343
344
  isUnique: boolean;
344
345
  }>;
345
346
  }>;
346
- version: "1";
347
347
  enums: Record<string, {
348
348
  name: string;
349
349
  values: Record<string, string>;
@@ -866,51 +866,6 @@ declare const table: import("zod").ZodObject<{
866
866
  columns: string[];
867
867
  }>;
868
868
  }>;
869
- export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
870
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
871
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
872
- isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
873
- dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
874
- rawType: import("zod").ZodOptional<import("zod").ZodString>;
875
- }, "strip", import("zod").ZodTypeAny, {
876
- isArray?: boolean | undefined;
877
- dimensions?: number | undefined;
878
- rawType?: string | undefined;
879
- }, {
880
- isArray?: boolean | undefined;
881
- dimensions?: number | undefined;
882
- rawType?: string | undefined;
883
- }>>>;
884
- }, "strip", import("zod").ZodTypeAny, {
885
- columns: Record<string, {
886
- isArray?: boolean | undefined;
887
- dimensions?: number | undefined;
888
- rawType?: string | undefined;
889
- } | undefined>;
890
- }, {
891
- columns: Record<string, {
892
- isArray?: boolean | undefined;
893
- dimensions?: number | undefined;
894
- rawType?: string | undefined;
895
- } | undefined>;
896
- }>>>;
897
- }, "strip", import("zod").ZodTypeAny, {
898
- tables: Record<string, {
899
- columns: Record<string, {
900
- isArray?: boolean | undefined;
901
- dimensions?: number | undefined;
902
- rawType?: string | undefined;
903
- } | undefined>;
904
- } | undefined>;
905
- }, {
906
- tables: Record<string, {
907
- columns: Record<string, {
908
- isArray?: boolean | undefined;
909
- dimensions?: number | undefined;
910
- rawType?: string | undefined;
911
- } | undefined>;
912
- } | undefined>;
913
- }>>;
914
869
  export declare const pgSchemaInternalV3: import("zod").ZodObject<{
915
870
  version: import("zod").ZodLiteral<"3">;
916
871
  dialect: import("zod").ZodLiteral<"pg">;
@@ -1051,6 +1006,8 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1051
1006
  values: Record<string, string>;
1052
1007
  }>>;
1053
1008
  }, "strict", import("zod").ZodTypeAny, {
1009
+ version: "3";
1010
+ dialect: "pg";
1054
1011
  tables: Record<string, {
1055
1012
  name: string;
1056
1013
  columns: Record<string, {
@@ -1079,13 +1036,13 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1079
1036
  columnsTo: string[];
1080
1037
  }>;
1081
1038
  }>;
1082
- version: "3";
1083
- dialect: "pg";
1084
1039
  enums: Record<string, {
1085
1040
  name: string;
1086
1041
  values: Record<string, string>;
1087
1042
  }>;
1088
1043
  }, {
1044
+ version: "3";
1045
+ dialect: "pg";
1089
1046
  tables: Record<string, {
1090
1047
  name: string;
1091
1048
  columns: Record<string, {
@@ -1114,8 +1071,6 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1114
1071
  columnsTo: string[];
1115
1072
  }>;
1116
1073
  }>;
1117
- version: "3";
1118
- dialect: "pg";
1119
1074
  enums: Record<string, {
1120
1075
  name: string;
1121
1076
  values: Record<string, string>;
@@ -1265,6 +1220,8 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1265
1220
  }>>;
1266
1221
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1267
1222
  }, "strict", import("zod").ZodTypeAny, {
1223
+ version: "4";
1224
+ dialect: "pg";
1268
1225
  tables: Record<string, {
1269
1226
  name: string;
1270
1227
  columns: Record<string, {
@@ -1294,14 +1251,14 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1294
1251
  }>;
1295
1252
  schema: string;
1296
1253
  }>;
1297
- version: "4";
1298
- dialect: "pg";
1299
1254
  schemas: Record<string, string>;
1300
1255
  enums: Record<string, {
1301
1256
  name: string;
1302
1257
  values: Record<string, string>;
1303
1258
  }>;
1304
1259
  }, {
1260
+ version: "4";
1261
+ dialect: "pg";
1305
1262
  tables: Record<string, {
1306
1263
  name: string;
1307
1264
  columns: Record<string, {
@@ -1331,18 +1288,16 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1331
1288
  }>;
1332
1289
  schema: string;
1333
1290
  }>;
1334
- version: "4";
1335
- dialect: "pg";
1336
1291
  schemas: Record<string, string>;
1337
1292
  enums: Record<string, {
1338
1293
  name: string;
1339
1294
  values: Record<string, string>;
1340
1295
  }>;
1341
1296
  }>;
1342
- export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1297
+ export declare const pgSchemaExternal: import("zod").ZodObject<{
1343
1298
  version: import("zod").ZodLiteral<"5">;
1344
1299
  dialect: import("zod").ZodLiteral<"pg">;
1345
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1300
+ tables: import("zod").ZodArray<import("zod").ZodObject<{
1346
1301
  name: import("zod").ZodString;
1347
1302
  schema: import("zod").ZodString;
1348
1303
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1511,8 +1466,8 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1511
1466
  name: string;
1512
1467
  columns: string[];
1513
1468
  }>;
1514
- }>>;
1515
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1469
+ }>, "many">;
1470
+ enums: import("zod").ZodArray<import("zod").ZodObject<{
1516
1471
  name: import("zod").ZodString;
1517
1472
  values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1518
1473
  }, "strict", import("zod").ZodTypeAny, {
@@ -1521,8 +1476,14 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1521
1476
  }, {
1522
1477
  name: string;
1523
1478
  values: Record<string, string>;
1524
- }>>;
1525
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1479
+ }>, "many">;
1480
+ schemas: import("zod").ZodArray<import("zod").ZodObject<{
1481
+ name: import("zod").ZodString;
1482
+ }, "strip", import("zod").ZodTypeAny, {
1483
+ name: string;
1484
+ }, {
1485
+ name: string;
1486
+ }>, "many">;
1526
1487
  _meta: import("zod").ZodObject<{
1527
1488
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1528
1489
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -1536,62 +1497,10 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1536
1497
  tables: Record<string, string>;
1537
1498
  schemas: Record<string, string>;
1538
1499
  }>;
1539
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
1540
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1541
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1542
- isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
1543
- dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
1544
- rawType: import("zod").ZodOptional<import("zod").ZodString>;
1545
- }, "strip", import("zod").ZodTypeAny, {
1546
- isArray?: boolean | undefined;
1547
- dimensions?: number | undefined;
1548
- rawType?: string | undefined;
1549
- }, {
1550
- isArray?: boolean | undefined;
1551
- dimensions?: number | undefined;
1552
- rawType?: string | undefined;
1553
- }>>>;
1554
- }, "strip", import("zod").ZodTypeAny, {
1555
- columns: Record<string, {
1556
- isArray?: boolean | undefined;
1557
- dimensions?: number | undefined;
1558
- rawType?: string | undefined;
1559
- } | undefined>;
1560
- }, {
1561
- columns: Record<string, {
1562
- isArray?: boolean | undefined;
1563
- dimensions?: number | undefined;
1564
- rawType?: string | undefined;
1565
- } | undefined>;
1566
- }>>>;
1567
- }, "strip", import("zod").ZodTypeAny, {
1568
- tables: Record<string, {
1569
- columns: Record<string, {
1570
- isArray?: boolean | undefined;
1571
- dimensions?: number | undefined;
1572
- rawType?: string | undefined;
1573
- } | undefined>;
1574
- } | undefined>;
1575
- }, {
1576
- tables: Record<string, {
1577
- columns: Record<string, {
1578
- isArray?: boolean | undefined;
1579
- dimensions?: number | undefined;
1580
- rawType?: string | undefined;
1581
- } | undefined>;
1582
- } | undefined>;
1583
- }>>;
1584
1500
  }, "strict", import("zod").ZodTypeAny, {
1585
- internal?: {
1586
- tables: Record<string, {
1587
- columns: Record<string, {
1588
- isArray?: boolean | undefined;
1589
- dimensions?: number | undefined;
1590
- rawType?: string | undefined;
1591
- } | undefined>;
1592
- } | undefined>;
1593
- } | undefined;
1594
- tables: Record<string, {
1501
+ version: "5";
1502
+ dialect: "pg";
1503
+ tables: {
1595
1504
  name: string;
1596
1505
  columns: Record<string, {
1597
1506
  isUnique?: any;
@@ -1628,30 +1537,23 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1628
1537
  columns: string[];
1629
1538
  nullsNotDistinct: boolean;
1630
1539
  }>;
1631
- }>;
1632
- version: "5";
1633
- dialect: "pg";
1634
- schemas: Record<string, string>;
1540
+ }[];
1541
+ schemas: {
1542
+ name: string;
1543
+ }[];
1635
1544
  _meta: {
1636
1545
  columns: Record<string, string>;
1637
1546
  tables: Record<string, string>;
1638
1547
  schemas: Record<string, string>;
1639
1548
  };
1640
- enums: Record<string, {
1549
+ enums: {
1641
1550
  name: string;
1642
1551
  values: Record<string, string>;
1643
- }>;
1552
+ }[];
1644
1553
  }, {
1645
- internal?: {
1646
- tables: Record<string, {
1647
- columns: Record<string, {
1648
- isArray?: boolean | undefined;
1649
- dimensions?: number | undefined;
1650
- rawType?: string | undefined;
1651
- } | undefined>;
1652
- } | undefined>;
1653
- } | undefined;
1654
- tables: Record<string, {
1554
+ version: "5";
1555
+ dialect: "pg";
1556
+ tables: {
1655
1557
  uniqueConstraints?: Record<string, {
1656
1558
  name: string;
1657
1559
  columns: string[];
@@ -1688,24 +1590,69 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1688
1590
  name: string;
1689
1591
  columns: string[];
1690
1592
  }>;
1691
- }>;
1692
- version: "5";
1693
- dialect: "pg";
1694
- schemas: Record<string, string>;
1593
+ }[];
1594
+ schemas: {
1595
+ name: string;
1596
+ }[];
1695
1597
  _meta: {
1696
1598
  columns: Record<string, string>;
1697
1599
  tables: Record<string, string>;
1698
1600
  schemas: Record<string, string>;
1699
1601
  };
1700
- enums: Record<string, {
1602
+ enums: {
1701
1603
  name: string;
1702
1604
  values: Record<string, string>;
1703
- }>;
1605
+ }[];
1704
1606
  }>;
1705
- export declare const pgSchemaExternal: import("zod").ZodObject<{
1607
+ export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
1608
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1609
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1610
+ isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
1611
+ dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
1612
+ rawType: import("zod").ZodOptional<import("zod").ZodString>;
1613
+ }, "strip", import("zod").ZodTypeAny, {
1614
+ isArray?: boolean | undefined;
1615
+ dimensions?: number | undefined;
1616
+ rawType?: string | undefined;
1617
+ }, {
1618
+ isArray?: boolean | undefined;
1619
+ dimensions?: number | undefined;
1620
+ rawType?: string | undefined;
1621
+ }>>>;
1622
+ }, "strip", import("zod").ZodTypeAny, {
1623
+ columns: Record<string, {
1624
+ isArray?: boolean | undefined;
1625
+ dimensions?: number | undefined;
1626
+ rawType?: string | undefined;
1627
+ } | undefined>;
1628
+ }, {
1629
+ columns: Record<string, {
1630
+ isArray?: boolean | undefined;
1631
+ dimensions?: number | undefined;
1632
+ rawType?: string | undefined;
1633
+ } | undefined>;
1634
+ }>>>;
1635
+ }, "strip", import("zod").ZodTypeAny, {
1636
+ tables: Record<string, {
1637
+ columns: Record<string, {
1638
+ isArray?: boolean | undefined;
1639
+ dimensions?: number | undefined;
1640
+ rawType?: string | undefined;
1641
+ } | undefined>;
1642
+ } | undefined>;
1643
+ }, {
1644
+ tables: Record<string, {
1645
+ columns: Record<string, {
1646
+ isArray?: boolean | undefined;
1647
+ dimensions?: number | undefined;
1648
+ rawType?: string | undefined;
1649
+ } | undefined>;
1650
+ } | undefined>;
1651
+ }>>;
1652
+ export declare const pgSchemaInternal: import("zod").ZodObject<{
1706
1653
  version: import("zod").ZodLiteral<"5">;
1707
1654
  dialect: import("zod").ZodLiteral<"pg">;
1708
- tables: import("zod").ZodArray<import("zod").ZodObject<{
1655
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1709
1656
  name: import("zod").ZodString;
1710
1657
  schema: import("zod").ZodString;
1711
1658
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1874,8 +1821,8 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1874
1821
  name: string;
1875
1822
  columns: string[];
1876
1823
  }>;
1877
- }>, "many">;
1878
- enums: import("zod").ZodArray<import("zod").ZodObject<{
1824
+ }>>;
1825
+ enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1879
1826
  name: import("zod").ZodString;
1880
1827
  values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1881
1828
  }, "strict", import("zod").ZodTypeAny, {
@@ -1884,14 +1831,8 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1884
1831
  }, {
1885
1832
  name: string;
1886
1833
  values: Record<string, string>;
1887
- }>, "many">;
1888
- schemas: import("zod").ZodArray<import("zod").ZodObject<{
1889
- name: import("zod").ZodString;
1890
- }, "strip", import("zod").ZodTypeAny, {
1891
- name: string;
1892
- }, {
1893
- name: string;
1894
- }>, "many">;
1834
+ }>>;
1835
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1895
1836
  _meta: import("zod").ZodObject<{
1896
1837
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1897
1838
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -1905,18 +1846,74 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1905
1846
  tables: Record<string, string>;
1906
1847
  schemas: Record<string, string>;
1907
1848
  }>;
1908
- }, "strict", import("zod").ZodTypeAny, {
1909
- tables: {
1910
- name: string;
1911
- columns: Record<string, {
1912
- isUnique?: any;
1913
- default?: any;
1914
- uniqueName?: string | undefined;
1915
- nullsNotDistinct?: boolean | undefined;
1916
- name: string;
1917
- type: string;
1918
- primaryKey: boolean;
1919
- notNull: boolean;
1849
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
1850
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1851
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1852
+ isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
1853
+ dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
1854
+ rawType: import("zod").ZodOptional<import("zod").ZodString>;
1855
+ }, "strip", import("zod").ZodTypeAny, {
1856
+ isArray?: boolean | undefined;
1857
+ dimensions?: number | undefined;
1858
+ rawType?: string | undefined;
1859
+ }, {
1860
+ isArray?: boolean | undefined;
1861
+ dimensions?: number | undefined;
1862
+ rawType?: string | undefined;
1863
+ }>>>;
1864
+ }, "strip", import("zod").ZodTypeAny, {
1865
+ columns: Record<string, {
1866
+ isArray?: boolean | undefined;
1867
+ dimensions?: number | undefined;
1868
+ rawType?: string | undefined;
1869
+ } | undefined>;
1870
+ }, {
1871
+ columns: Record<string, {
1872
+ isArray?: boolean | undefined;
1873
+ dimensions?: number | undefined;
1874
+ rawType?: string | undefined;
1875
+ } | undefined>;
1876
+ }>>>;
1877
+ }, "strip", import("zod").ZodTypeAny, {
1878
+ tables: Record<string, {
1879
+ columns: Record<string, {
1880
+ isArray?: boolean | undefined;
1881
+ dimensions?: number | undefined;
1882
+ rawType?: string | undefined;
1883
+ } | undefined>;
1884
+ } | undefined>;
1885
+ }, {
1886
+ tables: Record<string, {
1887
+ columns: Record<string, {
1888
+ isArray?: boolean | undefined;
1889
+ dimensions?: number | undefined;
1890
+ rawType?: string | undefined;
1891
+ } | undefined>;
1892
+ } | undefined>;
1893
+ }>>;
1894
+ }, "strict", import("zod").ZodTypeAny, {
1895
+ internal?: {
1896
+ tables: Record<string, {
1897
+ columns: Record<string, {
1898
+ isArray?: boolean | undefined;
1899
+ dimensions?: number | undefined;
1900
+ rawType?: string | undefined;
1901
+ } | undefined>;
1902
+ } | undefined>;
1903
+ } | undefined;
1904
+ version: "5";
1905
+ dialect: "pg";
1906
+ tables: Record<string, {
1907
+ name: string;
1908
+ columns: Record<string, {
1909
+ isUnique?: any;
1910
+ default?: any;
1911
+ uniqueName?: string | undefined;
1912
+ nullsNotDistinct?: boolean | undefined;
1913
+ name: string;
1914
+ type: string;
1915
+ primaryKey: boolean;
1916
+ notNull: boolean;
1920
1917
  }>;
1921
1918
  indexes: Record<string, {
1922
1919
  name: string;
@@ -1943,23 +1940,30 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1943
1940
  columns: string[];
1944
1941
  nullsNotDistinct: boolean;
1945
1942
  }>;
1946
- }[];
1947
- version: "5";
1948
- dialect: "pg";
1949
- schemas: {
1950
- name: string;
1951
- }[];
1943
+ }>;
1944
+ schemas: Record<string, string>;
1952
1945
  _meta: {
1953
1946
  columns: Record<string, string>;
1954
1947
  tables: Record<string, string>;
1955
1948
  schemas: Record<string, string>;
1956
1949
  };
1957
- enums: {
1950
+ enums: Record<string, {
1958
1951
  name: string;
1959
1952
  values: Record<string, string>;
1960
- }[];
1953
+ }>;
1961
1954
  }, {
1962
- tables: {
1955
+ internal?: {
1956
+ tables: Record<string, {
1957
+ columns: Record<string, {
1958
+ isArray?: boolean | undefined;
1959
+ dimensions?: number | undefined;
1960
+ rawType?: string | undefined;
1961
+ } | undefined>;
1962
+ } | undefined>;
1963
+ } | undefined;
1964
+ version: "5";
1965
+ dialect: "pg";
1966
+ tables: Record<string, {
1963
1967
  uniqueConstraints?: Record<string, {
1964
1968
  name: string;
1965
1969
  columns: string[];
@@ -1996,25 +2000,21 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1996
2000
  name: string;
1997
2001
  columns: string[];
1998
2002
  }>;
1999
- }[];
2000
- version: "5";
2001
- dialect: "pg";
2002
- schemas: {
2003
- name: string;
2004
- }[];
2003
+ }>;
2004
+ schemas: Record<string, string>;
2005
2005
  _meta: {
2006
2006
  columns: Record<string, string>;
2007
2007
  tables: Record<string, string>;
2008
2008
  schemas: Record<string, string>;
2009
2009
  };
2010
- enums: {
2010
+ enums: Record<string, {
2011
2011
  name: string;
2012
2012
  values: Record<string, string>;
2013
- }[];
2013
+ }>;
2014
2014
  }>;
2015
- export declare const pgSchemaInternal: import("zod").ZodObject<{
2016
- version: import("zod").ZodLiteral<"6">;
2017
- dialect: import("zod").ZodLiteral<"pg">;
2015
+ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2016
+ version: import("zod").ZodLiteral<"4">;
2017
+ dialect: import("zod").ZodEnum<["pg"]>;
2018
2018
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2019
2019
  name: import("zod").ZodString;
2020
2020
  schema: import("zod").ZodString;
@@ -2046,70 +2046,8 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2046
2046
  primaryKey: boolean;
2047
2047
  notNull: boolean;
2048
2048
  }>>;
2049
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2050
- name: import("zod").ZodString;
2051
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2052
- isUnique: import("zod").ZodBoolean;
2053
- }, "strict", import("zod").ZodTypeAny, {
2054
- name: string;
2055
- columns: string[];
2056
- isUnique: boolean;
2057
- }, {
2058
- name: string;
2059
- columns: string[];
2060
- isUnique: boolean;
2061
- }>>;
2062
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2063
- name: import("zod").ZodString;
2064
- tableFrom: import("zod").ZodString;
2065
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2066
- tableTo: import("zod").ZodString;
2067
- schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
2068
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2069
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2070
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2071
- }, "strict", import("zod").ZodTypeAny, {
2072
- onUpdate?: string | undefined;
2073
- onDelete?: string | undefined;
2074
- schemaTo?: string | undefined;
2075
- name: string;
2076
- tableFrom: string;
2077
- columnsFrom: string[];
2078
- tableTo: string;
2079
- columnsTo: string[];
2080
- }, {
2081
- onUpdate?: string | undefined;
2082
- onDelete?: string | undefined;
2083
- schemaTo?: string | undefined;
2084
- name: string;
2085
- tableFrom: string;
2086
- columnsFrom: string[];
2087
- tableTo: string;
2088
- columnsTo: string[];
2089
- }>>;
2090
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2091
- name: import("zod").ZodString;
2092
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2093
- }, "strict", import("zod").ZodTypeAny, {
2094
- name: string;
2095
- columns: string[];
2096
- }, {
2097
- name: string;
2098
- columns: string[];
2099
- }>>;
2100
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2101
- name: import("zod").ZodString;
2102
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2103
- nullsNotDistinct: import("zod").ZodBoolean;
2104
- }, "strict", import("zod").ZodTypeAny, {
2105
- name: string;
2106
- columns: string[];
2107
- nullsNotDistinct: boolean;
2108
- }, {
2109
- name: string;
2110
- columns: string[];
2111
- nullsNotDistinct: boolean;
2112
- }>>>;
2049
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2050
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2113
2051
  }, "strict", import("zod").ZodTypeAny, {
2114
2052
  name: string;
2115
2053
  columns: Record<string, {
@@ -2122,37 +2060,10 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2122
2060
  primaryKey: boolean;
2123
2061
  notNull: boolean;
2124
2062
  }>;
2125
- indexes: Record<string, {
2126
- name: string;
2127
- columns: string[];
2128
- isUnique: boolean;
2129
- }>;
2130
- foreignKeys: Record<string, {
2131
- onUpdate?: string | undefined;
2132
- onDelete?: string | undefined;
2133
- schemaTo?: string | undefined;
2134
- name: string;
2135
- tableFrom: string;
2136
- columnsFrom: string[];
2137
- tableTo: string;
2138
- columnsTo: string[];
2139
- }>;
2063
+ indexes: Record<string, string>;
2064
+ foreignKeys: Record<string, string>;
2140
2065
  schema: string;
2141
- compositePrimaryKeys: Record<string, {
2142
- name: string;
2143
- columns: string[];
2144
- }>;
2145
- uniqueConstraints: Record<string, {
2146
- name: string;
2147
- columns: string[];
2148
- nullsNotDistinct: boolean;
2149
- }>;
2150
2066
  }, {
2151
- uniqueConstraints?: Record<string, {
2152
- name: string;
2153
- columns: string[];
2154
- nullsNotDistinct: boolean;
2155
- }> | undefined;
2156
2067
  name: string;
2157
2068
  columns: Record<string, {
2158
2069
  isUnique?: any;
@@ -2164,26 +2075,9 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2164
2075
  primaryKey: boolean;
2165
2076
  notNull: boolean;
2166
2077
  }>;
2167
- indexes: Record<string, {
2168
- name: string;
2169
- columns: string[];
2170
- isUnique: boolean;
2171
- }>;
2172
- foreignKeys: Record<string, {
2173
- onUpdate?: string | undefined;
2174
- onDelete?: string | undefined;
2175
- schemaTo?: string | undefined;
2176
- name: string;
2177
- tableFrom: string;
2178
- columnsFrom: string[];
2179
- tableTo: string;
2180
- columnsTo: string[];
2181
- }>;
2078
+ indexes: Record<string, string>;
2079
+ foreignKeys: Record<string, string>;
2182
2080
  schema: string;
2183
- compositePrimaryKeys: Record<string, {
2184
- name: string;
2185
- columns: string[];
2186
- }>;
2187
2081
  }>>;
2188
2082
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2189
2083
  name: import("zod").ZodString;
@@ -2196,264 +2090,9 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2196
2090
  values: Record<string, string>;
2197
2091
  }>>;
2198
2092
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2199
- _meta: import("zod").ZodObject<{
2200
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2201
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2202
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2203
- }, "strip", import("zod").ZodTypeAny, {
2204
- columns: Record<string, string>;
2205
- tables: Record<string, string>;
2206
- schemas: Record<string, string>;
2207
- }, {
2208
- columns: Record<string, string>;
2209
- tables: Record<string, string>;
2210
- schemas: Record<string, string>;
2211
- }>;
2212
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
2213
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2214
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2215
- isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
2216
- dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
2217
- rawType: import("zod").ZodOptional<import("zod").ZodString>;
2218
- }, "strip", import("zod").ZodTypeAny, {
2219
- isArray?: boolean | undefined;
2220
- dimensions?: number | undefined;
2221
- rawType?: string | undefined;
2222
- }, {
2223
- isArray?: boolean | undefined;
2224
- dimensions?: number | undefined;
2225
- rawType?: string | undefined;
2226
- }>>>;
2227
- }, "strip", import("zod").ZodTypeAny, {
2228
- columns: Record<string, {
2229
- isArray?: boolean | undefined;
2230
- dimensions?: number | undefined;
2231
- rawType?: string | undefined;
2232
- } | undefined>;
2233
- }, {
2234
- columns: Record<string, {
2235
- isArray?: boolean | undefined;
2236
- dimensions?: number | undefined;
2237
- rawType?: string | undefined;
2238
- } | undefined>;
2239
- }>>>;
2240
- }, "strip", import("zod").ZodTypeAny, {
2241
- tables: Record<string, {
2242
- columns: Record<string, {
2243
- isArray?: boolean | undefined;
2244
- dimensions?: number | undefined;
2245
- rawType?: string | undefined;
2246
- } | undefined>;
2247
- } | undefined>;
2248
- }, {
2249
- tables: Record<string, {
2250
- columns: Record<string, {
2251
- isArray?: boolean | undefined;
2252
- dimensions?: number | undefined;
2253
- rawType?: string | undefined;
2254
- } | undefined>;
2255
- } | undefined>;
2256
- }>>;
2257
2093
  }, "strict", import("zod").ZodTypeAny, {
2258
- internal?: {
2259
- tables: Record<string, {
2260
- columns: Record<string, {
2261
- isArray?: boolean | undefined;
2262
- dimensions?: number | undefined;
2263
- rawType?: string | undefined;
2264
- } | undefined>;
2265
- } | undefined>;
2266
- } | undefined;
2267
- tables: Record<string, {
2268
- name: string;
2269
- columns: Record<string, {
2270
- isUnique?: any;
2271
- default?: any;
2272
- uniqueName?: string | undefined;
2273
- nullsNotDistinct?: boolean | undefined;
2274
- name: string;
2275
- type: string;
2276
- primaryKey: boolean;
2277
- notNull: boolean;
2278
- }>;
2279
- indexes: Record<string, {
2280
- name: string;
2281
- columns: string[];
2282
- isUnique: boolean;
2283
- }>;
2284
- foreignKeys: Record<string, {
2285
- onUpdate?: string | undefined;
2286
- onDelete?: string | undefined;
2287
- schemaTo?: string | undefined;
2288
- name: string;
2289
- tableFrom: string;
2290
- columnsFrom: string[];
2291
- tableTo: string;
2292
- columnsTo: string[];
2293
- }>;
2294
- schema: string;
2295
- compositePrimaryKeys: Record<string, {
2296
- name: string;
2297
- columns: string[];
2298
- }>;
2299
- uniqueConstraints: Record<string, {
2300
- name: string;
2301
- columns: string[];
2302
- nullsNotDistinct: boolean;
2303
- }>;
2304
- }>;
2305
- version: "6";
2306
- dialect: "pg";
2307
- schemas: Record<string, string>;
2308
- _meta: {
2309
- columns: Record<string, string>;
2310
- tables: Record<string, string>;
2311
- schemas: Record<string, string>;
2312
- };
2313
- enums: Record<string, {
2314
- name: string;
2315
- values: Record<string, string>;
2316
- }>;
2317
- }, {
2318
- internal?: {
2319
- tables: Record<string, {
2320
- columns: Record<string, {
2321
- isArray?: boolean | undefined;
2322
- dimensions?: number | undefined;
2323
- rawType?: string | undefined;
2324
- } | undefined>;
2325
- } | undefined>;
2326
- } | undefined;
2327
- tables: Record<string, {
2328
- uniqueConstraints?: Record<string, {
2329
- name: string;
2330
- columns: string[];
2331
- nullsNotDistinct: boolean;
2332
- }> | undefined;
2333
- name: string;
2334
- columns: Record<string, {
2335
- isUnique?: any;
2336
- default?: any;
2337
- uniqueName?: string | undefined;
2338
- nullsNotDistinct?: boolean | undefined;
2339
- name: string;
2340
- type: string;
2341
- primaryKey: boolean;
2342
- notNull: boolean;
2343
- }>;
2344
- indexes: Record<string, {
2345
- name: string;
2346
- columns: string[];
2347
- isUnique: boolean;
2348
- }>;
2349
- foreignKeys: Record<string, {
2350
- onUpdate?: string | undefined;
2351
- onDelete?: string | undefined;
2352
- schemaTo?: string | undefined;
2353
- name: string;
2354
- tableFrom: string;
2355
- columnsFrom: string[];
2356
- tableTo: string;
2357
- columnsTo: string[];
2358
- }>;
2359
- schema: string;
2360
- compositePrimaryKeys: Record<string, {
2361
- name: string;
2362
- columns: string[];
2363
- }>;
2364
- }>;
2365
- version: "6";
2094
+ version: "4";
2366
2095
  dialect: "pg";
2367
- schemas: Record<string, string>;
2368
- _meta: {
2369
- columns: Record<string, string>;
2370
- tables: Record<string, string>;
2371
- schemas: Record<string, string>;
2372
- };
2373
- enums: Record<string, {
2374
- name: string;
2375
- values: Record<string, string>;
2376
- }>;
2377
- }>;
2378
- export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2379
- version: import("zod").ZodLiteral<"4">;
2380
- dialect: import("zod").ZodEnum<["pg"]>;
2381
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2382
- name: import("zod").ZodString;
2383
- schema: import("zod").ZodString;
2384
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2385
- name: import("zod").ZodString;
2386
- type: import("zod").ZodString;
2387
- primaryKey: import("zod").ZodBoolean;
2388
- notNull: import("zod").ZodBoolean;
2389
- default: import("zod").ZodOptional<import("zod").ZodAny>;
2390
- isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
2391
- uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2392
- nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2393
- }, "strict", import("zod").ZodTypeAny, {
2394
- isUnique?: any;
2395
- default?: any;
2396
- uniqueName?: string | undefined;
2397
- nullsNotDistinct?: boolean | undefined;
2398
- name: string;
2399
- type: string;
2400
- primaryKey: boolean;
2401
- notNull: boolean;
2402
- }, {
2403
- isUnique?: any;
2404
- default?: any;
2405
- uniqueName?: string | undefined;
2406
- nullsNotDistinct?: boolean | undefined;
2407
- name: string;
2408
- type: string;
2409
- primaryKey: boolean;
2410
- notNull: boolean;
2411
- }>>;
2412
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2413
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2414
- }, "strict", import("zod").ZodTypeAny, {
2415
- name: string;
2416
- columns: Record<string, {
2417
- isUnique?: any;
2418
- default?: any;
2419
- uniqueName?: string | undefined;
2420
- nullsNotDistinct?: boolean | undefined;
2421
- name: string;
2422
- type: string;
2423
- primaryKey: boolean;
2424
- notNull: boolean;
2425
- }>;
2426
- indexes: Record<string, string>;
2427
- foreignKeys: Record<string, string>;
2428
- schema: string;
2429
- }, {
2430
- name: string;
2431
- columns: Record<string, {
2432
- isUnique?: any;
2433
- default?: any;
2434
- uniqueName?: string | undefined;
2435
- nullsNotDistinct?: boolean | undefined;
2436
- name: string;
2437
- type: string;
2438
- primaryKey: boolean;
2439
- notNull: boolean;
2440
- }>;
2441
- indexes: Record<string, string>;
2442
- foreignKeys: Record<string, string>;
2443
- schema: string;
2444
- }>>;
2445
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2446
- name: import("zod").ZodString;
2447
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2448
- }, "strict", import("zod").ZodTypeAny, {
2449
- name: string;
2450
- values: Record<string, string>;
2451
- }, {
2452
- name: string;
2453
- values: Record<string, string>;
2454
- }>>;
2455
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2456
- }, "strict", import("zod").ZodTypeAny, {
2457
2096
  tables: Record<string, {
2458
2097
  name: string;
2459
2098
  columns: Record<string, {
@@ -2470,14 +2109,14 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2470
2109
  foreignKeys: Record<string, string>;
2471
2110
  schema: string;
2472
2111
  }>;
2473
- version: "4";
2474
- dialect: "pg";
2475
2112
  schemas: Record<string, string>;
2476
2113
  enums: Record<string, {
2477
2114
  name: string;
2478
2115
  values: Record<string, string>;
2479
2116
  }>;
2480
2117
  }, {
2118
+ version: "4";
2119
+ dialect: "pg";
2481
2120
  tables: Record<string, {
2482
2121
  name: string;
2483
2122
  columns: Record<string, {
@@ -2494,8 +2133,6 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2494
2133
  foreignKeys: Record<string, string>;
2495
2134
  schema: string;
2496
2135
  }>;
2497
- version: "4";
2498
- dialect: "pg";
2499
2136
  schemas: Record<string, string>;
2500
2137
  enums: Record<string, {
2501
2138
  name: string;
@@ -2503,7 +2140,7 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2503
2140
  }>;
2504
2141
  }>;
2505
2142
  export declare const pgSchemaSquashed: import("zod").ZodObject<{
2506
- version: import("zod").ZodLiteral<"6">;
2143
+ version: import("zod").ZodLiteral<"5">;
2507
2144
  dialect: import("zod").ZodEnum<["pg"]>;
2508
2145
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2509
2146
  name: import("zod").ZodString;
@@ -2587,6 +2224,8 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2587
2224
  }>>;
2588
2225
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2589
2226
  }, "strict", import("zod").ZodTypeAny, {
2227
+ version: "5";
2228
+ dialect: "pg";
2590
2229
  tables: Record<string, {
2591
2230
  name: string;
2592
2231
  columns: Record<string, {
@@ -2605,14 +2244,14 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2605
2244
  compositePrimaryKeys: Record<string, string>;
2606
2245
  uniqueConstraints: Record<string, string>;
2607
2246
  }>;
2608
- version: "6";
2609
- dialect: "pg";
2610
2247
  schemas: Record<string, string>;
2611
2248
  enums: Record<string, {
2612
2249
  name: string;
2613
2250
  values: Record<string, string>;
2614
2251
  }>;
2615
2252
  }, {
2253
+ version: "5";
2254
+ dialect: "pg";
2616
2255
  tables: Record<string, {
2617
2256
  name: string;
2618
2257
  columns: Record<string, {
@@ -2631,8 +2270,6 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2631
2270
  compositePrimaryKeys: Record<string, string>;
2632
2271
  uniqueConstraints: Record<string, string>;
2633
2272
  }>;
2634
- version: "6";
2635
- dialect: "pg";
2636
2273
  schemas: Record<string, string>;
2637
2274
  enums: Record<string, {
2638
2275
  name: string;
@@ -2782,6 +2419,10 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2782
2419
  id: import("zod").ZodString;
2783
2420
  prevId: import("zod").ZodString;
2784
2421
  }>, "strip", import("zod").ZodTypeAny, {
2422
+ id: string;
2423
+ prevId: string;
2424
+ version: "3";
2425
+ dialect: "pg";
2785
2426
  tables: Record<string, {
2786
2427
  name: string;
2787
2428
  columns: Record<string, {
@@ -2810,15 +2451,15 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2810
2451
  columnsTo: string[];
2811
2452
  }>;
2812
2453
  }>;
2813
- id: string;
2814
- prevId: string;
2815
- version: "3";
2816
- dialect: "pg";
2817
2454
  enums: Record<string, {
2818
2455
  name: string;
2819
2456
  values: Record<string, string>;
2820
2457
  }>;
2821
2458
  }, {
2459
+ id: string;
2460
+ prevId: string;
2461
+ version: "3";
2462
+ dialect: "pg";
2822
2463
  tables: Record<string, {
2823
2464
  name: string;
2824
2465
  columns: Record<string, {
@@ -2847,10 +2488,6 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2847
2488
  columnsTo: string[];
2848
2489
  }>;
2849
2490
  }>;
2850
- id: string;
2851
- prevId: string;
2852
- version: "3";
2853
- dialect: "pg";
2854
2491
  enums: Record<string, {
2855
2492
  name: string;
2856
2493
  values: Record<string, string>;
@@ -3003,6 +2640,10 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3003
2640
  id: import("zod").ZodString;
3004
2641
  prevId: import("zod").ZodString;
3005
2642
  }>, "strip", import("zod").ZodTypeAny, {
2643
+ id: string;
2644
+ prevId: string;
2645
+ version: "4";
2646
+ dialect: "pg";
3006
2647
  tables: Record<string, {
3007
2648
  name: string;
3008
2649
  columns: Record<string, {
@@ -3032,16 +2673,16 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3032
2673
  }>;
3033
2674
  schema: string;
3034
2675
  }>;
3035
- id: string;
3036
- prevId: string;
3037
- version: "4";
3038
- dialect: "pg";
3039
2676
  schemas: Record<string, string>;
3040
2677
  enums: Record<string, {
3041
2678
  name: string;
3042
2679
  values: Record<string, string>;
3043
2680
  }>;
3044
2681
  }, {
2682
+ id: string;
2683
+ prevId: string;
2684
+ version: "4";
2685
+ dialect: "pg";
3045
2686
  tables: Record<string, {
3046
2687
  name: string;
3047
2688
  columns: Record<string, {
@@ -3071,17 +2712,13 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3071
2712
  }>;
3072
2713
  schema: string;
3073
2714
  }>;
3074
- id: string;
3075
- prevId: string;
3076
- version: "4";
3077
- dialect: "pg";
3078
2715
  schemas: Record<string, string>;
3079
2716
  enums: Record<string, {
3080
2717
  name: string;
3081
2718
  values: Record<string, string>;
3082
2719
  }>;
3083
2720
  }>;
3084
- export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
2721
+ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
3085
2722
  version: import("zod").ZodLiteral<"5">;
3086
2723
  dialect: import("zod").ZodLiteral<"pg">;
3087
2724
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3336,13 +2973,390 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3336
2973
  } | undefined>;
3337
2974
  } | undefined>;
3338
2975
  } | undefined;
2976
+ id: string;
2977
+ prevId: string;
2978
+ version: "5";
2979
+ dialect: "pg";
2980
+ tables: Record<string, {
2981
+ name: string;
2982
+ columns: Record<string, {
2983
+ isUnique?: any;
2984
+ default?: any;
2985
+ uniqueName?: string | undefined;
2986
+ nullsNotDistinct?: boolean | undefined;
2987
+ name: string;
2988
+ type: string;
2989
+ primaryKey: boolean;
2990
+ notNull: boolean;
2991
+ }>;
2992
+ indexes: Record<string, {
2993
+ name: string;
2994
+ columns: string[];
2995
+ isUnique: boolean;
2996
+ }>;
2997
+ foreignKeys: Record<string, {
2998
+ onUpdate?: string | undefined;
2999
+ onDelete?: string | undefined;
3000
+ schemaTo?: string | undefined;
3001
+ name: string;
3002
+ tableFrom: string;
3003
+ columnsFrom: string[];
3004
+ tableTo: string;
3005
+ columnsTo: string[];
3006
+ }>;
3007
+ schema: string;
3008
+ compositePrimaryKeys: Record<string, {
3009
+ name: string;
3010
+ columns: string[];
3011
+ }>;
3012
+ uniqueConstraints: Record<string, {
3013
+ name: string;
3014
+ columns: string[];
3015
+ nullsNotDistinct: boolean;
3016
+ }>;
3017
+ }>;
3018
+ schemas: Record<string, string>;
3019
+ _meta: {
3020
+ columns: Record<string, string>;
3021
+ tables: Record<string, string>;
3022
+ schemas: Record<string, string>;
3023
+ };
3024
+ enums: Record<string, {
3025
+ name: string;
3026
+ values: Record<string, string>;
3027
+ }>;
3028
+ }, {
3029
+ internal?: {
3030
+ tables: Record<string, {
3031
+ columns: Record<string, {
3032
+ isArray?: boolean | undefined;
3033
+ dimensions?: number | undefined;
3034
+ rawType?: string | undefined;
3035
+ } | undefined>;
3036
+ } | undefined>;
3037
+ } | undefined;
3038
+ id: string;
3039
+ prevId: string;
3040
+ version: "5";
3041
+ dialect: "pg";
3042
+ tables: Record<string, {
3043
+ uniqueConstraints?: Record<string, {
3044
+ name: string;
3045
+ columns: string[];
3046
+ nullsNotDistinct: boolean;
3047
+ }> | undefined;
3048
+ name: string;
3049
+ columns: Record<string, {
3050
+ isUnique?: any;
3051
+ default?: any;
3052
+ uniqueName?: string | undefined;
3053
+ nullsNotDistinct?: boolean | undefined;
3054
+ name: string;
3055
+ type: string;
3056
+ primaryKey: boolean;
3057
+ notNull: boolean;
3058
+ }>;
3059
+ indexes: Record<string, {
3060
+ name: string;
3061
+ columns: string[];
3062
+ isUnique: boolean;
3063
+ }>;
3064
+ foreignKeys: Record<string, {
3065
+ onUpdate?: string | undefined;
3066
+ onDelete?: string | undefined;
3067
+ schemaTo?: string | undefined;
3068
+ name: string;
3069
+ tableFrom: string;
3070
+ columnsFrom: string[];
3071
+ tableTo: string;
3072
+ columnsTo: string[];
3073
+ }>;
3074
+ schema: string;
3075
+ compositePrimaryKeys: Record<string, {
3076
+ name: string;
3077
+ columns: string[];
3078
+ }>;
3079
+ }>;
3080
+ schemas: Record<string, string>;
3081
+ _meta: {
3082
+ columns: Record<string, string>;
3083
+ tables: Record<string, string>;
3084
+ schemas: Record<string, string>;
3085
+ };
3086
+ enums: Record<string, {
3087
+ name: string;
3088
+ values: Record<string, string>;
3089
+ }>;
3090
+ }>;
3091
+ export type Enum = TypeOf<typeof enumSchema>;
3092
+ export type Column = TypeOf<typeof column>;
3093
+ export type TableV3 = TypeOf<typeof tableV3>;
3094
+ export type TableV4 = TypeOf<typeof tableV4>;
3095
+ export type Table = TypeOf<typeof table>;
3096
+ export type PgSchema = TypeOf<typeof pgSchema>;
3097
+ export type PgSchemaInternal = TypeOf<typeof pgSchemaInternal>;
3098
+ export type PgSchemaExternal = TypeOf<typeof pgSchemaExternal>;
3099
+ export type PgSchemaSquashed = TypeOf<typeof pgSchemaSquashed>;
3100
+ export type PgSchemaSquashedV4 = TypeOf<typeof pgSchemaSquashedV4>;
3101
+ export type Index = TypeOf<typeof index>;
3102
+ export type ForeignKey = TypeOf<typeof fk>;
3103
+ export type PrimaryKey = TypeOf<typeof compositePK>;
3104
+ export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
3105
+ export type PgKitInternals = TypeOf<typeof kitInternals>;
3106
+ export type PgSchemaV1 = TypeOf<typeof pgSchemaV1>;
3107
+ export type PgSchemaV2 = TypeOf<typeof pgSchemaV2>;
3108
+ export type PgSchemaV3 = TypeOf<typeof pgSchemaV3>;
3109
+ export type PgSchemaV4 = TypeOf<typeof pgSchemaV4>;
3110
+ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import("zod").ZodObject<{
3111
+ version: import("zod").ZodLiteral<"1">;
3112
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3113
+ name: import("zod").ZodString;
3114
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3115
+ name: import("zod").ZodString;
3116
+ type: import("zod").ZodString;
3117
+ primaryKey: import("zod").ZodBoolean;
3118
+ notNull: import("zod").ZodBoolean;
3119
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
3120
+ references: import("zod").ZodOptional<import("zod").ZodObject<{
3121
+ foreignKeyName: import("zod").ZodString;
3122
+ table: import("zod").ZodString;
3123
+ column: import("zod").ZodString;
3124
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3125
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3126
+ }, "strict", import("zod").ZodTypeAny, {
3127
+ onUpdate?: string | undefined;
3128
+ onDelete?: string | undefined;
3129
+ foreignKeyName: string;
3130
+ table: string;
3131
+ column: string;
3132
+ }, {
3133
+ onUpdate?: string | undefined;
3134
+ onDelete?: string | undefined;
3135
+ foreignKeyName: string;
3136
+ table: string;
3137
+ column: string;
3138
+ }>>;
3139
+ }, "strict", import("zod").ZodTypeAny, {
3140
+ default?: any;
3141
+ references?: {
3142
+ onUpdate?: string | undefined;
3143
+ onDelete?: string | undefined;
3144
+ foreignKeyName: string;
3145
+ table: string;
3146
+ column: string;
3147
+ } | undefined;
3148
+ name: string;
3149
+ type: string;
3150
+ primaryKey: boolean;
3151
+ notNull: boolean;
3152
+ }, {
3153
+ default?: any;
3154
+ references?: {
3155
+ onUpdate?: string | undefined;
3156
+ onDelete?: string | undefined;
3157
+ foreignKeyName: string;
3158
+ table: string;
3159
+ column: string;
3160
+ } | undefined;
3161
+ name: string;
3162
+ type: string;
3163
+ primaryKey: boolean;
3164
+ notNull: boolean;
3165
+ }>>;
3166
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3167
+ name: import("zod").ZodString;
3168
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3169
+ name: import("zod").ZodString;
3170
+ }, "strip", import("zod").ZodTypeAny, {
3171
+ name: string;
3172
+ }, {
3173
+ name: string;
3174
+ }>>;
3175
+ isUnique: import("zod").ZodBoolean;
3176
+ }, "strict", import("zod").ZodTypeAny, {
3177
+ name: string;
3178
+ columns: Record<string, {
3179
+ name: string;
3180
+ }>;
3181
+ isUnique: boolean;
3182
+ }, {
3183
+ name: string;
3184
+ columns: Record<string, {
3185
+ name: string;
3186
+ }>;
3187
+ isUnique: boolean;
3188
+ }>>;
3189
+ }, "strict", import("zod").ZodTypeAny, {
3190
+ name: string;
3191
+ columns: Record<string, {
3192
+ default?: any;
3193
+ references?: {
3194
+ onUpdate?: string | undefined;
3195
+ onDelete?: string | undefined;
3196
+ foreignKeyName: string;
3197
+ table: string;
3198
+ column: string;
3199
+ } | undefined;
3200
+ name: string;
3201
+ type: string;
3202
+ primaryKey: boolean;
3203
+ notNull: boolean;
3204
+ }>;
3205
+ indexes: Record<string, {
3206
+ name: string;
3207
+ columns: Record<string, {
3208
+ name: string;
3209
+ }>;
3210
+ isUnique: boolean;
3211
+ }>;
3212
+ }, {
3213
+ name: string;
3214
+ columns: Record<string, {
3215
+ default?: any;
3216
+ references?: {
3217
+ onUpdate?: string | undefined;
3218
+ onDelete?: string | undefined;
3219
+ foreignKeyName: string;
3220
+ table: string;
3221
+ column: string;
3222
+ } | undefined;
3223
+ name: string;
3224
+ type: string;
3225
+ primaryKey: boolean;
3226
+ notNull: boolean;
3227
+ }>;
3228
+ indexes: Record<string, {
3229
+ name: string;
3230
+ columns: Record<string, {
3231
+ name: string;
3232
+ }>;
3233
+ isUnique: boolean;
3234
+ }>;
3235
+ }>>;
3236
+ enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3237
+ name: import("zod").ZodString;
3238
+ values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3239
+ }, "strict", import("zod").ZodTypeAny, {
3240
+ name: string;
3241
+ values: Record<string, string>;
3242
+ }, {
3243
+ name: string;
3244
+ values: Record<string, string>;
3245
+ }>>;
3246
+ }, "strict", import("zod").ZodTypeAny, {
3247
+ version: "1";
3339
3248
  tables: Record<string, {
3340
3249
  name: string;
3341
3250
  columns: Record<string, {
3342
- isUnique?: any;
3343
3251
  default?: any;
3344
- uniqueName?: string | undefined;
3345
- nullsNotDistinct?: boolean | undefined;
3252
+ references?: {
3253
+ onUpdate?: string | undefined;
3254
+ onDelete?: string | undefined;
3255
+ foreignKeyName: string;
3256
+ table: string;
3257
+ column: string;
3258
+ } | undefined;
3259
+ name: string;
3260
+ type: string;
3261
+ primaryKey: boolean;
3262
+ notNull: boolean;
3263
+ }>;
3264
+ indexes: Record<string, {
3265
+ name: string;
3266
+ columns: Record<string, {
3267
+ name: string;
3268
+ }>;
3269
+ isUnique: boolean;
3270
+ }>;
3271
+ }>;
3272
+ enums: Record<string, {
3273
+ name: string;
3274
+ values: Record<string, string>;
3275
+ }>;
3276
+ }, {
3277
+ version: "1";
3278
+ tables: Record<string, {
3279
+ name: string;
3280
+ columns: Record<string, {
3281
+ default?: any;
3282
+ references?: {
3283
+ onUpdate?: string | undefined;
3284
+ onDelete?: string | undefined;
3285
+ foreignKeyName: string;
3286
+ table: string;
3287
+ column: string;
3288
+ } | undefined;
3289
+ name: string;
3290
+ type: string;
3291
+ primaryKey: boolean;
3292
+ notNull: boolean;
3293
+ }>;
3294
+ indexes: Record<string, {
3295
+ name: string;
3296
+ columns: Record<string, {
3297
+ name: string;
3298
+ }>;
3299
+ isUnique: boolean;
3300
+ }>;
3301
+ }>;
3302
+ enums: Record<string, {
3303
+ name: string;
3304
+ values: Record<string, string>;
3305
+ }>;
3306
+ }>, import("zod").ZodObject<{
3307
+ version: import("zod").ZodLiteral<"2">;
3308
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3309
+ name: import("zod").ZodString;
3310
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3311
+ name: import("zod").ZodString;
3312
+ type: import("zod").ZodString;
3313
+ primaryKey: import("zod").ZodBoolean;
3314
+ notNull: import("zod").ZodBoolean;
3315
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
3316
+ references: import("zod").ZodOptional<import("zod").ZodString>;
3317
+ }, "strict", import("zod").ZodTypeAny, {
3318
+ default?: any;
3319
+ references?: string | undefined;
3320
+ name: string;
3321
+ type: string;
3322
+ primaryKey: boolean;
3323
+ notNull: boolean;
3324
+ }, {
3325
+ default?: any;
3326
+ references?: string | undefined;
3327
+ name: string;
3328
+ type: string;
3329
+ primaryKey: boolean;
3330
+ notNull: boolean;
3331
+ }>>;
3332
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3333
+ name: import("zod").ZodString;
3334
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3335
+ name: import("zod").ZodString;
3336
+ }, "strip", import("zod").ZodTypeAny, {
3337
+ name: string;
3338
+ }, {
3339
+ name: string;
3340
+ }>>;
3341
+ isUnique: import("zod").ZodBoolean;
3342
+ }, "strict", import("zod").ZodTypeAny, {
3343
+ name: string;
3344
+ columns: Record<string, {
3345
+ name: string;
3346
+ }>;
3347
+ isUnique: boolean;
3348
+ }, {
3349
+ name: string;
3350
+ columns: Record<string, {
3351
+ name: string;
3352
+ }>;
3353
+ isUnique: boolean;
3354
+ }>>;
3355
+ }, "strict", import("zod").ZodTypeAny, {
3356
+ name: string;
3357
+ columns: Record<string, {
3358
+ default?: any;
3359
+ references?: string | undefined;
3346
3360
  name: string;
3347
3361
  type: string;
3348
3362
  primaryKey: boolean;
@@ -3350,66 +3364,70 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3350
3364
  }>;
3351
3365
  indexes: Record<string, {
3352
3366
  name: string;
3353
- columns: string[];
3367
+ columns: Record<string, {
3368
+ name: string;
3369
+ }>;
3354
3370
  isUnique: boolean;
3355
3371
  }>;
3356
- foreignKeys: Record<string, {
3357
- onUpdate?: string | undefined;
3358
- onDelete?: string | undefined;
3359
- schemaTo?: string | undefined;
3372
+ }, {
3373
+ name: string;
3374
+ columns: Record<string, {
3375
+ default?: any;
3376
+ references?: string | undefined;
3360
3377
  name: string;
3361
- tableFrom: string;
3362
- columnsFrom: string[];
3363
- tableTo: string;
3364
- columnsTo: string[];
3378
+ type: string;
3379
+ primaryKey: boolean;
3380
+ notNull: boolean;
3365
3381
  }>;
3366
- schema: string;
3367
- compositePrimaryKeys: Record<string, {
3382
+ indexes: Record<string, {
3368
3383
  name: string;
3369
- columns: string[];
3384
+ columns: Record<string, {
3385
+ name: string;
3386
+ }>;
3387
+ isUnique: boolean;
3370
3388
  }>;
3371
- uniqueConstraints: Record<string, {
3389
+ }>>;
3390
+ enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3391
+ name: import("zod").ZodString;
3392
+ values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3393
+ }, "strict", import("zod").ZodTypeAny, {
3394
+ name: string;
3395
+ values: Record<string, string>;
3396
+ }, {
3397
+ name: string;
3398
+ values: Record<string, string>;
3399
+ }>>;
3400
+ }, "strict", import("zod").ZodTypeAny, {
3401
+ version: "2";
3402
+ tables: Record<string, {
3403
+ name: string;
3404
+ columns: Record<string, {
3405
+ default?: any;
3406
+ references?: string | undefined;
3372
3407
  name: string;
3373
- columns: string[];
3374
- nullsNotDistinct: boolean;
3408
+ type: string;
3409
+ primaryKey: boolean;
3410
+ notNull: boolean;
3411
+ }>;
3412
+ indexes: Record<string, {
3413
+ name: string;
3414
+ columns: Record<string, {
3415
+ name: string;
3416
+ }>;
3417
+ isUnique: boolean;
3375
3418
  }>;
3376
3419
  }>;
3377
- id: string;
3378
- prevId: string;
3379
- version: "5";
3380
- dialect: "pg";
3381
- schemas: Record<string, string>;
3382
- _meta: {
3383
- columns: Record<string, string>;
3384
- tables: Record<string, string>;
3385
- schemas: Record<string, string>;
3386
- };
3387
3420
  enums: Record<string, {
3388
3421
  name: string;
3389
3422
  values: Record<string, string>;
3390
3423
  }>;
3391
3424
  }, {
3392
- internal?: {
3393
- tables: Record<string, {
3394
- columns: Record<string, {
3395
- isArray?: boolean | undefined;
3396
- dimensions?: number | undefined;
3397
- rawType?: string | undefined;
3398
- } | undefined>;
3399
- } | undefined>;
3400
- } | undefined;
3425
+ version: "2";
3401
3426
  tables: Record<string, {
3402
- uniqueConstraints?: Record<string, {
3403
- name: string;
3404
- columns: string[];
3405
- nullsNotDistinct: boolean;
3406
- }> | undefined;
3407
3427
  name: string;
3408
3428
  columns: Record<string, {
3409
- isUnique?: any;
3410
3429
  default?: any;
3411
- uniqueName?: string | undefined;
3412
- nullsNotDistinct?: boolean | undefined;
3430
+ references?: string | undefined;
3413
3431
  name: string;
3414
3432
  type: string;
3415
3433
  primaryKey: boolean;
@@ -3417,46 +3435,21 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3417
3435
  }>;
3418
3436
  indexes: Record<string, {
3419
3437
  name: string;
3420
- columns: string[];
3438
+ columns: Record<string, {
3439
+ name: string;
3440
+ }>;
3421
3441
  isUnique: boolean;
3422
3442
  }>;
3423
- foreignKeys: Record<string, {
3424
- onUpdate?: string | undefined;
3425
- onDelete?: string | undefined;
3426
- schemaTo?: string | undefined;
3427
- name: string;
3428
- tableFrom: string;
3429
- columnsFrom: string[];
3430
- tableTo: string;
3431
- columnsTo: string[];
3432
- }>;
3433
- schema: string;
3434
- compositePrimaryKeys: Record<string, {
3435
- name: string;
3436
- columns: string[];
3437
- }>;
3438
3443
  }>;
3439
- id: string;
3440
- prevId: string;
3441
- version: "5";
3442
- dialect: "pg";
3443
- schemas: Record<string, string>;
3444
- _meta: {
3445
- columns: Record<string, string>;
3446
- tables: Record<string, string>;
3447
- schemas: Record<string, string>;
3448
- };
3449
3444
  enums: Record<string, {
3450
3445
  name: string;
3451
3446
  values: Record<string, string>;
3452
3447
  }>;
3453
- }>;
3454
- export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
3455
- version: import("zod").ZodLiteral<"6">;
3448
+ }>, import("zod").ZodObject<import("zod").extendShape<{
3449
+ version: import("zod").ZodLiteral<"3">;
3456
3450
  dialect: import("zod").ZodLiteral<"pg">;
3457
3451
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3458
3452
  name: import("zod").ZodString;
3459
- schema: import("zod").ZodString;
3460
3453
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3461
3454
  name: import("zod").ZodString;
3462
3455
  type: import("zod").ZodString;
@@ -3526,29 +3519,6 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3526
3519
  tableTo: string;
3527
3520
  columnsTo: string[];
3528
3521
  }>>;
3529
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3530
- name: import("zod").ZodString;
3531
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3532
- }, "strict", import("zod").ZodTypeAny, {
3533
- name: string;
3534
- columns: string[];
3535
- }, {
3536
- name: string;
3537
- columns: string[];
3538
- }>>;
3539
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3540
- name: import("zod").ZodString;
3541
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3542
- nullsNotDistinct: import("zod").ZodBoolean;
3543
- }, "strict", import("zod").ZodTypeAny, {
3544
- name: string;
3545
- columns: string[];
3546
- nullsNotDistinct: boolean;
3547
- }, {
3548
- name: string;
3549
- columns: string[];
3550
- nullsNotDistinct: boolean;
3551
- }>>>;
3552
3522
  }, "strict", import("zod").ZodTypeAny, {
3553
3523
  name: string;
3554
3524
  columns: Record<string, {
@@ -3576,22 +3546,7 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3576
3546
  tableTo: string;
3577
3547
  columnsTo: string[];
3578
3548
  }>;
3579
- schema: string;
3580
- compositePrimaryKeys: Record<string, {
3581
- name: string;
3582
- columns: string[];
3583
- }>;
3584
- uniqueConstraints: Record<string, {
3585
- name: string;
3586
- columns: string[];
3587
- nullsNotDistinct: boolean;
3588
- }>;
3589
3549
  }, {
3590
- uniqueConstraints?: Record<string, {
3591
- name: string;
3592
- columns: string[];
3593
- nullsNotDistinct: boolean;
3594
- }> | undefined;
3595
3550
  name: string;
3596
3551
  columns: Record<string, {
3597
3552
  isUnique?: any;
@@ -3618,11 +3573,6 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3618
3573
  tableTo: string;
3619
3574
  columnsTo: string[];
3620
3575
  }>;
3621
- schema: string;
3622
- compositePrimaryKeys: Record<string, {
3623
- name: string;
3624
- columns: string[];
3625
- }>;
3626
3576
  }>>;
3627
3577
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3628
3578
  name: import("zod").ZodString;
@@ -3634,78 +3584,14 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3634
3584
  name: string;
3635
3585
  values: Record<string, string>;
3636
3586
  }>>;
3637
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3638
- _meta: import("zod").ZodObject<{
3639
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3640
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3641
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3642
- }, "strip", import("zod").ZodTypeAny, {
3643
- columns: Record<string, string>;
3644
- tables: Record<string, string>;
3645
- schemas: Record<string, string>;
3646
- }, {
3647
- columns: Record<string, string>;
3648
- tables: Record<string, string>;
3649
- schemas: Record<string, string>;
3650
- }>;
3651
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
3652
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
3653
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
3654
- isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
3655
- dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
3656
- rawType: import("zod").ZodOptional<import("zod").ZodString>;
3657
- }, "strip", import("zod").ZodTypeAny, {
3658
- isArray?: boolean | undefined;
3659
- dimensions?: number | undefined;
3660
- rawType?: string | undefined;
3661
- }, {
3662
- isArray?: boolean | undefined;
3663
- dimensions?: number | undefined;
3664
- rawType?: string | undefined;
3665
- }>>>;
3666
- }, "strip", import("zod").ZodTypeAny, {
3667
- columns: Record<string, {
3668
- isArray?: boolean | undefined;
3669
- dimensions?: number | undefined;
3670
- rawType?: string | undefined;
3671
- } | undefined>;
3672
- }, {
3673
- columns: Record<string, {
3674
- isArray?: boolean | undefined;
3675
- dimensions?: number | undefined;
3676
- rawType?: string | undefined;
3677
- } | undefined>;
3678
- }>>>;
3679
- }, "strip", import("zod").ZodTypeAny, {
3680
- tables: Record<string, {
3681
- columns: Record<string, {
3682
- isArray?: boolean | undefined;
3683
- dimensions?: number | undefined;
3684
- rawType?: string | undefined;
3685
- } | undefined>;
3686
- } | undefined>;
3687
- }, {
3688
- tables: Record<string, {
3689
- columns: Record<string, {
3690
- isArray?: boolean | undefined;
3691
- dimensions?: number | undefined;
3692
- rawType?: string | undefined;
3693
- } | undefined>;
3694
- } | undefined>;
3695
- }>>;
3696
3587
  }, {
3697
3588
  id: import("zod").ZodString;
3698
3589
  prevId: import("zod").ZodString;
3699
3590
  }>, "strip", import("zod").ZodTypeAny, {
3700
- internal?: {
3701
- tables: Record<string, {
3702
- columns: Record<string, {
3703
- isArray?: boolean | undefined;
3704
- dimensions?: number | undefined;
3705
- rawType?: string | undefined;
3706
- } | undefined>;
3707
- } | undefined>;
3708
- } | undefined;
3591
+ id: string;
3592
+ prevId: string;
3593
+ version: "3";
3594
+ dialect: "pg";
3709
3595
  tables: Record<string, {
3710
3596
  name: string;
3711
3597
  columns: Record<string, {
@@ -3724,56 +3610,26 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3724
3610
  isUnique: boolean;
3725
3611
  }>;
3726
3612
  foreignKeys: Record<string, {
3727
- onUpdate?: string | undefined;
3728
- onDelete?: string | undefined;
3729
- schemaTo?: string | undefined;
3730
- name: string;
3731
- tableFrom: string;
3732
- columnsFrom: string[];
3733
- tableTo: string;
3734
- columnsTo: string[];
3735
- }>;
3736
- schema: string;
3737
- compositePrimaryKeys: Record<string, {
3738
- name: string;
3739
- columns: string[];
3740
- }>;
3741
- uniqueConstraints: Record<string, {
3613
+ onUpdate?: string | undefined;
3614
+ onDelete?: string | undefined;
3615
+ schemaTo?: string | undefined;
3742
3616
  name: string;
3743
- columns: string[];
3744
- nullsNotDistinct: boolean;
3617
+ tableFrom: string;
3618
+ columnsFrom: string[];
3619
+ tableTo: string;
3620
+ columnsTo: string[];
3745
3621
  }>;
3746
3622
  }>;
3747
- id: string;
3748
- prevId: string;
3749
- version: "6";
3750
- dialect: "pg";
3751
- schemas: Record<string, string>;
3752
- _meta: {
3753
- columns: Record<string, string>;
3754
- tables: Record<string, string>;
3755
- schemas: Record<string, string>;
3756
- };
3757
3623
  enums: Record<string, {
3758
3624
  name: string;
3759
3625
  values: Record<string, string>;
3760
3626
  }>;
3761
3627
  }, {
3762
- internal?: {
3763
- tables: Record<string, {
3764
- columns: Record<string, {
3765
- isArray?: boolean | undefined;
3766
- dimensions?: number | undefined;
3767
- rawType?: string | undefined;
3768
- } | undefined>;
3769
- } | undefined>;
3770
- } | undefined;
3628
+ id: string;
3629
+ prevId: string;
3630
+ version: "3";
3631
+ dialect: "pg";
3771
3632
  tables: Record<string, {
3772
- uniqueConstraints?: Record<string, {
3773
- name: string;
3774
- columns: string[];
3775
- nullsNotDistinct: boolean;
3776
- }> | undefined;
3777
3633
  name: string;
3778
3634
  columns: Record<string, {
3779
3635
  isUnique?: any;
@@ -3800,49 +3656,13 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3800
3656
  tableTo: string;
3801
3657
  columnsTo: string[];
3802
3658
  }>;
3803
- schema: string;
3804
- compositePrimaryKeys: Record<string, {
3805
- name: string;
3806
- columns: string[];
3807
- }>;
3808
3659
  }>;
3809
- id: string;
3810
- prevId: string;
3811
- version: "6";
3812
- dialect: "pg";
3813
- schemas: Record<string, string>;
3814
- _meta: {
3815
- columns: Record<string, string>;
3816
- tables: Record<string, string>;
3817
- schemas: Record<string, string>;
3818
- };
3819
3660
  enums: Record<string, {
3820
3661
  name: string;
3821
3662
  values: Record<string, string>;
3822
3663
  }>;
3823
- }>;
3824
- export type Enum = TypeOf<typeof enumSchema>;
3825
- export type Column = TypeOf<typeof column>;
3826
- export type TableV3 = TypeOf<typeof tableV3>;
3827
- export type TableV4 = TypeOf<typeof tableV4>;
3828
- export type Table = TypeOf<typeof table>;
3829
- export type PgSchema = TypeOf<typeof pgSchema>;
3830
- export type PgSchemaInternal = TypeOf<typeof pgSchemaInternal>;
3831
- export type PgSchemaExternal = TypeOf<typeof pgSchemaExternal>;
3832
- export type PgSchemaSquashed = TypeOf<typeof pgSchemaSquashed>;
3833
- export type PgSchemaSquashedV4 = TypeOf<typeof pgSchemaSquashedV4>;
3834
- export type Index = TypeOf<typeof index>;
3835
- export type ForeignKey = TypeOf<typeof fk>;
3836
- export type PrimaryKey = TypeOf<typeof compositePK>;
3837
- export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
3838
- export type PgKitInternals = TypeOf<typeof kitInternals>;
3839
- export type PgSchemaV1 = TypeOf<typeof pgSchemaV1>;
3840
- export type PgSchemaV2 = TypeOf<typeof pgSchemaV2>;
3841
- export type PgSchemaV3 = TypeOf<typeof pgSchemaV3>;
3842
- export type PgSchemaV4 = TypeOf<typeof pgSchemaV4>;
3843
- export type PgSchemaV5 = TypeOf<typeof pgSchemaV5>;
3844
- export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
3845
- version: import("zod").ZodLiteral<"5">;
3664
+ }>, import("zod").ZodObject<import("zod").extendShape<{
3665
+ version: import("zod").ZodLiteral<"4">;
3846
3666
  dialect: import("zod").ZodLiteral<"pg">;
3847
3667
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3848
3668
  name: import("zod").ZodString;
@@ -3916,29 +3736,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3916
3736
  tableTo: string;
3917
3737
  columnsTo: string[];
3918
3738
  }>>;
3919
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3920
- name: import("zod").ZodString;
3921
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3922
- }, "strict", import("zod").ZodTypeAny, {
3923
- name: string;
3924
- columns: string[];
3925
- }, {
3926
- name: string;
3927
- columns: string[];
3928
- }>>;
3929
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3930
- name: import("zod").ZodString;
3931
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3932
- nullsNotDistinct: import("zod").ZodBoolean;
3933
- }, "strict", import("zod").ZodTypeAny, {
3934
- name: string;
3935
- columns: string[];
3936
- nullsNotDistinct: boolean;
3937
- }, {
3938
- name: string;
3939
- columns: string[];
3940
- nullsNotDistinct: boolean;
3941
- }>>>;
3942
3739
  }, "strict", import("zod").ZodTypeAny, {
3943
3740
  name: string;
3944
3741
  columns: Record<string, {
@@ -3967,21 +3764,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3967
3764
  columnsTo: string[];
3968
3765
  }>;
3969
3766
  schema: string;
3970
- compositePrimaryKeys: Record<string, {
3971
- name: string;
3972
- columns: string[];
3973
- }>;
3974
- uniqueConstraints: Record<string, {
3975
- name: string;
3976
- columns: string[];
3977
- nullsNotDistinct: boolean;
3978
- }>;
3979
3767
  }, {
3980
- uniqueConstraints?: Record<string, {
3981
- name: string;
3982
- columns: string[];
3983
- nullsNotDistinct: boolean;
3984
- }> | undefined;
3985
3768
  name: string;
3986
3769
  columns: Record<string, {
3987
3770
  isUnique?: any;
@@ -4009,10 +3792,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4009
3792
  columnsTo: string[];
4010
3793
  }>;
4011
3794
  schema: string;
4012
- compositePrimaryKeys: Record<string, {
4013
- name: string;
4014
- columns: string[];
4015
- }>;
4016
3795
  }>>;
4017
3796
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4018
3797
  name: import("zod").ZodString;
@@ -4025,77 +3804,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4025
3804
  values: Record<string, string>;
4026
3805
  }>>;
4027
3806
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4028
- _meta: import("zod").ZodObject<{
4029
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4030
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4031
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4032
- }, "strip", import("zod").ZodTypeAny, {
4033
- columns: Record<string, string>;
4034
- tables: Record<string, string>;
4035
- schemas: Record<string, string>;
4036
- }, {
4037
- columns: Record<string, string>;
4038
- tables: Record<string, string>;
4039
- schemas: Record<string, string>;
4040
- }>;
4041
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
4042
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4043
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
4044
- isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
4045
- dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
4046
- rawType: import("zod").ZodOptional<import("zod").ZodString>;
4047
- }, "strip", import("zod").ZodTypeAny, {
4048
- isArray?: boolean | undefined;
4049
- dimensions?: number | undefined;
4050
- rawType?: string | undefined;
4051
- }, {
4052
- isArray?: boolean | undefined;
4053
- dimensions?: number | undefined;
4054
- rawType?: string | undefined;
4055
- }>>>;
4056
- }, "strip", import("zod").ZodTypeAny, {
4057
- columns: Record<string, {
4058
- isArray?: boolean | undefined;
4059
- dimensions?: number | undefined;
4060
- rawType?: string | undefined;
4061
- } | undefined>;
4062
- }, {
4063
- columns: Record<string, {
4064
- isArray?: boolean | undefined;
4065
- dimensions?: number | undefined;
4066
- rawType?: string | undefined;
4067
- } | undefined>;
4068
- }>>>;
4069
- }, "strip", import("zod").ZodTypeAny, {
4070
- tables: Record<string, {
4071
- columns: Record<string, {
4072
- isArray?: boolean | undefined;
4073
- dimensions?: number | undefined;
4074
- rawType?: string | undefined;
4075
- } | undefined>;
4076
- } | undefined>;
4077
- }, {
4078
- tables: Record<string, {
4079
- columns: Record<string, {
4080
- isArray?: boolean | undefined;
4081
- dimensions?: number | undefined;
4082
- rawType?: string | undefined;
4083
- } | undefined>;
4084
- } | undefined>;
4085
- }>>;
4086
3807
  }, {
4087
3808
  id: import("zod").ZodString;
4088
3809
  prevId: import("zod").ZodString;
4089
3810
  }>, "strip", import("zod").ZodTypeAny, {
4090
- internal?: {
4091
- tables: Record<string, {
4092
- columns: Record<string, {
4093
- isArray?: boolean | undefined;
4094
- dimensions?: number | undefined;
4095
- rawType?: string | undefined;
4096
- } | undefined>;
4097
- } | undefined>;
4098
- } | undefined;
3811
+ id: string;
3812
+ prevId: string;
3813
+ version: "4";
3814
+ dialect: "pg";
4099
3815
  tables: Record<string, {
4100
3816
  name: string;
4101
3817
  columns: Record<string, {
@@ -4124,46 +3840,18 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4124
3840
  columnsTo: string[];
4125
3841
  }>;
4126
3842
  schema: string;
4127
- compositePrimaryKeys: Record<string, {
4128
- name: string;
4129
- columns: string[];
4130
- }>;
4131
- uniqueConstraints: Record<string, {
4132
- name: string;
4133
- columns: string[];
4134
- nullsNotDistinct: boolean;
4135
- }>;
4136
3843
  }>;
4137
- id: string;
4138
- prevId: string;
4139
- version: "5";
4140
- dialect: "pg";
4141
3844
  schemas: Record<string, string>;
4142
- _meta: {
4143
- columns: Record<string, string>;
4144
- tables: Record<string, string>;
4145
- schemas: Record<string, string>;
4146
- };
4147
3845
  enums: Record<string, {
4148
3846
  name: string;
4149
3847
  values: Record<string, string>;
4150
3848
  }>;
4151
3849
  }, {
4152
- internal?: {
4153
- tables: Record<string, {
4154
- columns: Record<string, {
4155
- isArray?: boolean | undefined;
4156
- dimensions?: number | undefined;
4157
- rawType?: string | undefined;
4158
- } | undefined>;
4159
- } | undefined>;
4160
- } | undefined;
3850
+ id: string;
3851
+ prevId: string;
3852
+ version: "4";
3853
+ dialect: "pg";
4161
3854
  tables: Record<string, {
4162
- uniqueConstraints?: Record<string, {
4163
- name: string;
4164
- columns: string[];
4165
- nullsNotDistinct: boolean;
4166
- }> | undefined;
4167
3855
  name: string;
4168
3856
  columns: Record<string, {
4169
3857
  isUnique?: any;
@@ -4191,27 +3879,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4191
3879
  columnsTo: string[];
4192
3880
  }>;
4193
3881
  schema: string;
4194
- compositePrimaryKeys: Record<string, {
4195
- name: string;
4196
- columns: string[];
4197
- }>;
4198
3882
  }>;
4199
- id: string;
4200
- prevId: string;
4201
- version: "5";
4202
- dialect: "pg";
4203
3883
  schemas: Record<string, string>;
4204
- _meta: {
4205
- columns: Record<string, string>;
4206
- tables: Record<string, string>;
4207
- schemas: Record<string, string>;
4208
- };
4209
3884
  enums: Record<string, {
4210
3885
  name: string;
4211
3886
  values: Record<string, string>;
4212
3887
  }>;
4213
3888
  }>, import("zod").ZodObject<import("zod").extendShape<{
4214
- version: import("zod").ZodLiteral<"6">;
3889
+ version: import("zod").ZodLiteral<"5">;
4215
3890
  dialect: import("zod").ZodLiteral<"pg">;
4216
3891
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4217
3892
  name: import("zod").ZodString;
@@ -4465,6 +4140,10 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4465
4140
  } | undefined>;
4466
4141
  } | undefined>;
4467
4142
  } | undefined;
4143
+ id: string;
4144
+ prevId: string;
4145
+ version: "5";
4146
+ dialect: "pg";
4468
4147
  tables: Record<string, {
4469
4148
  name: string;
4470
4149
  columns: Record<string, {
@@ -4503,10 +4182,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4503
4182
  nullsNotDistinct: boolean;
4504
4183
  }>;
4505
4184
  }>;
4506
- id: string;
4507
- prevId: string;
4508
- version: "6";
4509
- dialect: "pg";
4510
4185
  schemas: Record<string, string>;
4511
4186
  _meta: {
4512
4187
  columns: Record<string, string>;
@@ -4527,6 +4202,10 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4527
4202
  } | undefined>;
4528
4203
  } | undefined>;
4529
4204
  } | undefined;
4205
+ id: string;
4206
+ prevId: string;
4207
+ version: "5";
4208
+ dialect: "pg";
4530
4209
  tables: Record<string, {
4531
4210
  uniqueConstraints?: Record<string, {
4532
4211
  name: string;
@@ -4565,10 +4244,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4565
4244
  columns: string[];
4566
4245
  }>;
4567
4246
  }>;
4568
- id: string;
4569
- prevId: string;
4570
- version: "6";
4571
- dialect: "pg";
4572
4247
  schemas: Record<string, string>;
4573
4248
  _meta: {
4574
4249
  columns: Record<string, string>;
@@ -4602,6 +4277,10 @@ export declare const dryPg: {
4602
4277
  } | undefined>;
4603
4278
  } | undefined>;
4604
4279
  } | undefined;
4280
+ id: string;
4281
+ prevId: string;
4282
+ version: "5";
4283
+ dialect: "pg";
4605
4284
  tables: Record<string, {
4606
4285
  name: string;
4607
4286
  columns: Record<string, {
@@ -4640,10 +4319,6 @@ export declare const dryPg: {
4640
4319
  nullsNotDistinct: boolean;
4641
4320
  }>;
4642
4321
  }>;
4643
- id: string;
4644
- prevId: string;
4645
- version: "6";
4646
- dialect: "pg";
4647
4322
  schemas: Record<string, string>;
4648
4323
  _meta: {
4649
4324
  columns: Record<string, string>;