drizzle-kit 0.20.14-1ebe0ff → 0.20.14-1f99bf7

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 (54) hide show
  1. package/bin.cjs +46606 -46728
  2. package/cli/commands/migrate.d.ts +24 -24
  3. package/cli/commands/mysqlIntrospect.d.ts +119 -0
  4. package/cli/commands/mysqlPushUtils.d.ts +18 -0
  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 +21 -0
  12. package/cli/commands/upFolders.d.ts +1 -1
  13. package/cli/commands/utils.d.ts +14 -259
  14. package/cli/validations/cli.d.ts +104 -0
  15. package/cli/validations/common.d.ts +205 -7
  16. package/cli/validations/mysql.d.ts +6 -1
  17. package/cli/validations/pg.d.ts +6 -1
  18. package/cli/validations/sqlite.d.ts +165 -3
  19. package/cli/views.d.ts +1 -1
  20. package/drivers/index.d.ts +14 -0
  21. package/global.d.ts +2 -1
  22. package/index.d.mts +8 -6
  23. package/index.d.ts +8 -6
  24. package/index.js +1 -0
  25. package/introspect-mysql.d.ts +9 -0
  26. package/introspect-pg.d.ts +1 -1
  27. package/introspect-sqlite.d.ts +1 -1
  28. package/jsonStatements.d.ts +1 -1
  29. package/package.json +17 -4
  30. package/payload.d.mts +33 -0
  31. package/payload.d.ts +33 -0
  32. package/payload.js +37106 -0
  33. package/payload.mjs +37124 -0
  34. package/schemaValidator.d.ts +40 -40
  35. package/serializer/mysqlImports.d.ts +5 -0
  36. package/serializer/mysqlSchema.d.ts +1991 -753
  37. package/serializer/mysqlSerializer.d.ts +4 -4
  38. package/serializer/pgSchema.d.ts +1113 -788
  39. package/serializer/sqliteImports.d.ts +4 -0
  40. package/serializer/sqliteSchema.d.ts +144 -570
  41. package/serializer/sqliteSerializer.d.ts +2 -2
  42. package/snapshotsDiffer.d.ts +24 -20
  43. package/utils-studio.js +21 -8
  44. package/utils-studio.mjs +20 -8
  45. package/utils.d.ts +13 -27
  46. package/utils.js +3080 -54201
  47. package/utils.mjs +8175 -0
  48. package/cli/commands/sqliteUtils.d.ts +0 -162
  49. package/cli/utils.d.ts +0 -12
  50. package/cli/validations/studio.d.ts +0 -593
  51. package/orm-extenstions/d1-driver/driver.d.ts +0 -8
  52. package/orm-extenstions/d1-driver/session.d.ts +0 -51
  53. package/orm-extenstions/d1-driver/wrangler-client.d.ts +0 -3
  54. package/serializer/studioUtils.d.ts +0 -65
@@ -104,7 +104,6 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
104
104
  values: Record<string, string>;
105
105
  }>>;
106
106
  }, "strict", import("zod").ZodTypeAny, {
107
- version: "2";
108
107
  tables: Record<string, {
109
108
  name: string;
110
109
  columns: Record<string, {
@@ -123,12 +122,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
123
122
  isUnique: boolean;
124
123
  }>;
125
124
  }>;
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";
132
131
  tables: Record<string, {
133
132
  name: string;
134
133
  columns: Record<string, {
@@ -147,6 +146,7 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
147
146
  isUnique: boolean;
148
147
  }>;
149
148
  }>;
149
+ version: "2";
150
150
  enums: Record<string, {
151
151
  name: string;
152
152
  values: Record<string, string>;
@@ -289,7 +289,6 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
289
289
  values: Record<string, string>;
290
290
  }>>;
291
291
  }, "strict", import("zod").ZodTypeAny, {
292
- version: "1";
293
292
  tables: Record<string, {
294
293
  name: string;
295
294
  columns: Record<string, {
@@ -314,12 +313,12 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
314
313
  isUnique: boolean;
315
314
  }>;
316
315
  }>;
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";
323
322
  tables: Record<string, {
324
323
  name: string;
325
324
  columns: Record<string, {
@@ -344,6 +343,7 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
344
343
  isUnique: boolean;
345
344
  }>;
346
345
  }>;
346
+ version: "1";
347
347
  enums: Record<string, {
348
348
  name: string;
349
349
  values: Record<string, string>;
@@ -866,6 +866,51 @@ 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
+ }>>;
869
914
  export declare const pgSchemaInternalV3: import("zod").ZodObject<{
870
915
  version: import("zod").ZodLiteral<"3">;
871
916
  dialect: import("zod").ZodLiteral<"pg">;
@@ -1006,8 +1051,6 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1006
1051
  values: Record<string, string>;
1007
1052
  }>>;
1008
1053
  }, "strict", import("zod").ZodTypeAny, {
1009
- version: "3";
1010
- dialect: "pg";
1011
1054
  tables: Record<string, {
1012
1055
  name: string;
1013
1056
  columns: Record<string, {
@@ -1036,13 +1079,13 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1036
1079
  columnsTo: string[];
1037
1080
  }>;
1038
1081
  }>;
1082
+ version: "3";
1083
+ dialect: "pg";
1039
1084
  enums: Record<string, {
1040
1085
  name: string;
1041
1086
  values: Record<string, string>;
1042
1087
  }>;
1043
1088
  }, {
1044
- version: "3";
1045
- dialect: "pg";
1046
1089
  tables: Record<string, {
1047
1090
  name: string;
1048
1091
  columns: Record<string, {
@@ -1071,6 +1114,8 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1071
1114
  columnsTo: string[];
1072
1115
  }>;
1073
1116
  }>;
1117
+ version: "3";
1118
+ dialect: "pg";
1074
1119
  enums: Record<string, {
1075
1120
  name: string;
1076
1121
  values: Record<string, string>;
@@ -1220,8 +1265,6 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1220
1265
  }>>;
1221
1266
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1222
1267
  }, "strict", import("zod").ZodTypeAny, {
1223
- version: "4";
1224
- dialect: "pg";
1225
1268
  tables: Record<string, {
1226
1269
  name: string;
1227
1270
  columns: Record<string, {
@@ -1251,14 +1294,14 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1251
1294
  }>;
1252
1295
  schema: string;
1253
1296
  }>;
1297
+ version: "4";
1298
+ dialect: "pg";
1254
1299
  schemas: Record<string, string>;
1255
1300
  enums: Record<string, {
1256
1301
  name: string;
1257
1302
  values: Record<string, string>;
1258
1303
  }>;
1259
1304
  }, {
1260
- version: "4";
1261
- dialect: "pg";
1262
1305
  tables: Record<string, {
1263
1306
  name: string;
1264
1307
  columns: Record<string, {
@@ -1288,16 +1331,18 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1288
1331
  }>;
1289
1332
  schema: string;
1290
1333
  }>;
1334
+ version: "4";
1335
+ dialect: "pg";
1291
1336
  schemas: Record<string, string>;
1292
1337
  enums: Record<string, {
1293
1338
  name: string;
1294
1339
  values: Record<string, string>;
1295
1340
  }>;
1296
1341
  }>;
