drizzle-kit 0.20.14-1f99bf7 → 0.20.14-3ab22ec

Sign up to get free protection for your applications and to get access to all the features.
Files changed (43) hide show
  1. package/bin.cjs +36859 -33936
  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 -9
  8. package/cli/commands/pgPushUtils.d.ts +2 -2
  9. package/cli/commands/pgUp.d.ts +2 -2
  10. package/cli/commands/sqliteIntrospect.d.ts +9 -9
  11. package/cli/commands/sqlitePushUtils.d.ts +3 -3
  12. package/cli/commands/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 +1 -1
  25. package/introspect-sqlite.d.ts +1 -1
  26. package/jsonStatements.d.ts +1 -1
  27. package/package.json +8 -5
  28. package/payload.js +1527 -1841
  29. package/payload.mjs +1531 -1844
  30. package/schemaValidator.d.ts +40 -40
  31. package/serializer/mysqlSchema.d.ts +616 -1854
  32. package/serializer/mysqlSerializer.d.ts +2 -2
  33. package/serializer/pgSchema.d.ts +684 -1009
  34. package/serializer/sqliteSchema.d.ts +570 -144
  35. package/serializer/sqliteSerializer.d.ts +2 -2
  36. package/snapshotsDiffer.d.ts +20 -24
  37. package/utils-studio.js +8 -21
  38. package/utils-studio.mjs +8 -20
  39. package/utils.d.ts +12 -12
  40. package/utils.js +735 -849
  41. package/utils.mjs +736 -849
  42. package/cli/validations/cli.d.ts +0 -104
  43. package/cli/validations/sqlite.d.ts +0 -382
package/serializer/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>;