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.
- package/bin.cjs +46606 -46728
- package/cli/commands/migrate.d.ts +24 -24
- package/cli/commands/mysqlIntrospect.d.ts +119 -0
- package/cli/commands/mysqlPushUtils.d.ts +18 -0
- package/cli/commands/mysqlUp.d.ts +2 -2
- package/cli/commands/pgConnect.d.ts +1 -1
- package/cli/commands/pgIntrospect.d.ts +9 -9
- package/cli/commands/pgPushUtils.d.ts +2 -2
- package/cli/commands/pgUp.d.ts +2 -2
- package/cli/commands/sqliteIntrospect.d.ts +9 -9
- package/cli/commands/sqlitePushUtils.d.ts +21 -0
- package/cli/commands/upFolders.d.ts +1 -1
- package/cli/commands/utils.d.ts +14 -259
- package/cli/validations/cli.d.ts +104 -0
- package/cli/validations/common.d.ts +205 -7
- package/cli/validations/mysql.d.ts +6 -1
- package/cli/validations/pg.d.ts +6 -1
- package/cli/validations/sqlite.d.ts +165 -3
- package/cli/views.d.ts +1 -1
- package/drivers/index.d.ts +14 -0
- package/global.d.ts +2 -1
- package/index.d.mts +8 -6
- package/index.d.ts +8 -6
- package/index.js +1 -0
- package/introspect-mysql.d.ts +9 -0
- package/introspect-pg.d.ts +1 -1
- package/introspect-sqlite.d.ts +1 -1
- package/jsonStatements.d.ts +1 -1
- package/package.json +17 -4
- package/payload.d.mts +33 -0
- package/payload.d.ts +33 -0
- package/payload.js +37106 -0
- package/payload.mjs +37124 -0
- package/schemaValidator.d.ts +40 -40
- package/serializer/mysqlImports.d.ts +5 -0
- package/serializer/mysqlSchema.d.ts +1991 -753
- package/serializer/mysqlSerializer.d.ts +4 -4
- package/serializer/pgSchema.d.ts +1113 -788
- package/serializer/sqliteImports.d.ts +4 -0
- package/serializer/sqliteSchema.d.ts +144 -570
- package/serializer/sqliteSerializer.d.ts +2 -2
- package/snapshotsDiffer.d.ts +24 -20
- package/utils-studio.js +21 -8
- package/utils-studio.mjs +20 -8
- package/utils.d.ts +13 -27
- package/utils.js +3080 -54201
- package/utils.mjs +8175 -0
- package/cli/commands/sqliteUtils.d.ts +0 -162
- package/cli/utils.d.ts +0 -12
- package/cli/validations/studio.d.ts +0 -593
- package/orm-extenstions/d1-driver/driver.d.ts +0 -8
- package/orm-extenstions/d1-driver/session.d.ts +0 -51
- package/orm-extenstions/d1-driver/wrangler-client.d.ts +0 -3
- package/serializer/studioUtils.d.ts +0 -65
package/serializer/pgSchema.d.ts
CHANGED
@@ -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
|
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").
|
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
|
-
}
|
1470
|
-
enums: import("zod").
|
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
|
-
}
|
1480
|
-
schemas: import("zod").
|
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
|
-
|
1502
|
-
|
1503
|
-
|
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
|
-
|
1542
|
-
|
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
|
-
|
1555
|
-
|
1556
|
-
|
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
|
-
|
1595
|
-
|
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
|
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").
|
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").
|
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").
|
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
|
-
|
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
|
-
|
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:
|
1957
|
+
enums: {
|
1951
1958
|
name: string;
|
1952
1959
|
values: Record<string, string>;
|
1953
|
-
}
|
1960
|
+
}[];
|
1954
1961
|
}, {
|
1955
|
-
|
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
|
-
|
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:
|
2010
|
+
enums: {
|
2011
2011
|
name: string;
|
2012
2012
|
values: Record<string, string>;
|
2013
|
-
}
|
2013
|
+
}[];
|
2014
2014
|
}>;
|
2015
|
-
export declare const
|
2016
|
-
version: import("zod").ZodLiteral<"
|
2017
|
-
dialect: import("zod").
|
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").
|
2050
|
-
|
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,
|
2064
|
-
|
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,
|
2079
|
-
|
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
|
-
|
2094
|
-
|
2095
|
-
|
2096
|
-
|
2097
|
-
|
2098
|
-
columns: Record<string,
|
2099
|
-
|
2100
|
-
|
2101
|
-
|
2102
|
-
|
2103
|
-
|
2104
|
-
|
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
|
-
|
2119
|
-
|
2120
|
-
|
2121
|
-
|
2122
|
-
|
2123
|
-
|
2124
|
-
|
2125
|
-
|
2126
|
-
|
2127
|
-
|
2128
|
-
|
2129
|
-
|
2130
|
-
|
2131
|
-
|
2132
|
-
|
2133
|
-
|
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
|
2143
|
-
version: import("zod").ZodLiteral<"
|
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
|
2280
|
-
version: import("zod").ZodLiteral<"
|
2281
|
-
dialect: import("zod").
|
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").
|
2313
|
-
|
2314
|
-
|
2315
|
-
|
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
|
-
|
2367
|
-
|
2368
|
-
|
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
|
-
|
2394
|
-
|
2395
|
-
|
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
|
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
|
-
|
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
|
-
|
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:
|
3368
|
-
name: string;
|
3369
|
-
}>;
|
3353
|
+
columns: string[];
|
3370
3354
|
isUnique: boolean;
|
3371
3355
|
}>;
|
3372
|
-
|
3373
|
-
|
3374
|
-
|
3375
|
-
|
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
|
-
|
3385
|
-
|
3386
|
-
|
3387
|
-
|
3361
|
+
tableFrom: string;
|
3362
|
+
columnsFrom: string[];
|
3363
|
+
tableTo: string;
|
3364
|
+
columnsTo: string[];
|
3388
3365
|
}>;
|
3389
|
-
|
3390
|
-
|
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
|
-
|
3409
|
-
primaryKey: boolean;
|
3410
|
-
notNull: boolean;
|
3369
|
+
columns: string[];
|
3411
3370
|
}>;
|
3412
|
-
|
3371
|
+
uniqueConstraints: Record<string, {
|
3413
3372
|
name: string;
|
3414
|
-
columns:
|
3415
|
-
|
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
|
-
|
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
|
-
|
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:
|
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
|
-
}
|
3449
|
-
|
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
|
-
|
3592
|
-
|
3593
|
-
|
3594
|
-
|
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
|
-
|
3629
|
-
|
3630
|
-
|
3631
|
-
|
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
|
-
}
|
3665
|
-
|
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
|
-
|
3812
|
-
|
3813
|
-
|
3814
|
-
|
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
|
-
|
3851
|
-
|
3852
|
-
|
3853
|
-
|
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<"
|
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>;
|