1297
- export declare const pgSchemaExternal: import("zod").ZodObject<{
1342
+ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1298
1343
  version: import("zod").ZodLiteral<"5">;
1299
1344
  dialect: import("zod").ZodLiteral<"pg">;
1300
- tables: import("zod").ZodArray<import("zod").ZodObject<{
1345
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1301
1346
  name: import("zod").ZodString;
1302
1347
  schema: import("zod").ZodString;
1303
1348
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1466,8 +1511,8 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1466
1511
  name: string;
1467
1512
  columns: string[];
1468
1513
  }>;
1469
- }>, "many">;
1470
- enums: import("zod").ZodArray<import("zod").ZodObject<{
1514
+ }>>;
1515
+ enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1471
1516
  name: import("zod").ZodString;
1472
1517
  values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1473
1518
  }, "strict", import("zod").ZodTypeAny, {
@@ -1476,14 +1521,8 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1476
1521
  }, {
1477
1522
  name: string;
1478
1523
  values: Record<string, string>;
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">;
1524
+ }>>;
1525
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1487
1526
  _meta: import("zod").ZodObject<{
1488
1527
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1489
1528
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -1497,10 +1536,62 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1497
1536
  tables: Record<string, string>;
1498
1537
  schemas: Record<string, string>;
1499
1538
  }>;
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
+ }>>;
1500
1584
  }, "strict", import("zod").ZodTypeAny, {
1501
- version: "5";
1502
- dialect: "pg";
1503
- tables: {
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, {
1504
1595
  name: string;
1505
1596
  columns: Record<string, {
1506
1597
  isUnique?: any;
@@ -1537,23 +1628,30 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1537
1628
  columns: string[];
1538
1629
  nullsNotDistinct: boolean;
1539
1630
  }>;
1540
- }[];
1541
- schemas: {
1542
- name: string;
1543
- }[];
1631
+ }>;
1632
+ version: "5";
1633
+ dialect: "pg";
1634
+ schemas: Record<string, string>;
1544
1635
  _meta: {
1545
1636
  columns: Record<string, string>;
1546
1637
  tables: Record<string, string>;
1547
1638
  schemas: Record<string, string>;
1548
1639
  };
1549
- enums: {
1640
+ enums: Record<string, {
1550
1641
  name: string;
1551
1642
  values: Record<string, string>;
1552
- }[];
1643
+ }>;
1553
1644
  }, {
1554
- version: "5";
1555
- dialect: "pg";
1556
- tables: {
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, {
1557
1655
  uniqueConstraints?: Record<string, {
1558
1656
  name: string;
1559
1657
  columns: string[];
@@ -1590,69 +1688,24 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1590
1688
  name: string;
1591
1689
  columns: string[];
1592
1690
  }>;
1593
- }[];
1594
- schemas: {
1595
- name: string;
1596
- }[];
1691
+ }>;
1692
+ version: "5";
1693
+ dialect: "pg";
1694
+ schemas: Record<string, string>;
1597
1695
  _meta: {
1598
1696
  columns: Record<string, string>;
1599
1697
  tables: Record<string, string>;
1600
1698
  schemas: Record<string, string>;
1601
1699
  };
1602
- enums: {
1700
+ enums: Record<string, {
1603
1701
  name: string;
1604
1702
  values: Record<string, string>;
1605
- }[];
1703
+ }>;
1606
1704
  }>;
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<{
1705
+ export declare const pgSchemaExternal: import("zod").ZodObject<{
1653
1706
  version: import("zod").ZodLiteral<"5">;
1654
1707
  dialect: import("zod").ZodLiteral<"pg">;
1655
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1708
+ tables: import("zod").ZodArray<import("zod").ZodObject<{
1656
1709
  name: import("zod").ZodString;
1657
1710
  schema: import("zod").ZodString;
1658
1711
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1821,8 +1874,8 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
1821
1874
  name: string;
1822
1875
  columns: string[];
1823
1876
  }>;
1824
- }>>;
1825
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1877
+ }>, "many">;
1878
+ enums: import("zod").ZodArray<import("zod").ZodObject<{
1826
1879
  name: import("zod").ZodString;
1827
1880
  values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1828
1881
  }, "strict", import("zod").ZodTypeAny, {
@@ -1831,8 +1884,14 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
1831
1884
  }, {
1832
1885
  name: string;
1833
1886
  values: Record<string, string>;
1834
- }>>;
1835
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
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">;
1836
1895
  _meta: import("zod").ZodObject<{
1837
1896
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1838
1897
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -1846,64 +1905,8 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
1846
1905
  tables: Record<string, string>;
1847
1906
  schemas: Record<string, string>;
1848
1907
  }>;
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
1908
  }, "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, {
1909
+ tables: {
1907
1910
  name: string;
1908
1911
  columns: Record<string, {
1909
1912
  isUnique?: any;
@@ -1940,30 +1943,23 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
1940
1943
  columns: string[];
1941
1944
  nullsNotDistinct: boolean;
1942
1945
  }>;
1943
- }>;
1944
- schemas: Record<string, string>;
1946
+ }[];
1947
+ version: "5";
1948
+ dialect: "pg";
1949
+ schemas: {
1950
+ name: string;
1951
+ }[];
1945
1952
  _meta: {
1946
1953
  columns: Record<string, string>;
1947
1954
  tables: Record<string, string>;
1948
1955
  schemas: Record<string, string>;
1949
1956
  };
