alepha 0.7.1 → 0.7.2
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/datetime.d.ts +54 -66
- package/lock.d.ts +1 -12
- package/package.json +21 -28
- package/postgres.d.ts +454 -455
- package/react.d.ts +6 -50
- package/redis.d.ts +10 -8
- package/topic.d.ts +0 -17
- package/vite.d.ts +33 -3
- package/server/proxy.cjs +0 -12
- package/server/proxy.d.ts +0 -1
- package/server/proxy.js +0 -1
- package/src/server/proxy.ts +0 -1
package/postgres.d.ts
CHANGED
|
@@ -19,8 +19,8 @@ import * as zod from 'zod';
|
|
|
19
19
|
import { TypeOf } from 'zod';
|
|
20
20
|
import * as _alepha_lock from '@alepha/lock';
|
|
21
21
|
import { MigrationConfig } from 'drizzle-orm/migrator';
|
|
22
|
-
import {
|
|
23
|
-
import
|
|
22
|
+
import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
|
|
23
|
+
import postgres from 'postgres';
|
|
24
24
|
import { UpdateDeleteAction as UpdateDeleteAction$1 } from 'drizzle-orm/pg-core/foreign-keys';
|
|
25
25
|
|
|
26
26
|
/**
|
|
@@ -1445,29 +1445,29 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1445
1445
|
as: string;
|
|
1446
1446
|
}>>;
|
|
1447
1447
|
}, "strict", zod.ZodTypeAny, {
|
|
1448
|
-
name: string;
|
|
1449
1448
|
type: string;
|
|
1449
|
+
name: string;
|
|
1450
1450
|
primaryKey: boolean;
|
|
1451
1451
|
notNull: boolean;
|
|
1452
1452
|
default?: any;
|
|
1453
|
-
onUpdate?: any;
|
|
1454
|
-
autoincrement?: boolean | undefined;
|
|
1455
1453
|
generated?: {
|
|
1456
1454
|
type: "stored" | "virtual";
|
|
1457
1455
|
as: string;
|
|
1458
1456
|
} | undefined;
|
|
1457
|
+
onUpdate?: any;
|
|
1458
|
+
autoincrement?: boolean | undefined;
|
|
1459
1459
|
}, {
|
|
1460
|
-
name: string;
|
|
1461
1460
|
type: string;
|
|
1461
|
+
name: string;
|
|
1462
1462
|
primaryKey: boolean;
|
|
1463
1463
|
notNull: boolean;
|
|
1464
1464
|
default?: any;
|
|
1465
|
-
onUpdate?: any;
|
|
1466
|
-
autoincrement?: boolean | undefined;
|
|
1467
1465
|
generated?: {
|
|
1468
1466
|
type: "stored" | "virtual";
|
|
1469
1467
|
as: string;
|
|
1470
1468
|
} | undefined;
|
|
1469
|
+
onUpdate?: any;
|
|
1470
|
+
autoincrement?: boolean | undefined;
|
|
1471
1471
|
}>>;
|
|
1472
1472
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
1473
1473
|
name: zod.ZodString;
|
|
@@ -1482,14 +1482,14 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1482
1482
|
isUnique: boolean;
|
|
1483
1483
|
using?: "btree" | "hash" | undefined;
|
|
1484
1484
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1485
|
-
lock?: "
|
|
1485
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1486
1486
|
}, {
|
|
1487
1487
|
name: string;
|
|
1488
1488
|
columns: string[];
|
|
1489
1489
|
isUnique: boolean;
|
|
1490
1490
|
using?: "btree" | "hash" | undefined;
|
|
1491
1491
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1492
|
-
lock?: "
|
|
1492
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1493
1493
|
}>>;
|
|
1494
1494
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
1495
1495
|
name: zod.ZodString;
|
|
@@ -1540,26 +1540,26 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1540
1540
|
name: zod.ZodString;
|
|
1541
1541
|
value: zod.ZodString;
|
|
1542
1542
|
}, "strict", zod.ZodTypeAny, {
|
|
1543
|
-
name: string;
|
|
1544
1543
|
value: string;
|
|
1545
|
-
}, {
|
|
1546
1544
|
name: string;
|
|
1545
|
+
}, {
|
|
1547
1546
|
value: string;
|
|
1547
|
+
name: string;
|
|
1548
1548
|
}>>>;
|
|
1549
1549
|
}, "strict", zod.ZodTypeAny, {
|
|
1550
1550
|
name: string;
|
|
1551
1551
|
columns: Record<string, {
|
|
1552
|
-
name: string;
|
|
1553
1552
|
type: string;
|
|
1553
|
+
name: string;
|
|
1554
1554
|
primaryKey: boolean;
|
|
1555
1555
|
notNull: boolean;
|
|
1556
1556
|
default?: any;
|
|
1557
|
-
onUpdate?: any;
|
|
1558
|
-
autoincrement?: boolean | undefined;
|
|
1559
1557
|
generated?: {
|
|
1560
1558
|
type: "stored" | "virtual";
|
|
1561
1559
|
as: string;
|
|
1562
1560
|
} | undefined;
|
|
1561
|
+
onUpdate?: any;
|
|
1562
|
+
autoincrement?: boolean | undefined;
|
|
1563
1563
|
}>;
|
|
1564
1564
|
indexes: Record<string, {
|
|
1565
1565
|
name: string;
|
|
@@ -1567,7 +1567,7 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1567
1567
|
isUnique: boolean;
|
|
1568
1568
|
using?: "btree" | "hash" | undefined;
|
|
1569
1569
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1570
|
-
lock?: "
|
|
1570
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1571
1571
|
}>;
|
|
1572
1572
|
foreignKeys: Record<string, {
|
|
1573
1573
|
name: string;
|
|
@@ -1587,23 +1587,23 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1587
1587
|
columns: string[];
|
|
1588
1588
|
}>;
|
|
1589
1589
|
checkConstraint: Record<string, {
|
|
1590
|
-
name: string;
|
|
1591
1590
|
value: string;
|
|
1591
|
+
name: string;
|
|
1592
1592
|
}>;
|
|
1593
1593
|
}, {
|
|
1594
1594
|
name: string;
|
|
1595
1595
|
columns: Record<string, {
|
|
1596
|
-
name: string;
|
|
1597
1596
|
type: string;
|
|
1597
|
+
name: string;
|
|
1598
1598
|
primaryKey: boolean;
|
|
1599
1599
|
notNull: boolean;
|
|
1600
1600
|
default?: any;
|
|
1601
|
-
onUpdate?: any;
|
|
1602
|
-
autoincrement?: boolean | undefined;
|
|
1603
1601
|
generated?: {
|
|
1604
1602
|
type: "stored" | "virtual";
|
|
1605
1603
|
as: string;
|
|
1606
1604
|
} | undefined;
|
|
1605
|
+
onUpdate?: any;
|
|
1606
|
+
autoincrement?: boolean | undefined;
|
|
1607
1607
|
}>;
|
|
1608
1608
|
indexes: Record<string, {
|
|
1609
1609
|
name: string;
|
|
@@ -1611,7 +1611,7 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1611
1611
|
isUnique: boolean;
|
|
1612
1612
|
using?: "btree" | "hash" | undefined;
|
|
1613
1613
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1614
|
-
lock?: "
|
|
1614
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1615
1615
|
}>;
|
|
1616
1616
|
foreignKeys: Record<string, {
|
|
1617
1617
|
name: string;
|
|
@@ -1631,8 +1631,8 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1631
1631
|
columns: string[];
|
|
1632
1632
|
}> | undefined;
|
|
1633
1633
|
checkConstraint?: Record<string, {
|
|
1634
|
-
name: string;
|
|
1635
1634
|
value: string;
|
|
1635
|
+
name: string;
|
|
1636
1636
|
}> | undefined;
|
|
1637
1637
|
}>>;
|
|
1638
1638
|
views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -1656,29 +1656,29 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1656
1656
|
as: string;
|
|
1657
1657
|
}>>;
|
|
1658
1658
|
}, "strict", zod.ZodTypeAny, {
|
|
1659
|
-
name: string;
|
|
1660
1659
|
type: string;
|
|
1660
|
+
name: string;
|
|
1661
1661
|
primaryKey: boolean;
|
|
1662
1662
|
notNull: boolean;
|
|
1663
1663
|
default?: any;
|
|
1664
|
-
onUpdate?: any;
|
|
1665
|
-
autoincrement?: boolean | undefined;
|
|
1666
1664
|
generated?: {
|
|
1667
1665
|
type: "stored" | "virtual";
|
|
1668
1666
|
as: string;
|
|
1669
1667
|
} | undefined;
|
|
1668
|
+
onUpdate?: any;
|
|
1669
|
+
autoincrement?: boolean | undefined;
|
|
1670
1670
|
}, {
|
|
1671
|
-
name: string;
|
|
1672
1671
|
type: string;
|
|
1672
|
+
name: string;
|
|
1673
1673
|
primaryKey: boolean;
|
|
1674
1674
|
notNull: boolean;
|
|
1675
1675
|
default?: any;
|
|
1676
|
-
onUpdate?: any;
|
|
1677
|
-
autoincrement?: boolean | undefined;
|
|
1678
1676
|
generated?: {
|
|
1679
1677
|
type: "stored" | "virtual";
|
|
1680
1678
|
as: string;
|
|
1681
1679
|
} | undefined;
|
|
1680
|
+
onUpdate?: any;
|
|
1681
|
+
autoincrement?: boolean | undefined;
|
|
1682
1682
|
}>>;
|
|
1683
1683
|
definition: zod.ZodOptional<zod.ZodString>;
|
|
1684
1684
|
isExisting: zod.ZodBoolean;
|
|
@@ -1689,53 +1689,53 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1689
1689
|
}, "strict", zod.ZodTypeAny, {
|
|
1690
1690
|
name: string;
|
|
1691
1691
|
columns: Record<string, {
|
|
1692
|
-
name: string;
|
|
1693
1692
|
type: string;
|
|
1693
|
+
name: string;
|
|
1694
1694
|
primaryKey: boolean;
|
|
1695
1695
|
notNull: boolean;
|
|
1696
1696
|
default?: any;
|
|
1697
|
-
onUpdate?: any;
|
|
1698
|
-
autoincrement?: boolean | undefined;
|
|
1699
1697
|
generated?: {
|
|
1700
1698
|
type: "stored" | "virtual";
|
|
1701
1699
|
as: string;
|
|
1702
1700
|
} | undefined;
|
|
1701
|
+
onUpdate?: any;
|
|
1702
|
+
autoincrement?: boolean | undefined;
|
|
1703
1703
|
}>;
|
|
1704
|
+
isExisting: boolean;
|
|
1704
1705
|
algorithm: "undefined" | "merge" | "temptable";
|
|
1705
1706
|
sqlSecurity: "definer" | "invoker";
|
|
1706
|
-
isExisting: boolean;
|
|
1707
|
-
withCheckOption?: "local" | "cascaded" | undefined;
|
|
1708
1707
|
definition?: string | undefined;
|
|
1708
|
+
withCheckOption?: "local" | "cascaded" | undefined;
|
|
1709
1709
|
}, {
|
|
1710
1710
|
name: string;
|
|
1711
1711
|
columns: Record<string, {
|
|
1712
|
-
name: string;
|
|
1713
1712
|
type: string;
|
|
1713
|
+
name: string;
|
|
1714
1714
|
primaryKey: boolean;
|
|
1715
1715
|
notNull: boolean;
|
|
1716
1716
|
default?: any;
|
|
1717
|
-
onUpdate?: any;
|
|
1718
|
-
autoincrement?: boolean | undefined;
|
|
1719
1717
|
generated?: {
|
|
1720
1718
|
type: "stored" | "virtual";
|
|
1721
1719
|
as: string;
|
|
1722
1720
|
} | undefined;
|
|
1721
|
+
onUpdate?: any;
|
|
1722
|
+
autoincrement?: boolean | undefined;
|
|
1723
1723
|
}>;
|
|
1724
|
+
isExisting: boolean;
|
|
1724
1725
|
algorithm: "undefined" | "merge" | "temptable";
|
|
1725
1726
|
sqlSecurity: "definer" | "invoker";
|
|
1726
|
-
isExisting: boolean;
|
|
1727
|
-
withCheckOption?: "local" | "cascaded" | undefined;
|
|
1728
1727
|
definition?: string | undefined;
|
|
1728
|
+
withCheckOption?: "local" | "cascaded" | undefined;
|
|
1729
1729
|
}>>>;
|
|
1730
1730
|
_meta: zod.ZodObject<{
|
|
1731
1731
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
1732
1732
|
columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
1733
1733
|
}, "strip", zod.ZodTypeAny, {
|
|
1734
|
-
columns: Record<string, string>;
|
|
1735
1734
|
tables: Record<string, string>;
|
|
1736
|
-
}, {
|
|
1737
1735
|
columns: Record<string, string>;
|
|
1736
|
+
}, {
|
|
1738
1737
|
tables: Record<string, string>;
|
|
1738
|
+
columns: Record<string, string>;
|
|
1739
1739
|
}>;
|
|
1740
1740
|
internal: zod.ZodOptional<zod.ZodObject<{
|
|
1741
1741
|
tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
|
|
@@ -1773,46 +1773,48 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1773
1773
|
} | undefined>;
|
|
1774
1774
|
}>>>>;
|
|
1775
1775
|
}, "strip", zod.ZodTypeAny, {
|
|
1776
|
-
indexes?: Record<string, {
|
|
1777
|
-
columns: Record<string, {
|
|
1778
|
-
isExpression?: boolean | undefined;
|
|
1779
|
-
} | undefined>;
|
|
1780
|
-
} | undefined> | undefined;
|
|
1781
1776
|
tables?: Record<string, {
|
|
1782
1777
|
columns: Record<string, {
|
|
1783
1778
|
isDefaultAnExpression?: boolean | undefined;
|
|
1784
1779
|
} | undefined>;
|
|
1785
1780
|
} | undefined> | undefined;
|
|
1786
|
-
}, {
|
|
1787
1781
|
indexes?: Record<string, {
|
|
1788
1782
|
columns: Record<string, {
|
|
1789
1783
|
isExpression?: boolean | undefined;
|
|
1790
1784
|
} | undefined>;
|
|
1791
1785
|
} | undefined> | undefined;
|
|
1786
|
+
}, {
|
|
1792
1787
|
tables?: Record<string, {
|
|
1793
1788
|
columns: Record<string, {
|
|
1794
1789
|
isDefaultAnExpression?: boolean | undefined;
|
|
1795
1790
|
} | undefined>;
|
|
1796
1791
|
} | undefined> | undefined;
|
|
1792
|
+
indexes?: Record<string, {
|
|
1793
|
+
columns: Record<string, {
|
|
1794
|
+
isExpression?: boolean | undefined;
|
|
1795
|
+
} | undefined>;
|
|
1796
|
+
} | undefined> | undefined;
|
|
1797
1797
|
}>>;
|
|
1798
1798
|
} & {
|
|
1799
1799
|
id: zod.ZodString;
|
|
1800
1800
|
prevId: zod.ZodString;
|
|
1801
1801
|
}, "strip", zod.ZodTypeAny, {
|
|
1802
|
+
version: "5";
|
|
1803
|
+
dialect: "mysql";
|
|
1802
1804
|
tables: Record<string, {
|
|
1803
1805
|
name: string;
|
|
1804
1806
|
columns: Record<string, {
|
|
1805
|
-
name: string;
|
|
1806
1807
|
type: string;
|
|
1808
|
+
name: string;
|
|
1807
1809
|
primaryKey: boolean;
|
|
1808
1810
|
notNull: boolean;
|
|
1809
1811
|
default?: any;
|
|
1810
|
-
onUpdate?: any;
|
|
1811
|
-
autoincrement?: boolean | undefined;
|
|
1812
1812
|
generated?: {
|
|
1813
1813
|
type: "stored" | "virtual";
|
|
1814
1814
|
as: string;
|
|
1815
1815
|
} | undefined;
|
|
1816
|
+
onUpdate?: any;
|
|
1817
|
+
autoincrement?: boolean | undefined;
|
|
1816
1818
|
}>;
|
|
1817
1819
|
indexes: Record<string, {
|
|
1818
1820
|
name: string;
|
|
@@ -1820,7 +1822,7 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1820
1822
|
isUnique: boolean;
|
|
1821
1823
|
using?: "btree" | "hash" | undefined;
|
|
1822
1824
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1823
|
-
lock?: "
|
|
1825
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1824
1826
|
}>;
|
|
1825
1827
|
foreignKeys: Record<string, {
|
|
1826
1828
|
name: string;
|
|
@@ -1840,66 +1842,66 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1840
1842
|
columns: string[];
|
|
1841
1843
|
}>;
|
|
1842
1844
|
checkConstraint: Record<string, {
|
|
1843
|
-
name: string;
|
|
1844
1845
|
value: string;
|
|
1846
|
+
name: string;
|
|
1845
1847
|
}>;
|
|
1846
1848
|
}>;
|
|
1847
|
-
id: string;
|
|
1848
|
-
prevId: string;
|
|
1849
|
-
version: "5";
|
|
1850
|
-
dialect: "mysql";
|
|
1851
|
-
_meta: {
|
|
1852
|
-
columns: Record<string, string>;
|
|
1853
|
-
tables: Record<string, string>;
|
|
1854
|
-
};
|
|
1855
1849
|
views: Record<string, {
|
|
1856
1850
|
name: string;
|
|
1857
1851
|
columns: Record<string, {
|
|
1858
|
-
name: string;
|
|
1859
1852
|
type: string;
|
|
1853
|
+
name: string;
|
|
1860
1854
|
primaryKey: boolean;
|
|
1861
1855
|
notNull: boolean;
|
|
1862
1856
|
default?: any;
|
|
1863
|
-
onUpdate?: any;
|
|
1864
|
-
autoincrement?: boolean | undefined;
|
|
1865
1857
|
generated?: {
|
|
1866
1858
|
type: "stored" | "virtual";
|
|
1867
1859
|
as: string;
|
|
1868
1860
|
} | undefined;
|
|
1861
|
+
onUpdate?: any;
|
|
1862
|
+
autoincrement?: boolean | undefined;
|
|
1869
1863
|
}>;
|
|
1864
|
+
isExisting: boolean;
|
|
1870
1865
|
algorithm: "undefined" | "merge" | "temptable";
|
|
1871
1866
|
sqlSecurity: "definer" | "invoker";
|
|
1872
|
-
isExisting: boolean;
|
|
1873
|
-
withCheckOption?: "local" | "cascaded" | undefined;
|
|
1874
1867
|
definition?: string | undefined;
|
|
1868
|
+
withCheckOption?: "local" | "cascaded" | undefined;
|
|
1875
1869
|
}>;
|
|
1870
|
+
_meta: {
|
|
1871
|
+
tables: Record<string, string>;
|
|
1872
|
+
columns: Record<string, string>;
|
|
1873
|
+
};
|
|
1874
|
+
id: string;
|
|
1875
|
+
prevId: string;
|
|
1876
1876
|
internal?: {
|
|
1877
|
-
|
|
1877
|
+
tables?: Record<string, {
|
|
1878
1878
|
columns: Record<string, {
|
|
1879
|
-
|
|
1879
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1880
1880
|
} | undefined>;
|
|
1881
1881
|
} | undefined> | undefined;
|
|
1882
|
-
|
|
1882
|
+
indexes?: Record<string, {
|
|
1883
1883
|
columns: Record<string, {
|
|
1884
|
-
|
|
1884
|
+
isExpression?: boolean | undefined;
|
|
1885
1885
|
} | undefined>;
|
|
1886
1886
|
} | undefined> | undefined;
|
|
1887
1887
|
} | undefined;
|
|
1888
1888
|
}, {
|
|
1889
|
+
version: "5";
|
|
1890
|
+
dialect: "mysql";
|
|
1889
1891
|
tables: Record<string, {
|
|
1890
1892
|
name: string;
|
|
1891
1893
|
columns: Record<string, {
|
|
1892
|
-
name: string;
|
|
1893
1894
|
type: string;
|
|
1895
|
+
name: string;
|
|
1894
1896
|
primaryKey: boolean;
|
|
1895
1897
|
notNull: boolean;
|
|
1896
1898
|
default?: any;
|
|
1897
|
-
onUpdate?: any;
|
|
1898
|
-
autoincrement?: boolean | undefined;
|
|
1899
1899
|
generated?: {
|
|
1900
1900
|
type: "stored" | "virtual";
|
|
1901
1901
|
as: string;
|
|
1902
1902
|
} | undefined;
|
|
1903
|
+
onUpdate?: any;
|
|
1904
|
+
autoincrement?: boolean | undefined;
|
|
1903
1905
|
}>;
|
|
1904
1906
|
indexes: Record<string, {
|
|
1905
1907
|
name: string;
|
|
@@ -1907,7 +1909,7 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1907
1909
|
isUnique: boolean;
|
|
1908
1910
|
using?: "btree" | "hash" | undefined;
|
|
1909
1911
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1910
|
-
lock?: "
|
|
1912
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1911
1913
|
}>;
|
|
1912
1914
|
foreignKeys: Record<string, {
|
|
1913
1915
|
name: string;
|
|
@@ -1927,51 +1929,49 @@ declare const schema$2: zod.ZodObject<{
|
|
|
1927
1929
|
columns: string[];
|
|
1928
1930
|
}> | undefined;
|
|
1929
1931
|
checkConstraint?: Record<string, {
|
|
1930
|
-
name: string;
|
|
1931
1932
|
value: string;
|
|
1933
|
+
name: string;
|
|
1932
1934
|
}> | undefined;
|
|
1933
1935
|
}>;
|
|
1934
|
-
id: string;
|
|
1935
|
-
prevId: string;
|
|
1936
|
-
version: "5";
|
|
1937
|
-
dialect: "mysql";
|
|
1938
1936
|
_meta: {
|
|
1939
|
-
columns: Record<string, string>;
|
|
1940
1937
|
tables: Record<string, string>;
|
|
1938
|
+
columns: Record<string, string>;
|
|
1941
1939
|
};
|
|
1942
|
-
|
|
1943
|
-
|
|
1944
|
-
columns: Record<string, {
|
|
1945
|
-
isExpression?: boolean | undefined;
|
|
1946
|
-
} | undefined>;
|
|
1947
|
-
} | undefined> | undefined;
|
|
1948
|
-
tables?: Record<string, {
|
|
1949
|
-
columns: Record<string, {
|
|
1950
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
1951
|
-
} | undefined>;
|
|
1952
|
-
} | undefined> | undefined;
|
|
1953
|
-
} | undefined;
|
|
1940
|
+
id: string;
|
|
1941
|
+
prevId: string;
|
|
1954
1942
|
views?: Record<string, {
|
|
1955
1943
|
name: string;
|
|
1956
1944
|
columns: Record<string, {
|
|
1957
|
-
name: string;
|
|
1958
1945
|
type: string;
|
|
1946
|
+
name: string;
|
|
1959
1947
|
primaryKey: boolean;
|
|
1960
1948
|
notNull: boolean;
|
|
1961
1949
|
default?: any;
|
|
1962
|
-
onUpdate?: any;
|
|
1963
|
-
autoincrement?: boolean | undefined;
|
|
1964
1950
|
generated?: {
|
|
1965
1951
|
type: "stored" | "virtual";
|
|
1966
1952
|
as: string;
|
|
1967
1953
|
} | undefined;
|
|
1954
|
+
onUpdate?: any;
|
|
1955
|
+
autoincrement?: boolean | undefined;
|
|
1968
1956
|
}>;
|
|
1957
|
+
isExisting: boolean;
|
|
1969
1958
|
algorithm: "undefined" | "merge" | "temptable";
|
|
1970
1959
|
sqlSecurity: "definer" | "invoker";
|
|
1971
|
-
isExisting: boolean;
|
|
1972
|
-
withCheckOption?: "local" | "cascaded" | undefined;
|
|
1973
1960
|
definition?: string | undefined;
|
|
1961
|
+
withCheckOption?: "local" | "cascaded" | undefined;
|
|
1974
1962
|
}> | undefined;
|
|
1963
|
+
internal?: {
|
|
1964
|
+
tables?: Record<string, {
|
|
1965
|
+
columns: Record<string, {
|
|
1966
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1967
|
+
} | undefined>;
|
|
1968
|
+
} | undefined> | undefined;
|
|
1969
|
+
indexes?: Record<string, {
|
|
1970
|
+
columns: Record<string, {
|
|
1971
|
+
isExpression?: boolean | undefined;
|
|
1972
|
+
} | undefined>;
|
|
1973
|
+
} | undefined> | undefined;
|
|
1974
|
+
} | undefined;
|
|
1975
1975
|
}>;
|
|
1976
1976
|
type MySqlSchema = TypeOf<typeof schema$2>;
|
|
1977
1977
|
|
|
@@ -2013,8 +2013,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2013
2013
|
} & {
|
|
2014
2014
|
type: zod.ZodEnum<["always", "byDefault"]>;
|
|
2015
2015
|
}, "strip", zod.ZodTypeAny, {
|
|
2016
|
-
name: string;
|
|
2017
2016
|
type: "always" | "byDefault";
|
|
2017
|
+
name: string;
|
|
2018
2018
|
schema: string;
|
|
2019
2019
|
increment?: string | undefined;
|
|
2020
2020
|
minValue?: string | undefined;
|
|
@@ -2023,8 +2023,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2023
2023
|
cache?: string | undefined;
|
|
2024
2024
|
cycle?: boolean | undefined;
|
|
2025
2025
|
}, {
|
|
2026
|
-
name: string;
|
|
2027
2026
|
type: "always" | "byDefault";
|
|
2027
|
+
name: string;
|
|
2028
2028
|
schema: string;
|
|
2029
2029
|
increment?: string | undefined;
|
|
2030
2030
|
minValue?: string | undefined;
|
|
@@ -2034,22 +2034,22 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2034
2034
|
cycle?: boolean | undefined;
|
|
2035
2035
|
}>>;
|
|
2036
2036
|
}, "strict", zod.ZodTypeAny, {
|
|
2037
|
-
name: string;
|
|
2038
2037
|
type: string;
|
|
2038
|
+
name: string;
|
|
2039
2039
|
primaryKey: boolean;
|
|
2040
2040
|
notNull: boolean;
|
|
2041
|
+
typeSchema?: string | undefined;
|
|
2041
2042
|
default?: any;
|
|
2042
2043
|
isUnique?: any;
|
|
2044
|
+
uniqueName?: string | undefined;
|
|
2045
|
+
nullsNotDistinct?: boolean | undefined;
|
|
2043
2046
|
generated?: {
|
|
2044
2047
|
type: "stored";
|
|
2045
2048
|
as: string;
|
|
2046
2049
|
} | undefined;
|
|
2047
|
-
typeSchema?: string | undefined;
|
|
2048
|
-
uniqueName?: string | undefined;
|
|
2049
|
-
nullsNotDistinct?: boolean | undefined;
|
|
2050
2050
|
identity?: {
|
|
2051
|
-
name: string;
|
|
2052
2051
|
type: "always" | "byDefault";
|
|
2052
|
+
name: string;
|
|
2053
2053
|
schema: string;
|
|
2054
2054
|
increment?: string | undefined;
|
|
2055
2055
|
minValue?: string | undefined;
|
|
@@ -2059,22 +2059,22 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2059
2059
|
cycle?: boolean | undefined;
|
|
2060
2060
|
} | undefined;
|
|
2061
2061
|
}, {
|
|
2062
|
-
name: string;
|
|
2063
2062
|
type: string;
|
|
2063
|
+
name: string;
|
|
2064
2064
|
primaryKey: boolean;
|
|
2065
2065
|
notNull: boolean;
|
|
2066
|
+
typeSchema?: string | undefined;
|
|
2066
2067
|
default?: any;
|
|
2067
2068
|
isUnique?: any;
|
|
2069
|
+
uniqueName?: string | undefined;
|
|
2070
|
+
nullsNotDistinct?: boolean | undefined;
|
|
2068
2071
|
generated?: {
|
|
2069
2072
|
type: "stored";
|
|
2070
2073
|
as: string;
|
|
2071
2074
|
} | undefined;
|
|
2072
|
-
typeSchema?: string | undefined;
|
|
2073
|
-
uniqueName?: string | undefined;
|
|
2074
|
-
nullsNotDistinct?: boolean | undefined;
|
|
2075
2075
|
identity?: {
|
|
2076
|
-
name: string;
|
|
2077
2076
|
type: "always" | "byDefault";
|
|
2077
|
+
name: string;
|
|
2078
2078
|
schema: string;
|
|
2079
2079
|
increment?: string | undefined;
|
|
2080
2080
|
minValue?: string | undefined;
|
|
@@ -2093,14 +2093,14 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2093
2093
|
nulls: zod.ZodOptional<zod.ZodString>;
|
|
2094
2094
|
opclass: zod.ZodOptional<zod.ZodString>;
|
|
2095
2095
|
}, "strip", zod.ZodTypeAny, {
|
|
2096
|
-
isExpression: boolean;
|
|
2097
2096
|
expression: string;
|
|
2097
|
+
isExpression: boolean;
|
|
2098
2098
|
asc: boolean;
|
|
2099
2099
|
nulls?: string | undefined;
|
|
2100
2100
|
opclass?: string | undefined;
|
|
2101
2101
|
}, {
|
|
2102
|
-
isExpression: boolean;
|
|
2103
2102
|
expression: string;
|
|
2103
|
+
isExpression: boolean;
|
|
2104
2104
|
asc: boolean;
|
|
2105
2105
|
nulls?: string | undefined;
|
|
2106
2106
|
opclass?: string | undefined;
|
|
@@ -2113,8 +2113,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2113
2113
|
}, "strict", zod.ZodTypeAny, {
|
|
2114
2114
|
name: string;
|
|
2115
2115
|
columns: {
|
|
2116
|
-
isExpression: boolean;
|
|
2117
2116
|
expression: string;
|
|
2117
|
+
isExpression: boolean;
|
|
2118
2118
|
asc: boolean;
|
|
2119
2119
|
nulls?: string | undefined;
|
|
2120
2120
|
opclass?: string | undefined;
|
|
@@ -2127,8 +2127,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2127
2127
|
}, {
|
|
2128
2128
|
name: string;
|
|
2129
2129
|
columns: {
|
|
2130
|
-
isExpression: boolean;
|
|
2131
2130
|
expression: string;
|
|
2131
|
+
isExpression: boolean;
|
|
2132
2132
|
asc: boolean;
|
|
2133
2133
|
nulls?: string | undefined;
|
|
2134
2134
|
opclass?: string | undefined;
|
|
@@ -2154,18 +2154,18 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2154
2154
|
columnsFrom: string[];
|
|
2155
2155
|
tableTo: string;
|
|
2156
2156
|
columnsTo: string[];
|
|
2157
|
+
schemaTo?: string | undefined;
|
|
2157
2158
|
onUpdate?: string | undefined;
|
|
2158
2159
|
onDelete?: string | undefined;
|
|
2159
|
-
schemaTo?: string | undefined;
|
|
2160
2160
|
}, {
|
|
2161
2161
|
name: string;
|
|
2162
2162
|
tableFrom: string;
|
|
2163
2163
|
columnsFrom: string[];
|
|
2164
2164
|
tableTo: string;
|
|
2165
2165
|
columnsTo: string[];
|
|
2166
|
+
schemaTo?: string | undefined;
|
|
2166
2167
|
onUpdate?: string | undefined;
|
|
2167
2168
|
onDelete?: string | undefined;
|
|
2168
|
-
schemaTo?: string | undefined;
|
|
2169
2169
|
}>>;
|
|
2170
2170
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
2171
2171
|
name: zod.ZodString;
|
|
@@ -2201,20 +2201,20 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2201
2201
|
schema: zod.ZodOptional<zod.ZodString>;
|
|
2202
2202
|
}, "strict", zod.ZodTypeAny, {
|
|
2203
2203
|
name: string;
|
|
2204
|
-
using?: string | undefined;
|
|
2205
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2206
2204
|
schema?: string | undefined;
|
|
2205
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2207
2206
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
2208
2207
|
to?: string[] | undefined;
|
|
2208
|
+
using?: string | undefined;
|
|
2209
2209
|
withCheck?: string | undefined;
|
|
2210
2210
|
on?: string | undefined;
|
|
2211
2211
|
}, {
|
|
2212
2212
|
name: string;
|
|
2213
|
-
using?: string | undefined;
|
|
2214
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2215
2213
|
schema?: string | undefined;
|
|
2214
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2216
2215
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
2217
2216
|
to?: string[] | undefined;
|
|
2217
|
+
using?: string | undefined;
|
|
2218
2218
|
withCheck?: string | undefined;
|
|
2219
2219
|
on?: string | undefined;
|
|
2220
2220
|
}>>>;
|
|
@@ -2222,32 +2222,33 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2222
2222
|
name: zod.ZodString;
|
|
2223
2223
|
value: zod.ZodString;
|
|
2224
2224
|
}, "strict", zod.ZodTypeAny, {
|
|
2225
|
-
name: string;
|
|
2226
2225
|
value: string;
|
|
2227
|
-
}, {
|
|
2228
2226
|
name: string;
|
|
2227
|
+
}, {
|
|
2229
2228
|
value: string;
|
|
2229
|
+
name: string;
|
|
2230
2230
|
}>>>;
|
|
2231
2231
|
isRLSEnabled: zod.ZodDefault<zod.ZodBoolean>;
|
|
2232
2232
|
}, "strict", zod.ZodTypeAny, {
|
|
2233
2233
|
name: string;
|
|
2234
|
+
schema: string;
|
|
2234
2235
|
columns: Record<string, {
|
|
2235
|
-
name: string;
|
|
2236
2236
|
type: string;
|
|
2237
|
+
name: string;
|
|
2237
2238
|
primaryKey: boolean;
|
|
2238
2239
|
notNull: boolean;
|
|
2240
|
+
typeSchema?: string | undefined;
|
|
2239
2241
|
default?: any;
|
|
2240
2242
|
isUnique?: any;
|
|
2243
|
+
uniqueName?: string | undefined;
|
|
2244
|
+
nullsNotDistinct?: boolean | undefined;
|
|
2241
2245
|
generated?: {
|
|
2242
2246
|
type: "stored";
|
|
2243
2247
|
as: string;
|
|
2244
2248
|
} | undefined;
|
|
2245
|
-
typeSchema?: string | undefined;
|
|
2246
|
-
uniqueName?: string | undefined;
|
|
2247
|
-
nullsNotDistinct?: boolean | undefined;
|
|
2248
2249
|
identity?: {
|
|
2249
|
-
name: string;
|
|
2250
2250
|
type: "always" | "byDefault";
|
|
2251
|
+
name: string;
|
|
2251
2252
|
schema: string;
|
|
2252
2253
|
increment?: string | undefined;
|
|
2253
2254
|
minValue?: string | undefined;
|
|
@@ -2260,8 +2261,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2260
2261
|
indexes: Record<string, {
|
|
2261
2262
|
name: string;
|
|
2262
2263
|
columns: {
|
|
2263
|
-
isExpression: boolean;
|
|
2264
2264
|
expression: string;
|
|
2265
|
+
isExpression: boolean;
|
|
2265
2266
|
asc: boolean;
|
|
2266
2267
|
nulls?: string | undefined;
|
|
2267
2268
|
opclass?: string | undefined;
|
|
@@ -2278,11 +2279,10 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2278
2279
|
columnsFrom: string[];
|
|
2279
2280
|
tableTo: string;
|
|
2280
2281
|
columnsTo: string[];
|
|
2282
|
+
schemaTo?: string | undefined;
|
|
2281
2283
|
onUpdate?: string | undefined;
|
|
2282
2284
|
onDelete?: string | undefined;
|
|
2283
|
-
schemaTo?: string | undefined;
|
|
2284
2285
|
}>;
|
|
2285
|
-
schema: string;
|
|
2286
2286
|
compositePrimaryKeys: Record<string, {
|
|
2287
2287
|
name: string;
|
|
2288
2288
|
columns: string[];
|
|
@@ -2292,40 +2292,41 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2292
2292
|
columns: string[];
|
|
2293
2293
|
nullsNotDistinct: boolean;
|
|
2294
2294
|
}>;
|
|
2295
|
-
checkConstraints: Record<string, {
|
|
2296
|
-
name: string;
|
|
2297
|
-
value: string;
|
|
2298
|
-
}>;
|
|
2299
2295
|
policies: Record<string, {
|
|
2300
2296
|
name: string;
|
|
2301
|
-
using?: string | undefined;
|
|
2302
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2303
2297
|
schema?: string | undefined;
|
|
2298
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2304
2299
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
2305
2300
|
to?: string[] | undefined;
|
|
2301
|
+
using?: string | undefined;
|
|
2306
2302
|
withCheck?: string | undefined;
|
|
2307
2303
|
on?: string | undefined;
|
|
2308
2304
|
}>;
|
|
2305
|
+
checkConstraints: Record<string, {
|
|
2306
|
+
value: string;
|
|
2307
|
+
name: string;
|
|
2308
|
+
}>;
|
|
2309
2309
|
isRLSEnabled: boolean;
|
|
2310
2310
|
}, {
|
|
2311
2311
|
name: string;
|
|
2312
|
+
schema: string;
|
|
2312
2313
|
columns: Record<string, {
|
|
2313
|
-
name: string;
|
|
2314
2314
|
type: string;
|
|
2315
|
+
name: string;
|
|
2315
2316
|
primaryKey: boolean;
|
|
2316
2317
|
notNull: boolean;
|
|
2318
|
+
typeSchema?: string | undefined;
|
|
2317
2319
|
default?: any;
|
|
2318
2320
|
isUnique?: any;
|
|
2321
|
+
uniqueName?: string | undefined;
|
|
2322
|
+
nullsNotDistinct?: boolean | undefined;
|
|
2319
2323
|
generated?: {
|
|
2320
2324
|
type: "stored";
|
|
2321
2325
|
as: string;
|
|
2322
2326
|
} | undefined;
|
|
2323
|
-
typeSchema?: string | undefined;
|
|
2324
|
-
uniqueName?: string | undefined;
|
|
2325
|
-
nullsNotDistinct?: boolean | undefined;
|
|
2326
2327
|
identity?: {
|
|
2327
|
-
name: string;
|
|
2328
2328
|
type: "always" | "byDefault";
|
|
2329
|
+
name: string;
|
|
2329
2330
|
schema: string;
|
|
2330
2331
|
increment?: string | undefined;
|
|
2331
2332
|
minValue?: string | undefined;
|
|
@@ -2338,8 +2339,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2338
2339
|
indexes: Record<string, {
|
|
2339
2340
|
name: string;
|
|
2340
2341
|
columns: {
|
|
2341
|
-
isExpression: boolean;
|
|
2342
2342
|
expression: string;
|
|
2343
|
+
isExpression: boolean;
|
|
2343
2344
|
asc: boolean;
|
|
2344
2345
|
nulls?: string | undefined;
|
|
2345
2346
|
opclass?: string | undefined;
|
|
@@ -2356,11 +2357,10 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2356
2357
|
columnsFrom: string[];
|
|
2357
2358
|
tableTo: string;
|
|
2358
2359
|
columnsTo: string[];
|
|
2360
|
+
schemaTo?: string | undefined;
|
|
2359
2361
|
onUpdate?: string | undefined;
|
|
2360
2362
|
onDelete?: string | undefined;
|
|
2361
|
-
schemaTo?: string | undefined;
|
|
2362
2363
|
}>;
|
|
2363
|
-
schema: string;
|
|
2364
2364
|
compositePrimaryKeys: Record<string, {
|
|
2365
2365
|
name: string;
|
|
2366
2366
|
columns: string[];
|
|
@@ -2370,20 +2370,20 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2370
2370
|
columns: string[];
|
|
2371
2371
|
nullsNotDistinct: boolean;
|
|
2372
2372
|
}> | undefined;
|
|
2373
|
-
checkConstraints?: Record<string, {
|
|
2374
|
-
name: string;
|
|
2375
|
-
value: string;
|
|
2376
|
-
}> | undefined;
|
|
2377
2373
|
policies?: Record<string, {
|
|
2378
2374
|
name: string;
|
|
2379
|
-
using?: string | undefined;
|
|
2380
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2381
2375
|
schema?: string | undefined;
|
|
2376
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2382
2377
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
2383
2378
|
to?: string[] | undefined;
|
|
2379
|
+
using?: string | undefined;
|
|
2384
2380
|
withCheck?: string | undefined;
|
|
2385
2381
|
on?: string | undefined;
|
|
2386
2382
|
}> | undefined;
|
|
2383
|
+
checkConstraints?: Record<string, {
|
|
2384
|
+
value: string;
|
|
2385
|
+
name: string;
|
|
2386
|
+
}> | undefined;
|
|
2387
2387
|
isRLSEnabled?: boolean | undefined;
|
|
2388
2388
|
}>>;
|
|
2389
2389
|
enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -2391,12 +2391,12 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2391
2391
|
schema: zod.ZodString;
|
|
2392
2392
|
values: zod.ZodArray<zod.ZodString, "many">;
|
|
2393
2393
|
}, "strict", zod.ZodTypeAny, {
|
|
2394
|
-
name: string;
|
|
2395
2394
|
values: string[];
|
|
2395
|
+
name: string;
|
|
2396
2396
|
schema: string;
|
|
2397
2397
|
}, {
|
|
2398
|
-
name: string;
|
|
2399
2398
|
values: string[];
|
|
2399
|
+
name: string;
|
|
2400
2400
|
schema: string;
|
|
2401
2401
|
}>>;
|
|
2402
2402
|
schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
@@ -2435,8 +2435,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2435
2435
|
} & {
|
|
2436
2436
|
type: zod.ZodEnum<["always", "byDefault"]>;
|
|
2437
2437
|
}, "strip", zod.ZodTypeAny, {
|
|
2438
|
-
name: string;
|
|
2439
2438
|
type: "always" | "byDefault";
|
|
2439
|
+
name: string;
|
|
2440
2440
|
schema: string;
|
|
2441
2441
|
increment?: string | undefined;
|
|
2442
2442
|
minValue?: string | undefined;
|
|
@@ -2445,8 +2445,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2445
2445
|
cache?: string | undefined;
|
|
2446
2446
|
cycle?: boolean | undefined;
|
|
2447
2447
|
}, {
|
|
2448
|
-
name: string;
|
|
2449
2448
|
type: "always" | "byDefault";
|
|
2449
|
+
name: string;
|
|
2450
2450
|
schema: string;
|
|
2451
2451
|
increment?: string | undefined;
|
|
2452
2452
|
minValue?: string | undefined;
|
|
@@ -2456,22 +2456,22 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2456
2456
|
cycle?: boolean | undefined;
|
|
2457
2457
|
}>>;
|
|
2458
2458
|
}, "strict", zod.ZodTypeAny, {
|
|
2459
|
-
name: string;
|
|
2460
2459
|
type: string;
|
|
2460
|
+
name: string;
|
|
2461
2461
|
primaryKey: boolean;
|
|
2462
2462
|
notNull: boolean;
|
|
2463
|
+
typeSchema?: string | undefined;
|
|
2463
2464
|
default?: any;
|
|
2464
2465
|
isUnique?: any;
|
|
2466
|
+
uniqueName?: string | undefined;
|
|
2467
|
+
nullsNotDistinct?: boolean | undefined;
|
|
2465
2468
|
generated?: {
|
|
2466
2469
|
type: "stored";
|
|
2467
2470
|
as: string;
|
|
2468
2471
|
} | undefined;
|
|
2469
|
-
typeSchema?: string | undefined;
|
|
2470
|
-
uniqueName?: string | undefined;
|
|
2471
|
-
nullsNotDistinct?: boolean | undefined;
|
|
2472
2472
|
identity?: {
|
|
2473
|
-
name: string;
|
|
2474
2473
|
type: "always" | "byDefault";
|
|
2474
|
+
name: string;
|
|
2475
2475
|
schema: string;
|
|
2476
2476
|
increment?: string | undefined;
|
|
2477
2477
|
minValue?: string | undefined;
|
|
@@ -2481,22 +2481,22 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2481
2481
|
cycle?: boolean | undefined;
|
|
2482
2482
|
} | undefined;
|
|
2483
2483
|
}, {
|
|
2484
|
-
name: string;
|
|
2485
2484
|
type: string;
|
|
2485
|
+
name: string;
|
|
2486
2486
|
primaryKey: boolean;
|
|
2487
2487
|
notNull: boolean;
|
|
2488
|
+
typeSchema?: string | undefined;
|
|
2488
2489
|
default?: any;
|
|
2489
2490
|
isUnique?: any;
|
|
2491
|
+
uniqueName?: string | undefined;
|
|
2492
|
+
nullsNotDistinct?: boolean | undefined;
|
|
2490
2493
|
generated?: {
|
|
2491
2494
|
type: "stored";
|
|
2492
2495
|
as: string;
|
|
2493
2496
|
} | undefined;
|
|
2494
|
-
typeSchema?: string | undefined;
|
|
2495
|
-
uniqueName?: string | undefined;
|
|
2496
|
-
nullsNotDistinct?: boolean | undefined;
|
|
2497
2497
|
identity?: {
|
|
2498
|
-
name: string;
|
|
2499
2498
|
type: "always" | "byDefault";
|
|
2499
|
+
name: string;
|
|
2500
2500
|
schema: string;
|
|
2501
2501
|
increment?: string | undefined;
|
|
2502
2502
|
minValue?: string | undefined;
|
|
@@ -2582,23 +2582,24 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2582
2582
|
tablespace: zod.ZodOptional<zod.ZodString>;
|
|
2583
2583
|
}, "strict", zod.ZodTypeAny, {
|
|
2584
2584
|
name: string;
|
|
2585
|
+
schema: string;
|
|
2585
2586
|
columns: Record<string, {
|
|
2586
|
-
name: string;
|
|
2587
2587
|
type: string;
|
|
2588
|
+
name: string;
|
|
2588
2589
|
primaryKey: boolean;
|
|
2589
2590
|
notNull: boolean;
|
|
2591
|
+
typeSchema?: string | undefined;
|
|
2590
2592
|
default?: any;
|
|
2591
2593
|
isUnique?: any;
|
|
2594
|
+
uniqueName?: string | undefined;
|
|
2595
|
+
nullsNotDistinct?: boolean | undefined;
|
|
2592
2596
|
generated?: {
|
|
2593
2597
|
type: "stored";
|
|
2594
2598
|
as: string;
|
|
2595
2599
|
} | undefined;
|
|
2596
|
-
typeSchema?: string | undefined;
|
|
2597
|
-
uniqueName?: string | undefined;
|
|
2598
|
-
nullsNotDistinct?: boolean | undefined;
|
|
2599
2600
|
identity?: {
|
|
2600
|
-
name: string;
|
|
2601
2601
|
type: "always" | "byDefault";
|
|
2602
|
+
name: string;
|
|
2602
2603
|
schema: string;
|
|
2603
2604
|
increment?: string | undefined;
|
|
2604
2605
|
minValue?: string | undefined;
|
|
@@ -2608,11 +2609,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2608
2609
|
cycle?: boolean | undefined;
|
|
2609
2610
|
} | undefined;
|
|
2610
2611
|
}>;
|
|
2611
|
-
schema: string;
|
|
2612
|
-
isExisting: boolean;
|
|
2613
2612
|
materialized: boolean;
|
|
2614
|
-
|
|
2615
|
-
definition?: string | undefined;
|
|
2613
|
+
isExisting: boolean;
|
|
2616
2614
|
with?: {
|
|
2617
2615
|
checkOption?: "local" | "cascaded" | undefined;
|
|
2618
2616
|
securityBarrier?: boolean | undefined;
|
|
@@ -2636,27 +2634,30 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2636
2634
|
logAutovacuumMinDuration?: number | undefined;
|
|
2637
2635
|
userCatalogTable?: boolean | undefined;
|
|
2638
2636
|
} | undefined;
|
|
2637
|
+
using?: string | undefined;
|
|
2638
|
+
definition?: string | undefined;
|
|
2639
2639
|
withNoData?: boolean | undefined;
|
|
2640
2640
|
tablespace?: string | undefined;
|
|
2641
2641
|
}, {
|
|
2642
2642
|
name: string;
|
|
2643
|
+
schema: string;
|
|
2643
2644
|
columns: Record<string, {
|
|
2644
|
-
name: string;
|
|
2645
2645
|
type: string;
|
|
2646
|
+
name: string;
|
|
2646
2647
|
primaryKey: boolean;
|
|
2647
2648
|
notNull: boolean;
|
|
2649
|
+
typeSchema?: string | undefined;
|
|
2648
2650
|
default?: any;
|
|
2649
2651
|
isUnique?: any;
|
|
2652
|
+
uniqueName?: string | undefined;
|
|
2653
|
+
nullsNotDistinct?: boolean | undefined;
|
|
2650
2654
|
generated?: {
|
|
2651
2655
|
type: "stored";
|
|
2652
2656
|
as: string;
|
|
2653
2657
|
} | undefined;
|
|
2654
|
-
typeSchema?: string | undefined;
|
|
2655
|
-
uniqueName?: string | undefined;
|
|
2656
|
-
nullsNotDistinct?: boolean | undefined;
|
|
2657
2658
|
identity?: {
|
|
2658
|
-
name: string;
|
|
2659
2659
|
type: "always" | "byDefault";
|
|
2660
|
+
name: string;
|
|
2660
2661
|
schema: string;
|
|
2661
2662
|
increment?: string | undefined;
|
|
2662
2663
|
minValue?: string | undefined;
|
|
@@ -2666,11 +2667,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2666
2667
|
cycle?: boolean | undefined;
|
|
2667
2668
|
} | undefined;
|
|
2668
2669
|
}>;
|
|
2669
|
-
schema: string;
|
|
2670
|
-
isExisting: boolean;
|
|
2671
2670
|
materialized: boolean;
|
|
2672
|
-
|
|
2673
|
-
definition?: string | undefined;
|
|
2671
|
+
isExisting: boolean;
|
|
2674
2672
|
with?: {
|
|
2675
2673
|
checkOption?: "local" | "cascaded" | undefined;
|
|
2676
2674
|
securityBarrier?: boolean | undefined;
|
|
@@ -2694,6 +2692,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2694
2692
|
logAutovacuumMinDuration?: number | undefined;
|
|
2695
2693
|
userCatalogTable?: boolean | undefined;
|
|
2696
2694
|
} | undefined;
|
|
2695
|
+
using?: string | undefined;
|
|
2696
|
+
definition?: string | undefined;
|
|
2697
2697
|
withNoData?: boolean | undefined;
|
|
2698
2698
|
tablespace?: string | undefined;
|
|
2699
2699
|
}>>>;
|
|
@@ -2752,20 +2752,20 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2752
2752
|
schema: zod.ZodOptional<zod.ZodString>;
|
|
2753
2753
|
}, "strict", zod.ZodTypeAny, {
|
|
2754
2754
|
name: string;
|
|
2755
|
-
using?: string | undefined;
|
|
2756
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2757
2755
|
schema?: string | undefined;
|
|
2756
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2758
2757
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
2759
2758
|
to?: string[] | undefined;
|
|
2759
|
+
using?: string | undefined;
|
|
2760
2760
|
withCheck?: string | undefined;
|
|
2761
2761
|
on?: string | undefined;
|
|
2762
2762
|
}, {
|
|
2763
2763
|
name: string;
|
|
2764
|
-
using?: string | undefined;
|
|
2765
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2766
2764
|
schema?: string | undefined;
|
|
2765
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2767
2766
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
2768
2767
|
to?: string[] | undefined;
|
|
2768
|
+
using?: string | undefined;
|
|
2769
2769
|
withCheck?: string | undefined;
|
|
2770
2770
|
on?: string | undefined;
|
|
2771
2771
|
}>>>;
|
|
@@ -2774,12 +2774,12 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2774
2774
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
2775
2775
|
columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
2776
2776
|
}, "strip", zod.ZodTypeAny, {
|
|
2777
|
-
columns: Record<string, string>;
|
|
2778
2777
|
tables: Record<string, string>;
|
|
2778
|
+
columns: Record<string, string>;
|
|
2779
2779
|
schemas: Record<string, string>;
|
|
2780
2780
|
}, {
|
|
2781
|
-
columns: Record<string, string>;
|
|
2782
2781
|
tables: Record<string, string>;
|
|
2782
|
+
columns: Record<string, string>;
|
|
2783
2783
|
schemas: Record<string, string>;
|
|
2784
2784
|
}>;
|
|
2785
2785
|
internal: zod.ZodOptional<zod.ZodObject<{
|
|
@@ -2790,47 +2790,47 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2790
2790
|
rawType: zod.ZodOptional<zod.ZodString>;
|
|
2791
2791
|
isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
|
|
2792
2792
|
}, "strip", zod.ZodTypeAny, {
|
|
2793
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
2794
2793
|
isArray?: boolean | undefined;
|
|
2795
2794
|
dimensions?: number | undefined;
|
|
2796
2795
|
rawType?: string | undefined;
|
|
2797
|
-
}, {
|
|
2798
2796
|
isDefaultAnExpression?: boolean | undefined;
|
|
2797
|
+
}, {
|
|
2799
2798
|
isArray?: boolean | undefined;
|
|
2800
2799
|
dimensions?: number | undefined;
|
|
2801
2800
|
rawType?: string | undefined;
|
|
2801
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
2802
2802
|
}>>>;
|
|
2803
2803
|
}, "strip", zod.ZodTypeAny, {
|
|
2804
2804
|
columns: Record<string, {
|
|
2805
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
2806
2805
|
isArray?: boolean | undefined;
|
|
2807
2806
|
dimensions?: number | undefined;
|
|
2808
2807
|
rawType?: string | undefined;
|
|
2808
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
2809
2809
|
} | undefined>;
|
|
2810
2810
|
}, {
|
|
2811
2811
|
columns: Record<string, {
|
|
2812
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
2813
2812
|
isArray?: boolean | undefined;
|
|
2814
2813
|
dimensions?: number | undefined;
|
|
2815
2814
|
rawType?: string | undefined;
|
|
2815
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
2816
2816
|
} | undefined>;
|
|
2817
2817
|
}>>>;
|
|
2818
2818
|
}, "strip", zod.ZodTypeAny, {
|
|
2819
2819
|
tables: Record<string, {
|
|
2820
2820
|
columns: Record<string, {
|
|
2821
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
2822
2821
|
isArray?: boolean | undefined;
|
|
2823
2822
|
dimensions?: number | undefined;
|
|
2824
2823
|
rawType?: string | undefined;
|
|
2824
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
2825
2825
|
} | undefined>;
|
|
2826
2826
|
} | undefined>;
|
|
2827
2827
|
}, {
|
|
2828
2828
|
tables: Record<string, {
|
|
2829
2829
|
columns: Record<string, {
|
|
2830
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
2831
2830
|
isArray?: boolean | undefined;
|
|
2832
2831
|
dimensions?: number | undefined;
|
|
2833
2832
|
rawType?: string | undefined;
|
|
2833
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
2834
2834
|
} | undefined>;
|
|
2835
2835
|
} | undefined>;
|
|
2836
2836
|
}>>;
|
|
@@ -2838,25 +2838,28 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2838
2838
|
id: zod.ZodString;
|
|
2839
2839
|
prevId: zod.ZodString;
|
|
2840
2840
|
}, "strip", zod.ZodTypeAny, {
|
|
2841
|
+
version: "7";
|
|
2842
|
+
dialect: "postgresql";
|
|
2841
2843
|
tables: Record<string, {
|
|
2842
2844
|
name: string;
|
|
2845
|
+
schema: string;
|
|
2843
2846
|
columns: Record<string, {
|
|
2844
|
-
name: string;
|
|
2845
2847
|
type: string;
|
|
2848
|
+
name: string;
|
|
2846
2849
|
primaryKey: boolean;
|
|
2847
2850
|
notNull: boolean;
|
|
2851
|
+
typeSchema?: string | undefined;
|
|
2848
2852
|
default?: any;
|
|
2849
2853
|
isUnique?: any;
|
|
2854
|
+
uniqueName?: string | undefined;
|
|
2855
|
+
nullsNotDistinct?: boolean | undefined;
|
|
2850
2856
|
generated?: {
|
|
2851
2857
|
type: "stored";
|
|
2852
2858
|
as: string;
|
|
2853
2859
|
} | undefined;
|
|
2854
|
-
typeSchema?: string | undefined;
|
|
2855
|
-
uniqueName?: string | undefined;
|
|
2856
|
-
nullsNotDistinct?: boolean | undefined;
|
|
2857
2860
|
identity?: {
|
|
2858
|
-
name: string;
|
|
2859
2861
|
type: "always" | "byDefault";
|
|
2862
|
+
name: string;
|
|
2860
2863
|
schema: string;
|
|
2861
2864
|
increment?: string | undefined;
|
|
2862
2865
|
minValue?: string | undefined;
|
|
@@ -2869,8 +2872,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2869
2872
|
indexes: Record<string, {
|
|
2870
2873
|
name: string;
|
|
2871
2874
|
columns: {
|
|
2872
|
-
isExpression: boolean;
|
|
2873
2875
|
expression: string;
|
|
2876
|
+
isExpression: boolean;
|
|
2874
2877
|
asc: boolean;
|
|
2875
2878
|
nulls?: string | undefined;
|
|
2876
2879
|
opclass?: string | undefined;
|
|
@@ -2887,11 +2890,10 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2887
2890
|
columnsFrom: string[];
|
|
2888
2891
|
tableTo: string;
|
|
2889
2892
|
columnsTo: string[];
|
|
2893
|
+
schemaTo?: string | undefined;
|
|
2890
2894
|
onUpdate?: string | undefined;
|
|
2891
2895
|
onDelete?: string | undefined;
|
|
2892
|
-
schemaTo?: string | undefined;
|
|
2893
2896
|
}>;
|
|
2894
|
-
schema: string;
|
|
2895
2897
|
compositePrimaryKeys: Record<string, {
|
|
2896
2898
|
name: string;
|
|
2897
2899
|
columns: string[];
|
|
@@ -2901,51 +2903,58 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2901
2903
|
columns: string[];
|
|
2902
2904
|
nullsNotDistinct: boolean;
|
|
2903
2905
|
}>;
|
|
2904
|
-
checkConstraints: Record<string, {
|
|
2905
|
-
name: string;
|
|
2906
|
-
value: string;
|
|
2907
|
-
}>;
|
|
2908
2906
|
policies: Record<string, {
|
|
2909
2907
|
name: string;
|
|
2910
|
-
using?: string | undefined;
|
|
2911
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2912
2908
|
schema?: string | undefined;
|
|
2909
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2913
2910
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
2914
2911
|
to?: string[] | undefined;
|
|
2912
|
+
using?: string | undefined;
|
|
2915
2913
|
withCheck?: string | undefined;
|
|
2916
2914
|
on?: string | undefined;
|
|
2917
2915
|
}>;
|
|
2916
|
+
checkConstraints: Record<string, {
|
|
2917
|
+
value: string;
|
|
2918
|
+
name: string;
|
|
2919
|
+
}>;
|
|
2918
2920
|
isRLSEnabled: boolean;
|
|
2919
2921
|
}>;
|
|
2920
|
-
|
|
2921
|
-
|
|
2922
|
-
|
|
2923
|
-
|
|
2922
|
+
policies: Record<string, {
|
|
2923
|
+
name: string;
|
|
2924
|
+
schema?: string | undefined;
|
|
2925
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2926
|
+
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
2927
|
+
to?: string[] | undefined;
|
|
2928
|
+
using?: string | undefined;
|
|
2929
|
+
withCheck?: string | undefined;
|
|
2930
|
+
on?: string | undefined;
|
|
2931
|
+
}>;
|
|
2932
|
+
enums: Record<string, {
|
|
2933
|
+
values: string[];
|
|
2934
|
+
name: string;
|
|
2935
|
+
schema: string;
|
|
2936
|
+
}>;
|
|
2924
2937
|
schemas: Record<string, string>;
|
|
2925
|
-
_meta: {
|
|
2926
|
-
columns: Record<string, string>;
|
|
2927
|
-
tables: Record<string, string>;
|
|
2928
|
-
schemas: Record<string, string>;
|
|
2929
|
-
};
|
|
2930
2938
|
views: Record<string, {
|
|
2931
2939
|
name: string;
|
|
2940
|
+
schema: string;
|
|
2932
2941
|
columns: Record<string, {
|
|
2933
|
-
name: string;
|
|
2934
2942
|
type: string;
|
|
2943
|
+
name: string;
|
|
2935
2944
|
primaryKey: boolean;
|
|
2936
2945
|
notNull: boolean;
|
|
2946
|
+
typeSchema?: string | undefined;
|
|
2937
2947
|
default?: any;
|
|
2938
2948
|
isUnique?: any;
|
|
2949
|
+
uniqueName?: string | undefined;
|
|
2950
|
+
nullsNotDistinct?: boolean | undefined;
|
|
2939
2951
|
generated?: {
|
|
2940
2952
|
type: "stored";
|
|
2941
2953
|
as: string;
|
|
2942
2954
|
} | undefined;
|
|
2943
|
-
typeSchema?: string | undefined;
|
|
2944
|
-
uniqueName?: string | undefined;
|
|
2945
|
-
nullsNotDistinct?: boolean | undefined;
|
|
2946
2955
|
identity?: {
|
|
2947
|
-
name: string;
|
|
2948
2956
|
type: "always" | "byDefault";
|
|
2957
|
+
name: string;
|
|
2949
2958
|
schema: string;
|
|
2950
2959
|
increment?: string | undefined;
|
|
2951
2960
|
minValue?: string | undefined;
|
|
@@ -2955,11 +2964,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2955
2964
|
cycle?: boolean | undefined;
|
|
2956
2965
|
} | undefined;
|
|
2957
2966
|
}>;
|
|
2958
|
-
schema: string;
|
|
2959
|
-
isExisting: boolean;
|
|
2960
2967
|
materialized: boolean;
|
|
2961
|
-
|
|
2962
|
-
definition?: string | undefined;
|
|
2968
|
+
isExisting: boolean;
|
|
2963
2969
|
with?: {
|
|
2964
2970
|
checkOption?: "local" | "cascaded" | undefined;
|
|
2965
2971
|
securityBarrier?: boolean | undefined;
|
|
@@ -2983,24 +2989,11 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
2983
2989
|
logAutovacuumMinDuration?: number | undefined;
|
|
2984
2990
|
userCatalogTable?: boolean | undefined;
|
|
2985
2991
|
} | undefined;
|
|
2992
|
+
using?: string | undefined;
|
|
2993
|
+
definition?: string | undefined;
|
|
2986
2994
|
withNoData?: boolean | undefined;
|
|
2987
2995
|
tablespace?: string | undefined;
|
|
2988
2996
|
}>;
|
|
2989
|
-
enums: Record<string, {
|
|
2990
|
-
name: string;
|
|
2991
|
-
values: string[];
|
|
2992
|
-
schema: string;
|
|
2993
|
-
}>;
|
|
2994
|
-
policies: Record<string, {
|
|
2995
|
-
name: string;
|
|
2996
|
-
using?: string | undefined;
|
|
2997
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
2998
|
-
schema?: string | undefined;
|
|
2999
|
-
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
3000
|
-
to?: string[] | undefined;
|
|
3001
|
-
withCheck?: string | undefined;
|
|
3002
|
-
on?: string | undefined;
|
|
3003
|
-
}>;
|
|
3004
2997
|
sequences: Record<string, {
|
|
3005
2998
|
name: string;
|
|
3006
2999
|
schema: string;
|
|
@@ -3017,36 +3010,46 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
3017
3010
|
createRole?: boolean | undefined;
|
|
3018
3011
|
inherit?: boolean | undefined;
|
|
3019
3012
|
}>;
|
|
3013
|
+
_meta: {
|
|
3014
|
+
tables: Record<string, string>;
|
|
3015
|
+
columns: Record<string, string>;
|
|
3016
|
+
schemas: Record<string, string>;
|
|
3017
|
+
};
|
|
3018
|
+
id: string;
|
|
3019
|
+
prevId: string;
|
|
3020
3020
|
internal?: {
|
|
3021
3021
|
tables: Record<string, {
|
|
3022
3022
|
columns: Record<string, {
|
|
3023
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
3024
3023
|
isArray?: boolean | undefined;
|
|
3025
3024
|
dimensions?: number | undefined;
|
|
3026
3025
|
rawType?: string | undefined;
|
|
3026
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
3027
3027
|
} | undefined>;
|
|
3028
3028
|
} | undefined>;
|
|
3029
3029
|
} | undefined;
|
|
3030
3030
|
}, {
|
|
3031
|
+
version: "7";
|
|
3032
|
+
dialect: "postgresql";
|
|
3031
3033
|
tables: Record<string, {
|
|
3032
3034
|
name: string;
|
|
3035
|
+
schema: string;
|
|
3033
3036
|
columns: Record<string, {
|
|
3034
|
-
name: string;
|
|
3035
3037
|
type: string;
|
|
3038
|
+
name: string;
|
|
3036
3039
|
primaryKey: boolean;
|
|
3037
3040
|
notNull: boolean;
|
|
3041
|
+
typeSchema?: string | undefined;
|
|
3038
3042
|
default?: any;
|
|
3039
3043
|
isUnique?: any;
|
|
3044
|
+
uniqueName?: string | undefined;
|
|
3045
|
+
nullsNotDistinct?: boolean | undefined;
|
|
3040
3046
|
generated?: {
|
|
3041
3047
|
type: "stored";
|
|
3042
3048
|
as: string;
|
|
3043
3049
|
} | undefined;
|
|
3044
|
-
typeSchema?: string | undefined;
|
|
3045
|
-
uniqueName?: string | undefined;
|
|
3046
|
-
nullsNotDistinct?: boolean | undefined;
|
|
3047
3050
|
identity?: {
|
|
3048
|
-
name: string;
|
|
3049
3051
|
type: "always" | "byDefault";
|
|
3052
|
+
name: string;
|
|
3050
3053
|
schema: string;
|
|
3051
3054
|
increment?: string | undefined;
|
|
3052
3055
|
minValue?: string | undefined;
|
|
@@ -3059,8 +3062,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
3059
3062
|
indexes: Record<string, {
|
|
3060
3063
|
name: string;
|
|
3061
3064
|
columns: {
|
|
3062
|
-
isExpression: boolean;
|
|
3063
3065
|
expression: string;
|
|
3066
|
+
isExpression: boolean;
|
|
3064
3067
|
asc: boolean;
|
|
3065
3068
|
nulls?: string | undefined;
|
|
3066
3069
|
opclass?: string | undefined;
|
|
@@ -3077,11 +3080,10 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
3077
3080
|
columnsFrom: string[];
|
|
3078
3081
|
tableTo: string;
|
|
3079
3082
|
columnsTo: string[];
|
|
3083
|
+
schemaTo?: string | undefined;
|
|
3080
3084
|
onUpdate?: string | undefined;
|
|
3081
3085
|
onDelete?: string | undefined;
|
|
3082
|
-
schemaTo?: string | undefined;
|
|
3083
3086
|
}>;
|
|
3084
|
-
schema: string;
|
|
3085
3087
|
compositePrimaryKeys: Record<string, {
|
|
3086
3088
|
name: string;
|
|
3087
3089
|
columns: string[];
|
|
@@ -3091,66 +3093,65 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
3091
3093
|
columns: string[];
|
|
3092
3094
|
nullsNotDistinct: boolean;
|
|
3093
3095
|
}> | undefined;
|
|
3094
|
-
checkConstraints?: Record<string, {
|
|
3095
|
-
name: string;
|
|
3096
|
-
value: string;
|
|
3097
|
-
}> | undefined;
|
|
3098
3096
|
policies?: Record<string, {
|
|
3099
3097
|
name: string;
|
|
3100
|
-
using?: string | undefined;
|
|
3101
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
3102
3098
|
schema?: string | undefined;
|
|
3099
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
3103
3100
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
3104
3101
|
to?: string[] | undefined;
|
|
3102
|
+
using?: string | undefined;
|
|
3105
3103
|
withCheck?: string | undefined;
|
|
3106
3104
|
on?: string | undefined;
|
|
3107
3105
|
}> | undefined;
|
|
3106
|
+
checkConstraints?: Record<string, {
|
|
3107
|
+
value: string;
|
|
3108
|
+
name: string;
|
|
3109
|
+
}> | undefined;
|
|
3108
3110
|
isRLSEnabled?: boolean | undefined;
|
|
3109
3111
|
}>;
|
|
3110
|
-
|
|
3111
|
-
|
|
3112
|
-
|
|
3113
|
-
|
|
3112
|
+
enums: Record<string, {
|
|
3113
|
+
values: string[];
|
|
3114
|
+
name: string;
|
|
3115
|
+
schema: string;
|
|
3116
|
+
}>;
|
|
3114
3117
|
schemas: Record<string, string>;
|
|
3115
3118
|
_meta: {
|
|
3116
|
-
columns: Record<string, string>;
|
|
3117
3119
|
tables: Record<string, string>;
|
|
3120
|
+
columns: Record<string, string>;
|
|
3118
3121
|
schemas: Record<string, string>;
|
|
3119
3122
|
};
|
|
3120
|
-
|
|
3123
|
+
id: string;
|
|
3124
|
+
prevId: string;
|
|
3125
|
+
policies?: Record<string, {
|
|
3121
3126
|
name: string;
|
|
3122
|
-
|
|
3123
|
-
|
|
3124
|
-
|
|
3125
|
-
|
|
3126
|
-
|
|
3127
|
-
|
|
3128
|
-
|
|
3129
|
-
|
|
3130
|
-
dimensions?: number | undefined;
|
|
3131
|
-
rawType?: string | undefined;
|
|
3132
|
-
} | undefined>;
|
|
3133
|
-
} | undefined>;
|
|
3134
|
-
} | undefined;
|
|
3127
|
+
schema?: string | undefined;
|
|
3128
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
3129
|
+
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
3130
|
+
to?: string[] | undefined;
|
|
3131
|
+
using?: string | undefined;
|
|
3132
|
+
withCheck?: string | undefined;
|
|
3133
|
+
on?: string | undefined;
|
|
3134
|
+
}> | undefined;
|
|
3135
3135
|
views?: Record<string, {
|
|
3136
3136
|
name: string;
|
|
3137
|
+
schema: string;
|
|
3137
3138
|
columns: Record<string, {
|
|
3138
|
-
name: string;
|
|
3139
3139
|
type: string;
|
|
3140
|
+
name: string;
|
|
3140
3141
|
primaryKey: boolean;
|
|
3141
3142
|
notNull: boolean;
|
|
3143
|
+
typeSchema?: string | undefined;
|
|
3142
3144
|
default?: any;
|
|
3143
3145
|
isUnique?: any;
|
|
3146
|
+
uniqueName?: string | undefined;
|
|
3147
|
+
nullsNotDistinct?: boolean | undefined;
|
|
3144
3148
|
generated?: {
|
|
3145
3149
|
type: "stored";
|
|
3146
3150
|
as: string;
|
|
3147
3151
|
} | undefined;
|
|
3148
|
-
typeSchema?: string | undefined;
|
|
3149
|
-
uniqueName?: string | undefined;
|
|
3150
|
-
nullsNotDistinct?: boolean | undefined;
|
|
3151
3152
|
identity?: {
|
|
3152
|
-
name: string;
|
|
3153
3153
|
type: "always" | "byDefault";
|
|
3154
|
+
name: string;
|
|
3154
3155
|
schema: string;
|
|
3155
3156
|
increment?: string | undefined;
|
|
3156
3157
|
minValue?: string | undefined;
|
|
@@ -3160,11 +3161,8 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
3160
3161
|
cycle?: boolean | undefined;
|
|
3161
3162
|
} | undefined;
|
|
3162
3163
|
}>;
|
|
3163
|
-
schema: string;
|
|
3164
|
-
isExisting: boolean;
|
|
3165
3164
|
materialized: boolean;
|
|
3166
|
-
|
|
3167
|
-
definition?: string | undefined;
|
|
3165
|
+
isExisting: boolean;
|
|
3168
3166
|
with?: {
|
|
3169
3167
|
checkOption?: "local" | "cascaded" | undefined;
|
|
3170
3168
|
securityBarrier?: boolean | undefined;
|
|
@@ -3188,19 +3186,11 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
3188
3186
|
logAutovacuumMinDuration?: number | undefined;
|
|
3189
3187
|
userCatalogTable?: boolean | undefined;
|
|
3190
3188
|
} | undefined;
|
|
3189
|
+
using?: string | undefined;
|
|
3190
|
+
definition?: string | undefined;
|
|
3191
3191
|
withNoData?: boolean | undefined;
|
|
3192
3192
|
tablespace?: string | undefined;
|
|
3193
3193
|
}> | undefined;
|
|
3194
|
-
policies?: Record<string, {
|
|
3195
|
-
name: string;
|
|
3196
|
-
using?: string | undefined;
|
|
3197
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
3198
|
-
schema?: string | undefined;
|
|
3199
|
-
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
3200
|
-
to?: string[] | undefined;
|
|
3201
|
-
withCheck?: string | undefined;
|
|
3202
|
-
on?: string | undefined;
|
|
3203
|
-
}> | undefined;
|
|
3204
3194
|
sequences?: Record<string, {
|
|
3205
3195
|
name: string;
|
|
3206
3196
|
schema: string;
|
|
@@ -3217,6 +3207,16 @@ declare const pgSchema: zod.ZodObject<{
|
|
|
3217
3207
|
createRole?: boolean | undefined;
|
|
3218
3208
|
inherit?: boolean | undefined;
|
|
3219
3209
|
}> | undefined;
|
|
3210
|
+
internal?: {
|
|
3211
|
+
tables: Record<string, {
|
|
3212
|
+
columns: Record<string, {
|
|
3213
|
+
isArray?: boolean | undefined;
|
|
3214
|
+
dimensions?: number | undefined;
|
|
3215
|
+
rawType?: string | undefined;
|
|
3216
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
3217
|
+
} | undefined>;
|
|
3218
|
+
} | undefined>;
|
|
3219
|
+
} | undefined;
|
|
3220
3220
|
}>;
|
|
3221
3221
|
type PgSchema = TypeOf<typeof pgSchema>;
|
|
3222
3222
|
|
|
@@ -3244,29 +3244,29 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3244
3244
|
as: string;
|
|
3245
3245
|
}>>;
|
|
3246
3246
|
}, "strict", zod.ZodTypeAny, {
|
|
3247
|
-
name: string;
|
|
3248
3247
|
type: string;
|
|
3248
|
+
name: string;
|
|
3249
3249
|
primaryKey: boolean;
|
|
3250
3250
|
notNull: boolean;
|
|
3251
3251
|
default?: any;
|
|
3252
|
-
onUpdate?: any;
|
|
3253
|
-
autoincrement?: boolean | undefined;
|
|
3254
3252
|
generated?: {
|
|
3255
3253
|
type: "stored" | "virtual";
|
|
3256
3254
|
as: string;
|
|
3257
3255
|
} | undefined;
|
|
3256
|
+
onUpdate?: any;
|
|
3257
|
+
autoincrement?: boolean | undefined;
|
|
3258
3258
|
}, {
|
|
3259
|
-
name: string;
|
|
3260
3259
|
type: string;
|
|
3260
|
+
name: string;
|
|
3261
3261
|
primaryKey: boolean;
|
|
3262
3262
|
notNull: boolean;
|
|
3263
3263
|
default?: any;
|
|
3264
|
-
onUpdate?: any;
|
|
3265
|
-
autoincrement?: boolean | undefined;
|
|
3266
3264
|
generated?: {
|
|
3267
3265
|
type: "stored" | "virtual";
|
|
3268
3266
|
as: string;
|
|
3269
3267
|
} | undefined;
|
|
3268
|
+
onUpdate?: any;
|
|
3269
|
+
autoincrement?: boolean | undefined;
|
|
3270
3270
|
}>>;
|
|
3271
3271
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
3272
3272
|
name: zod.ZodString;
|
|
@@ -3281,14 +3281,14 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3281
3281
|
isUnique: boolean;
|
|
3282
3282
|
using?: "btree" | "hash" | undefined;
|
|
3283
3283
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3284
|
-
lock?: "
|
|
3284
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3285
3285
|
}, {
|
|
3286
3286
|
name: string;
|
|
3287
3287
|
columns: string[];
|
|
3288
3288
|
isUnique: boolean;
|
|
3289
3289
|
using?: "btree" | "hash" | undefined;
|
|
3290
3290
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3291
|
-
lock?: "
|
|
3291
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3292
3292
|
}>>;
|
|
3293
3293
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
3294
3294
|
name: zod.ZodString;
|
|
@@ -3313,17 +3313,17 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3313
3313
|
}, "strict", zod.ZodTypeAny, {
|
|
3314
3314
|
name: string;
|
|
3315
3315
|
columns: Record<string, {
|
|
3316
|
-
name: string;
|
|
3317
3316
|
type: string;
|
|
3317
|
+
name: string;
|
|
3318
3318
|
primaryKey: boolean;
|
|
3319
3319
|
notNull: boolean;
|
|
3320
3320
|
default?: any;
|
|
3321
|
-
onUpdate?: any;
|
|
3322
|
-
autoincrement?: boolean | undefined;
|
|
3323
3321
|
generated?: {
|
|
3324
3322
|
type: "stored" | "virtual";
|
|
3325
3323
|
as: string;
|
|
3326
3324
|
} | undefined;
|
|
3325
|
+
onUpdate?: any;
|
|
3326
|
+
autoincrement?: boolean | undefined;
|
|
3327
3327
|
}>;
|
|
3328
3328
|
indexes: Record<string, {
|
|
3329
3329
|
name: string;
|
|
@@ -3331,7 +3331,7 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3331
3331
|
isUnique: boolean;
|
|
3332
3332
|
using?: "btree" | "hash" | undefined;
|
|
3333
3333
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3334
|
-
lock?: "
|
|
3334
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3335
3335
|
}>;
|
|
3336
3336
|
compositePrimaryKeys: Record<string, {
|
|
3337
3337
|
name: string;
|
|
@@ -3344,17 +3344,17 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3344
3344
|
}, {
|
|
3345
3345
|
name: string;
|
|
3346
3346
|
columns: Record<string, {
|
|
3347
|
-
name: string;
|
|
3348
3347
|
type: string;
|
|
3348
|
+
name: string;
|
|
3349
3349
|
primaryKey: boolean;
|
|
3350
3350
|
notNull: boolean;
|
|
3351
3351
|
default?: any;
|
|
3352
|
-
onUpdate?: any;
|
|
3353
|
-
autoincrement?: boolean | undefined;
|
|
3354
3352
|
generated?: {
|
|
3355
3353
|
type: "stored" | "virtual";
|
|
3356
3354
|
as: string;
|
|
3357
3355
|
} | undefined;
|
|
3356
|
+
onUpdate?: any;
|
|
3357
|
+
autoincrement?: boolean | undefined;
|
|
3358
3358
|
}>;
|
|
3359
3359
|
indexes: Record<string, {
|
|
3360
3360
|
name: string;
|
|
@@ -3362,7 +3362,7 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3362
3362
|
isUnique: boolean;
|
|
3363
3363
|
using?: "btree" | "hash" | undefined;
|
|
3364
3364
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3365
|
-
lock?: "
|
|
3365
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3366
3366
|
}>;
|
|
3367
3367
|
compositePrimaryKeys: Record<string, {
|
|
3368
3368
|
name: string;
|
|
@@ -3377,11 +3377,11 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3377
3377
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
3378
3378
|
columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
3379
3379
|
}, "strip", zod.ZodTypeAny, {
|
|
3380
|
-
columns: Record<string, string>;
|
|
3381
3380
|
tables: Record<string, string>;
|
|
3382
|
-
}, {
|
|
3383
3381
|
columns: Record<string, string>;
|
|
3382
|
+
}, {
|
|
3384
3383
|
tables: Record<string, string>;
|
|
3384
|
+
columns: Record<string, string>;
|
|
3385
3385
|
}>;
|
|
3386
3386
|
internal: zod.ZodOptional<zod.ZodObject<{
|
|
3387
3387
|
tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
|
|
@@ -3419,46 +3419,48 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3419
3419
|
} | undefined>;
|
|
3420
3420
|
}>>>>;
|
|
3421
3421
|
}, "strip", zod.ZodTypeAny, {
|
|
3422
|
-
indexes?: Record<string, {
|
|
3423
|
-
columns: Record<string, {
|
|
3424
|
-
isExpression?: boolean | undefined;
|
|
3425
|
-
} | undefined>;
|
|
3426
|
-
} | undefined> | undefined;
|
|
3427
3422
|
tables?: Record<string, {
|
|
3428
3423
|
columns: Record<string, {
|
|
3429
3424
|
isDefaultAnExpression?: boolean | undefined;
|
|
3430
3425
|
} | undefined>;
|
|
3431
3426
|
} | undefined> | undefined;
|
|
3432
|
-
}, {
|
|
3433
3427
|
indexes?: Record<string, {
|
|
3434
3428
|
columns: Record<string, {
|
|
3435
3429
|
isExpression?: boolean | undefined;
|
|
3436
3430
|
} | undefined>;
|
|
3437
3431
|
} | undefined> | undefined;
|
|
3432
|
+
}, {
|
|
3438
3433
|
tables?: Record<string, {
|
|
3439
3434
|
columns: Record<string, {
|
|
3440
3435
|
isDefaultAnExpression?: boolean | undefined;
|
|
3441
3436
|
} | undefined>;
|
|
3442
3437
|
} | undefined> | undefined;
|
|
3438
|
+
indexes?: Record<string, {
|
|
3439
|
+
columns: Record<string, {
|
|
3440
|
+
isExpression?: boolean | undefined;
|
|
3441
|
+
} | undefined>;
|
|
3442
|
+
} | undefined> | undefined;
|
|
3443
3443
|
}>>;
|
|
3444
3444
|
} & {
|
|
3445
3445
|
id: zod.ZodString;
|
|
3446
3446
|
prevId: zod.ZodString;
|
|
3447
3447
|
}, "strip", zod.ZodTypeAny, {
|
|
3448
|
+
version: "1";
|
|
3449
|
+
dialect: "singlestore";
|
|
3448
3450
|
tables: Record<string, {
|
|
3449
3451
|
name: string;
|
|
3450
3452
|
columns: Record<string, {
|
|
3451
|
-
name: string;
|
|
3452
3453
|
type: string;
|
|
3454
|
+
name: string;
|
|
3453
3455
|
primaryKey: boolean;
|
|
3454
3456
|
notNull: boolean;
|
|
3455
3457
|
default?: any;
|
|
3456
|
-
onUpdate?: any;
|
|
3457
|
-
autoincrement?: boolean | undefined;
|
|
3458
3458
|
generated?: {
|
|
3459
3459
|
type: "stored" | "virtual";
|
|
3460
3460
|
as: string;
|
|
3461
3461
|
} | undefined;
|
|
3462
|
+
onUpdate?: any;
|
|
3463
|
+
autoincrement?: boolean | undefined;
|
|
3462
3464
|
}>;
|
|
3463
3465
|
indexes: Record<string, {
|
|
3464
3466
|
name: string;
|
|
@@ -3466,7 +3468,7 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3466
3468
|
isUnique: boolean;
|
|
3467
3469
|
using?: "btree" | "hash" | undefined;
|
|
3468
3470
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3469
|
-
lock?: "
|
|
3471
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3470
3472
|
}>;
|
|
3471
3473
|
compositePrimaryKeys: Record<string, {
|
|
3472
3474
|
name: string;
|
|
@@ -3477,41 +3479,41 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3477
3479
|
columns: string[];
|
|
3478
3480
|
}>;
|
|
3479
3481
|
}>;
|
|
3480
|
-
id: string;
|
|
3481
|
-
prevId: string;
|
|
3482
|
-
version: "1";
|
|
3483
|
-
dialect: "singlestore";
|
|
3484
3482
|
_meta: {
|
|
3485
|
-
columns: Record<string, string>;
|
|
3486
3483
|
tables: Record<string, string>;
|
|
3484
|
+
columns: Record<string, string>;
|
|
3487
3485
|
};
|
|
3486
|
+
id: string;
|
|
3487
|
+
prevId: string;
|
|
3488
3488
|
internal?: {
|
|
3489
|
-
|
|
3489
|
+
tables?: Record<string, {
|
|
3490
3490
|
columns: Record<string, {
|
|
3491
|
-
|
|
3491
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
3492
3492
|
} | undefined>;
|
|
3493
3493
|
} | undefined> | undefined;
|
|
3494
|
-
|
|
3494
|
+
indexes?: Record<string, {
|
|
3495
3495
|
columns: Record<string, {
|
|
3496
|
-
|
|
3496
|
+
isExpression?: boolean | undefined;
|
|
3497
3497
|
} | undefined>;
|
|
3498
3498
|
} | undefined> | undefined;
|
|
3499
3499
|
} | undefined;
|
|
3500
3500
|
}, {
|
|
3501
|
+
version: "1";
|
|
3502
|
+
dialect: "singlestore";
|
|
3501
3503
|
tables: Record<string, {
|
|
3502
3504
|
name: string;
|
|
3503
3505
|
columns: Record<string, {
|
|
3504
|
-
name: string;
|
|
3505
3506
|
type: string;
|
|
3507
|
+
name: string;
|
|
3506
3508
|
primaryKey: boolean;
|
|
3507
3509
|
notNull: boolean;
|
|
3508
3510
|
default?: any;
|
|
3509
|
-
onUpdate?: any;
|
|
3510
|
-
autoincrement?: boolean | undefined;
|
|
3511
3511
|
generated?: {
|
|
3512
3512
|
type: "stored" | "virtual";
|
|
3513
3513
|
as: string;
|
|
3514
3514
|
} | undefined;
|
|
3515
|
+
onUpdate?: any;
|
|
3516
|
+
autoincrement?: boolean | undefined;
|
|
3515
3517
|
}>;
|
|
3516
3518
|
indexes: Record<string, {
|
|
3517
3519
|
name: string;
|
|
@@ -3519,7 +3521,7 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3519
3521
|
isUnique: boolean;
|
|
3520
3522
|
using?: "btree" | "hash" | undefined;
|
|
3521
3523
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
3522
|
-
lock?: "
|
|
3524
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
3523
3525
|
}>;
|
|
3524
3526
|
compositePrimaryKeys: Record<string, {
|
|
3525
3527
|
name: string;
|
|
@@ -3530,23 +3532,21 @@ declare const schema$1: zod.ZodObject<{
|
|
|
3530
3532
|
columns: string[];
|
|
3531
3533
|
}> | undefined;
|
|
3532
3534
|
}>;
|
|
3533
|
-
id: string;
|
|
3534
|
-
prevId: string;
|
|
3535
|
-
version: "1";
|
|
3536
|
-
dialect: "singlestore";
|
|
3537
3535
|
_meta: {
|
|
3538
|
-
columns: Record<string, string>;
|
|
3539
3536
|
tables: Record<string, string>;
|
|
3537
|
+
columns: Record<string, string>;
|
|
3540
3538
|
};
|
|
3539
|
+
id: string;
|
|
3540
|
+
prevId: string;
|
|
3541
3541
|
internal?: {
|
|
3542
|
-
|
|
3542
|
+
tables?: Record<string, {
|
|
3543
3543
|
columns: Record<string, {
|
|
3544
|
-
|
|
3544
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
3545
3545
|
} | undefined>;
|
|
3546
3546
|
} | undefined> | undefined;
|
|
3547
|
-
|
|
3547
|
+
indexes?: Record<string, {
|
|
3548
3548
|
columns: Record<string, {
|
|
3549
|
-
|
|
3549
|
+
isExpression?: boolean | undefined;
|
|
3550
3550
|
} | undefined>;
|
|
3551
3551
|
} | undefined> | undefined;
|
|
3552
3552
|
} | undefined;
|
|
@@ -3576,27 +3576,27 @@ declare const schema$3: zod.ZodObject<{
|
|
|
3576
3576
|
as: string;
|
|
3577
3577
|
}>>;
|
|
3578
3578
|
}, "strict", zod.ZodTypeAny, {
|
|
3579
|
-
name: string;
|
|
3580
3579
|
type: string;
|
|
3580
|
+
name: string;
|
|
3581
3581
|
primaryKey: boolean;
|
|
3582
3582
|
notNull: boolean;
|
|
3583
3583
|
default?: any;
|
|
3584
|
-
autoincrement?: boolean | undefined;
|
|
3585
3584
|
generated?: {
|
|
3586
3585
|
type: "stored" | "virtual";
|
|
3587
3586
|
as: string;
|
|
3588
3587
|
} | undefined;
|
|
3588
|
+
autoincrement?: boolean | undefined;
|
|
3589
3589
|
}, {
|
|
3590
|
-
name: string;
|
|
3591
3590
|
type: string;
|
|
3591
|
+
name: string;
|
|
3592
3592
|
primaryKey: boolean;
|
|
3593
3593
|
notNull: boolean;
|
|
3594
3594
|
default?: any;
|
|
3595
|
-
autoincrement?: boolean | undefined;
|
|
3596
3595
|
generated?: {
|
|
3597
3596
|
type: "stored" | "virtual";
|
|
3598
3597
|
as: string;
|
|
3599
3598
|
} | undefined;
|
|
3599
|
+
autoincrement?: boolean | undefined;
|
|
3600
3600
|
}>>;
|
|
3601
3601
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
3602
3602
|
name: zod.ZodString;
|
|
@@ -3663,25 +3663,25 @@ declare const schema$3: zod.ZodObject<{
|
|
|
3663
3663
|
name: zod.ZodString;
|
|
3664
3664
|
value: zod.ZodString;
|
|
3665
3665
|
}, "strict", zod.ZodTypeAny, {
|
|
3666
|
-
name: string;
|
|
3667
3666
|
value: string;
|
|
3668
|
-
}, {
|
|
3669
3667
|
name: string;
|
|
3668
|
+
}, {
|
|
3670
3669
|
value: string;
|
|
3670
|
+
name: string;
|
|
3671
3671
|
}>>>;
|
|
3672
3672
|
}, "strict", zod.ZodTypeAny, {
|
|
3673
3673
|
name: string;
|
|
3674
3674
|
columns: Record<string, {
|
|
3675
|
-
name: string;
|
|
3676
3675
|
type: string;
|
|
3676
|
+
name: string;
|
|
3677
3677
|
primaryKey: boolean;
|
|
3678
3678
|
notNull: boolean;
|
|
3679
3679
|
default?: any;
|
|
3680
|
-
autoincrement?: boolean | undefined;
|
|
3681
3680
|
generated?: {
|
|
3682
3681
|
type: "stored" | "virtual";
|
|
3683
3682
|
as: string;
|
|
3684
3683
|
} | undefined;
|
|
3684
|
+
autoincrement?: boolean | undefined;
|
|
3685
3685
|
}>;
|
|
3686
3686
|
indexes: Record<string, {
|
|
3687
3687
|
name: string;
|
|
@@ -3707,22 +3707,22 @@ declare const schema$3: zod.ZodObject<{
|
|
|
3707
3707
|
columns: string[];
|
|
3708
3708
|
}>;
|
|
3709
3709
|
checkConstraints: Record<string, {
|
|
3710
|
-
name: string;
|
|
3711
3710
|
value: string;
|
|
3711
|
+
name: string;
|
|
3712
3712
|
}>;
|
|
3713
3713
|
}, {
|
|
3714
3714
|
name: string;
|
|
3715
3715
|
columns: Record<string, {
|
|
3716
|
-
name: string;
|
|
3717
3716
|
type: string;
|
|
3717
|
+
name: string;
|
|
3718
3718
|
primaryKey: boolean;
|
|
3719
3719
|
notNull: boolean;
|
|
3720
3720
|
default?: any;
|
|
3721
|
-
autoincrement?: boolean | undefined;
|
|
3722
3721
|
generated?: {
|
|
3723
3722
|
type: "stored" | "virtual";
|
|
3724
3723
|
as: string;
|
|
3725
3724
|
} | undefined;
|
|
3725
|
+
autoincrement?: boolean | undefined;
|
|
3726
3726
|
}>;
|
|
3727
3727
|
indexes: Record<string, {
|
|
3728
3728
|
name: string;
|
|
@@ -3748,8 +3748,8 @@ declare const schema$3: zod.ZodObject<{
|
|
|
3748
3748
|
columns: string[];
|
|
3749
3749
|
}> | undefined;
|
|
3750
3750
|
checkConstraints?: Record<string, {
|
|
3751
|
-
name: string;
|
|
3752
3751
|
value: string;
|
|
3752
|
+
name: string;
|
|
3753
3753
|
}> | undefined;
|
|
3754
3754
|
}>>;
|
|
3755
3755
|
views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -3772,59 +3772,59 @@ declare const schema$3: zod.ZodObject<{
|
|
|
3772
3772
|
as: string;
|
|
3773
3773
|
}>>;
|
|
3774
3774
|
}, "strict", zod.ZodTypeAny, {
|
|
3775
|
-
name: string;
|
|
3776
3775
|
type: string;
|
|
3776
|
+
name: string;
|
|
3777
3777
|
primaryKey: boolean;
|
|
3778
3778
|
notNull: boolean;
|
|
3779
3779
|
default?: any;
|
|
3780
|
-
autoincrement?: boolean | undefined;
|
|
3781
3780
|
generated?: {
|
|
3782
3781
|
type: "stored" | "virtual";
|
|
3783
3782
|
as: string;
|
|
3784
3783
|
} | undefined;
|
|
3784
|
+
autoincrement?: boolean | undefined;
|
|
3785
3785
|
}, {
|
|
3786
|
-
name: string;
|
|
3787
3786
|
type: string;
|
|
3787
|
+
name: string;
|
|
3788
3788
|
primaryKey: boolean;
|
|
3789
3789
|
notNull: boolean;
|
|
3790
3790
|
default?: any;
|
|
3791
|
-
autoincrement?: boolean | undefined;
|
|
3792
3791
|
generated?: {
|
|
3793
3792
|
type: "stored" | "virtual";
|
|
3794
3793
|
as: string;
|
|
3795
3794
|
} | undefined;
|
|
3795
|
+
autoincrement?: boolean | undefined;
|
|
3796
3796
|
}>>;
|
|
3797
3797
|
definition: zod.ZodOptional<zod.ZodString>;
|
|
3798
3798
|
isExisting: zod.ZodBoolean;
|
|
3799
3799
|
}, "strict", zod.ZodTypeAny, {
|
|
3800
3800
|
name: string;
|
|
3801
3801
|
columns: Record<string, {
|
|
3802
|
-
name: string;
|
|
3803
3802
|
type: string;
|
|
3803
|
+
name: string;
|
|
3804
3804
|
primaryKey: boolean;
|
|
3805
3805
|
notNull: boolean;
|
|
3806
3806
|
default?: any;
|
|
3807
|
-
autoincrement?: boolean | undefined;
|
|
3808
3807
|
generated?: {
|
|
3809
3808
|
type: "stored" | "virtual";
|
|
3810
3809
|
as: string;
|
|
3811
3810
|
} | undefined;
|
|
3811
|
+
autoincrement?: boolean | undefined;
|
|
3812
3812
|
}>;
|
|
3813
3813
|
isExisting: boolean;
|
|
3814
3814
|
definition?: string | undefined;
|
|
3815
3815
|
}, {
|
|
3816
3816
|
name: string;
|
|
3817
3817
|
columns: Record<string, {
|
|
3818
|
-
name: string;
|
|
3819
3818
|
type: string;
|
|
3819
|
+
name: string;
|
|
3820
3820
|
primaryKey: boolean;
|
|
3821
3821
|
notNull: boolean;
|
|
3822
3822
|
default?: any;
|
|
3823
|
-
autoincrement?: boolean | undefined;
|
|
3824
3823
|
generated?: {
|
|
3825
3824
|
type: "stored" | "virtual";
|
|
3826
3825
|
as: string;
|
|
3827
3826
|
} | undefined;
|
|
3827
|
+
autoincrement?: boolean | undefined;
|
|
3828
3828
|
}>;
|
|
3829
3829
|
isExisting: boolean;
|
|
3830
3830
|
definition?: string | undefined;
|
|
@@ -3834,11 +3834,11 @@ declare const schema$3: zod.ZodObject<{
|
|
|
3834
3834
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
3835
3835
|
columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
3836
3836
|
}, "strip", zod.ZodTypeAny, {
|
|
3837
|
-
columns: Record<string, string>;
|
|
3838
3837
|
tables: Record<string, string>;
|
|
3839
|
-
}, {
|
|
3840
3838
|
columns: Record<string, string>;
|
|
3839
|
+
}, {
|
|
3841
3840
|
tables: Record<string, string>;
|
|
3841
|
+
columns: Record<string, string>;
|
|
3842
3842
|
}>;
|
|
3843
3843
|
internal: zod.ZodOptional<zod.ZodObject<{
|
|
3844
3844
|
indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
|
|
@@ -3875,19 +3875,21 @@ declare const schema$3: zod.ZodObject<{
|
|
|
3875
3875
|
id: zod.ZodString;
|
|
3876
3876
|
prevId: zod.ZodString;
|
|
3877
3877
|
}, "strict", zod.ZodTypeAny, {
|
|
3878
|
+
version: "6";
|
|
3879
|
+
dialect: "sqlite";
|
|
3878
3880
|
tables: Record<string, {
|
|
3879
3881
|
name: string;
|
|
3880
3882
|
columns: Record<string, {
|
|
3881
|
-
name: string;
|
|
3882
3883
|
type: string;
|
|
3884
|
+
name: string;
|
|
3883
3885
|
primaryKey: boolean;
|
|
3884
3886
|
notNull: boolean;
|
|
3885
3887
|
default?: any;
|
|
3886
|
-
autoincrement?: boolean | undefined;
|
|
3887
3888
|
generated?: {
|
|
3888
3889
|
type: "stored" | "virtual";
|
|
3889
3890
|
as: string;
|
|
3890
3891
|
} | undefined;
|
|
3892
|
+
autoincrement?: boolean | undefined;
|
|
3891
3893
|
}>;
|
|
3892
3894
|
indexes: Record<string, {
|
|
3893
3895
|
name: string;
|
|
@@ -3913,36 +3915,34 @@ declare const schema$3: zod.ZodObject<{
|
|
|
3913
3915
|
columns: string[];
|
|
3914
3916
|
}>;
|
|
3915
3917
|
checkConstraints: Record<string, {
|
|
3916
|
-
name: string;
|
|
3917
3918
|
value: string;
|
|
3919
|
+
name: string;
|
|
3918
3920
|
}>;
|
|
3919
3921
|
}>;
|
|
3920
|
-
|
|
3921
|
-
prevId: string;
|
|
3922
|
-
version: "6";
|
|
3923
|
-
dialect: "sqlite";
|
|
3924
|
-
_meta: {
|
|
3925
|
-
columns: Record<string, string>;
|
|
3926
|
-
tables: Record<string, string>;
|
|
3927
|
-
};
|
|
3922
|
+
enums: {};
|
|
3928
3923
|
views: Record<string, {
|
|
3929
3924
|
name: string;
|
|
3930
3925
|
columns: Record<string, {
|
|
3931
|
-
name: string;
|
|
3932
3926
|
type: string;
|
|
3927
|
+
name: string;
|
|
3933
3928
|
primaryKey: boolean;
|
|
3934
3929
|
notNull: boolean;
|
|
3935
3930
|
default?: any;
|
|
3936
|
-
autoincrement?: boolean | undefined;
|
|
3937
3931
|
generated?: {
|
|
3938
3932
|
type: "stored" | "virtual";
|
|
3939
3933
|
as: string;
|
|
3940
3934
|
} | undefined;
|
|
3935
|
+
autoincrement?: boolean | undefined;
|
|
3941
3936
|
}>;
|
|
3942
3937
|
isExisting: boolean;
|
|
3943
3938
|
definition?: string | undefined;
|
|
3944
3939
|
}>;
|
|
3945
|
-
|
|
3940
|
+
_meta: {
|
|
3941
|
+
tables: Record<string, string>;
|
|
3942
|
+
columns: Record<string, string>;
|
|
3943
|
+
};
|
|
3944
|
+
id: string;
|
|
3945
|
+
prevId: string;
|
|
3946
3946
|
internal?: {
|
|
3947
3947
|
indexes?: Record<string, {
|
|
3948
3948
|
columns: Record<string, {
|
|
@@ -3951,19 +3951,21 @@ declare const schema$3: zod.ZodObject<{
|
|
|
3951
3951
|
} | undefined> | undefined;
|
|
3952
3952
|
} | undefined;
|
|
3953
3953
|
}, {
|
|
3954
|
+
version: "6";
|
|
3955
|
+
dialect: "sqlite";
|
|
3954
3956
|
tables: Record<string, {
|
|
3955
3957
|
name: string;
|
|
3956
3958
|
columns: Record<string, {
|
|
3957
|
-
name: string;
|
|
3958
3959
|
type: string;
|
|
3960
|
+
name: string;
|
|
3959
3961
|
primaryKey: boolean;
|
|
3960
3962
|
notNull: boolean;
|
|
3961
3963
|
default?: any;
|
|
3962
|
-
autoincrement?: boolean | undefined;
|
|
3963
3964
|
generated?: {
|
|
3964
3965
|
type: "stored" | "virtual";
|
|
3965
3966
|
as: string;
|
|
3966
3967
|
} | undefined;
|
|
3968
|
+
autoincrement?: boolean | undefined;
|
|
3967
3969
|
}>;
|
|
3968
3970
|
indexes: Record<string, {
|
|
3969
3971
|
name: string;
|
|
@@ -3989,43 +3991,41 @@ declare const schema$3: zod.ZodObject<{
|
|
|
3989
3991
|
columns: string[];
|
|
3990
3992
|
}> | undefined;
|
|
3991
3993
|
checkConstraints?: Record<string, {
|
|
3992
|
-
name: string;
|
|
3993
3994
|
value: string;
|
|
3995
|
+
name: string;
|
|
3994
3996
|
}> | undefined;
|
|
3995
3997
|
}>;
|
|
3996
|
-
|
|
3997
|
-
prevId: string;
|
|
3998
|
-
version: "6";
|
|
3999
|
-
dialect: "sqlite";
|
|
3998
|
+
enums: {};
|
|
4000
3999
|
_meta: {
|
|
4001
|
-
columns: Record<string, string>;
|
|
4002
4000
|
tables: Record<string, string>;
|
|
4001
|
+
columns: Record<string, string>;
|
|
4003
4002
|
};
|
|
4004
|
-
|
|
4005
|
-
|
|
4006
|
-
indexes?: Record<string, {
|
|
4007
|
-
columns: Record<string, {
|
|
4008
|
-
isExpression?: boolean | undefined;
|
|
4009
|
-
} | undefined>;
|
|
4010
|
-
} | undefined> | undefined;
|
|
4011
|
-
} | undefined;
|
|
4003
|
+
id: string;
|
|
4004
|
+
prevId: string;
|
|
4012
4005
|
views?: Record<string, {
|
|
4013
4006
|
name: string;
|
|
4014
4007
|
columns: Record<string, {
|
|
4015
|
-
name: string;
|
|
4016
4008
|
type: string;
|
|
4009
|
+
name: string;
|
|
4017
4010
|
primaryKey: boolean;
|
|
4018
4011
|
notNull: boolean;
|
|
4019
4012
|
default?: any;
|
|
4020
|
-
autoincrement?: boolean | undefined;
|
|
4021
4013
|
generated?: {
|
|
4022
4014
|
type: "stored" | "virtual";
|
|
4023
4015
|
as: string;
|
|
4024
4016
|
} | undefined;
|
|
4017
|
+
autoincrement?: boolean | undefined;
|
|
4025
4018
|
}>;
|
|
4026
4019
|
isExisting: boolean;
|
|
4027
4020
|
definition?: string | undefined;
|
|
4028
4021
|
}> | undefined;
|
|
4022
|
+
internal?: {
|
|
4023
|
+
indexes?: Record<string, {
|
|
4024
|
+
columns: Record<string, {
|
|
4025
|
+
isExpression?: boolean | undefined;
|
|
4026
|
+
} | undefined>;
|
|
4027
|
+
} | undefined> | undefined;
|
|
4028
|
+
} | undefined;
|
|
4029
4029
|
}>;
|
|
4030
4030
|
type SQLiteSchema = TypeOf<typeof schema$3>;
|
|
4031
4031
|
|
|
@@ -4066,25 +4066,28 @@ declare const pushSingleStoreSchema: (imports: Record<string, unknown>, drizzleI
|
|
|
4066
4066
|
apply: () => Promise<void>;
|
|
4067
4067
|
}>;
|
|
4068
4068
|
declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
4069
|
+
version: "7";
|
|
4070
|
+
dialect: "postgresql";
|
|
4069
4071
|
tables: Record<string, {
|
|
4070
4072
|
name: string;
|
|
4073
|
+
schema: string;
|
|
4071
4074
|
columns: Record<string, {
|
|
4072
|
-
name: string;
|
|
4073
4075
|
type: string;
|
|
4076
|
+
name: string;
|
|
4074
4077
|
primaryKey: boolean;
|
|
4075
4078
|
notNull: boolean;
|
|
4079
|
+
typeSchema?: string | undefined;
|
|
4076
4080
|
default?: any;
|
|
4077
4081
|
isUnique?: any;
|
|
4082
|
+
uniqueName?: string | undefined;
|
|
4083
|
+
nullsNotDistinct?: boolean | undefined;
|
|
4078
4084
|
generated?: {
|
|
4079
4085
|
type: "stored";
|
|
4080
4086
|
as: string;
|
|
4081
4087
|
} | undefined;
|
|
4082
|
-
typeSchema?: string | undefined;
|
|
4083
|
-
uniqueName?: string | undefined;
|
|
4084
|
-
nullsNotDistinct?: boolean | undefined;
|
|
4085
4088
|
identity?: {
|
|
4086
|
-
name: string;
|
|
4087
4089
|
type: "always" | "byDefault";
|
|
4090
|
+
name: string;
|
|
4088
4091
|
schema: string;
|
|
4089
4092
|
increment?: string | undefined;
|
|
4090
4093
|
minValue?: string | undefined;
|
|
@@ -4097,8 +4100,8 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
4097
4100
|
indexes: Record<string, {
|
|
4098
4101
|
name: string;
|
|
4099
4102
|
columns: {
|
|
4100
|
-
isExpression: boolean;
|
|
4101
4103
|
expression: string;
|
|
4104
|
+
isExpression: boolean;
|
|
4102
4105
|
asc: boolean;
|
|
4103
4106
|
nulls?: string | undefined;
|
|
4104
4107
|
opclass?: string | undefined;
|
|
@@ -4115,11 +4118,10 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
4115
4118
|
columnsFrom: string[];
|
|
4116
4119
|
tableTo: string;
|
|
4117
4120
|
columnsTo: string[];
|
|
4121
|
+
schemaTo?: string | undefined;
|
|
4118
4122
|
onUpdate?: string | undefined;
|
|
4119
4123
|
onDelete?: string | undefined;
|
|
4120
|
-
schemaTo?: string | undefined;
|
|
4121
4124
|
}>;
|
|
4122
|
-
schema: string;
|
|
4123
4125
|
compositePrimaryKeys: Record<string, {
|
|
4124
4126
|
name: string;
|
|
4125
4127
|
columns: string[];
|
|
@@ -4129,51 +4131,58 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
4129
4131
|
columns: string[];
|
|
4130
4132
|
nullsNotDistinct: boolean;
|
|
4131
4133
|
}>;
|
|
4132
|
-
checkConstraints: Record<string, {
|
|
4133
|
-
name: string;
|
|
4134
|
-
value: string;
|
|
4135
|
-
}>;
|
|
4136
4134
|
policies: Record<string, {
|
|
4137
4135
|
name: string;
|
|
4138
|
-
using?: string | undefined;
|
|
4139
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
4140
4136
|
schema?: string | undefined;
|
|
4137
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
4141
4138
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
4142
4139
|
to?: string[] | undefined;
|
|
4140
|
+
using?: string | undefined;
|
|
4143
4141
|
withCheck?: string | undefined;
|
|
4144
4142
|
on?: string | undefined;
|
|
4145
4143
|
}>;
|
|
4144
|
+
checkConstraints: Record<string, {
|
|
4145
|
+
value: string;
|
|
4146
|
+
name: string;
|
|
4147
|
+
}>;
|
|
4146
4148
|
isRLSEnabled: boolean;
|
|
4147
4149
|
}>;
|
|
4148
|
-
|
|
4149
|
-
|
|
4150
|
-
|
|
4151
|
-
|
|
4150
|
+
policies: Record<string, {
|
|
4151
|
+
name: string;
|
|
4152
|
+
schema?: string | undefined;
|
|
4153
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
4154
|
+
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
4155
|
+
to?: string[] | undefined;
|
|
4156
|
+
using?: string | undefined;
|
|
4157
|
+
withCheck?: string | undefined;
|
|
4158
|
+
on?: string | undefined;
|
|
4159
|
+
}>;
|
|
4160
|
+
enums: Record<string, {
|
|
4161
|
+
values: string[];
|
|
4162
|
+
name: string;
|
|
4163
|
+
schema: string;
|
|
4164
|
+
}>;
|
|
4152
4165
|
schemas: Record<string, string>;
|
|
4153
|
-
_meta: {
|
|
4154
|
-
columns: Record<string, string>;
|
|
4155
|
-
tables: Record<string, string>;
|
|
4156
|
-
schemas: Record<string, string>;
|
|
4157
|
-
};
|
|
4158
4166
|
views: Record<string, {
|
|
4159
4167
|
name: string;
|
|
4168
|
+
schema: string;
|
|
4160
4169
|
columns: Record<string, {
|
|
4161
|
-
name: string;
|
|
4162
4170
|
type: string;
|
|
4171
|
+
name: string;
|
|
4163
4172
|
primaryKey: boolean;
|
|
4164
4173
|
notNull: boolean;
|
|
4174
|
+
typeSchema?: string | undefined;
|
|
4165
4175
|
default?: any;
|
|
4166
4176
|
isUnique?: any;
|
|
4177
|
+
uniqueName?: string | undefined;
|
|
4178
|
+
nullsNotDistinct?: boolean | undefined;
|
|
4167
4179
|
generated?: {
|
|
4168
4180
|
type: "stored";
|
|
4169
4181
|
as: string;
|
|
4170
4182
|
} | undefined;
|
|
4171
|
-
typeSchema?: string | undefined;
|
|
4172
|
-
uniqueName?: string | undefined;
|
|
4173
|
-
nullsNotDistinct?: boolean | undefined;
|
|
4174
4183
|
identity?: {
|
|
4175
|
-
name: string;
|
|
4176
4184
|
type: "always" | "byDefault";
|
|
4185
|
+
name: string;
|
|
4177
4186
|
schema: string;
|
|
4178
4187
|
increment?: string | undefined;
|
|
4179
4188
|
minValue?: string | undefined;
|
|
@@ -4183,11 +4192,8 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
4183
4192
|
cycle?: boolean | undefined;
|
|
4184
4193
|
} | undefined;
|
|
4185
4194
|
}>;
|
|
4186
|
-
schema: string;
|
|
4187
|
-
isExisting: boolean;
|
|
4188
4195
|
materialized: boolean;
|
|
4189
|
-
|
|
4190
|
-
definition?: string | undefined;
|
|
4196
|
+
isExisting: boolean;
|
|
4191
4197
|
with?: {
|
|
4192
4198
|
checkOption?: "local" | "cascaded" | undefined;
|
|
4193
4199
|
securityBarrier?: boolean | undefined;
|
|
@@ -4211,24 +4217,11 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
4211
4217
|
logAutovacuumMinDuration?: number | undefined;
|
|
4212
4218
|
userCatalogTable?: boolean | undefined;
|
|
4213
4219
|
} | undefined;
|
|
4220
|
+
using?: string | undefined;
|
|
4221
|
+
definition?: string | undefined;
|
|
4214
4222
|
withNoData?: boolean | undefined;
|
|
4215
4223
|
tablespace?: string | undefined;
|
|
4216
4224
|
}>;
|
|
4217
|
-
enums: Record<string, {
|
|
4218
|
-
name: string;
|
|
4219
|
-
values: string[];
|
|
4220
|
-
schema: string;
|
|
4221
|
-
}>;
|
|
4222
|
-
policies: Record<string, {
|
|
4223
|
-
name: string;
|
|
4224
|
-
using?: string | undefined;
|
|
4225
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
4226
|
-
schema?: string | undefined;
|
|
4227
|
-
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
4228
|
-
to?: string[] | undefined;
|
|
4229
|
-
withCheck?: string | undefined;
|
|
4230
|
-
on?: string | undefined;
|
|
4231
|
-
}>;
|
|
4232
4225
|
sequences: Record<string, {
|
|
4233
4226
|
name: string;
|
|
4234
4227
|
schema: string;
|
|
@@ -4245,13 +4238,20 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
4245
4238
|
createRole?: boolean | undefined;
|
|
4246
4239
|
inherit?: boolean | undefined;
|
|
4247
4240
|
}>;
|
|
4241
|
+
_meta: {
|
|
4242
|
+
tables: Record<string, string>;
|
|
4243
|
+
columns: Record<string, string>;
|
|
4244
|
+
schemas: Record<string, string>;
|
|
4245
|
+
};
|
|
4246
|
+
id: string;
|
|
4247
|
+
prevId: string;
|
|
4248
4248
|
internal?: {
|
|
4249
4249
|
tables: Record<string, {
|
|
4250
4250
|
columns: Record<string, {
|
|
4251
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
4252
4251
|
isArray?: boolean | undefined;
|
|
4253
4252
|
dimensions?: number | undefined;
|
|
4254
4253
|
rawType?: string | undefined;
|
|
4254
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
4255
4255
|
} | undefined>;
|
|
4256
4256
|
} | undefined>;
|
|
4257
4257
|
} | undefined;
|
|
@@ -4342,11 +4342,10 @@ declare class DrizzleKitProvider {
|
|
|
4342
4342
|
protected executeStatements(statements: string[], provider: PostgresProvider, _schema?: string, catchErrors?: boolean): Promise<void>;
|
|
4343
4343
|
protected prepareSchema(schemaName: string, provider: PostgresProvider, repositories: any[]): Promise<void>;
|
|
4344
4344
|
/**
|
|
4345
|
-
*
|
|
4346
|
-
*
|
|
4347
|
-
* @protected
|
|
4345
|
+
* Try to load the official Drizzle Kit API.
|
|
4346
|
+
* If not available, fallback to the local kit import.
|
|
4348
4347
|
*/
|
|
4349
|
-
protected importDrizzleKit(): typeof DrizzleKit
|
|
4348
|
+
protected importDrizzleKit(): Promise<typeof DrizzleKit>;
|
|
4350
4349
|
}
|
|
4351
4350
|
|
|
4352
4351
|
declare module "alepha" {
|
|
@@ -4358,6 +4357,7 @@ declare const envSchema$1: _alepha_core.TObject<{
|
|
|
4358
4357
|
PG_USERNAME: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
|
|
4359
4358
|
PG_DATABASE: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
|
|
4360
4359
|
PG_PASSWORD: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
|
|
4360
|
+
PG_PORT: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
|
|
4361
4361
|
/**
|
|
4362
4362
|
*
|
|
4363
4363
|
*/
|
|
@@ -4392,8 +4392,8 @@ declare const envSchema$1: _alepha_core.TObject<{
|
|
|
4392
4392
|
POSTGRES_REJECT_UNAUTHORIZED: _sinclair_typebox.TBoolean;
|
|
4393
4393
|
}>;
|
|
4394
4394
|
interface NodePostgresProviderState {
|
|
4395
|
-
client:
|
|
4396
|
-
db:
|
|
4395
|
+
client: postgres.Sql;
|
|
4396
|
+
db: PostgresJsDatabase;
|
|
4397
4397
|
}
|
|
4398
4398
|
declare class NodePostgresProvider implements PostgresProvider {
|
|
4399
4399
|
readonly dialect = "postgres";
|
|
@@ -4403,6 +4403,7 @@ declare class NodePostgresProvider implements PostgresProvider {
|
|
|
4403
4403
|
PG_USERNAME?: string | undefined;
|
|
4404
4404
|
PG_DATABASE?: string | undefined;
|
|
4405
4405
|
PG_PASSWORD?: string | undefined;
|
|
4406
|
+
PG_PORT?: number | undefined;
|
|
4406
4407
|
POSTGRES_SCHEMA?: string | undefined;
|
|
4407
4408
|
POSTGRES_SYNCHRONIZE?: boolean | undefined;
|
|
4408
4409
|
POSTGRES_PUSH_SCHEMA?: boolean | undefined;
|
|
@@ -4417,7 +4418,7 @@ declare class NodePostgresProvider implements PostgresProvider {
|
|
|
4417
4418
|
* In testing mode, the schema name will be generated and deleted after the test.
|
|
4418
4419
|
*/
|
|
4419
4420
|
protected testingSchemaName?: string;
|
|
4420
|
-
get db():
|
|
4421
|
+
get db(): PostgresJsDatabase;
|
|
4421
4422
|
protected readonly configure: _alepha_core.HookDescriptor<"start">;
|
|
4422
4423
|
protected readonly stop: _alepha_core.HookDescriptor<"stop">;
|
|
4423
4424
|
/**
|
|
@@ -4427,14 +4428,12 @@ declare class NodePostgresProvider implements PostgresProvider {
|
|
|
4427
4428
|
execute(query: SQLLike): Promise<any[]>;
|
|
4428
4429
|
connect(): Promise<void>;
|
|
4429
4430
|
close(): Promise<void>;
|
|
4430
|
-
/**
|
|
4431
|
-
*
|
|
4432
|
-
* @protected
|
|
4433
|
-
*/
|
|
4434
4431
|
protected migrate: _alepha_lock.LockDescriptor<() => Promise<void>>;
|
|
4435
4432
|
protected createClient(): NodePostgresProviderState;
|
|
4436
4433
|
protected getMigrationOptions(): MigrationConfig;
|
|
4437
|
-
protected getClientOptions():
|
|
4434
|
+
protected getClientOptions(): postgres.Options<any>;
|
|
4435
|
+
protected sslModes: readonly ["require", "allow", "prefer", "verify-full"];
|
|
4436
|
+
protected ssl(url: URL | undefined): "require" | "allow" | "prefer" | "verify-full" | undefined;
|
|
4438
4437
|
}
|
|
4439
4438
|
|
|
4440
4439
|
/**
|