1950
- enums: Record<string, {
1957
+ enums: {
1951
1958
  name: string;
1952
1959
  values: Record<string, string>;
1953
- }>;
1960
+ }[];
1954
1961
  }, {
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, {
1962
+ tables: {
1967
1963
  uniqueConstraints?: Record<string, {
1968
1964
  name: string;
1969
1965
  columns: string[];
@@ -2000,21 +1996,25 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2000
1996
  name: string;
2001
1997
  columns: string[];
2002
1998
  }>;
2003
- }>;
2004
- schemas: Record<string, string>;
1999
+ }[];
2000
+ version: "5";
2001
+ dialect: "pg";
2002
+ schemas: {
2003
+ name: string;
2004
+ }[];
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: Record<string, {
2010
+ enums: {
2011
2011
  name: string;
2012
2012
  values: Record<string, string>;
2013
- }>;
2013
+ }[];
2014
2014
  }>;
2015
- export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2016
- version: import("zod").ZodLiteral<"4">;
2017
- dialect: import("zod").ZodEnum<["pg"]>;
2015
+ export declare const pgSchemaInternal: import("zod").ZodObject<{
2016
+ version: import("zod").ZodLiteral<"6">;
2017
+ dialect: import("zod").ZodLiteral<"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,8 +2046,70 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2046
2046
  primaryKey: boolean;
2047
2047
  notNull: boolean;
2048
2048
  }>>;
2049
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2050
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
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
+ }>>>;
2051
2113
  }, "strict", import("zod").ZodTypeAny, {
2052
2114
  name: string;
2053
2115
  columns: Record<string, {
@@ -2060,10 +2122,37 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2060
2122
  primaryKey: boolean;
2061
2123
  notNull: boolean;
2062
2124
  }>;
2063
- indexes: Record<string, string>;
2064
- foreignKeys: Record<string, string>;
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
+ }>;
2065
2140
  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
+ }>;
2066
2150
  }, {
2151
+ uniqueConstraints?: Record<string, {
2152
+ name: string;
2153
+ columns: string[];
2154
+ nullsNotDistinct: boolean;
2155
+ }> | undefined;
2067
2156
  name: string;
2068
2157
  columns: Record<string, {
2069
2158
  isUnique?: any;
@@ -2075,9 +2164,26 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2075
2164
  primaryKey: boolean;
2076
2165
  notNull: boolean;
2077
2166
  }>;
2078
- indexes: Record<string, string>;
2079
- foreignKeys: Record<string, string>;
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
+ }>;
2080
2182
  schema: string;
2183
+ compositePrimaryKeys: Record<string, {
2184
+ name: string;
2185
+ columns: string[];
2186
+ }>;
2081
2187
  }>>;
2082
2188
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2083
2189
  name: import("zod").ZodString;
@@ -2090,57 +2196,187 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2090
2196
  values: Record<string, string>;
2091
2197
  }>>;
2092
2198
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2093
- }, "strict", import("zod").ZodTypeAny, {
2094
- version: "4";
2095
- dialect: "pg";
2096
- tables: Record<string, {
2097
- name: string;
2098
- columns: Record<string, {
2099
- isUnique?: any;
2100
- default?: any;
2101
- uniqueName?: string | undefined;
2102
- nullsNotDistinct?: boolean | undefined;
2103
- name: string;
2104
- type: string;
2105
- primaryKey: boolean;
2106
- notNull: boolean;
2107
- }>;
2108
- indexes: Record<string, string>;
2109
- foreignKeys: Record<string, string>;
2110
- schema: string;
2111
- }>;
2112
- schemas: Record<string, string>;
2113
- enums: Record<string, {
2114
- name: string;
2115
- values: Record<string, string>;
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>;
2116
2211
  }>;
2117
- }, {
2118
- version: "4";
2119
- dialect: "pg";
2120
- tables: Record<string, {
2121
- name: string;
2122
- columns: Record<string, {
2123
- isUnique?: any;
2124
- default?: any;
2125
- uniqueName?: string | undefined;
2126
- nullsNotDistinct?: boolean | undefined;
2127
- name: string;
2128
- type: string;
2129
- primaryKey: boolean;
2130
- notNull: boolean;
2131
- }>;
2132
- indexes: Record<string, string>;
2133
- foreignKeys: Record<string, string>;
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
+ }, "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
+ }>;
2134
2359
  schema: string;
2360
+ compositePrimaryKeys: Record<string, {
2361
+ name: string;
2362
+ columns: string[];
2363
+ }>;
2135
2364
  }>;
2365
+ version: "6";
2366
+ dialect: "pg";
2136
2367
  schemas: Record<string, string>;
2368
+ _meta: {
2369
+ columns: Record<string, string>;
2370
+ tables: Record<string, string>;
2371
+ schemas: Record<string, string>;
2372
+ };
2137
2373
  enums: Record<string, {
2138
2374
  name: string;
2139
2375
  values: Record<string, string>;
2140
2376
  }>;
2141
2377
  }>;
2142
- export declare const pgSchemaSquashed: import("zod").ZodObject<{
2143
- version: import("zod").ZodLiteral<"5">;
2378
+ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2379
+ version: import("zod").ZodLiteral<"4">;
2144
2380
  dialect: import("zod").ZodEnum<["pg"]>;
2145
2381
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2146
2382
  name: import("zod").ZodString;
@@ -2175,8 +2411,6 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2175
2411
  }>>;
2176
2412
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2177
2413
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2178
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2179
- uniqueConstraints: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2180
2414
  }, "strict", import("zod").ZodTypeAny, {
2181
2415
  name: string;
2182
2416
  columns: Record<string, {
@@ -2192,8 +2426,6 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2192
2426
  indexes: Record<string, string>;
2193
2427
  foreignKeys: Record<string, string>;
2194
2428
  schema: string;
2195
- compositePrimaryKeys: Record<string, string>;
2196
- uniqueConstraints: Record<string, string>;
2197
2429
  }, {
2198
2430
  name: string;
2199
2431
  columns: Record<string, {
@@ -2209,8 +2441,6 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2209
2441
  indexes: Record<string, string>;
2210
2442
  foreignKeys: Record<string, string>;
2211
2443
  schema: string;
2212
- compositePrimaryKeys: Record<string, string>;
2213
- uniqueConstraints: Record<string, string>;
2214
2444
  }>>;
2215
2445
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2216
2446
  name: import("zod").ZodString;
@@ -2224,8 +2454,6 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2224
2454
  }>>;
2225
2455
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2226
2456
  }, "strict", import("zod").ZodTypeAny, {
2227
- version: "5";
2228
- dialect: "pg";
2229
2457
  tables: Record<string, {
2230
2458
  name: string;
2231
2459
  columns: Record<string, {
@@ -2241,17 +2469,15 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2241
2469
  indexes: Record<string, string>;
2242
2470
  foreignKeys: Record<string, string>;
2243
2471
  schema: string;
2244
- compositePrimaryKeys: Record<string, string>;
2245
- uniqueConstraints: Record<string, string>;
2246
2472
  }>;
2473
+ version: "4";
2474
+ dialect: "pg";
2247
2475
  schemas: Record<string, string>;
2248
2476
  enums: Record<string, {
2249
2477
  name: string;
2250
2478
  values: Record<string, string>;
2251
2479
  }>;
2252
2480
  }, {
2253
- version: "5";
2254
- dialect: "pg";
2255
2481
  tables: Record<string, {
2256
2482
  name: string;
2257
2483
  columns: Record<string, {
@@ -2267,20 +2493,21 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2267
2493
  indexes: Record<string, string>;
2268
2494
  foreignKeys: Record<string, string>;
2269
2495
  schema: string;
2270
- compositePrimaryKeys: Record<string, string>;
2271
- uniqueConstraints: Record<string, string>;
2272
2496
  }>;
2497
+ version: "4";
2498
+ dialect: "pg";
2273
2499
  schemas: Record<string, string>;
2274
2500
  enums: Record<string, {
2275
2501
  name: string;
2276
2502
  values: Record<string, string>;
2277
2503
  }>;
2278
2504
  }>;
2279
- export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
2280
- version: import("zod").ZodLiteral<"3">;
2281
- dialect: import("zod").ZodLiteral<"pg">;
2505
+ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2506
+ version: import("zod").ZodLiteral<"6">;
2507
+ dialect: import("zod").ZodEnum<["pg"]>;
2282
2508
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2283
2509
  name: import("zod").ZodString;
2510
+ schema: import("zod").ZodString;
2284
2511
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2285
2512
  name: import("zod").ZodString;
2286
2513
  type: import("zod").ZodString;
@@ -2309,47 +2536,10 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2309
2536
  primaryKey: boolean;
2310
2537
  notNull: boolean;
2311
2538
  }>>;
2312
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2313
- name: import("zod").ZodString;
2314
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2315
- isUnique: import("zod").ZodBoolean;
2316
- }, "strict", import("zod").ZodTypeAny, {
2317
- name: string;
2318
- columns: string[];
2319
- isUnique: boolean;
2320
- }, {
2321
- name: string;
2322
- columns: string[];
2323
- isUnique: boolean;
2324
- }>>;
2325
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2326
- name: import("zod").ZodString;
2327
- tableFrom: import("zod").ZodString;
2328
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2329
- tableTo: import("zod").ZodString;
2330
- schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
2331
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2332
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2333
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2334
- }, "strict", import("zod").ZodTypeAny, {
2335
- onUpdate?: string | undefined;
2336
- onDelete?: string | undefined;
2337
- schemaTo?: string | undefined;
2338
- name: string;
2339
- tableFrom: string;
2340
- columnsFrom: string[];
2341
- tableTo: string;
2342
- columnsTo: string[];
2343
- }, {
2344
- onUpdate?: string | undefined;
2345
- onDelete?: string | undefined;
2346
- schemaTo?: string | undefined;
2347
- name: string;
2348
- tableFrom: string;
2349
- columnsFrom: string[];
2350
- tableTo: string;
2351
- columnsTo: string[];
2352
- }>>;
2539
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2540
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2541
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2542
+ uniqueConstraints: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2353
2543
  }, "strict", import("zod").ZodTypeAny, {
2354
2544
  name: string;
2355
2545
  columns: Record<string, {
@@ -2362,21 +2552,11 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2362
2552
  primaryKey: boolean;
2363
2553
  notNull: boolean;
2364
2554
  }>;
2365
- indexes: Record<string, {
2366
- name: string;
2367
- columns: string[];
2368
- isUnique: boolean;
2369
- }>;
2370
- foreignKeys: Record<string, {
2371
- onUpdate?: string | undefined;
2372
- onDelete?: string | undefined;
2373
- schemaTo?: string | undefined;
2374
- name: string;
2375
- tableFrom: string;
2376
- columnsFrom: string[];
2377
- tableTo: string;
2378
- columnsTo: string[];
2379
- }>;
2555
+ indexes: Record<string, string>;
2556
+ foreignKeys: Record<string, string>;
2557
+ schema: string;
2558
+ compositePrimaryKeys: Record<string, string>;
2559
+ uniqueConstraints: Record<string, string>;
2380
2560
  }, {
2381
2561
  name: string;
2382
2562
  columns: Record<string, {
@@ -2389,11 +2569,194 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2389
2569
  primaryKey: boolean;
2390
2570
  notNull: boolean;
2391
2571
  }>;
2392
- indexes: Record<string, {
2393
- name: string;
2394
- columns: string[];
2395
- isUnique: boolean;
2396
- }>;
2572
+ indexes: Record<string, string>;
2573
+ foreignKeys: Record<string, string>;
2574
+ schema: string;
2575
+ compositePrimaryKeys: Record<string, string>;
2576
+ uniqueConstraints: Record<string, string>;
2577
+ }>>;
2578
+ enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2579
+ name: import("zod").ZodString;
2580
+ values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2581
+ }, "strict", import("zod").ZodTypeAny, {
2582
+ name: string;
2583
+ values: Record<string, string>;
2584
+ }, {
2585
+ name: string;
2586
+ values: Record<string, string>;
2587
+ }>>;
2588
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2589
+ }, "strict", import("zod").ZodTypeAny, {
2590
+ tables: Record<string, {
2591
+ name: string;
2592
+ columns: Record<string, {
2593
+ isUnique?: any;
2594
+ default?: any;
2595
+ uniqueName?: string | undefined;
2596
+ nullsNotDistinct?: boolean | undefined;
2597
+ name: string;
2598
+ type: string;
2599
+ primaryKey: boolean;
2600
+ notNull: boolean;
2601
+ }>;
2602
+ indexes: Record<string, string>;
2603
+ foreignKeys: Record<string, string>;
2604
+ schema: string;
2605
+ compositePrimaryKeys: Record<string, string>;
2606
+ uniqueConstraints: Record<string, string>;
2607
+ }>;
2608
+ version: "6";
2609
+ dialect: "pg";
2610
+ schemas: Record<string, string>;
2611
+ enums: Record<string, {
2612
+ name: string;
2613
+ values: Record<string, string>;
2614
+ }>;
2615
+ }, {
2616
+ tables: Record<string, {
2617
+ name: string;
2618
+ columns: Record<string, {
2619
+ isUnique?: any;
2620
+ default?: any;
2621
+ uniqueName?: string | undefined;
2622
+ nullsNotDistinct?: boolean | undefined;
2623
+ name: string;
2624
+ type: string;
2625
+ primaryKey: boolean;
2626
+ notNull: boolean;
2627
+ }>;
2628
+ indexes: Record<string, string>;
2629
+ foreignKeys: Record<string, string>;
2630
+ schema: string;
2631
+ compositePrimaryKeys: Record<string, string>;
2632
+ uniqueConstraints: Record<string, string>;
2633
+ }>;
2634
+ version: "6";
2635
+ dialect: "pg";
2636
+ schemas: Record<string, string>;
2637
+ enums: Record<string, {
2638
+ name: string;
2639
+ values: Record<string, string>;
2640
+ }>;
2641
+ }>;
2642
+ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
2643
+ version: import("zod").ZodLiteral<"3">;
2644
+ dialect: import("zod").ZodLiteral<"pg">;
2645
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2646
+ name: import("zod").ZodString;
2647
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2648
+ name: import("zod").ZodString;
2649
+ type: import("zod").ZodString;
2650
+ primaryKey: import("zod").ZodBoolean;
2651
+ notNull: import("zod").ZodBoolean;
2652
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2653
+ isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
2654
+ uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2655
+ nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2656
+ }, "strict", import("zod").ZodTypeAny, {
2657
+ isUnique?: any;
2658
+ default?: any;
2659
+ uniqueName?: string | undefined;
2660
+ nullsNotDistinct?: boolean | undefined;
2661
+ name: string;
2662
+ type: string;
2663
+ primaryKey: boolean;
2664
+ notNull: boolean;
2665
+ }, {
2666
+ isUnique?: any;
2667
+ default?: any;
2668
+ uniqueName?: string | undefined;
2669
+ nullsNotDistinct?: boolean | undefined;
2670
+ name: string;
2671
+ type: string;
2672
+ primaryKey: boolean;
2673
+ notNull: boolean;
2674
+ }>>;
2675
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2676
+ name: import("zod").ZodString;
2677
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2678
+ isUnique: import("zod").ZodBoolean;
2679
+ }, "strict", import("zod").ZodTypeAny, {
2680
+ name: string;
2681
+ columns: string[];
2682
+ isUnique: boolean;
2683
+ }, {
2684
+ name: string;
2685
+ columns: string[];
2686
+ isUnique: boolean;
2687
+ }>>;
2688
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2689
+ name: import("zod").ZodString;
2690
+ tableFrom: import("zod").ZodString;
2691
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2692
+ tableTo: import("zod").ZodString;
2693
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
2694
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2695
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2696
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2697
+ }, "strict", import("zod").ZodTypeAny, {
2698
+ onUpdate?: string | undefined;
2699
+ onDelete?: string | undefined;
2700
+ schemaTo?: string | undefined;
2701
+ name: string;
2702
+ tableFrom: string;
2703
+ columnsFrom: string[];
2704
+ tableTo: string;
2705
+ columnsTo: string[];
2706
+ }, {
2707
+ onUpdate?: string | undefined;
2708
+ onDelete?: string | undefined;
2709
+ schemaTo?: string | undefined;
2710
+ name: string;
2711
+ tableFrom: string;
2712
+ columnsFrom: string[];
2713
+ tableTo: string;
2714
+ columnsTo: string[];
2715
+ }>>;
2716
+ }, "strict", import("zod").ZodTypeAny, {
2717
+ name: string;
2718
+ columns: Record<string, {
2719
+ isUnique?: any;
2720
+ default?: any;
2721
+ uniqueName?: string | undefined;
2722
+ nullsNotDistinct?: boolean | undefined;
2723
+ name: string;
2724
+ type: string;
2725
+ primaryKey: boolean;
2726
+ notNull: boolean;
2727
+ }>;
2728
+ indexes: Record<string, {
2729
+ name: string;
2730
+ columns: string[];
2731
+ isUnique: boolean;
2732
+ }>;
2733
+ foreignKeys: Record<string, {
2734
+ onUpdate?: string | undefined;
2735
+ onDelete?: string | undefined;
2736
+ schemaTo?: string | undefined;
2737
+ name: string;
2738
+ tableFrom: string;
2739
+ columnsFrom: string[];
2740
+ tableTo: string;
2741
+ columnsTo: string[];
2742
+ }>;
2743
+ }, {
2744
+ name: string;
2745
+ columns: Record<string, {
2746
+ isUnique?: any;
2747
+ default?: any;
2748
+ uniqueName?: string | undefined;
2749
+ nullsNotDistinct?: boolean | undefined;
2750
+ name: string;
2751
+ type: string;
2752
+ primaryKey: boolean;
2753
+ notNull: boolean;
2754
+ }>;
2755
+ indexes: Record<string, {
2756
+ name: string;
2757
+ columns: string[];
2758
+ isUnique: boolean;
2759
+ }>;
2397
2760
  foreignKeys: Record<string, {
2398
2761
  onUpdate?: string | undefined;
2399
2762
  onDelete?: string | undefined;
@@ -2419,10 +2782,6 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2419
2782
  id: import("zod").ZodString;
2420
2783
  prevId: import("zod").ZodString;
2421
2784
  }>, "strip", import("zod").ZodTypeAny, {
2422
- id: string;
2423
- prevId: string;
2424
- version: "3";
2425
- dialect: "pg";
2426
2785
  tables: Record<string, {
2427
2786
  name: string;
2428
2787
  columns: Record<string, {
@@ -2451,15 +2810,15 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2451
2810
  columnsTo: string[];
2452
2811
  }>;
2453
2812
  }>;
2813
+ id: string;
2814
+ prevId: string;
2815
+ version: "3";
2816
+ dialect: "pg";
2454
2817
  enums: Record<string, {
2455
2818
  name: string;
2456
2819
  values: Record<string, string>;
2457
2820
  }>;
2458
2821
  }, {
2459
- id: string;
2460
- prevId: string;
2461
- version: "3";
2462
- dialect: "pg";
2463
2822
  tables: Record<string, {
2464
2823
  name: string;
2465
2824
  columns: Record<string, {
@@ -2488,6 +2847,10 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2488
2847
  columnsTo: string[];
2489
2848
  }>;
2490
2849
  }>;
2850
+ id: string;
2851
+ prevId: string;
2852
+ version: "3";
2853
+ dialect: "pg";
2491
2854
  enums: Record<string, {
2492
2855
  name: string;
2493
2856
  values: Record<string, string>;
@@ -2640,10 +3003,6 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
2640
3003
  id: import("zod").ZodString;
2641
3004
  prevId: import("zod").ZodString;
2642
3005
  }>, "strip", import("zod").ZodTypeAny, {
2643
- id: string;
2644
- prevId: string;
2645
- version: "4";
2646
- dialect: "pg";
2647
3006
  tables: Record<string, {
2648
3007
  name: string;
2649
3008
  columns: Record<string, {
@@ -2673,16 +3032,16 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
2673
3032
  }>;
2674
3033
  schema: string;
2675
3034
  }>;
3035
+ id: string;
3036
+ prevId: string;
3037
+ version: "4";
3038
+ dialect: "pg";
2676
3039
  schemas: Record<string, string>;
2677
3040
  enums: Record<string, {
2678
3041
  name: string;
2679
3042
  values: Record<string, string>;
2680
3043
  }>;
2681
3044
  }, {
2682
- id: string;
2683
- prevId: string;
2684
- version: "4";
2685
- dialect: "pg";
2686
3045
  tables: Record<string, {
2687
3046
  name: string;
2688
3047
  columns: Record<string, {
@@ -2712,13 +3071,17 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
2712
3071
  }>;
2713
3072
  schema: string;
2714
3073
  }>;
3074
+ id: string;
3075
+ prevId: string;
3076
+ version: "4";
3077
+ dialect: "pg";
2715
3078
  schemas: Record<string, string>;
2716
3079
  enums: Record<string, {
2717
3080
  name: string;
2718
3081
  values: Record<string, string>;
2719
3082
  }>;
2720
3083
  }>;
2721
- export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
3084
+ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
2722
3085
  version: import("zod").ZodLiteral<"5">;
2723
3086
  dialect: import("zod").ZodLiteral<"pg">;
2724
3087
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2968,395 +3331,18 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
2968
3331
  tables: Record<string, {
2969
3332
  columns: Record<string, {
2970
3333
  isArray?: boolean | undefined;
2971
- dimensions?: number | undefined;
2972
- rawType?: string | undefined;
2973
- } | undefined>;
2974
- } | undefined>;
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";
3248
- tables: Record<string, {
3249
- name: string;
3250
- columns: Record<string, {
3251
- default?: any;
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, {
3334
+ dimensions?: number | undefined;
3335
+ rawType?: string | undefined;
3336
+ } | undefined>;
3337
+ } | undefined>;
3338
+ } | undefined;
3339
+ tables: Record<string, {
3356
3340
  name: string;
3357
3341
  columns: Record<string, {
3342
+ isUnique?: any;
3358
3343
  default?: any;
3359
- references?: string | undefined;
3344
+ uniqueName?: string | undefined;
3345
+ nullsNotDistinct?: boolean | undefined;
3360
3346
  name: string;
3361
3347
  type: string;
3362
3348
  primaryKey: boolean;
@@ -3364,70 +3350,66 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3364
3350
  }>;
3365
3351
  indexes: Record<string, {
3366
3352
  name: string;
3367
- columns: Record<string, {
3368
- name: string;
3369
- }>;
3353
+ columns: string[];
3370
3354
  isUnique: boolean;
3371
3355
  }>;
3372
- }, {
3373
- name: string;
3374
- columns: Record<string, {
3375
- default?: any;
3376
- references?: string | undefined;
3377
- name: string;
3378
- type: string;
3379
- primaryKey: boolean;
3380
- notNull: boolean;
3381
- }>;
3382
- indexes: Record<string, {
3356
+ foreignKeys: Record<string, {
3357
+ onUpdate?: string | undefined;
3358
+ onDelete?: string | undefined;
3359
+ schemaTo?: string | undefined;
3383
3360
  name: string;
3384
- columns: Record<string, {
3385
- name: string;
3386
- }>;
3387
- isUnique: boolean;
3361
+ tableFrom: string;
3362
+ columnsFrom: string[];
3363
+ tableTo: string;
3364
+ columnsTo: string[];
3388
3365
  }>;
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;
3366
+ schema: string;
3367
+ compositePrimaryKeys: Record<string, {
3407
3368
  name: string;
3408
- type: string;
3409
- primaryKey: boolean;
3410
- notNull: boolean;
3369
+ columns: string[];
3411
3370
  }>;
3412
- indexes: Record<string, {
3371
+ uniqueConstraints: Record<string, {
3413
3372
  name: string;
3414
- columns: Record<string, {
3415
- name: string;
3416
- }>;
3417
- isUnique: boolean;
3373
+ columns: string[];
3374
+ nullsNotDistinct: boolean;
3418
3375
  }>;
3419
3376
  }>;
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
+ };
3420
3387
  enums: Record<string, {
3421
3388
  name: string;
3422
3389
  values: Record<string, string>;
3423
3390
  }>;
3424
3391
  }, {
3425
- version: "2";
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;
3426
3401
  tables: Record<string, {
3402
+ uniqueConstraints?: Record<string, {
3403
+ name: string;
3404
+ columns: string[];
3405
+ nullsNotDistinct: boolean;
3406
+ }> | undefined;
3427
3407
  name: string;
3428
3408
  columns: Record<string, {
3409
+ isUnique?: any;
3429
3410
  default?: any;
3430
- references?: string | undefined;
3411
+ uniqueName?: string | undefined;
3412
+ nullsNotDistinct?: boolean | undefined;
3431
3413
  name: string;
3432
3414
  type: string;
3433
3415
  primaryKey: boolean;
@@ -3435,21 +3417,46 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3435
3417
  }>;
3436
3418
  indexes: Record<string, {
3437
3419
  name: string;
3438
- columns: Record<string, {
3439
- name: string;
3440
- }>;
3420
+ columns: string[];
3441
3421
  isUnique: boolean;
3442
3422
  }>;
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
+ }>;
3443
3438
  }>;
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
+ };
3444
3449
  enums: Record<string, {
3445
3450
  name: string;
3446
3451
  values: Record<string, string>;
3447
3452
  }>;
3448
- }>, import("zod").ZodObject<import("zod").extendShape<{
3449
- version: import("zod").ZodLiteral<"3">;
3453
+ }>;
3454
+ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
3455
+ version: import("zod").ZodLiteral<"6">;
3450
3456
  dialect: import("zod").ZodLiteral<"pg">;
3451
3457
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3452
3458
  name: import("zod").ZodString;
3459
+ schema: import("zod").ZodString;
3453
3460
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3454
3461
  name: import("zod").ZodString;
3455
3462
  type: import("zod").ZodString;
@@ -3519,6 +3526,29 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3519
3526
  tableTo: string;
3520
3527
  columnsTo: string[];
3521
3528
  }>>;
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
+ }>>>;
3522
3552
  }, "strict", import("zod").ZodTypeAny, {
3523
3553
  name: string;
3524
3554
  columns: Record<string, {
@@ -3546,7 +3576,22 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3546
3576
  tableTo: string;
3547
3577
  columnsTo: string[];
3548
3578
  }>;
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
+ }>;
3549
3589
  }, {
3590
+ uniqueConstraints?: Record<string, {
3591
+ name: string;
3592
+ columns: string[];
3593
+ nullsNotDistinct: boolean;
3594
+ }> | undefined;
3550
3595
  name: string;
3551
3596
  columns: Record<string, {
3552
3597
  isUnique?: any;
@@ -3573,6 +3618,11 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3573
3618
  tableTo: string;
3574
3619
  columnsTo: string[];
3575
3620
  }>;
3621
+ schema: string;
3622
+ compositePrimaryKeys: Record<string, {
3623
+ name: string;
3624
+ columns: string[];
3625
+ }>;
3576
3626
  }>>;
3577
3627
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3578
3628
  name: import("zod").ZodString;
@@ -3584,14 +3634,78 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3584
3634
  name: string;
3585
3635
  values: Record<string, string>;
3586
3636
  }>>;
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
+ }>>;
3587
3696
  }, {
3588
3697
  id: import("zod").ZodString;
3589
3698
  prevId: import("zod").ZodString;
3590
3699
  }>, "strip", import("zod").ZodTypeAny, {
3591
- id: string;
3592
- prevId: string;
3593
- version: "3";
3594
- dialect: "pg";
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;
3595
3709
  tables: Record<string, {
3596
3710
  name: string;
3597
3711
  columns: Record<string, {
@@ -3614,22 +3728,52 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3614
3728
  onDelete?: string | undefined;
3615
3729
  schemaTo?: string | undefined;
3616
3730
  name: string;
3617
- tableFrom: string;
3618
- columnsFrom: string[];
3619
- tableTo: string;
3620
- columnsTo: 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, {
3742
+ name: string;
3743
+ columns: string[];
3744
+ nullsNotDistinct: boolean;
3621
3745
  }>;
3622
3746
  }>;
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
+ };
3623
3757
  enums: Record<string, {
3624
3758
  name: string;
3625
3759
  values: Record<string, string>;
3626
3760
  }>;
3627
3761
  }, {
3628
- id: string;
3629
- prevId: string;
3630
- version: "3";
3631
- dialect: "pg";
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;
3632
3771
  tables: Record<string, {
3772
+ uniqueConstraints?: Record<string, {
3773
+ name: string;
3774
+ columns: string[];
3775
+ nullsNotDistinct: boolean;
3776
+ }> | undefined;
3633
3777
  name: string;
3634
3778
  columns: Record<string, {
3635
3779
  isUnique?: any;
@@ -3656,13 +3800,49 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3656
3800
  tableTo: string;
3657
3801
  columnsTo: string[];
3658
3802
  }>;
3803
+ schema: string;
3804
+ compositePrimaryKeys: Record<string, {
3805
+ name: string;
3806
+ columns: string[];
3807
+ }>;
3659
3808
  }>;
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
+ };
3660
3819
  enums: Record<string, {
3661
3820
  name: string;
3662
3821
  values: Record<string, string>;
3663
3822
  }>;
3664
- }>, import("zod").ZodObject<import("zod").extendShape<{
3665
- version: import("zod").ZodLiteral<"4">;
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">;
3666
3846
  dialect: import("zod").ZodLiteral<"pg">;
3667
3847
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3668
3848
  name: import("zod").ZodString;
@@ -3736,6 +3916,29 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3736
3916
  tableTo: string;
3737
3917
  columnsTo: string[];
3738
3918
  }>>;
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
+ }>>>;
3739
3942
  }, "strict", import("zod").ZodTypeAny, {
3740
3943
  name: string;
3741
3944
  columns: Record<string, {
@@ -3764,7 +3967,21 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3764
3967
  columnsTo: string[];
3765
3968
  }>;
3766
3969
  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
+ }>;
3767
3979
  }, {
3980
+ uniqueConstraints?: Record<string, {
3981
+ name: string;
3982
+ columns: string[];
3983
+ nullsNotDistinct: boolean;
3984
+ }> | undefined;
3768
3985
  name: string;
3769
3986
  columns: Record<string, {
3770
3987
  isUnique?: any;
@@ -3792,6 +4009,10 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3792
4009
  columnsTo: string[];
3793
4010
  }>;
3794
4011
  schema: string;
4012
+ compositePrimaryKeys: Record<string, {
4013
+ name: string;
4014
+ columns: string[];
4015
+ }>;
3795
4016
  }>>;
3796
4017
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3797
4018
  name: import("zod").ZodString;
@@ -3804,14 +4025,77 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3804
4025
  values: Record<string, string>;
3805
4026
  }>>;
3806
4027
  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
+ }>>;
3807
4086
  }, {
3808
4087
  id: import("zod").ZodString;
3809
4088
  prevId: import("zod").ZodString;
3810
4089
  }>, "strip", import("zod").ZodTypeAny, {
3811
- id: string;
3812
- prevId: string;
3813
- version: "4";
3814
- dialect: "pg";
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;
3815
4099
  tables: Record<string, {
3816
4100
  name: string;
3817
4101
  columns: Record<string, {
@@ -3840,18 +4124,46 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3840
4124
  columnsTo: string[];
3841
4125
  }>;
3842
4126
  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
+ }>;
3843
4136
  }>;
4137
+ id: string;
4138
+ prevId: string;
4139
+ version: "5";
4140
+ dialect: "pg";
3844
4141
  schemas: Record<string, string>;
4142
+ _meta: {
4143
+ columns: Record<string, string>;
4144
+ tables: Record<string, string>;
4145
+ schemas: Record<string, string>;
4146
+ };
3845
4147
  enums: Record<string, {
3846
4148
  name: string;
3847
4149
  values: Record<string, string>;
3848
4150
  }>;
3849
4151
  }, {
3850
- id: string;
3851
- prevId: string;
3852
- version: "4";
3853
- dialect: "pg";
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;
3854
4161
  tables: Record<string, {
4162
+ uniqueConstraints?: Record<string, {
4163
+ name: string;
4164
+ columns: string[];
4165
+ nullsNotDistinct: boolean;
4166
+ }> | undefined;
3855
4167
  name: string;
3856
4168
  columns: Record<string, {
3857
4169
  isUnique?: any;
@@ -3879,14 +4191,27 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3879
4191
  columnsTo: string[];
3880
4192
  }>;
3881
4193
  schema: string;
4194
+ compositePrimaryKeys: Record<string, {
4195
+ name: string;
4196
+ columns: string[];
4197
+ }>;
3882
4198
  }>;
4199
+ id: string;
4200
+ prevId: string;
4201
+ version: "5";
4202
+ dialect: "pg";
3883
4203
  schemas: Record<string, string>;
4204
+ _meta: {
4205
+ columns: Record<string, string>;
4206
+ tables: Record<string, string>;
4207
+ schemas: Record<string, string>;
4208
+ };
3884
4209
  enums: Record<string, {
3885
4210
  name: string;
3886
4211
  values: Record<string, string>;
3887
4212
  }>;
3888
4213
  }>, import("zod").ZodObject<import("zod").extendShape<{
3889
- version: import("zod").ZodLiteral<"5">;
4214
+ version: import("zod").ZodLiteral<"6">;
3890
4215
  dialect: import("zod").ZodLiteral<"pg">;
3891
4216
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3892
4217
  name: import("zod").ZodString;
@@ -4140,10 +4465,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4140
4465
  } | undefined>;
4141
4466
  } | undefined>;
4142
4467
  } | undefined;
4143
- id: string;
4144
- prevId: string;
4145
- version: "5";
4146
- dialect: "pg";
4147
4468
  tables: Record<string, {
4148
4469
  name: string;
4149
4470
  columns: Record<string, {
@@ -4182,6 +4503,10 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4182
4503
  nullsNotDistinct: boolean;
4183
4504
  }>;
4184
4505
  }>;
4506
+ id: string;
4507
+ prevId: string;
4508
+ version: "6";
4509
+ dialect: "pg";
4185
4510
  schemas: Record<string, string>;
4186
4511
  _meta: {
4187
4512
  columns: Record<string, string>;
@@ -4202,10 +4527,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4202
4527
  } | undefined>;
4203
4528
  } | undefined>;
4204
4529
  } | undefined;
4205
- id: string;
4206
- prevId: string;
4207
- version: "5";
4208
- dialect: "pg";
4209
4530
  tables: Record<string, {
4210
4531
  uniqueConstraints?: Record<string, {
4211
4532
  name: string;
@@ -4244,6 +4565,10 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4244
4565
  columns: string[];
4245
4566
  }>;
4246
4567
  }>;
4568
+ id: string;
4569
+ prevId: string;
4570
+ version: "6";
4571
+ dialect: "pg";
4247
4572
  schemas: Record<string, string>;
4248
4573
  _meta: {
4249
4574
  columns: Record<string, string>;
@@ -4277,10 +4602,6 @@ export declare const dryPg: {
4277
4602
  } | undefined>;
4278
4603
  } | undefined>;
4279
4604
  } | undefined;
4280
- id: string;
4281
- prevId: string;
4282
- version: "5";
4283
- dialect: "pg";
4284
4605
  tables: Record<string, {
4285
4606
  name: string;
4286
4607
  columns: Record<string, {
@@ -4319,6 +4640,10 @@ export declare const dryPg: {
4319
4640
  nullsNotDistinct: boolean;
4320
4641
  }>;
4321
4642
  }>;
4643
+ id: string;
4644
+ prevId: string;
4645
+ version: "6";
4646
+ dialect: "pg";
4322
4647
  schemas: Record<string, string>;
4323
4648
  _meta: {
4324
4649
  columns: Record<string, string>;