@aphexcms/postgresql-adapter 14.1.1 → 14.3.0

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/dist/schema.d.ts CHANGED
@@ -1,6 +1,7 @@
1
1
  export declare const documentStatusEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "published", "unpublished"]>;
2
2
  export declare const versionEventEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "publish"]>;
3
3
  export declare const schemaTypeEnum: import("drizzle-orm/pg-core").PgEnum<["document", "object"]>;
4
+ export declare const jobStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "leased", "completed", "failed", "cancelled"]>;
4
5
  export declare const organizations: import("drizzle-orm/pg-core").PgTableWithColumns<{
5
6
  name: "cms_organizations";
6
7
  schema: undefined;
@@ -535,6 +536,85 @@ export declare const instanceSettings: import("drizzle-orm/pg-core").PgTableWith
535
536
  };
536
537
  dialect: "pg";
537
538
  }>;
539
+ export declare const pluginSettings: import("drizzle-orm/pg-core").PgTableWithColumns<{
540
+ name: "cms_plugin_settings";
541
+ schema: undefined;
542
+ columns: {
543
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
544
+ name: "organization_id";
545
+ tableName: "cms_plugin_settings";
546
+ dataType: "string";
547
+ columnType: "PgUUID";
548
+ data: string;
549
+ driverParam: string;
550
+ notNull: true;
551
+ hasDefault: false;
552
+ isPrimaryKey: false;
553
+ isAutoincrement: false;
554
+ hasRuntimeDefault: false;
555
+ enumValues: undefined;
556
+ baseColumn: never;
557
+ identity: undefined;
558
+ generated: undefined;
559
+ }, {}, {}>;
560
+ pluginId: import("drizzle-orm/pg-core").PgColumn<{
561
+ name: "plugin_id";
562
+ tableName: "cms_plugin_settings";
563
+ dataType: "string";
564
+ columnType: "PgVarchar";
565
+ data: string;
566
+ driverParam: string;
567
+ notNull: true;
568
+ hasDefault: false;
569
+ isPrimaryKey: false;
570
+ isAutoincrement: false;
571
+ hasRuntimeDefault: false;
572
+ enumValues: [string, ...string[]];
573
+ baseColumn: never;
574
+ identity: undefined;
575
+ generated: undefined;
576
+ }, {}, {
577
+ length: 200;
578
+ }>;
579
+ values: import("drizzle-orm/pg-core").PgColumn<{
580
+ name: "values";
581
+ tableName: "cms_plugin_settings";
582
+ dataType: "json";
583
+ columnType: "PgJsonb";
584
+ data: Record<string, unknown>;
585
+ driverParam: unknown;
586
+ notNull: true;
587
+ hasDefault: true;
588
+ isPrimaryKey: false;
589
+ isAutoincrement: false;
590
+ hasRuntimeDefault: false;
591
+ enumValues: undefined;
592
+ baseColumn: never;
593
+ identity: undefined;
594
+ generated: undefined;
595
+ }, {}, {
596
+ $type: Record<string, unknown>;
597
+ }>;
598
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
599
+ name: "updated_at";
600
+ tableName: "cms_plugin_settings";
601
+ dataType: "date";
602
+ columnType: "PgTimestamp";
603
+ data: Date;
604
+ driverParam: string;
605
+ notNull: true;
606
+ hasDefault: true;
607
+ isPrimaryKey: false;
608
+ isAutoincrement: false;
609
+ hasRuntimeDefault: false;
610
+ enumValues: undefined;
611
+ baseColumn: never;
612
+ identity: undefined;
613
+ generated: undefined;
614
+ }, {}, {}>;
615
+ };
616
+ dialect: "pg";
617
+ }>;
538
618
  export declare const roles: import("drizzle-orm/pg-core").PgTableWithColumns<{
539
619
  name: "cms_roles";
540
620
  schema: undefined;
@@ -1549,13 +1629,13 @@ export declare const documentReferences: import("drizzle-orm/pg-core").PgTableWi
1549
1629
  };
1550
1630
  dialect: "pg";
1551
1631
  }>;
1552
- export declare const schemaTypes: import("drizzle-orm/pg-core").PgTableWithColumns<{
1553
- name: "cms_schema_types";
1632
+ export declare const domainEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
1633
+ name: "cms_domain_events";
1554
1634
  schema: undefined;
1555
1635
  columns: {
1556
1636
  id: import("drizzle-orm/pg-core").PgColumn<{
1557
1637
  name: "id";
1558
- tableName: "cms_schema_types";
1638
+ tableName: "cms_domain_events";
1559
1639
  dataType: "string";
1560
1640
  columnType: "PgUUID";
1561
1641
  data: string;
@@ -1570,11 +1650,11 @@ export declare const schemaTypes: import("drizzle-orm/pg-core").PgTableWithColum
1570
1650
  identity: undefined;
1571
1651
  generated: undefined;
1572
1652
  }, {}, {}>;
1573
- name: import("drizzle-orm/pg-core").PgColumn<{
1574
- name: "name";
1575
- tableName: "cms_schema_types";
1653
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
1654
+ name: "organization_id";
1655
+ tableName: "cms_domain_events";
1576
1656
  dataType: "string";
1577
- columnType: "PgVarchar";
1657
+ columnType: "PgUUID";
1578
1658
  data: string;
1579
1659
  driverParam: string;
1580
1660
  notNull: true;
@@ -1582,16 +1662,14 @@ export declare const schemaTypes: import("drizzle-orm/pg-core").PgTableWithColum
1582
1662
  isPrimaryKey: false;
1583
1663
  isAutoincrement: false;
1584
1664
  hasRuntimeDefault: false;
1585
- enumValues: [string, ...string[]];
1665
+ enumValues: undefined;
1586
1666
  baseColumn: never;
1587
1667
  identity: undefined;
1588
1668
  generated: undefined;
1589
- }, {}, {
1590
- length: 100;
1591
- }>;
1592
- title: import("drizzle-orm/pg-core").PgColumn<{
1593
- name: "title";
1594
- tableName: "cms_schema_types";
1669
+ }, {}, {}>;
1670
+ type: import("drizzle-orm/pg-core").PgColumn<{
1671
+ name: "type";
1672
+ tableName: "cms_domain_events";
1595
1673
  dataType: "string";
1596
1674
  columnType: "PgVarchar";
1597
1675
  data: string;
@@ -1608,26 +1686,28 @@ export declare const schemaTypes: import("drizzle-orm/pg-core").PgTableWithColum
1608
1686
  }, {}, {
1609
1687
  length: 200;
1610
1688
  }>;
1611
- type: import("drizzle-orm/pg-core").PgColumn<{
1612
- name: "type";
1613
- tableName: "cms_schema_types";
1614
- dataType: "string";
1615
- columnType: "PgEnumColumn";
1616
- data: "object" | "document";
1617
- driverParam: string;
1689
+ payload: import("drizzle-orm/pg-core").PgColumn<{
1690
+ name: "payload";
1691
+ tableName: "cms_domain_events";
1692
+ dataType: "json";
1693
+ columnType: "PgJsonb";
1694
+ data: Record<string, unknown>;
1695
+ driverParam: unknown;
1618
1696
  notNull: true;
1619
- hasDefault: false;
1697
+ hasDefault: true;
1620
1698
  isPrimaryKey: false;
1621
1699
  isAutoincrement: false;
1622
1700
  hasRuntimeDefault: false;
1623
- enumValues: ["document", "object"];
1701
+ enumValues: undefined;
1624
1702
  baseColumn: never;
1625
1703
  identity: undefined;
1626
1704
  generated: undefined;
1627
- }, {}, {}>;
1628
- description: import("drizzle-orm/pg-core").PgColumn<{
1629
- name: "description";
1630
- tableName: "cms_schema_types";
1705
+ }, {}, {
1706
+ $type: Record<string, unknown>;
1707
+ }>;
1708
+ correlationId: import("drizzle-orm/pg-core").PgColumn<{
1709
+ name: "correlation_id";
1710
+ tableName: "cms_domain_events";
1631
1711
  dataType: "string";
1632
1712
  columnType: "PgText";
1633
1713
  data: string;
@@ -1642,48 +1722,48 @@ export declare const schemaTypes: import("drizzle-orm/pg-core").PgTableWithColum
1642
1722
  identity: undefined;
1643
1723
  generated: undefined;
1644
1724
  }, {}, {}>;
1645
- fields: import("drizzle-orm/pg-core").PgColumn<{
1646
- name: "fields";
1647
- tableName: "cms_schema_types";
1648
- dataType: "json";
1649
- columnType: "PgJsonb";
1650
- data: unknown;
1651
- driverParam: unknown;
1652
- notNull: true;
1725
+ causationId: import("drizzle-orm/pg-core").PgColumn<{
1726
+ name: "causation_id";
1727
+ tableName: "cms_domain_events";
1728
+ dataType: "string";
1729
+ columnType: "PgText";
1730
+ data: string;
1731
+ driverParam: string;
1732
+ notNull: false;
1653
1733
  hasDefault: false;
1654
1734
  isPrimaryKey: false;
1655
1735
  isAutoincrement: false;
1656
1736
  hasRuntimeDefault: false;
1657
- enumValues: undefined;
1737
+ enumValues: [string, ...string[]];
1658
1738
  baseColumn: never;
1659
1739
  identity: undefined;
1660
1740
  generated: undefined;
1661
1741
  }, {}, {}>;
1662
- createdAt: import("drizzle-orm/pg-core").PgColumn<{
1663
- name: "created_at";
1664
- tableName: "cms_schema_types";
1665
- dataType: "date";
1666
- columnType: "PgTimestamp";
1667
- data: Date;
1742
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
1743
+ name: "created_by";
1744
+ tableName: "cms_domain_events";
1745
+ dataType: "string";
1746
+ columnType: "PgText";
1747
+ data: string;
1668
1748
  driverParam: string;
1669
1749
  notNull: false;
1670
- hasDefault: true;
1750
+ hasDefault: false;
1671
1751
  isPrimaryKey: false;
1672
1752
  isAutoincrement: false;
1673
1753
  hasRuntimeDefault: false;
1674
- enumValues: undefined;
1754
+ enumValues: [string, ...string[]];
1675
1755
  baseColumn: never;
1676
1756
  identity: undefined;
1677
1757
  generated: undefined;
1678
1758
  }, {}, {}>;
1679
- updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1680
- name: "updated_at";
1681
- tableName: "cms_schema_types";
1759
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1760
+ name: "created_at";
1761
+ tableName: "cms_domain_events";
1682
1762
  dataType: "date";
1683
1763
  columnType: "PgTimestamp";
1684
1764
  data: Date;
1685
1765
  driverParam: string;
1686
- notNull: false;
1766
+ notNull: true;
1687
1767
  hasDefault: true;
1688
1768
  isPrimaryKey: false;
1689
1769
  isAutoincrement: false;
@@ -1696,58 +1776,72 @@ export declare const schemaTypes: import("drizzle-orm/pg-core").PgTableWithColum
1696
1776
  };
1697
1777
  dialect: "pg";
1698
1778
  }>;
1699
- export declare const userProfiles: import("drizzle-orm/pg-core").PgTableWithColumns<{
1700
- name: "cms_user_profiles";
1779
+ export declare const jobs: import("drizzle-orm/pg-core").PgTableWithColumns<{
1780
+ name: "cms_jobs";
1701
1781
  schema: undefined;
1702
1782
  columns: {
1703
- userId: import("drizzle-orm/pg-core").PgColumn<{
1704
- name: "user_id";
1705
- tableName: "cms_user_profiles";
1783
+ id: import("drizzle-orm/pg-core").PgColumn<{
1784
+ name: "id";
1785
+ tableName: "cms_jobs";
1706
1786
  dataType: "string";
1707
- columnType: "PgText";
1787
+ columnType: "PgUUID";
1708
1788
  data: string;
1709
1789
  driverParam: string;
1710
1790
  notNull: true;
1711
- hasDefault: false;
1791
+ hasDefault: true;
1712
1792
  isPrimaryKey: true;
1713
1793
  isAutoincrement: false;
1714
1794
  hasRuntimeDefault: false;
1715
- enumValues: [string, ...string[]];
1795
+ enumValues: undefined;
1716
1796
  baseColumn: never;
1717
1797
  identity: undefined;
1718
1798
  generated: undefined;
1719
1799
  }, {}, {}>;
1720
- role: import("drizzle-orm/pg-core").PgColumn<{
1721
- name: "role";
1722
- tableName: "cms_user_profiles";
1800
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
1801
+ name: "organization_id";
1802
+ tableName: "cms_jobs";
1723
1803
  dataType: "string";
1724
- columnType: "PgText";
1725
- data: "super_admin" | "admin" | "editor" | "viewer";
1804
+ columnType: "PgUUID";
1805
+ data: string;
1726
1806
  driverParam: string;
1727
1807
  notNull: true;
1728
- hasDefault: true;
1808
+ hasDefault: false;
1729
1809
  isPrimaryKey: false;
1730
1810
  isAutoincrement: false;
1731
1811
  hasRuntimeDefault: false;
1732
- enumValues: ["super_admin", "admin", "editor", "viewer"];
1812
+ enumValues: undefined;
1733
1813
  baseColumn: never;
1734
1814
  identity: undefined;
1735
1815
  generated: undefined;
1736
1816
  }, {}, {}>;
1737
- preferences: import("drizzle-orm/pg-core").PgColumn<{
1738
- name: "preferences";
1739
- tableName: "cms_user_profiles";
1817
+ type: import("drizzle-orm/pg-core").PgColumn<{
1818
+ name: "type";
1819
+ tableName: "cms_jobs";
1820
+ dataType: "string";
1821
+ columnType: "PgVarchar";
1822
+ data: string;
1823
+ driverParam: string;
1824
+ notNull: true;
1825
+ hasDefault: false;
1826
+ isPrimaryKey: false;
1827
+ isAutoincrement: false;
1828
+ hasRuntimeDefault: false;
1829
+ enumValues: [string, ...string[]];
1830
+ baseColumn: never;
1831
+ identity: undefined;
1832
+ generated: undefined;
1833
+ }, {}, {
1834
+ length: 200;
1835
+ }>;
1836
+ payload: import("drizzle-orm/pg-core").PgColumn<{
1837
+ name: "payload";
1838
+ tableName: "cms_jobs";
1740
1839
  dataType: "json";
1741
1840
  columnType: "PgJsonb";
1742
- data: {
1743
- [key: string]: any;
1744
- theme?: "light" | "dark";
1745
- language?: string;
1746
- includeChildOrganizations?: boolean;
1747
- };
1841
+ data: Record<string, unknown>;
1748
1842
  driverParam: unknown;
1749
- notNull: false;
1750
- hasDefault: false;
1843
+ notNull: true;
1844
+ hasDefault: true;
1751
1845
  isPrimaryKey: false;
1752
1846
  isAutoincrement: false;
1753
1847
  hasRuntimeDefault: false;
@@ -1756,33 +1850,28 @@ export declare const userProfiles: import("drizzle-orm/pg-core").PgTableWithColu
1756
1850
  identity: undefined;
1757
1851
  generated: undefined;
1758
1852
  }, {}, {
1759
- $type: {
1760
- [key: string]: any;
1761
- theme?: "light" | "dark";
1762
- language?: string;
1763
- includeChildOrganizations?: boolean;
1764
- };
1853
+ $type: Record<string, unknown>;
1765
1854
  }>;
1766
- createdAt: import("drizzle-orm/pg-core").PgColumn<{
1767
- name: "created_at";
1768
- tableName: "cms_user_profiles";
1769
- dataType: "date";
1770
- columnType: "PgTimestamp";
1771
- data: Date;
1855
+ status: import("drizzle-orm/pg-core").PgColumn<{
1856
+ name: "status";
1857
+ tableName: "cms_jobs";
1858
+ dataType: "string";
1859
+ columnType: "PgEnumColumn";
1860
+ data: "pending" | "leased" | "completed" | "failed" | "cancelled";
1772
1861
  driverParam: string;
1773
1862
  notNull: true;
1774
1863
  hasDefault: true;
1775
1864
  isPrimaryKey: false;
1776
1865
  isAutoincrement: false;
1777
1866
  hasRuntimeDefault: false;
1778
- enumValues: undefined;
1867
+ enumValues: ["pending", "leased", "completed", "failed", "cancelled"];
1779
1868
  baseColumn: never;
1780
1869
  identity: undefined;
1781
1870
  generated: undefined;
1782
1871
  }, {}, {}>;
1783
- updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1784
- name: "updated_at";
1785
- tableName: "cms_user_profiles";
1872
+ runAt: import("drizzle-orm/pg-core").PgColumn<{
1873
+ name: "run_at";
1874
+ tableName: "cms_jobs";
1786
1875
  dataType: "date";
1787
1876
  columnType: "PgTimestamp";
1788
1877
  data: Date;
@@ -1797,55 +1886,1837 @@ export declare const userProfiles: import("drizzle-orm/pg-core").PgTableWithColu
1797
1886
  identity: undefined;
1798
1887
  generated: undefined;
1799
1888
  }, {}, {}>;
1800
- };
1801
- dialect: "pg";
1802
- }>;
1803
- export declare const cmsSchema: {
1804
- organizations: import("drizzle-orm/pg-core").PgTableWithColumns<{
1805
- name: "cms_organizations";
1806
- schema: undefined;
1807
- columns: {
1808
- id: import("drizzle-orm/pg-core").PgColumn<{
1809
- name: "id";
1810
- tableName: "cms_organizations";
1811
- dataType: "string";
1812
- columnType: "PgUUID";
1813
- data: string;
1814
- driverParam: string;
1815
- notNull: true;
1816
- hasDefault: true;
1817
- isPrimaryKey: true;
1818
- isAutoincrement: false;
1819
- hasRuntimeDefault: false;
1820
- enumValues: undefined;
1821
- baseColumn: never;
1822
- identity: undefined;
1823
- generated: undefined;
1824
- }, {}, {}>;
1825
- name: import("drizzle-orm/pg-core").PgColumn<{
1826
- name: "name";
1827
- tableName: "cms_organizations";
1828
- dataType: "string";
1829
- columnType: "PgVarchar";
1830
- data: string;
1831
- driverParam: string;
1832
- notNull: true;
1833
- hasDefault: false;
1889
+ attempts: import("drizzle-orm/pg-core").PgColumn<{
1890
+ name: "attempts";
1891
+ tableName: "cms_jobs";
1892
+ dataType: "number";
1893
+ columnType: "PgInteger";
1894
+ data: number;
1895
+ driverParam: string | number;
1896
+ notNull: true;
1897
+ hasDefault: true;
1898
+ isPrimaryKey: false;
1899
+ isAutoincrement: false;
1900
+ hasRuntimeDefault: false;
1901
+ enumValues: undefined;
1902
+ baseColumn: never;
1903
+ identity: undefined;
1904
+ generated: undefined;
1905
+ }, {}, {}>;
1906
+ maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
1907
+ name: "max_attempts";
1908
+ tableName: "cms_jobs";
1909
+ dataType: "number";
1910
+ columnType: "PgInteger";
1911
+ data: number;
1912
+ driverParam: string | number;
1913
+ notNull: true;
1914
+ hasDefault: true;
1915
+ isPrimaryKey: false;
1916
+ isAutoincrement: false;
1917
+ hasRuntimeDefault: false;
1918
+ enumValues: undefined;
1919
+ baseColumn: never;
1920
+ identity: undefined;
1921
+ generated: undefined;
1922
+ }, {}, {}>;
1923
+ leaseOwner: import("drizzle-orm/pg-core").PgColumn<{
1924
+ name: "lease_owner";
1925
+ tableName: "cms_jobs";
1926
+ dataType: "string";
1927
+ columnType: "PgText";
1928
+ data: string;
1929
+ driverParam: string;
1930
+ notNull: false;
1931
+ hasDefault: false;
1932
+ isPrimaryKey: false;
1933
+ isAutoincrement: false;
1934
+ hasRuntimeDefault: false;
1935
+ enumValues: [string, ...string[]];
1936
+ baseColumn: never;
1937
+ identity: undefined;
1938
+ generated: undefined;
1939
+ }, {}, {}>;
1940
+ leaseExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
1941
+ name: "lease_expires_at";
1942
+ tableName: "cms_jobs";
1943
+ dataType: "date";
1944
+ columnType: "PgTimestamp";
1945
+ data: Date;
1946
+ driverParam: string;
1947
+ notNull: false;
1948
+ hasDefault: false;
1949
+ isPrimaryKey: false;
1950
+ isAutoincrement: false;
1951
+ hasRuntimeDefault: false;
1952
+ enumValues: undefined;
1953
+ baseColumn: never;
1954
+ identity: undefined;
1955
+ generated: undefined;
1956
+ }, {}, {}>;
1957
+ lastError: import("drizzle-orm/pg-core").PgColumn<{
1958
+ name: "last_error";
1959
+ tableName: "cms_jobs";
1960
+ dataType: "string";
1961
+ columnType: "PgText";
1962
+ data: string;
1963
+ driverParam: string;
1964
+ notNull: false;
1965
+ hasDefault: false;
1966
+ isPrimaryKey: false;
1967
+ isAutoincrement: false;
1968
+ hasRuntimeDefault: false;
1969
+ enumValues: [string, ...string[]];
1970
+ baseColumn: never;
1971
+ identity: undefined;
1972
+ generated: undefined;
1973
+ }, {}, {}>;
1974
+ idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
1975
+ name: "idempotency_key";
1976
+ tableName: "cms_jobs";
1977
+ dataType: "string";
1978
+ columnType: "PgText";
1979
+ data: string;
1980
+ driverParam: string;
1981
+ notNull: false;
1982
+ hasDefault: false;
1983
+ isPrimaryKey: false;
1984
+ isAutoincrement: false;
1985
+ hasRuntimeDefault: false;
1986
+ enumValues: [string, ...string[]];
1987
+ baseColumn: never;
1988
+ identity: undefined;
1989
+ generated: undefined;
1990
+ }, {}, {}>;
1991
+ correlationId: import("drizzle-orm/pg-core").PgColumn<{
1992
+ name: "correlation_id";
1993
+ tableName: "cms_jobs";
1994
+ dataType: "string";
1995
+ columnType: "PgText";
1996
+ data: string;
1997
+ driverParam: string;
1998
+ notNull: false;
1999
+ hasDefault: false;
2000
+ isPrimaryKey: false;
2001
+ isAutoincrement: false;
2002
+ hasRuntimeDefault: false;
2003
+ enumValues: [string, ...string[]];
2004
+ baseColumn: never;
2005
+ identity: undefined;
2006
+ generated: undefined;
2007
+ }, {}, {}>;
2008
+ causationId: import("drizzle-orm/pg-core").PgColumn<{
2009
+ name: "causation_id";
2010
+ tableName: "cms_jobs";
2011
+ dataType: "string";
2012
+ columnType: "PgText";
2013
+ data: string;
2014
+ driverParam: string;
2015
+ notNull: false;
2016
+ hasDefault: false;
2017
+ isPrimaryKey: false;
2018
+ isAutoincrement: false;
2019
+ hasRuntimeDefault: false;
2020
+ enumValues: [string, ...string[]];
2021
+ baseColumn: never;
2022
+ identity: undefined;
2023
+ generated: undefined;
2024
+ }, {}, {}>;
2025
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
2026
+ name: "created_by";
2027
+ tableName: "cms_jobs";
2028
+ dataType: "string";
2029
+ columnType: "PgText";
2030
+ data: string;
2031
+ driverParam: string;
2032
+ notNull: false;
2033
+ hasDefault: false;
2034
+ isPrimaryKey: false;
2035
+ isAutoincrement: false;
2036
+ hasRuntimeDefault: false;
2037
+ enumValues: [string, ...string[]];
2038
+ baseColumn: never;
2039
+ identity: undefined;
2040
+ generated: undefined;
2041
+ }, {}, {}>;
2042
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2043
+ name: "created_at";
2044
+ tableName: "cms_jobs";
2045
+ dataType: "date";
2046
+ columnType: "PgTimestamp";
2047
+ data: Date;
2048
+ driverParam: string;
2049
+ notNull: true;
2050
+ hasDefault: true;
2051
+ isPrimaryKey: false;
2052
+ isAutoincrement: false;
2053
+ hasRuntimeDefault: false;
2054
+ enumValues: undefined;
2055
+ baseColumn: never;
2056
+ identity: undefined;
2057
+ generated: undefined;
2058
+ }, {}, {}>;
2059
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2060
+ name: "updated_at";
2061
+ tableName: "cms_jobs";
2062
+ dataType: "date";
2063
+ columnType: "PgTimestamp";
2064
+ data: Date;
2065
+ driverParam: string;
2066
+ notNull: true;
2067
+ hasDefault: true;
2068
+ isPrimaryKey: false;
2069
+ isAutoincrement: false;
2070
+ hasRuntimeDefault: false;
2071
+ enumValues: undefined;
2072
+ baseColumn: never;
2073
+ identity: undefined;
2074
+ generated: undefined;
2075
+ }, {}, {}>;
2076
+ completedAt: import("drizzle-orm/pg-core").PgColumn<{
2077
+ name: "completed_at";
2078
+ tableName: "cms_jobs";
2079
+ dataType: "date";
2080
+ columnType: "PgTimestamp";
2081
+ data: Date;
2082
+ driverParam: string;
2083
+ notNull: false;
2084
+ hasDefault: false;
2085
+ isPrimaryKey: false;
2086
+ isAutoincrement: false;
2087
+ hasRuntimeDefault: false;
2088
+ enumValues: undefined;
2089
+ baseColumn: never;
2090
+ identity: undefined;
2091
+ generated: undefined;
2092
+ }, {}, {}>;
2093
+ };
2094
+ dialect: "pg";
2095
+ }>;
2096
+ export declare const eventOutbox: import("drizzle-orm/pg-core").PgTableWithColumns<{
2097
+ name: "cms_event_outbox";
2098
+ schema: undefined;
2099
+ columns: {
2100
+ id: import("drizzle-orm/pg-core").PgColumn<{
2101
+ name: "id";
2102
+ tableName: "cms_event_outbox";
2103
+ dataType: "string";
2104
+ columnType: "PgUUID";
2105
+ data: string;
2106
+ driverParam: string;
2107
+ notNull: true;
2108
+ hasDefault: true;
2109
+ isPrimaryKey: true;
2110
+ isAutoincrement: false;
2111
+ hasRuntimeDefault: false;
2112
+ enumValues: undefined;
2113
+ baseColumn: never;
2114
+ identity: undefined;
2115
+ generated: undefined;
2116
+ }, {}, {}>;
2117
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
2118
+ name: "organization_id";
2119
+ tableName: "cms_event_outbox";
2120
+ dataType: "string";
2121
+ columnType: "PgUUID";
2122
+ data: string;
2123
+ driverParam: string;
2124
+ notNull: true;
2125
+ hasDefault: false;
2126
+ isPrimaryKey: false;
2127
+ isAutoincrement: false;
2128
+ hasRuntimeDefault: false;
2129
+ enumValues: undefined;
2130
+ baseColumn: never;
2131
+ identity: undefined;
2132
+ generated: undefined;
2133
+ }, {}, {}>;
2134
+ eventId: import("drizzle-orm/pg-core").PgColumn<{
2135
+ name: "event_id";
2136
+ tableName: "cms_event_outbox";
2137
+ dataType: "string";
2138
+ columnType: "PgUUID";
2139
+ data: string;
2140
+ driverParam: string;
2141
+ notNull: true;
2142
+ hasDefault: false;
2143
+ isPrimaryKey: false;
2144
+ isAutoincrement: false;
2145
+ hasRuntimeDefault: false;
2146
+ enumValues: undefined;
2147
+ baseColumn: never;
2148
+ identity: undefined;
2149
+ generated: undefined;
2150
+ }, {}, {}>;
2151
+ eventType: import("drizzle-orm/pg-core").PgColumn<{
2152
+ name: "event_type";
2153
+ tableName: "cms_event_outbox";
2154
+ dataType: "string";
2155
+ columnType: "PgVarchar";
2156
+ data: string;
2157
+ driverParam: string;
2158
+ notNull: true;
2159
+ hasDefault: false;
2160
+ isPrimaryKey: false;
2161
+ isAutoincrement: false;
2162
+ hasRuntimeDefault: false;
2163
+ enumValues: [string, ...string[]];
2164
+ baseColumn: never;
2165
+ identity: undefined;
2166
+ generated: undefined;
2167
+ }, {}, {
2168
+ length: 200;
2169
+ }>;
2170
+ payload: import("drizzle-orm/pg-core").PgColumn<{
2171
+ name: "payload";
2172
+ tableName: "cms_event_outbox";
2173
+ dataType: "json";
2174
+ columnType: "PgJsonb";
2175
+ data: Record<string, unknown>;
2176
+ driverParam: unknown;
2177
+ notNull: true;
2178
+ hasDefault: true;
2179
+ isPrimaryKey: false;
2180
+ isAutoincrement: false;
2181
+ hasRuntimeDefault: false;
2182
+ enumValues: undefined;
2183
+ baseColumn: never;
2184
+ identity: undefined;
2185
+ generated: undefined;
2186
+ }, {}, {
2187
+ $type: Record<string, unknown>;
2188
+ }>;
2189
+ correlationId: import("drizzle-orm/pg-core").PgColumn<{
2190
+ name: "correlation_id";
2191
+ tableName: "cms_event_outbox";
2192
+ dataType: "string";
2193
+ columnType: "PgText";
2194
+ data: string;
2195
+ driverParam: string;
2196
+ notNull: false;
2197
+ hasDefault: false;
2198
+ isPrimaryKey: false;
2199
+ isAutoincrement: false;
2200
+ hasRuntimeDefault: false;
2201
+ enumValues: [string, ...string[]];
2202
+ baseColumn: never;
2203
+ identity: undefined;
2204
+ generated: undefined;
2205
+ }, {}, {}>;
2206
+ causationId: import("drizzle-orm/pg-core").PgColumn<{
2207
+ name: "causation_id";
2208
+ tableName: "cms_event_outbox";
2209
+ dataType: "string";
2210
+ columnType: "PgText";
2211
+ data: string;
2212
+ driverParam: string;
2213
+ notNull: false;
2214
+ hasDefault: false;
2215
+ isPrimaryKey: false;
2216
+ isAutoincrement: false;
2217
+ hasRuntimeDefault: false;
2218
+ enumValues: [string, ...string[]];
2219
+ baseColumn: never;
2220
+ identity: undefined;
2221
+ generated: undefined;
2222
+ }, {}, {}>;
2223
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
2224
+ name: "created_by";
2225
+ tableName: "cms_event_outbox";
2226
+ dataType: "string";
2227
+ columnType: "PgText";
2228
+ data: string;
2229
+ driverParam: string;
2230
+ notNull: false;
2231
+ hasDefault: false;
2232
+ isPrimaryKey: false;
2233
+ isAutoincrement: false;
2234
+ hasRuntimeDefault: false;
2235
+ enumValues: [string, ...string[]];
2236
+ baseColumn: never;
2237
+ identity: undefined;
2238
+ generated: undefined;
2239
+ }, {}, {}>;
2240
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2241
+ name: "created_at";
2242
+ tableName: "cms_event_outbox";
2243
+ dataType: "date";
2244
+ columnType: "PgTimestamp";
2245
+ data: Date;
2246
+ driverParam: string;
2247
+ notNull: true;
2248
+ hasDefault: true;
2249
+ isPrimaryKey: false;
2250
+ isAutoincrement: false;
2251
+ hasRuntimeDefault: false;
2252
+ enumValues: undefined;
2253
+ baseColumn: never;
2254
+ identity: undefined;
2255
+ generated: undefined;
2256
+ }, {}, {}>;
2257
+ processedAt: import("drizzle-orm/pg-core").PgColumn<{
2258
+ name: "processed_at";
2259
+ tableName: "cms_event_outbox";
2260
+ dataType: "date";
2261
+ columnType: "PgTimestamp";
2262
+ data: Date;
2263
+ driverParam: string;
2264
+ notNull: false;
2265
+ hasDefault: false;
2266
+ isPrimaryKey: false;
2267
+ isAutoincrement: false;
2268
+ hasRuntimeDefault: false;
2269
+ enumValues: undefined;
2270
+ baseColumn: never;
2271
+ identity: undefined;
2272
+ generated: undefined;
2273
+ }, {}, {}>;
2274
+ };
2275
+ dialect: "pg";
2276
+ }>;
2277
+ export declare const pluginStorage: import("drizzle-orm/pg-core").PgTableWithColumns<{
2278
+ name: "cms_plugin_storage";
2279
+ schema: undefined;
2280
+ columns: {
2281
+ id: import("drizzle-orm/pg-core").PgColumn<{
2282
+ name: "id";
2283
+ tableName: "cms_plugin_storage";
2284
+ dataType: "string";
2285
+ columnType: "PgUUID";
2286
+ data: string;
2287
+ driverParam: string;
2288
+ notNull: true;
2289
+ hasDefault: true;
2290
+ isPrimaryKey: true;
2291
+ isAutoincrement: false;
2292
+ hasRuntimeDefault: false;
2293
+ enumValues: undefined;
2294
+ baseColumn: never;
2295
+ identity: undefined;
2296
+ generated: undefined;
2297
+ }, {}, {}>;
2298
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
2299
+ name: "organization_id";
2300
+ tableName: "cms_plugin_storage";
2301
+ dataType: "string";
2302
+ columnType: "PgUUID";
2303
+ data: string;
2304
+ driverParam: string;
2305
+ notNull: true;
2306
+ hasDefault: false;
2307
+ isPrimaryKey: false;
2308
+ isAutoincrement: false;
2309
+ hasRuntimeDefault: false;
2310
+ enumValues: undefined;
2311
+ baseColumn: never;
2312
+ identity: undefined;
2313
+ generated: undefined;
2314
+ }, {}, {}>;
2315
+ plugin: import("drizzle-orm/pg-core").PgColumn<{
2316
+ name: "plugin";
2317
+ tableName: "cms_plugin_storage";
2318
+ dataType: "string";
2319
+ columnType: "PgVarchar";
2320
+ data: string;
2321
+ driverParam: string;
2322
+ notNull: true;
2323
+ hasDefault: false;
2324
+ isPrimaryKey: false;
2325
+ isAutoincrement: false;
2326
+ hasRuntimeDefault: false;
2327
+ enumValues: [string, ...string[]];
2328
+ baseColumn: never;
2329
+ identity: undefined;
2330
+ generated: undefined;
2331
+ }, {}, {
2332
+ length: 200;
2333
+ }>;
2334
+ collection: import("drizzle-orm/pg-core").PgColumn<{
2335
+ name: "collection";
2336
+ tableName: "cms_plugin_storage";
2337
+ dataType: "string";
2338
+ columnType: "PgVarchar";
2339
+ data: string;
2340
+ driverParam: string;
2341
+ notNull: true;
2342
+ hasDefault: false;
2343
+ isPrimaryKey: false;
2344
+ isAutoincrement: false;
2345
+ hasRuntimeDefault: false;
2346
+ enumValues: [string, ...string[]];
2347
+ baseColumn: never;
2348
+ identity: undefined;
2349
+ generated: undefined;
2350
+ }, {}, {
2351
+ length: 200;
2352
+ }>;
2353
+ data: import("drizzle-orm/pg-core").PgColumn<{
2354
+ name: "data";
2355
+ tableName: "cms_plugin_storage";
2356
+ dataType: "json";
2357
+ columnType: "PgJsonb";
2358
+ data: Record<string, unknown>;
2359
+ driverParam: unknown;
2360
+ notNull: true;
2361
+ hasDefault: true;
2362
+ isPrimaryKey: false;
2363
+ isAutoincrement: false;
2364
+ hasRuntimeDefault: false;
2365
+ enumValues: undefined;
2366
+ baseColumn: never;
2367
+ identity: undefined;
2368
+ generated: undefined;
2369
+ }, {}, {
2370
+ $type: Record<string, unknown>;
2371
+ }>;
2372
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2373
+ name: "created_at";
2374
+ tableName: "cms_plugin_storage";
2375
+ dataType: "date";
2376
+ columnType: "PgTimestamp";
2377
+ data: Date;
2378
+ driverParam: string;
2379
+ notNull: true;
2380
+ hasDefault: true;
2381
+ isPrimaryKey: false;
2382
+ isAutoincrement: false;
2383
+ hasRuntimeDefault: false;
2384
+ enumValues: undefined;
2385
+ baseColumn: never;
2386
+ identity: undefined;
2387
+ generated: undefined;
2388
+ }, {}, {}>;
2389
+ };
2390
+ dialect: "pg";
2391
+ }>;
2392
+ export declare const schemaTypes: import("drizzle-orm/pg-core").PgTableWithColumns<{
2393
+ name: "cms_schema_types";
2394
+ schema: undefined;
2395
+ columns: {
2396
+ id: import("drizzle-orm/pg-core").PgColumn<{
2397
+ name: "id";
2398
+ tableName: "cms_schema_types";
2399
+ dataType: "string";
2400
+ columnType: "PgUUID";
2401
+ data: string;
2402
+ driverParam: string;
2403
+ notNull: true;
2404
+ hasDefault: true;
2405
+ isPrimaryKey: true;
2406
+ isAutoincrement: false;
2407
+ hasRuntimeDefault: false;
2408
+ enumValues: undefined;
2409
+ baseColumn: never;
2410
+ identity: undefined;
2411
+ generated: undefined;
2412
+ }, {}, {}>;
2413
+ name: import("drizzle-orm/pg-core").PgColumn<{
2414
+ name: "name";
2415
+ tableName: "cms_schema_types";
2416
+ dataType: "string";
2417
+ columnType: "PgVarchar";
2418
+ data: string;
2419
+ driverParam: string;
2420
+ notNull: true;
2421
+ hasDefault: false;
2422
+ isPrimaryKey: false;
2423
+ isAutoincrement: false;
2424
+ hasRuntimeDefault: false;
2425
+ enumValues: [string, ...string[]];
2426
+ baseColumn: never;
2427
+ identity: undefined;
2428
+ generated: undefined;
2429
+ }, {}, {
2430
+ length: 100;
2431
+ }>;
2432
+ title: import("drizzle-orm/pg-core").PgColumn<{
2433
+ name: "title";
2434
+ tableName: "cms_schema_types";
2435
+ dataType: "string";
2436
+ columnType: "PgVarchar";
2437
+ data: string;
2438
+ driverParam: string;
2439
+ notNull: true;
2440
+ hasDefault: false;
2441
+ isPrimaryKey: false;
2442
+ isAutoincrement: false;
2443
+ hasRuntimeDefault: false;
2444
+ enumValues: [string, ...string[]];
2445
+ baseColumn: never;
2446
+ identity: undefined;
2447
+ generated: undefined;
2448
+ }, {}, {
2449
+ length: 200;
2450
+ }>;
2451
+ type: import("drizzle-orm/pg-core").PgColumn<{
2452
+ name: "type";
2453
+ tableName: "cms_schema_types";
2454
+ dataType: "string";
2455
+ columnType: "PgEnumColumn";
2456
+ data: "object" | "document";
2457
+ driverParam: string;
2458
+ notNull: true;
2459
+ hasDefault: false;
2460
+ isPrimaryKey: false;
2461
+ isAutoincrement: false;
2462
+ hasRuntimeDefault: false;
2463
+ enumValues: ["document", "object"];
2464
+ baseColumn: never;
2465
+ identity: undefined;
2466
+ generated: undefined;
2467
+ }, {}, {}>;
2468
+ description: import("drizzle-orm/pg-core").PgColumn<{
2469
+ name: "description";
2470
+ tableName: "cms_schema_types";
2471
+ dataType: "string";
2472
+ columnType: "PgText";
2473
+ data: string;
2474
+ driverParam: string;
2475
+ notNull: false;
2476
+ hasDefault: false;
2477
+ isPrimaryKey: false;
2478
+ isAutoincrement: false;
2479
+ hasRuntimeDefault: false;
2480
+ enumValues: [string, ...string[]];
2481
+ baseColumn: never;
2482
+ identity: undefined;
2483
+ generated: undefined;
2484
+ }, {}, {}>;
2485
+ fields: import("drizzle-orm/pg-core").PgColumn<{
2486
+ name: "fields";
2487
+ tableName: "cms_schema_types";
2488
+ dataType: "json";
2489
+ columnType: "PgJsonb";
2490
+ data: unknown;
2491
+ driverParam: unknown;
2492
+ notNull: true;
2493
+ hasDefault: false;
2494
+ isPrimaryKey: false;
2495
+ isAutoincrement: false;
2496
+ hasRuntimeDefault: false;
2497
+ enumValues: undefined;
2498
+ baseColumn: never;
2499
+ identity: undefined;
2500
+ generated: undefined;
2501
+ }, {}, {}>;
2502
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2503
+ name: "created_at";
2504
+ tableName: "cms_schema_types";
2505
+ dataType: "date";
2506
+ columnType: "PgTimestamp";
2507
+ data: Date;
2508
+ driverParam: string;
2509
+ notNull: false;
2510
+ hasDefault: true;
2511
+ isPrimaryKey: false;
2512
+ isAutoincrement: false;
2513
+ hasRuntimeDefault: false;
2514
+ enumValues: undefined;
2515
+ baseColumn: never;
2516
+ identity: undefined;
2517
+ generated: undefined;
2518
+ }, {}, {}>;
2519
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2520
+ name: "updated_at";
2521
+ tableName: "cms_schema_types";
2522
+ dataType: "date";
2523
+ columnType: "PgTimestamp";
2524
+ data: Date;
2525
+ driverParam: string;
2526
+ notNull: false;
2527
+ hasDefault: true;
2528
+ isPrimaryKey: false;
2529
+ isAutoincrement: false;
2530
+ hasRuntimeDefault: false;
2531
+ enumValues: undefined;
2532
+ baseColumn: never;
2533
+ identity: undefined;
2534
+ generated: undefined;
2535
+ }, {}, {}>;
2536
+ };
2537
+ dialect: "pg";
2538
+ }>;
2539
+ export declare const userProfiles: import("drizzle-orm/pg-core").PgTableWithColumns<{
2540
+ name: "cms_user_profiles";
2541
+ schema: undefined;
2542
+ columns: {
2543
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2544
+ name: "user_id";
2545
+ tableName: "cms_user_profiles";
2546
+ dataType: "string";
2547
+ columnType: "PgText";
2548
+ data: string;
2549
+ driverParam: string;
2550
+ notNull: true;
2551
+ hasDefault: false;
2552
+ isPrimaryKey: true;
2553
+ isAutoincrement: false;
2554
+ hasRuntimeDefault: false;
2555
+ enumValues: [string, ...string[]];
2556
+ baseColumn: never;
2557
+ identity: undefined;
2558
+ generated: undefined;
2559
+ }, {}, {}>;
2560
+ role: import("drizzle-orm/pg-core").PgColumn<{
2561
+ name: "role";
2562
+ tableName: "cms_user_profiles";
2563
+ dataType: "string";
2564
+ columnType: "PgText";
2565
+ data: "super_admin" | "admin" | "editor" | "viewer";
2566
+ driverParam: string;
2567
+ notNull: true;
2568
+ hasDefault: true;
2569
+ isPrimaryKey: false;
2570
+ isAutoincrement: false;
2571
+ hasRuntimeDefault: false;
2572
+ enumValues: ["super_admin", "admin", "editor", "viewer"];
2573
+ baseColumn: never;
2574
+ identity: undefined;
2575
+ generated: undefined;
2576
+ }, {}, {}>;
2577
+ preferences: import("drizzle-orm/pg-core").PgColumn<{
2578
+ name: "preferences";
2579
+ tableName: "cms_user_profiles";
2580
+ dataType: "json";
2581
+ columnType: "PgJsonb";
2582
+ data: {
2583
+ [key: string]: any;
2584
+ theme?: "light" | "dark";
2585
+ language?: string;
2586
+ includeChildOrganizations?: boolean;
2587
+ };
2588
+ driverParam: unknown;
2589
+ notNull: false;
2590
+ hasDefault: false;
2591
+ isPrimaryKey: false;
2592
+ isAutoincrement: false;
2593
+ hasRuntimeDefault: false;
2594
+ enumValues: undefined;
2595
+ baseColumn: never;
2596
+ identity: undefined;
2597
+ generated: undefined;
2598
+ }, {}, {
2599
+ $type: {
2600
+ [key: string]: any;
2601
+ theme?: "light" | "dark";
2602
+ language?: string;
2603
+ includeChildOrganizations?: boolean;
2604
+ };
2605
+ }>;
2606
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2607
+ name: "created_at";
2608
+ tableName: "cms_user_profiles";
2609
+ dataType: "date";
2610
+ columnType: "PgTimestamp";
2611
+ data: Date;
2612
+ driverParam: string;
2613
+ notNull: true;
2614
+ hasDefault: true;
2615
+ isPrimaryKey: false;
2616
+ isAutoincrement: false;
2617
+ hasRuntimeDefault: false;
2618
+ enumValues: undefined;
2619
+ baseColumn: never;
2620
+ identity: undefined;
2621
+ generated: undefined;
2622
+ }, {}, {}>;
2623
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2624
+ name: "updated_at";
2625
+ tableName: "cms_user_profiles";
2626
+ dataType: "date";
2627
+ columnType: "PgTimestamp";
2628
+ data: Date;
2629
+ driverParam: string;
2630
+ notNull: true;
2631
+ hasDefault: true;
2632
+ isPrimaryKey: false;
2633
+ isAutoincrement: false;
2634
+ hasRuntimeDefault: false;
2635
+ enumValues: undefined;
2636
+ baseColumn: never;
2637
+ identity: undefined;
2638
+ generated: undefined;
2639
+ }, {}, {}>;
2640
+ };
2641
+ dialect: "pg";
2642
+ }>;
2643
+ export declare const cmsSchema: {
2644
+ organizations: import("drizzle-orm/pg-core").PgTableWithColumns<{
2645
+ name: "cms_organizations";
2646
+ schema: undefined;
2647
+ columns: {
2648
+ id: import("drizzle-orm/pg-core").PgColumn<{
2649
+ name: "id";
2650
+ tableName: "cms_organizations";
2651
+ dataType: "string";
2652
+ columnType: "PgUUID";
2653
+ data: string;
2654
+ driverParam: string;
2655
+ notNull: true;
2656
+ hasDefault: true;
2657
+ isPrimaryKey: true;
2658
+ isAutoincrement: false;
2659
+ hasRuntimeDefault: false;
2660
+ enumValues: undefined;
2661
+ baseColumn: never;
2662
+ identity: undefined;
2663
+ generated: undefined;
2664
+ }, {}, {}>;
2665
+ name: import("drizzle-orm/pg-core").PgColumn<{
2666
+ name: "name";
2667
+ tableName: "cms_organizations";
2668
+ dataType: "string";
2669
+ columnType: "PgVarchar";
2670
+ data: string;
2671
+ driverParam: string;
2672
+ notNull: true;
2673
+ hasDefault: false;
2674
+ isPrimaryKey: false;
2675
+ isAutoincrement: false;
2676
+ hasRuntimeDefault: false;
2677
+ enumValues: [string, ...string[]];
2678
+ baseColumn: never;
2679
+ identity: undefined;
2680
+ generated: undefined;
2681
+ }, {}, {
2682
+ length: 200;
2683
+ }>;
2684
+ slug: import("drizzle-orm/pg-core").PgColumn<{
2685
+ name: "slug";
2686
+ tableName: "cms_organizations";
2687
+ dataType: "string";
2688
+ columnType: "PgVarchar";
2689
+ data: string;
2690
+ driverParam: string;
2691
+ notNull: true;
2692
+ hasDefault: false;
2693
+ isPrimaryKey: false;
2694
+ isAutoincrement: false;
2695
+ hasRuntimeDefault: false;
2696
+ enumValues: [string, ...string[]];
2697
+ baseColumn: never;
2698
+ identity: undefined;
2699
+ generated: undefined;
2700
+ }, {}, {
2701
+ length: 100;
2702
+ }>;
2703
+ parentOrganizationId: import("drizzle-orm/pg-core").PgColumn<{
2704
+ name: "parent_organization_id";
2705
+ tableName: "cms_organizations";
2706
+ dataType: "string";
2707
+ columnType: "PgUUID";
2708
+ data: string;
2709
+ driverParam: string;
2710
+ notNull: false;
2711
+ hasDefault: false;
2712
+ isPrimaryKey: false;
2713
+ isAutoincrement: false;
2714
+ hasRuntimeDefault: false;
2715
+ enumValues: undefined;
2716
+ baseColumn: never;
2717
+ identity: undefined;
2718
+ generated: undefined;
2719
+ }, {}, {}>;
2720
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
2721
+ name: "metadata";
2722
+ tableName: "cms_organizations";
2723
+ dataType: "json";
2724
+ columnType: "PgJsonb";
2725
+ data: {
2726
+ logo?: string;
2727
+ theme?: {
2728
+ primaryColor: string;
2729
+ fontFamily: string;
2730
+ logoUrl: string;
2731
+ };
2732
+ website?: string;
2733
+ settings?: Record<string, any>;
2734
+ };
2735
+ driverParam: unknown;
2736
+ notNull: false;
2737
+ hasDefault: false;
2738
+ isPrimaryKey: false;
2739
+ isAutoincrement: false;
2740
+ hasRuntimeDefault: false;
2741
+ enumValues: undefined;
2742
+ baseColumn: never;
2743
+ identity: undefined;
2744
+ generated: undefined;
2745
+ }, {}, {
2746
+ $type: {
2747
+ logo?: string;
2748
+ theme?: {
2749
+ primaryColor: string;
2750
+ fontFamily: string;
2751
+ logoUrl: string;
2752
+ };
2753
+ website?: string;
2754
+ settings?: Record<string, any>;
2755
+ };
2756
+ }>;
2757
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
2758
+ name: "created_by";
2759
+ tableName: "cms_organizations";
2760
+ dataType: "string";
2761
+ columnType: "PgText";
2762
+ data: string;
2763
+ driverParam: string;
2764
+ notNull: true;
2765
+ hasDefault: false;
2766
+ isPrimaryKey: false;
2767
+ isAutoincrement: false;
2768
+ hasRuntimeDefault: false;
2769
+ enumValues: [string, ...string[]];
2770
+ baseColumn: never;
2771
+ identity: undefined;
2772
+ generated: undefined;
2773
+ }, {}, {}>;
2774
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2775
+ name: "created_at";
2776
+ tableName: "cms_organizations";
2777
+ dataType: "date";
2778
+ columnType: "PgTimestamp";
2779
+ data: Date;
2780
+ driverParam: string;
2781
+ notNull: true;
2782
+ hasDefault: true;
2783
+ isPrimaryKey: false;
2784
+ isAutoincrement: false;
2785
+ hasRuntimeDefault: false;
2786
+ enumValues: undefined;
2787
+ baseColumn: never;
2788
+ identity: undefined;
2789
+ generated: undefined;
2790
+ }, {}, {}>;
2791
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2792
+ name: "updated_at";
2793
+ tableName: "cms_organizations";
2794
+ dataType: "date";
2795
+ columnType: "PgTimestamp";
2796
+ data: Date;
2797
+ driverParam: string;
2798
+ notNull: true;
2799
+ hasDefault: true;
2800
+ isPrimaryKey: false;
2801
+ isAutoincrement: false;
2802
+ hasRuntimeDefault: false;
2803
+ enumValues: undefined;
2804
+ baseColumn: never;
2805
+ identity: undefined;
2806
+ generated: undefined;
2807
+ }, {}, {}>;
2808
+ };
2809
+ dialect: "pg";
2810
+ }>;
2811
+ organizationMembers: import("drizzle-orm/pg-core").PgTableWithColumns<{
2812
+ name: "cms_organization_members";
2813
+ schema: undefined;
2814
+ columns: {
2815
+ id: import("drizzle-orm/pg-core").PgColumn<{
2816
+ name: "id";
2817
+ tableName: "cms_organization_members";
2818
+ dataType: "string";
2819
+ columnType: "PgUUID";
2820
+ data: string;
2821
+ driverParam: string;
2822
+ notNull: true;
2823
+ hasDefault: true;
2824
+ isPrimaryKey: true;
2825
+ isAutoincrement: false;
2826
+ hasRuntimeDefault: false;
2827
+ enumValues: undefined;
2828
+ baseColumn: never;
2829
+ identity: undefined;
2830
+ generated: undefined;
2831
+ }, {}, {}>;
2832
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
2833
+ name: "organization_id";
2834
+ tableName: "cms_organization_members";
2835
+ dataType: "string";
2836
+ columnType: "PgUUID";
2837
+ data: string;
2838
+ driverParam: string;
2839
+ notNull: true;
2840
+ hasDefault: false;
2841
+ isPrimaryKey: false;
2842
+ isAutoincrement: false;
2843
+ hasRuntimeDefault: false;
2844
+ enumValues: undefined;
2845
+ baseColumn: never;
2846
+ identity: undefined;
2847
+ generated: undefined;
2848
+ }, {}, {}>;
2849
+ userId: import("drizzle-orm/pg-core").PgColumn<{
2850
+ name: "user_id";
2851
+ tableName: "cms_organization_members";
2852
+ dataType: "string";
2853
+ columnType: "PgText";
2854
+ data: string;
2855
+ driverParam: string;
2856
+ notNull: true;
2857
+ hasDefault: false;
2858
+ isPrimaryKey: false;
2859
+ isAutoincrement: false;
2860
+ hasRuntimeDefault: false;
2861
+ enumValues: [string, ...string[]];
2862
+ baseColumn: never;
2863
+ identity: undefined;
2864
+ generated: undefined;
2865
+ }, {}, {}>;
2866
+ role: import("drizzle-orm/pg-core").PgColumn<{
2867
+ name: "role";
2868
+ tableName: "cms_organization_members";
2869
+ dataType: "string";
2870
+ columnType: "PgText";
2871
+ data: string;
2872
+ driverParam: string;
2873
+ notNull: true;
2874
+ hasDefault: false;
2875
+ isPrimaryKey: false;
2876
+ isAutoincrement: false;
2877
+ hasRuntimeDefault: false;
2878
+ enumValues: [string, ...string[]];
2879
+ baseColumn: never;
2880
+ identity: undefined;
2881
+ generated: undefined;
2882
+ }, {}, {}>;
2883
+ preferences: import("drizzle-orm/pg-core").PgColumn<{
2884
+ name: "preferences";
2885
+ tableName: "cms_organization_members";
2886
+ dataType: "json";
2887
+ columnType: "PgJsonb";
2888
+ data: Record<string, any>;
2889
+ driverParam: unknown;
2890
+ notNull: false;
2891
+ hasDefault: false;
2892
+ isPrimaryKey: false;
2893
+ isAutoincrement: false;
2894
+ hasRuntimeDefault: false;
2895
+ enumValues: undefined;
2896
+ baseColumn: never;
2897
+ identity: undefined;
2898
+ generated: undefined;
2899
+ }, {}, {
2900
+ $type: Record<string, any>;
2901
+ }>;
2902
+ invitationId: import("drizzle-orm/pg-core").PgColumn<{
2903
+ name: "invitation_id";
2904
+ tableName: "cms_organization_members";
2905
+ dataType: "string";
2906
+ columnType: "PgUUID";
2907
+ data: string;
2908
+ driverParam: string;
2909
+ notNull: false;
2910
+ hasDefault: false;
2911
+ isPrimaryKey: false;
2912
+ isAutoincrement: false;
2913
+ hasRuntimeDefault: false;
2914
+ enumValues: undefined;
2915
+ baseColumn: never;
2916
+ identity: undefined;
2917
+ generated: undefined;
2918
+ }, {}, {}>;
2919
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2920
+ name: "created_at";
2921
+ tableName: "cms_organization_members";
2922
+ dataType: "date";
2923
+ columnType: "PgTimestamp";
2924
+ data: Date;
2925
+ driverParam: string;
2926
+ notNull: true;
2927
+ hasDefault: true;
2928
+ isPrimaryKey: false;
2929
+ isAutoincrement: false;
2930
+ hasRuntimeDefault: false;
2931
+ enumValues: undefined;
2932
+ baseColumn: never;
2933
+ identity: undefined;
2934
+ generated: undefined;
2935
+ }, {}, {}>;
2936
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2937
+ name: "updated_at";
2938
+ tableName: "cms_organization_members";
2939
+ dataType: "date";
2940
+ columnType: "PgTimestamp";
2941
+ data: Date;
2942
+ driverParam: string;
2943
+ notNull: true;
2944
+ hasDefault: true;
2945
+ isPrimaryKey: false;
2946
+ isAutoincrement: false;
2947
+ hasRuntimeDefault: false;
2948
+ enumValues: undefined;
2949
+ baseColumn: never;
2950
+ identity: undefined;
2951
+ generated: undefined;
2952
+ }, {}, {}>;
2953
+ };
2954
+ dialect: "pg";
2955
+ }>;
2956
+ invitations: import("drizzle-orm/pg-core").PgTableWithColumns<{
2957
+ name: "cms_invitations";
2958
+ schema: undefined;
2959
+ columns: {
2960
+ id: import("drizzle-orm/pg-core").PgColumn<{
2961
+ name: "id";
2962
+ tableName: "cms_invitations";
2963
+ dataType: "string";
2964
+ columnType: "PgUUID";
2965
+ data: string;
2966
+ driverParam: string;
2967
+ notNull: true;
2968
+ hasDefault: true;
2969
+ isPrimaryKey: true;
2970
+ isAutoincrement: false;
2971
+ hasRuntimeDefault: false;
2972
+ enumValues: undefined;
2973
+ baseColumn: never;
2974
+ identity: undefined;
2975
+ generated: undefined;
2976
+ }, {}, {}>;
2977
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
2978
+ name: "organization_id";
2979
+ tableName: "cms_invitations";
2980
+ dataType: "string";
2981
+ columnType: "PgUUID";
2982
+ data: string;
2983
+ driverParam: string;
2984
+ notNull: true;
2985
+ hasDefault: false;
2986
+ isPrimaryKey: false;
2987
+ isAutoincrement: false;
2988
+ hasRuntimeDefault: false;
2989
+ enumValues: undefined;
2990
+ baseColumn: never;
2991
+ identity: undefined;
2992
+ generated: undefined;
2993
+ }, {}, {}>;
2994
+ email: import("drizzle-orm/pg-core").PgColumn<{
2995
+ name: "email";
2996
+ tableName: "cms_invitations";
2997
+ dataType: "string";
2998
+ columnType: "PgVarchar";
2999
+ data: string;
3000
+ driverParam: string;
3001
+ notNull: true;
3002
+ hasDefault: false;
3003
+ isPrimaryKey: false;
3004
+ isAutoincrement: false;
3005
+ hasRuntimeDefault: false;
3006
+ enumValues: [string, ...string[]];
3007
+ baseColumn: never;
3008
+ identity: undefined;
3009
+ generated: undefined;
3010
+ }, {}, {
3011
+ length: 255;
3012
+ }>;
3013
+ role: import("drizzle-orm/pg-core").PgColumn<{
3014
+ name: "role";
3015
+ tableName: "cms_invitations";
3016
+ dataType: "string";
3017
+ columnType: "PgText";
3018
+ data: string;
3019
+ driverParam: string;
3020
+ notNull: true;
3021
+ hasDefault: false;
3022
+ isPrimaryKey: false;
3023
+ isAutoincrement: false;
3024
+ hasRuntimeDefault: false;
3025
+ enumValues: [string, ...string[]];
3026
+ baseColumn: never;
3027
+ identity: undefined;
3028
+ generated: undefined;
3029
+ }, {}, {}>;
3030
+ token: import("drizzle-orm/pg-core").PgColumn<{
3031
+ name: "token";
3032
+ tableName: "cms_invitations";
3033
+ dataType: "string";
3034
+ columnType: "PgText";
3035
+ data: string;
3036
+ driverParam: string;
3037
+ notNull: true;
3038
+ hasDefault: false;
3039
+ isPrimaryKey: false;
3040
+ isAutoincrement: false;
3041
+ hasRuntimeDefault: false;
3042
+ enumValues: [string, ...string[]];
3043
+ baseColumn: never;
3044
+ identity: undefined;
3045
+ generated: undefined;
3046
+ }, {}, {}>;
3047
+ invitedBy: import("drizzle-orm/pg-core").PgColumn<{
3048
+ name: "invited_by";
3049
+ tableName: "cms_invitations";
3050
+ dataType: "string";
3051
+ columnType: "PgText";
3052
+ data: string;
3053
+ driverParam: string;
3054
+ notNull: true;
3055
+ hasDefault: false;
3056
+ isPrimaryKey: false;
3057
+ isAutoincrement: false;
3058
+ hasRuntimeDefault: false;
3059
+ enumValues: [string, ...string[]];
3060
+ baseColumn: never;
3061
+ identity: undefined;
3062
+ generated: undefined;
3063
+ }, {}, {}>;
3064
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
3065
+ name: "expires_at";
3066
+ tableName: "cms_invitations";
3067
+ dataType: "date";
3068
+ columnType: "PgTimestamp";
3069
+ data: Date;
3070
+ driverParam: string;
3071
+ notNull: true;
3072
+ hasDefault: false;
3073
+ isPrimaryKey: false;
3074
+ isAutoincrement: false;
3075
+ hasRuntimeDefault: false;
3076
+ enumValues: undefined;
3077
+ baseColumn: never;
3078
+ identity: undefined;
3079
+ generated: undefined;
3080
+ }, {}, {}>;
3081
+ acceptedAt: import("drizzle-orm/pg-core").PgColumn<{
3082
+ name: "accepted_at";
3083
+ tableName: "cms_invitations";
3084
+ dataType: "date";
3085
+ columnType: "PgTimestamp";
3086
+ data: Date;
3087
+ driverParam: string;
3088
+ notNull: false;
3089
+ hasDefault: false;
3090
+ isPrimaryKey: false;
3091
+ isAutoincrement: false;
3092
+ hasRuntimeDefault: false;
3093
+ enumValues: undefined;
3094
+ baseColumn: never;
3095
+ identity: undefined;
3096
+ generated: undefined;
3097
+ }, {}, {}>;
3098
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3099
+ name: "created_at";
3100
+ tableName: "cms_invitations";
3101
+ dataType: "date";
3102
+ columnType: "PgTimestamp";
3103
+ data: Date;
3104
+ driverParam: string;
3105
+ notNull: true;
3106
+ hasDefault: true;
3107
+ isPrimaryKey: false;
3108
+ isAutoincrement: false;
3109
+ hasRuntimeDefault: false;
3110
+ enumValues: undefined;
3111
+ baseColumn: never;
3112
+ identity: undefined;
3113
+ generated: undefined;
3114
+ }, {}, {}>;
3115
+ };
3116
+ dialect: "pg";
3117
+ }>;
3118
+ roles: import("drizzle-orm/pg-core").PgTableWithColumns<{
3119
+ name: "cms_roles";
3120
+ schema: undefined;
3121
+ columns: {
3122
+ id: import("drizzle-orm/pg-core").PgColumn<{
3123
+ name: "id";
3124
+ tableName: "cms_roles";
3125
+ dataType: "string";
3126
+ columnType: "PgUUID";
3127
+ data: string;
3128
+ driverParam: string;
3129
+ notNull: true;
3130
+ hasDefault: true;
3131
+ isPrimaryKey: true;
3132
+ isAutoincrement: false;
3133
+ hasRuntimeDefault: false;
3134
+ enumValues: undefined;
3135
+ baseColumn: never;
3136
+ identity: undefined;
3137
+ generated: undefined;
3138
+ }, {}, {}>;
3139
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
3140
+ name: "organization_id";
3141
+ tableName: "cms_roles";
3142
+ dataType: "string";
3143
+ columnType: "PgUUID";
3144
+ data: string;
3145
+ driverParam: string;
3146
+ notNull: true;
3147
+ hasDefault: false;
3148
+ isPrimaryKey: false;
3149
+ isAutoincrement: false;
3150
+ hasRuntimeDefault: false;
3151
+ enumValues: undefined;
3152
+ baseColumn: never;
3153
+ identity: undefined;
3154
+ generated: undefined;
3155
+ }, {}, {}>;
3156
+ name: import("drizzle-orm/pg-core").PgColumn<{
3157
+ name: "name";
3158
+ tableName: "cms_roles";
3159
+ dataType: "string";
3160
+ columnType: "PgVarchar";
3161
+ data: string;
3162
+ driverParam: string;
3163
+ notNull: true;
3164
+ hasDefault: false;
3165
+ isPrimaryKey: false;
3166
+ isAutoincrement: false;
3167
+ hasRuntimeDefault: false;
3168
+ enumValues: [string, ...string[]];
3169
+ baseColumn: never;
3170
+ identity: undefined;
3171
+ generated: undefined;
3172
+ }, {}, {
3173
+ length: 100;
3174
+ }>;
3175
+ description: import("drizzle-orm/pg-core").PgColumn<{
3176
+ name: "description";
3177
+ tableName: "cms_roles";
3178
+ dataType: "string";
3179
+ columnType: "PgText";
3180
+ data: string;
3181
+ driverParam: string;
3182
+ notNull: false;
3183
+ hasDefault: false;
3184
+ isPrimaryKey: false;
3185
+ isAutoincrement: false;
3186
+ hasRuntimeDefault: false;
3187
+ enumValues: [string, ...string[]];
3188
+ baseColumn: never;
3189
+ identity: undefined;
3190
+ generated: undefined;
3191
+ }, {}, {}>;
3192
+ capabilities: import("drizzle-orm/pg-core").PgColumn<{
3193
+ name: "capabilities";
3194
+ tableName: "cms_roles";
3195
+ dataType: "json";
3196
+ columnType: "PgJsonb";
3197
+ data: string[];
3198
+ driverParam: unknown;
3199
+ notNull: true;
3200
+ hasDefault: true;
3201
+ isPrimaryKey: false;
3202
+ isAutoincrement: false;
3203
+ hasRuntimeDefault: false;
3204
+ enumValues: undefined;
3205
+ baseColumn: never;
3206
+ identity: undefined;
3207
+ generated: undefined;
3208
+ }, {}, {
3209
+ $type: string[];
3210
+ }>;
3211
+ isBuiltIn: import("drizzle-orm/pg-core").PgColumn<{
3212
+ name: "is_built_in";
3213
+ tableName: "cms_roles";
3214
+ dataType: "string";
3215
+ columnType: "PgText";
3216
+ data: string;
3217
+ driverParam: string;
3218
+ notNull: true;
3219
+ hasDefault: true;
3220
+ isPrimaryKey: false;
3221
+ isAutoincrement: false;
3222
+ hasRuntimeDefault: false;
3223
+ enumValues: [string, ...string[]];
3224
+ baseColumn: never;
3225
+ identity: undefined;
3226
+ generated: undefined;
3227
+ }, {}, {}>;
3228
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3229
+ name: "created_at";
3230
+ tableName: "cms_roles";
3231
+ dataType: "date";
3232
+ columnType: "PgTimestamp";
3233
+ data: Date;
3234
+ driverParam: string;
3235
+ notNull: true;
3236
+ hasDefault: true;
3237
+ isPrimaryKey: false;
3238
+ isAutoincrement: false;
3239
+ hasRuntimeDefault: false;
3240
+ enumValues: undefined;
3241
+ baseColumn: never;
3242
+ identity: undefined;
3243
+ generated: undefined;
3244
+ }, {}, {}>;
3245
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3246
+ name: "updated_at";
3247
+ tableName: "cms_roles";
3248
+ dataType: "date";
3249
+ columnType: "PgTimestamp";
3250
+ data: Date;
3251
+ driverParam: string;
3252
+ notNull: true;
3253
+ hasDefault: true;
3254
+ isPrimaryKey: false;
3255
+ isAutoincrement: false;
3256
+ hasRuntimeDefault: false;
3257
+ enumValues: undefined;
3258
+ baseColumn: never;
3259
+ identity: undefined;
3260
+ generated: undefined;
3261
+ }, {}, {}>;
3262
+ };
3263
+ dialect: "pg";
3264
+ }>;
3265
+ instanceSettings: import("drizzle-orm/pg-core").PgTableWithColumns<{
3266
+ name: "cms_instance_settings";
3267
+ schema: undefined;
3268
+ columns: {
3269
+ id: import("drizzle-orm/pg-core").PgColumn<{
3270
+ name: "id";
3271
+ tableName: "cms_instance_settings";
3272
+ dataType: "string";
3273
+ columnType: "PgText";
3274
+ data: string;
3275
+ driverParam: string;
3276
+ notNull: true;
3277
+ hasDefault: true;
3278
+ isPrimaryKey: true;
3279
+ isAutoincrement: false;
3280
+ hasRuntimeDefault: false;
3281
+ enumValues: [string, ...string[]];
3282
+ baseColumn: never;
3283
+ identity: undefined;
3284
+ generated: undefined;
3285
+ }, {}, {}>;
3286
+ settings: import("drizzle-orm/pg-core").PgColumn<{
3287
+ name: "settings";
3288
+ tableName: "cms_instance_settings";
3289
+ dataType: "json";
3290
+ columnType: "PgJsonb";
3291
+ data: Record<string, any>;
3292
+ driverParam: unknown;
3293
+ notNull: true;
3294
+ hasDefault: true;
3295
+ isPrimaryKey: false;
3296
+ isAutoincrement: false;
3297
+ hasRuntimeDefault: false;
3298
+ enumValues: undefined;
3299
+ baseColumn: never;
3300
+ identity: undefined;
3301
+ generated: undefined;
3302
+ }, {}, {
3303
+ $type: Record<string, any>;
3304
+ }>;
3305
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3306
+ name: "updated_at";
3307
+ tableName: "cms_instance_settings";
3308
+ dataType: "date";
3309
+ columnType: "PgTimestamp";
3310
+ data: Date;
3311
+ driverParam: string;
3312
+ notNull: true;
3313
+ hasDefault: true;
3314
+ isPrimaryKey: false;
3315
+ isAutoincrement: false;
3316
+ hasRuntimeDefault: false;
3317
+ enumValues: undefined;
3318
+ baseColumn: never;
3319
+ identity: undefined;
3320
+ generated: undefined;
3321
+ }, {}, {}>;
3322
+ };
3323
+ dialect: "pg";
3324
+ }>;
3325
+ pluginSettings: import("drizzle-orm/pg-core").PgTableWithColumns<{
3326
+ name: "cms_plugin_settings";
3327
+ schema: undefined;
3328
+ columns: {
3329
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
3330
+ name: "organization_id";
3331
+ tableName: "cms_plugin_settings";
3332
+ dataType: "string";
3333
+ columnType: "PgUUID";
3334
+ data: string;
3335
+ driverParam: string;
3336
+ notNull: true;
3337
+ hasDefault: false;
3338
+ isPrimaryKey: false;
3339
+ isAutoincrement: false;
3340
+ hasRuntimeDefault: false;
3341
+ enumValues: undefined;
3342
+ baseColumn: never;
3343
+ identity: undefined;
3344
+ generated: undefined;
3345
+ }, {}, {}>;
3346
+ pluginId: import("drizzle-orm/pg-core").PgColumn<{
3347
+ name: "plugin_id";
3348
+ tableName: "cms_plugin_settings";
3349
+ dataType: "string";
3350
+ columnType: "PgVarchar";
3351
+ data: string;
3352
+ driverParam: string;
3353
+ notNull: true;
3354
+ hasDefault: false;
3355
+ isPrimaryKey: false;
3356
+ isAutoincrement: false;
3357
+ hasRuntimeDefault: false;
3358
+ enumValues: [string, ...string[]];
3359
+ baseColumn: never;
3360
+ identity: undefined;
3361
+ generated: undefined;
3362
+ }, {}, {
3363
+ length: 200;
3364
+ }>;
3365
+ values: import("drizzle-orm/pg-core").PgColumn<{
3366
+ name: "values";
3367
+ tableName: "cms_plugin_settings";
3368
+ dataType: "json";
3369
+ columnType: "PgJsonb";
3370
+ data: Record<string, unknown>;
3371
+ driverParam: unknown;
3372
+ notNull: true;
3373
+ hasDefault: true;
3374
+ isPrimaryKey: false;
3375
+ isAutoincrement: false;
3376
+ hasRuntimeDefault: false;
3377
+ enumValues: undefined;
3378
+ baseColumn: never;
3379
+ identity: undefined;
3380
+ generated: undefined;
3381
+ }, {}, {
3382
+ $type: Record<string, unknown>;
3383
+ }>;
3384
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3385
+ name: "updated_at";
3386
+ tableName: "cms_plugin_settings";
3387
+ dataType: "date";
3388
+ columnType: "PgTimestamp";
3389
+ data: Date;
3390
+ driverParam: string;
3391
+ notNull: true;
3392
+ hasDefault: true;
3393
+ isPrimaryKey: false;
3394
+ isAutoincrement: false;
3395
+ hasRuntimeDefault: false;
3396
+ enumValues: undefined;
3397
+ baseColumn: never;
3398
+ identity: undefined;
3399
+ generated: undefined;
3400
+ }, {}, {}>;
3401
+ };
3402
+ dialect: "pg";
3403
+ }>;
3404
+ userSessions: import("drizzle-orm/pg-core").PgTableWithColumns<{
3405
+ name: "cms_user_sessions";
3406
+ schema: undefined;
3407
+ columns: {
3408
+ userId: import("drizzle-orm/pg-core").PgColumn<{
3409
+ name: "user_id";
3410
+ tableName: "cms_user_sessions";
3411
+ dataType: "string";
3412
+ columnType: "PgText";
3413
+ data: string;
3414
+ driverParam: string;
3415
+ notNull: true;
3416
+ hasDefault: false;
3417
+ isPrimaryKey: true;
3418
+ isAutoincrement: false;
3419
+ hasRuntimeDefault: false;
3420
+ enumValues: [string, ...string[]];
3421
+ baseColumn: never;
3422
+ identity: undefined;
3423
+ generated: undefined;
3424
+ }, {}, {}>;
3425
+ activeOrganizationId: import("drizzle-orm/pg-core").PgColumn<{
3426
+ name: "active_organization_id";
3427
+ tableName: "cms_user_sessions";
3428
+ dataType: "string";
3429
+ columnType: "PgUUID";
3430
+ data: string;
3431
+ driverParam: string;
3432
+ notNull: false;
3433
+ hasDefault: false;
3434
+ isPrimaryKey: false;
3435
+ isAutoincrement: false;
3436
+ hasRuntimeDefault: false;
3437
+ enumValues: undefined;
3438
+ baseColumn: never;
3439
+ identity: undefined;
3440
+ generated: undefined;
3441
+ }, {}, {}>;
3442
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3443
+ name: "updated_at";
3444
+ tableName: "cms_user_sessions";
3445
+ dataType: "date";
3446
+ columnType: "PgTimestamp";
3447
+ data: Date;
3448
+ driverParam: string;
3449
+ notNull: true;
3450
+ hasDefault: true;
3451
+ isPrimaryKey: false;
3452
+ isAutoincrement: false;
3453
+ hasRuntimeDefault: false;
3454
+ enumValues: undefined;
3455
+ baseColumn: never;
3456
+ identity: undefined;
3457
+ generated: undefined;
3458
+ }, {}, {}>;
3459
+ };
3460
+ dialect: "pg";
3461
+ }>;
3462
+ documents: import("drizzle-orm/pg-core").PgTableWithColumns<{
3463
+ name: "cms_documents";
3464
+ schema: undefined;
3465
+ columns: {
3466
+ id: import("drizzle-orm/pg-core").PgColumn<{
3467
+ name: "id";
3468
+ tableName: "cms_documents";
3469
+ dataType: "string";
3470
+ columnType: "PgUUID";
3471
+ data: string;
3472
+ driverParam: string;
3473
+ notNull: true;
3474
+ hasDefault: true;
3475
+ isPrimaryKey: true;
3476
+ isAutoincrement: false;
3477
+ hasRuntimeDefault: false;
3478
+ enumValues: undefined;
3479
+ baseColumn: never;
3480
+ identity: undefined;
3481
+ generated: undefined;
3482
+ }, {}, {}>;
3483
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
3484
+ name: "organization_id";
3485
+ tableName: "cms_documents";
3486
+ dataType: "string";
3487
+ columnType: "PgUUID";
3488
+ data: string;
3489
+ driverParam: string;
3490
+ notNull: true;
3491
+ hasDefault: false;
3492
+ isPrimaryKey: false;
3493
+ isAutoincrement: false;
3494
+ hasRuntimeDefault: false;
3495
+ enumValues: undefined;
3496
+ baseColumn: never;
3497
+ identity: undefined;
3498
+ generated: undefined;
3499
+ }, {}, {}>;
3500
+ type: import("drizzle-orm/pg-core").PgColumn<{
3501
+ name: "type";
3502
+ tableName: "cms_documents";
3503
+ dataType: "string";
3504
+ columnType: "PgVarchar";
3505
+ data: string;
3506
+ driverParam: string;
3507
+ notNull: true;
3508
+ hasDefault: false;
3509
+ isPrimaryKey: false;
3510
+ isAutoincrement: false;
3511
+ hasRuntimeDefault: false;
3512
+ enumValues: [string, ...string[]];
3513
+ baseColumn: never;
3514
+ identity: undefined;
3515
+ generated: undefined;
3516
+ }, {}, {
3517
+ length: 100;
3518
+ }>;
3519
+ status: import("drizzle-orm/pg-core").PgColumn<{
3520
+ name: "status";
3521
+ tableName: "cms_documents";
3522
+ dataType: "string";
3523
+ columnType: "PgEnumColumn";
3524
+ data: "draft" | "published" | "unpublished";
3525
+ driverParam: string;
3526
+ notNull: false;
3527
+ hasDefault: true;
3528
+ isPrimaryKey: false;
3529
+ isAutoincrement: false;
3530
+ hasRuntimeDefault: false;
3531
+ enumValues: ["draft", "published", "unpublished"];
3532
+ baseColumn: never;
3533
+ identity: undefined;
3534
+ generated: undefined;
3535
+ }, {}, {}>;
3536
+ draftData: import("drizzle-orm/pg-core").PgColumn<{
3537
+ name: "draft_data";
3538
+ tableName: "cms_documents";
3539
+ dataType: "json";
3540
+ columnType: "PgJsonb";
3541
+ data: unknown;
3542
+ driverParam: unknown;
3543
+ notNull: false;
3544
+ hasDefault: false;
3545
+ isPrimaryKey: false;
3546
+ isAutoincrement: false;
3547
+ hasRuntimeDefault: false;
3548
+ enumValues: undefined;
3549
+ baseColumn: never;
3550
+ identity: undefined;
3551
+ generated: undefined;
3552
+ }, {}, {}>;
3553
+ publishedData: import("drizzle-orm/pg-core").PgColumn<{
3554
+ name: "published_data";
3555
+ tableName: "cms_documents";
3556
+ dataType: "json";
3557
+ columnType: "PgJsonb";
3558
+ data: unknown;
3559
+ driverParam: unknown;
3560
+ notNull: false;
3561
+ hasDefault: false;
3562
+ isPrimaryKey: false;
3563
+ isAutoincrement: false;
3564
+ hasRuntimeDefault: false;
3565
+ enumValues: undefined;
3566
+ baseColumn: never;
3567
+ identity: undefined;
3568
+ generated: undefined;
3569
+ }, {}, {}>;
3570
+ publishedHash: import("drizzle-orm/pg-core").PgColumn<{
3571
+ name: "published_hash";
3572
+ tableName: "cms_documents";
3573
+ dataType: "string";
3574
+ columnType: "PgVarchar";
3575
+ data: string;
3576
+ driverParam: string;
3577
+ notNull: false;
3578
+ hasDefault: false;
3579
+ isPrimaryKey: false;
3580
+ isAutoincrement: false;
3581
+ hasRuntimeDefault: false;
3582
+ enumValues: [string, ...string[]];
3583
+ baseColumn: never;
3584
+ identity: undefined;
3585
+ generated: undefined;
3586
+ }, {}, {
3587
+ length: 20;
3588
+ }>;
3589
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
3590
+ name: "created_by";
3591
+ tableName: "cms_documents";
3592
+ dataType: "string";
3593
+ columnType: "PgText";
3594
+ data: string;
3595
+ driverParam: string;
3596
+ notNull: false;
3597
+ hasDefault: false;
3598
+ isPrimaryKey: false;
3599
+ isAutoincrement: false;
3600
+ hasRuntimeDefault: false;
3601
+ enumValues: [string, ...string[]];
3602
+ baseColumn: never;
3603
+ identity: undefined;
3604
+ generated: undefined;
3605
+ }, {}, {}>;
3606
+ updatedBy: import("drizzle-orm/pg-core").PgColumn<{
3607
+ name: "updated_by";
3608
+ tableName: "cms_documents";
3609
+ dataType: "string";
3610
+ columnType: "PgText";
3611
+ data: string;
3612
+ driverParam: string;
3613
+ notNull: false;
3614
+ hasDefault: false;
3615
+ isPrimaryKey: false;
3616
+ isAutoincrement: false;
3617
+ hasRuntimeDefault: false;
3618
+ enumValues: [string, ...string[]];
3619
+ baseColumn: never;
3620
+ identity: undefined;
3621
+ generated: undefined;
3622
+ }, {}, {}>;
3623
+ publishedAt: import("drizzle-orm/pg-core").PgColumn<{
3624
+ name: "published_at";
3625
+ tableName: "cms_documents";
3626
+ dataType: "date";
3627
+ columnType: "PgTimestamp";
3628
+ data: Date;
3629
+ driverParam: string;
3630
+ notNull: false;
3631
+ hasDefault: false;
3632
+ isPrimaryKey: false;
3633
+ isAutoincrement: false;
3634
+ hasRuntimeDefault: false;
3635
+ enumValues: undefined;
3636
+ baseColumn: never;
3637
+ identity: undefined;
3638
+ generated: undefined;
3639
+ }, {}, {}>;
3640
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3641
+ name: "created_at";
3642
+ tableName: "cms_documents";
3643
+ dataType: "date";
3644
+ columnType: "PgTimestamp";
3645
+ data: Date;
3646
+ driverParam: string;
3647
+ notNull: false;
3648
+ hasDefault: true;
3649
+ isPrimaryKey: false;
3650
+ isAutoincrement: false;
3651
+ hasRuntimeDefault: false;
3652
+ enumValues: undefined;
3653
+ baseColumn: never;
3654
+ identity: undefined;
3655
+ generated: undefined;
3656
+ }, {}, {}>;
3657
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3658
+ name: "updated_at";
3659
+ tableName: "cms_documents";
3660
+ dataType: "date";
3661
+ columnType: "PgTimestamp";
3662
+ data: Date;
3663
+ driverParam: string;
3664
+ notNull: false;
3665
+ hasDefault: true;
3666
+ isPrimaryKey: false;
3667
+ isAutoincrement: false;
3668
+ hasRuntimeDefault: false;
3669
+ enumValues: undefined;
3670
+ baseColumn: never;
3671
+ identity: undefined;
3672
+ generated: undefined;
3673
+ }, {}, {}>;
3674
+ };
3675
+ dialect: "pg";
3676
+ }>;
3677
+ documentVersions: import("drizzle-orm/pg-core").PgTableWithColumns<{
3678
+ name: "cms_document_versions";
3679
+ schema: undefined;
3680
+ columns: {
3681
+ id: import("drizzle-orm/pg-core").PgColumn<{
3682
+ name: "id";
3683
+ tableName: "cms_document_versions";
3684
+ dataType: "string";
3685
+ columnType: "PgUUID";
3686
+ data: string;
3687
+ driverParam: string;
3688
+ notNull: true;
3689
+ hasDefault: true;
3690
+ isPrimaryKey: true;
3691
+ isAutoincrement: false;
3692
+ hasRuntimeDefault: false;
3693
+ enumValues: undefined;
3694
+ baseColumn: never;
3695
+ identity: undefined;
3696
+ generated: undefined;
3697
+ }, {}, {}>;
3698
+ documentId: import("drizzle-orm/pg-core").PgColumn<{
3699
+ name: "document_id";
3700
+ tableName: "cms_document_versions";
3701
+ dataType: "string";
3702
+ columnType: "PgUUID";
3703
+ data: string;
3704
+ driverParam: string;
3705
+ notNull: true;
3706
+ hasDefault: false;
1834
3707
  isPrimaryKey: false;
1835
3708
  isAutoincrement: false;
1836
3709
  hasRuntimeDefault: false;
1837
- enumValues: [string, ...string[]];
3710
+ enumValues: undefined;
1838
3711
  baseColumn: never;
1839
3712
  identity: undefined;
1840
3713
  generated: undefined;
1841
- }, {}, {
1842
- length: 200;
1843
- }>;
1844
- slug: import("drizzle-orm/pg-core").PgColumn<{
1845
- name: "slug";
1846
- tableName: "cms_organizations";
3714
+ }, {}, {}>;
3715
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
3716
+ name: "organization_id";
3717
+ tableName: "cms_document_versions";
1847
3718
  dataType: "string";
1848
- columnType: "PgVarchar";
3719
+ columnType: "PgUUID";
1849
3720
  data: string;
1850
3721
  driverParam: string;
1851
3722
  notNull: true;
@@ -1853,47 +3724,53 @@ export declare const cmsSchema: {
1853
3724
  isPrimaryKey: false;
1854
3725
  isAutoincrement: false;
1855
3726
  hasRuntimeDefault: false;
1856
- enumValues: [string, ...string[]];
3727
+ enumValues: undefined;
1857
3728
  baseColumn: never;
1858
3729
  identity: undefined;
1859
3730
  generated: undefined;
1860
- }, {}, {
1861
- length: 100;
1862
- }>;
1863
- parentOrganizationId: import("drizzle-orm/pg-core").PgColumn<{
1864
- name: "parent_organization_id";
1865
- tableName: "cms_organizations";
3731
+ }, {}, {}>;
3732
+ versionNumber: import("drizzle-orm/pg-core").PgColumn<{
3733
+ name: "version_number";
3734
+ tableName: "cms_document_versions";
3735
+ dataType: "number";
3736
+ columnType: "PgInteger";
3737
+ data: number;
3738
+ driverParam: string | number;
3739
+ notNull: true;
3740
+ hasDefault: false;
3741
+ isPrimaryKey: false;
3742
+ isAutoincrement: false;
3743
+ hasRuntimeDefault: false;
3744
+ enumValues: undefined;
3745
+ baseColumn: never;
3746
+ identity: undefined;
3747
+ generated: undefined;
3748
+ }, {}, {}>;
3749
+ eventType: import("drizzle-orm/pg-core").PgColumn<{
3750
+ name: "event_type";
3751
+ tableName: "cms_document_versions";
1866
3752
  dataType: "string";
1867
- columnType: "PgUUID";
1868
- data: string;
3753
+ columnType: "PgEnumColumn";
3754
+ data: "draft" | "publish";
1869
3755
  driverParam: string;
1870
- notNull: false;
3756
+ notNull: true;
1871
3757
  hasDefault: false;
1872
3758
  isPrimaryKey: false;
1873
3759
  isAutoincrement: false;
1874
3760
  hasRuntimeDefault: false;
1875
- enumValues: undefined;
3761
+ enumValues: ["draft", "publish"];
1876
3762
  baseColumn: never;
1877
3763
  identity: undefined;
1878
3764
  generated: undefined;
1879
3765
  }, {}, {}>;
1880
- metadata: import("drizzle-orm/pg-core").PgColumn<{
1881
- name: "metadata";
1882
- tableName: "cms_organizations";
3766
+ data: import("drizzle-orm/pg-core").PgColumn<{
3767
+ name: "data";
3768
+ tableName: "cms_document_versions";
1883
3769
  dataType: "json";
1884
3770
  columnType: "PgJsonb";
1885
- data: {
1886
- logo?: string;
1887
- theme?: {
1888
- primaryColor: string;
1889
- fontFamily: string;
1890
- logoUrl: string;
1891
- };
1892
- website?: string;
1893
- settings?: Record<string, any>;
1894
- };
3771
+ data: unknown;
1895
3772
  driverParam: unknown;
1896
- notNull: false;
3773
+ notNull: true;
1897
3774
  hasDefault: false;
1898
3775
  isPrimaryKey: false;
1899
3776
  isAutoincrement: false;
@@ -1902,26 +3779,15 @@ export declare const cmsSchema: {
1902
3779
  baseColumn: never;
1903
3780
  identity: undefined;
1904
3781
  generated: undefined;
1905
- }, {}, {
1906
- $type: {
1907
- logo?: string;
1908
- theme?: {
1909
- primaryColor: string;
1910
- fontFamily: string;
1911
- logoUrl: string;
1912
- };
1913
- website?: string;
1914
- settings?: Record<string, any>;
1915
- };
1916
- }>;
3782
+ }, {}, {}>;
1917
3783
  createdBy: import("drizzle-orm/pg-core").PgColumn<{
1918
3784
  name: "created_by";
1919
- tableName: "cms_organizations";
3785
+ tableName: "cms_document_versions";
1920
3786
  dataType: "string";
1921
3787
  columnType: "PgText";
1922
3788
  data: string;
1923
3789
  driverParam: string;
1924
- notNull: true;
3790
+ notNull: false;
1925
3791
  hasDefault: false;
1926
3792
  isPrimaryKey: false;
1927
3793
  isAutoincrement: false;
@@ -1933,7 +3799,7 @@ export declare const cmsSchema: {
1933
3799
  }, {}, {}>;
1934
3800
  createdAt: import("drizzle-orm/pg-core").PgColumn<{
1935
3801
  name: "created_at";
1936
- tableName: "cms_organizations";
3802
+ tableName: "cms_document_versions";
1937
3803
  dataType: "date";
1938
3804
  columnType: "PgTimestamp";
1939
3805
  data: Date;
@@ -1948,9 +3814,67 @@ export declare const cmsSchema: {
1948
3814
  identity: undefined;
1949
3815
  generated: undefined;
1950
3816
  }, {}, {}>;
1951
- updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1952
- name: "updated_at";
1953
- tableName: "cms_organizations";
3817
+ };
3818
+ dialect: "pg";
3819
+ }>;
3820
+ documentReferences: import("drizzle-orm/pg-core").PgTableWithColumns<{
3821
+ name: "cms_document_references";
3822
+ schema: undefined;
3823
+ columns: {
3824
+ referencerId: import("drizzle-orm/pg-core").PgColumn<{
3825
+ name: "referencer_id";
3826
+ tableName: "cms_document_references";
3827
+ dataType: "string";
3828
+ columnType: "PgUUID";
3829
+ data: string;
3830
+ driverParam: string;
3831
+ notNull: true;
3832
+ hasDefault: false;
3833
+ isPrimaryKey: false;
3834
+ isAutoincrement: false;
3835
+ hasRuntimeDefault: false;
3836
+ enumValues: undefined;
3837
+ baseColumn: never;
3838
+ identity: undefined;
3839
+ generated: undefined;
3840
+ }, {}, {}>;
3841
+ refId: import("drizzle-orm/pg-core").PgColumn<{
3842
+ name: "ref_id";
3843
+ tableName: "cms_document_references";
3844
+ dataType: "string";
3845
+ columnType: "PgUUID";
3846
+ data: string;
3847
+ driverParam: string;
3848
+ notNull: true;
3849
+ hasDefault: false;
3850
+ isPrimaryKey: false;
3851
+ isAutoincrement: false;
3852
+ hasRuntimeDefault: false;
3853
+ enumValues: undefined;
3854
+ baseColumn: never;
3855
+ identity: undefined;
3856
+ generated: undefined;
3857
+ }, {}, {}>;
3858
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
3859
+ name: "organization_id";
3860
+ tableName: "cms_document_references";
3861
+ dataType: "string";
3862
+ columnType: "PgUUID";
3863
+ data: string;
3864
+ driverParam: string;
3865
+ notNull: true;
3866
+ hasDefault: false;
3867
+ isPrimaryKey: false;
3868
+ isAutoincrement: false;
3869
+ hasRuntimeDefault: false;
3870
+ enumValues: undefined;
3871
+ baseColumn: never;
3872
+ identity: undefined;
3873
+ generated: undefined;
3874
+ }, {}, {}>;
3875
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3876
+ name: "created_at";
3877
+ tableName: "cms_document_references";
1954
3878
  dataType: "date";
1955
3879
  columnType: "PgTimestamp";
1956
3880
  data: Date;
@@ -1968,13 +3892,13 @@ export declare const cmsSchema: {
1968
3892
  };
1969
3893
  dialect: "pg";
1970
3894
  }>;
1971
- organizationMembers: import("drizzle-orm/pg-core").PgTableWithColumns<{
1972
- name: "cms_organization_members";
3895
+ assets: import("drizzle-orm/pg-core").PgTableWithColumns<{
3896
+ name: "cms_assets";
1973
3897
  schema: undefined;
1974
3898
  columns: {
1975
3899
  id: import("drizzle-orm/pg-core").PgColumn<{
1976
3900
  name: "id";
1977
- tableName: "cms_organization_members";
3901
+ tableName: "cms_assets";
1978
3902
  dataType: "string";
1979
3903
  columnType: "PgUUID";
1980
3904
  data: string;
@@ -1984,18 +3908,111 @@ export declare const cmsSchema: {
1984
3908
  isPrimaryKey: true;
1985
3909
  isAutoincrement: false;
1986
3910
  hasRuntimeDefault: false;
1987
- enumValues: undefined;
3911
+ enumValues: undefined;
3912
+ baseColumn: never;
3913
+ identity: undefined;
3914
+ generated: undefined;
3915
+ }, {}, {}>;
3916
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
3917
+ name: "organization_id";
3918
+ tableName: "cms_assets";
3919
+ dataType: "string";
3920
+ columnType: "PgUUID";
3921
+ data: string;
3922
+ driverParam: string;
3923
+ notNull: true;
3924
+ hasDefault: false;
3925
+ isPrimaryKey: false;
3926
+ isAutoincrement: false;
3927
+ hasRuntimeDefault: false;
3928
+ enumValues: undefined;
3929
+ baseColumn: never;
3930
+ identity: undefined;
3931
+ generated: undefined;
3932
+ }, {}, {}>;
3933
+ assetType: import("drizzle-orm/pg-core").PgColumn<{
3934
+ name: "asset_type";
3935
+ tableName: "cms_assets";
3936
+ dataType: "string";
3937
+ columnType: "PgVarchar";
3938
+ data: string;
3939
+ driverParam: string;
3940
+ notNull: true;
3941
+ hasDefault: false;
3942
+ isPrimaryKey: false;
3943
+ isAutoincrement: false;
3944
+ hasRuntimeDefault: false;
3945
+ enumValues: [string, ...string[]];
3946
+ baseColumn: never;
3947
+ identity: undefined;
3948
+ generated: undefined;
3949
+ }, {}, {
3950
+ length: 20;
3951
+ }>;
3952
+ filename: import("drizzle-orm/pg-core").PgColumn<{
3953
+ name: "filename";
3954
+ tableName: "cms_assets";
3955
+ dataType: "string";
3956
+ columnType: "PgVarchar";
3957
+ data: string;
3958
+ driverParam: string;
3959
+ notNull: true;
3960
+ hasDefault: false;
3961
+ isPrimaryKey: false;
3962
+ isAutoincrement: false;
3963
+ hasRuntimeDefault: false;
3964
+ enumValues: [string, ...string[]];
3965
+ baseColumn: never;
3966
+ identity: undefined;
3967
+ generated: undefined;
3968
+ }, {}, {
3969
+ length: 255;
3970
+ }>;
3971
+ originalFilename: import("drizzle-orm/pg-core").PgColumn<{
3972
+ name: "original_filename";
3973
+ tableName: "cms_assets";
3974
+ dataType: "string";
3975
+ columnType: "PgVarchar";
3976
+ data: string;
3977
+ driverParam: string;
3978
+ notNull: true;
3979
+ hasDefault: false;
3980
+ isPrimaryKey: false;
3981
+ isAutoincrement: false;
3982
+ hasRuntimeDefault: false;
3983
+ enumValues: [string, ...string[]];
3984
+ baseColumn: never;
3985
+ identity: undefined;
3986
+ generated: undefined;
3987
+ }, {}, {
3988
+ length: 255;
3989
+ }>;
3990
+ mimeType: import("drizzle-orm/pg-core").PgColumn<{
3991
+ name: "mime_type";
3992
+ tableName: "cms_assets";
3993
+ dataType: "string";
3994
+ columnType: "PgVarchar";
3995
+ data: string;
3996
+ driverParam: string;
3997
+ notNull: true;
3998
+ hasDefault: false;
3999
+ isPrimaryKey: false;
4000
+ isAutoincrement: false;
4001
+ hasRuntimeDefault: false;
4002
+ enumValues: [string, ...string[]];
1988
4003
  baseColumn: never;
1989
4004
  identity: undefined;
1990
4005
  generated: undefined;
1991
- }, {}, {}>;
1992
- organizationId: import("drizzle-orm/pg-core").PgColumn<{
1993
- name: "organization_id";
1994
- tableName: "cms_organization_members";
1995
- dataType: "string";
1996
- columnType: "PgUUID";
1997
- data: string;
1998
- driverParam: string;
4006
+ }, {}, {
4007
+ length: 100;
4008
+ }>;
4009
+ size: import("drizzle-orm/pg-core").PgColumn<{
4010
+ name: "size";
4011
+ tableName: "cms_assets";
4012
+ dataType: "number";
4013
+ columnType: "PgInteger";
4014
+ data: number;
4015
+ driverParam: string | number;
1999
4016
  notNull: true;
2000
4017
  hasDefault: false;
2001
4018
  isPrimaryKey: false;
@@ -2006,9 +4023,9 @@ export declare const cmsSchema: {
2006
4023
  identity: undefined;
2007
4024
  generated: undefined;
2008
4025
  }, {}, {}>;
2009
- userId: import("drizzle-orm/pg-core").PgColumn<{
2010
- name: "user_id";
2011
- tableName: "cms_organization_members";
4026
+ url: import("drizzle-orm/pg-core").PgColumn<{
4027
+ name: "url";
4028
+ tableName: "cms_assets";
2012
4029
  dataType: "string";
2013
4030
  columnType: "PgText";
2014
4031
  data: string;
@@ -2023,9 +4040,9 @@ export declare const cmsSchema: {
2023
4040
  identity: undefined;
2024
4041
  generated: undefined;
2025
4042
  }, {}, {}>;
2026
- role: import("drizzle-orm/pg-core").PgColumn<{
2027
- name: "role";
2028
- tableName: "cms_organization_members";
4043
+ path: import("drizzle-orm/pg-core").PgColumn<{
4044
+ name: "path";
4045
+ tableName: "cms_assets";
2029
4046
  dataType: "string";
2030
4047
  columnType: "PgText";
2031
4048
  data: string;
@@ -2040,32 +4057,32 @@ export declare const cmsSchema: {
2040
4057
  identity: undefined;
2041
4058
  generated: undefined;
2042
4059
  }, {}, {}>;
2043
- preferences: import("drizzle-orm/pg-core").PgColumn<{
2044
- name: "preferences";
2045
- tableName: "cms_organization_members";
2046
- dataType: "json";
2047
- columnType: "PgJsonb";
2048
- data: Record<string, any>;
2049
- driverParam: unknown;
2050
- notNull: false;
2051
- hasDefault: false;
4060
+ storageAdapter: import("drizzle-orm/pg-core").PgColumn<{
4061
+ name: "storage_adapter";
4062
+ tableName: "cms_assets";
4063
+ dataType: "string";
4064
+ columnType: "PgVarchar";
4065
+ data: string;
4066
+ driverParam: string;
4067
+ notNull: true;
4068
+ hasDefault: true;
2052
4069
  isPrimaryKey: false;
2053
4070
  isAutoincrement: false;
2054
4071
  hasRuntimeDefault: false;
2055
- enumValues: undefined;
4072
+ enumValues: [string, ...string[]];
2056
4073
  baseColumn: never;
2057
4074
  identity: undefined;
2058
4075
  generated: undefined;
2059
4076
  }, {}, {
2060
- $type: Record<string, any>;
4077
+ length: 50;
2061
4078
  }>;
2062
- invitationId: import("drizzle-orm/pg-core").PgColumn<{
2063
- name: "invitation_id";
2064
- tableName: "cms_organization_members";
2065
- dataType: "string";
2066
- columnType: "PgUUID";
2067
- data: string;
2068
- driverParam: string;
4079
+ width: import("drizzle-orm/pg-core").PgColumn<{
4080
+ name: "width";
4081
+ tableName: "cms_assets";
4082
+ dataType: "number";
4083
+ columnType: "PgInteger";
4084
+ data: number;
4085
+ driverParam: string | number;
2069
4086
  notNull: false;
2070
4087
  hasDefault: false;
2071
4088
  isPrimaryKey: false;
@@ -2076,15 +4093,15 @@ export declare const cmsSchema: {
2076
4093
  identity: undefined;
2077
4094
  generated: undefined;
2078
4095
  }, {}, {}>;
2079
- createdAt: import("drizzle-orm/pg-core").PgColumn<{
2080
- name: "created_at";
2081
- tableName: "cms_organization_members";
2082
- dataType: "date";
2083
- columnType: "PgTimestamp";
2084
- data: Date;
2085
- driverParam: string;
2086
- notNull: true;
2087
- hasDefault: true;
4096
+ height: import("drizzle-orm/pg-core").PgColumn<{
4097
+ name: "height";
4098
+ tableName: "cms_assets";
4099
+ dataType: "number";
4100
+ columnType: "PgInteger";
4101
+ data: number;
4102
+ driverParam: string | number;
4103
+ notNull: false;
4104
+ hasDefault: false;
2088
4105
  isPrimaryKey: false;
2089
4106
  isAutoincrement: false;
2090
4107
  hasRuntimeDefault: false;
@@ -2093,15 +4110,15 @@ export declare const cmsSchema: {
2093
4110
  identity: undefined;
2094
4111
  generated: undefined;
2095
4112
  }, {}, {}>;
2096
- updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2097
- name: "updated_at";
2098
- tableName: "cms_organization_members";
2099
- dataType: "date";
2100
- columnType: "PgTimestamp";
2101
- data: Date;
2102
- driverParam: string;
2103
- notNull: true;
2104
- hasDefault: true;
4113
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
4114
+ name: "metadata";
4115
+ tableName: "cms_assets";
4116
+ dataType: "json";
4117
+ columnType: "PgJsonb";
4118
+ data: unknown;
4119
+ driverParam: unknown;
4120
+ notNull: false;
4121
+ hasDefault: false;
2105
4122
  isPrimaryKey: false;
2106
4123
  isAutoincrement: false;
2107
4124
  hasRuntimeDefault: false;
@@ -2110,55 +4127,33 @@ export declare const cmsSchema: {
2110
4127
  identity: undefined;
2111
4128
  generated: undefined;
2112
4129
  }, {}, {}>;
2113
- };
2114
- dialect: "pg";
2115
- }>;
2116
- invitations: import("drizzle-orm/pg-core").PgTableWithColumns<{
2117
- name: "cms_invitations";
2118
- schema: undefined;
2119
- columns: {
2120
- id: import("drizzle-orm/pg-core").PgColumn<{
2121
- name: "id";
2122
- tableName: "cms_invitations";
2123
- dataType: "string";
2124
- columnType: "PgUUID";
2125
- data: string;
2126
- driverParam: string;
2127
- notNull: true;
2128
- hasDefault: true;
2129
- isPrimaryKey: true;
2130
- isAutoincrement: false;
2131
- hasRuntimeDefault: false;
2132
- enumValues: undefined;
2133
- baseColumn: never;
2134
- identity: undefined;
2135
- generated: undefined;
2136
- }, {}, {}>;
2137
- organizationId: import("drizzle-orm/pg-core").PgColumn<{
2138
- name: "organization_id";
2139
- tableName: "cms_invitations";
4130
+ title: import("drizzle-orm/pg-core").PgColumn<{
4131
+ name: "title";
4132
+ tableName: "cms_assets";
2140
4133
  dataType: "string";
2141
- columnType: "PgUUID";
4134
+ columnType: "PgVarchar";
2142
4135
  data: string;
2143
4136
  driverParam: string;
2144
- notNull: true;
4137
+ notNull: false;
2145
4138
  hasDefault: false;
2146
4139
  isPrimaryKey: false;
2147
4140
  isAutoincrement: false;
2148
4141
  hasRuntimeDefault: false;
2149
- enumValues: undefined;
4142
+ enumValues: [string, ...string[]];
2150
4143
  baseColumn: never;
2151
4144
  identity: undefined;
2152
4145
  generated: undefined;
2153
- }, {}, {}>;
2154
- email: import("drizzle-orm/pg-core").PgColumn<{
2155
- name: "email";
2156
- tableName: "cms_invitations";
4146
+ }, {}, {
4147
+ length: 255;
4148
+ }>;
4149
+ description: import("drizzle-orm/pg-core").PgColumn<{
4150
+ name: "description";
4151
+ tableName: "cms_assets";
2157
4152
  dataType: "string";
2158
- columnType: "PgVarchar";
4153
+ columnType: "PgText";
2159
4154
  data: string;
2160
4155
  driverParam: string;
2161
- notNull: true;
4156
+ notNull: false;
2162
4157
  hasDefault: false;
2163
4158
  isPrimaryKey: false;
2164
4159
  isAutoincrement: false;
@@ -2167,17 +4162,15 @@ export declare const cmsSchema: {
2167
4162
  baseColumn: never;
2168
4163
  identity: undefined;
2169
4164
  generated: undefined;
2170
- }, {}, {
2171
- length: 255;
2172
- }>;
2173
- role: import("drizzle-orm/pg-core").PgColumn<{
2174
- name: "role";
2175
- tableName: "cms_invitations";
4165
+ }, {}, {}>;
4166
+ alt: import("drizzle-orm/pg-core").PgColumn<{
4167
+ name: "alt";
4168
+ tableName: "cms_assets";
2176
4169
  dataType: "string";
2177
4170
  columnType: "PgText";
2178
4171
  data: string;
2179
4172
  driverParam: string;
2180
- notNull: true;
4173
+ notNull: false;
2181
4174
  hasDefault: false;
2182
4175
  isPrimaryKey: false;
2183
4176
  isAutoincrement: false;
@@ -2187,14 +4180,14 @@ export declare const cmsSchema: {
2187
4180
  identity: undefined;
2188
4181
  generated: undefined;
2189
4182
  }, {}, {}>;
2190
- token: import("drizzle-orm/pg-core").PgColumn<{
2191
- name: "token";
2192
- tableName: "cms_invitations";
4183
+ creditLine: import("drizzle-orm/pg-core").PgColumn<{
4184
+ name: "credit_line";
4185
+ tableName: "cms_assets";
2193
4186
  dataType: "string";
2194
4187
  columnType: "PgText";
2195
4188
  data: string;
2196
4189
  driverParam: string;
2197
- notNull: true;
4190
+ notNull: false;
2198
4191
  hasDefault: false;
2199
4192
  isPrimaryKey: false;
2200
4193
  isAutoincrement: false;
@@ -2204,14 +4197,14 @@ export declare const cmsSchema: {
2204
4197
  identity: undefined;
2205
4198
  generated: undefined;
2206
4199
  }, {}, {}>;
2207
- invitedBy: import("drizzle-orm/pg-core").PgColumn<{
2208
- name: "invited_by";
2209
- tableName: "cms_invitations";
4200
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
4201
+ name: "created_by";
4202
+ tableName: "cms_assets";
2210
4203
  dataType: "string";
2211
4204
  columnType: "PgText";
2212
4205
  data: string;
2213
4206
  driverParam: string;
2214
- notNull: true;
4207
+ notNull: false;
2215
4208
  hasDefault: false;
2216
4209
  isPrimaryKey: false;
2217
4210
  isAutoincrement: false;
@@ -2221,32 +4214,32 @@ export declare const cmsSchema: {
2221
4214
  identity: undefined;
2222
4215
  generated: undefined;
2223
4216
  }, {}, {}>;
2224
- expiresAt: import("drizzle-orm/pg-core").PgColumn<{
2225
- name: "expires_at";
2226
- tableName: "cms_invitations";
2227
- dataType: "date";
2228
- columnType: "PgTimestamp";
2229
- data: Date;
4217
+ updatedBy: import("drizzle-orm/pg-core").PgColumn<{
4218
+ name: "updated_by";
4219
+ tableName: "cms_assets";
4220
+ dataType: "string";
4221
+ columnType: "PgText";
4222
+ data: string;
2230
4223
  driverParam: string;
2231
- notNull: true;
4224
+ notNull: false;
2232
4225
  hasDefault: false;
2233
4226
  isPrimaryKey: false;
2234
4227
  isAutoincrement: false;
2235
4228
  hasRuntimeDefault: false;
2236
- enumValues: undefined;
4229
+ enumValues: [string, ...string[]];
2237
4230
  baseColumn: never;
2238
4231
  identity: undefined;
2239
4232
  generated: undefined;
2240
4233
  }, {}, {}>;
2241
- acceptedAt: import("drizzle-orm/pg-core").PgColumn<{
2242
- name: "accepted_at";
2243
- tableName: "cms_invitations";
4234
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
4235
+ name: "created_at";
4236
+ tableName: "cms_assets";
2244
4237
  dataType: "date";
2245
4238
  columnType: "PgTimestamp";
2246
4239
  data: Date;
2247
4240
  driverParam: string;
2248
4241
  notNull: false;
2249
- hasDefault: false;
4242
+ hasDefault: true;
2250
4243
  isPrimaryKey: false;
2251
4244
  isAutoincrement: false;
2252
4245
  hasRuntimeDefault: false;
@@ -2255,14 +4248,14 @@ export declare const cmsSchema: {
2255
4248
  identity: undefined;
2256
4249
  generated: undefined;
2257
4250
  }, {}, {}>;
2258
- createdAt: import("drizzle-orm/pg-core").PgColumn<{
2259
- name: "created_at";
2260
- tableName: "cms_invitations";
4251
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
4252
+ name: "updated_at";
4253
+ tableName: "cms_assets";
2261
4254
  dataType: "date";
2262
4255
  columnType: "PgTimestamp";
2263
4256
  data: Date;
2264
4257
  driverParam: string;
2265
- notNull: true;
4258
+ notNull: false;
2266
4259
  hasDefault: true;
2267
4260
  isPrimaryKey: false;
2268
4261
  isAutoincrement: false;
@@ -2275,13 +4268,13 @@ export declare const cmsSchema: {
2275
4268
  };
2276
4269
  dialect: "pg";
2277
4270
  }>;
2278
- roles: import("drizzle-orm/pg-core").PgTableWithColumns<{
2279
- name: "cms_roles";
4271
+ schemaTypes: import("drizzle-orm/pg-core").PgTableWithColumns<{
4272
+ name: "cms_schema_types";
2280
4273
  schema: undefined;
2281
4274
  columns: {
2282
4275
  id: import("drizzle-orm/pg-core").PgColumn<{
2283
4276
  name: "id";
2284
- tableName: "cms_roles";
4277
+ tableName: "cms_schema_types";
2285
4278
  dataType: "string";
2286
4279
  columnType: "PgUUID";
2287
4280
  data: string;
@@ -2296,11 +4289,11 @@ export declare const cmsSchema: {
2296
4289
  identity: undefined;
2297
4290
  generated: undefined;
2298
4291
  }, {}, {}>;
2299
- organizationId: import("drizzle-orm/pg-core").PgColumn<{
2300
- name: "organization_id";
2301
- tableName: "cms_roles";
4292
+ name: import("drizzle-orm/pg-core").PgColumn<{
4293
+ name: "name";
4294
+ tableName: "cms_schema_types";
2302
4295
  dataType: "string";
2303
- columnType: "PgUUID";
4296
+ columnType: "PgVarchar";
2304
4297
  data: string;
2305
4298
  driverParam: string;
2306
4299
  notNull: true;
@@ -2308,33 +4301,52 @@ export declare const cmsSchema: {
2308
4301
  isPrimaryKey: false;
2309
4302
  isAutoincrement: false;
2310
4303
  hasRuntimeDefault: false;
2311
- enumValues: undefined;
4304
+ enumValues: [string, ...string[]];
2312
4305
  baseColumn: never;
2313
4306
  identity: undefined;
2314
4307
  generated: undefined;
2315
- }, {}, {}>;
2316
- name: import("drizzle-orm/pg-core").PgColumn<{
2317
- name: "name";
2318
- tableName: "cms_roles";
4308
+ }, {}, {
4309
+ length: 100;
4310
+ }>;
4311
+ title: import("drizzle-orm/pg-core").PgColumn<{
4312
+ name: "title";
4313
+ tableName: "cms_schema_types";
4314
+ dataType: "string";
4315
+ columnType: "PgVarchar";
4316
+ data: string;
4317
+ driverParam: string;
4318
+ notNull: true;
4319
+ hasDefault: false;
4320
+ isPrimaryKey: false;
4321
+ isAutoincrement: false;
4322
+ hasRuntimeDefault: false;
4323
+ enumValues: [string, ...string[]];
4324
+ baseColumn: never;
4325
+ identity: undefined;
4326
+ generated: undefined;
4327
+ }, {}, {
4328
+ length: 200;
4329
+ }>;
4330
+ type: import("drizzle-orm/pg-core").PgColumn<{
4331
+ name: "type";
4332
+ tableName: "cms_schema_types";
2319
4333
  dataType: "string";
2320
- columnType: "PgVarchar";
2321
- data: string;
4334
+ columnType: "PgEnumColumn";
4335
+ data: "object" | "document";
2322
4336
  driverParam: string;
2323
4337
  notNull: true;
2324
4338
  hasDefault: false;
2325
4339
  isPrimaryKey: false;
2326
4340
  isAutoincrement: false;
2327
4341
  hasRuntimeDefault: false;
2328
- enumValues: [string, ...string[]];
4342
+ enumValues: ["document", "object"];
2329
4343
  baseColumn: never;
2330
4344
  identity: undefined;
2331
4345
  generated: undefined;
2332
- }, {}, {
2333
- length: 100;
2334
- }>;
4346
+ }, {}, {}>;
2335
4347
  description: import("drizzle-orm/pg-core").PgColumn<{
2336
4348
  name: "description";
2337
- tableName: "cms_roles";
4349
+ tableName: "cms_schema_types";
2338
4350
  dataType: "string";
2339
4351
  columnType: "PgText";
2340
4352
  data: string;
@@ -2349,15 +4361,15 @@ export declare const cmsSchema: {
2349
4361
  identity: undefined;
2350
4362
  generated: undefined;
2351
4363
  }, {}, {}>;
2352
- capabilities: import("drizzle-orm/pg-core").PgColumn<{
2353
- name: "capabilities";
2354
- tableName: "cms_roles";
4364
+ fields: import("drizzle-orm/pg-core").PgColumn<{
4365
+ name: "fields";
4366
+ tableName: "cms_schema_types";
2355
4367
  dataType: "json";
2356
4368
  columnType: "PgJsonb";
2357
- data: string[];
4369
+ data: unknown;
2358
4370
  driverParam: unknown;
2359
4371
  notNull: true;
2360
- hasDefault: true;
4372
+ hasDefault: false;
2361
4373
  isPrimaryKey: false;
2362
4374
  isAutoincrement: false;
2363
4375
  hasRuntimeDefault: false;
@@ -2365,34 +4377,15 @@ export declare const cmsSchema: {
2365
4377
  baseColumn: never;
2366
4378
  identity: undefined;
2367
4379
  generated: undefined;
2368
- }, {}, {
2369
- $type: string[];
2370
- }>;
2371
- isBuiltIn: import("drizzle-orm/pg-core").PgColumn<{
2372
- name: "is_built_in";
2373
- tableName: "cms_roles";
2374
- dataType: "string";
2375
- columnType: "PgText";
2376
- data: string;
2377
- driverParam: string;
2378
- notNull: true;
2379
- hasDefault: true;
2380
- isPrimaryKey: false;
2381
- isAutoincrement: false;
2382
- hasRuntimeDefault: false;
2383
- enumValues: [string, ...string[]];
2384
- baseColumn: never;
2385
- identity: undefined;
2386
- generated: undefined;
2387
4380
  }, {}, {}>;
2388
4381
  createdAt: import("drizzle-orm/pg-core").PgColumn<{
2389
4382
  name: "created_at";
2390
- tableName: "cms_roles";
4383
+ tableName: "cms_schema_types";
2391
4384
  dataType: "date";
2392
4385
  columnType: "PgTimestamp";
2393
4386
  data: Date;
2394
4387
  driverParam: string;
2395
- notNull: true;
4388
+ notNull: false;
2396
4389
  hasDefault: true;
2397
4390
  isPrimaryKey: false;
2398
4391
  isAutoincrement: false;
@@ -2404,12 +4397,12 @@ export declare const cmsSchema: {
2404
4397
  }, {}, {}>;
2405
4398
  updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2406
4399
  name: "updated_at";
2407
- tableName: "cms_roles";
4400
+ tableName: "cms_schema_types";
2408
4401
  dataType: "date";
2409
4402
  columnType: "PgTimestamp";
2410
4403
  data: Date;
2411
4404
  driverParam: string;
2412
- notNull: true;
4405
+ notNull: false;
2413
4406
  hasDefault: true;
2414
4407
  isPrimaryKey: false;
2415
4408
  isAutoincrement: false;
@@ -2422,19 +4415,19 @@ export declare const cmsSchema: {
2422
4415
  };
2423
4416
  dialect: "pg";
2424
4417
  }>;
2425
- instanceSettings: import("drizzle-orm/pg-core").PgTableWithColumns<{
2426
- name: "cms_instance_settings";
4418
+ userProfiles: import("drizzle-orm/pg-core").PgTableWithColumns<{
4419
+ name: "cms_user_profiles";
2427
4420
  schema: undefined;
2428
4421
  columns: {
2429
- id: import("drizzle-orm/pg-core").PgColumn<{
2430
- name: "id";
2431
- tableName: "cms_instance_settings";
4422
+ userId: import("drizzle-orm/pg-core").PgColumn<{
4423
+ name: "user_id";
4424
+ tableName: "cms_user_profiles";
2432
4425
  dataType: "string";
2433
4426
  columnType: "PgText";
2434
4427
  data: string;
2435
4428
  driverParam: string;
2436
4429
  notNull: true;
2437
- hasDefault: true;
4430
+ hasDefault: false;
2438
4431
  isPrimaryKey: true;
2439
4432
  isAutoincrement: false;
2440
4433
  hasRuntimeDefault: false;
@@ -2443,15 +4436,37 @@ export declare const cmsSchema: {
2443
4436
  identity: undefined;
2444
4437
  generated: undefined;
2445
4438
  }, {}, {}>;
2446
- settings: import("drizzle-orm/pg-core").PgColumn<{
2447
- name: "settings";
2448
- tableName: "cms_instance_settings";
4439
+ role: import("drizzle-orm/pg-core").PgColumn<{
4440
+ name: "role";
4441
+ tableName: "cms_user_profiles";
4442
+ dataType: "string";
4443
+ columnType: "PgText";
4444
+ data: "super_admin" | "admin" | "editor" | "viewer";
4445
+ driverParam: string;
4446
+ notNull: true;
4447
+ hasDefault: true;
4448
+ isPrimaryKey: false;
4449
+ isAutoincrement: false;
4450
+ hasRuntimeDefault: false;
4451
+ enumValues: ["super_admin", "admin", "editor", "viewer"];
4452
+ baseColumn: never;
4453
+ identity: undefined;
4454
+ generated: undefined;
4455
+ }, {}, {}>;
4456
+ preferences: import("drizzle-orm/pg-core").PgColumn<{
4457
+ name: "preferences";
4458
+ tableName: "cms_user_profiles";
2449
4459
  dataType: "json";
2450
4460
  columnType: "PgJsonb";
2451
- data: Record<string, any>;
4461
+ data: {
4462
+ [key: string]: any;
4463
+ theme?: "light" | "dark";
4464
+ language?: string;
4465
+ includeChildOrganizations?: boolean;
4466
+ };
2452
4467
  driverParam: unknown;
2453
- notNull: true;
2454
- hasDefault: true;
4468
+ notNull: false;
4469
+ hasDefault: false;
2455
4470
  isPrimaryKey: false;
2456
4471
  isAutoincrement: false;
2457
4472
  hasRuntimeDefault: false;
@@ -2460,11 +4475,16 @@ export declare const cmsSchema: {
2460
4475
  identity: undefined;
2461
4476
  generated: undefined;
2462
4477
  }, {}, {
2463
- $type: Record<string, any>;
4478
+ $type: {
4479
+ [key: string]: any;
4480
+ theme?: "light" | "dark";
4481
+ language?: string;
4482
+ includeChildOrganizations?: boolean;
4483
+ };
2464
4484
  }>;
2465
- updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2466
- name: "updated_at";
2467
- tableName: "cms_instance_settings";
4485
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
4486
+ name: "created_at";
4487
+ tableName: "cms_user_profiles";
2468
4488
  dataType: "date";
2469
4489
  columnType: "PgTimestamp";
2470
4490
  data: Date;
@@ -2479,50 +4499,9 @@ export declare const cmsSchema: {
2479
4499
  identity: undefined;
2480
4500
  generated: undefined;
2481
4501
  }, {}, {}>;
2482
- };
2483
- dialect: "pg";
2484
- }>;
2485
- userSessions: import("drizzle-orm/pg-core").PgTableWithColumns<{
2486
- name: "cms_user_sessions";
2487
- schema: undefined;
2488
- columns: {
2489
- userId: import("drizzle-orm/pg-core").PgColumn<{
2490
- name: "user_id";
2491
- tableName: "cms_user_sessions";
2492
- dataType: "string";
2493
- columnType: "PgText";
2494
- data: string;
2495
- driverParam: string;
2496
- notNull: true;
2497
- hasDefault: false;
2498
- isPrimaryKey: true;
2499
- isAutoincrement: false;
2500
- hasRuntimeDefault: false;
2501
- enumValues: [string, ...string[]];
2502
- baseColumn: never;
2503
- identity: undefined;
2504
- generated: undefined;
2505
- }, {}, {}>;
2506
- activeOrganizationId: import("drizzle-orm/pg-core").PgColumn<{
2507
- name: "active_organization_id";
2508
- tableName: "cms_user_sessions";
2509
- dataType: "string";
2510
- columnType: "PgUUID";
2511
- data: string;
2512
- driverParam: string;
2513
- notNull: false;
2514
- hasDefault: false;
2515
- isPrimaryKey: false;
2516
- isAutoincrement: false;
2517
- hasRuntimeDefault: false;
2518
- enumValues: undefined;
2519
- baseColumn: never;
2520
- identity: undefined;
2521
- generated: undefined;
2522
- }, {}, {}>;
2523
4502
  updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2524
4503
  name: "updated_at";
2525
- tableName: "cms_user_sessions";
4504
+ tableName: "cms_user_profiles";
2526
4505
  dataType: "date";
2527
4506
  columnType: "PgTimestamp";
2528
4507
  data: Date;
@@ -2540,13 +4519,13 @@ export declare const cmsSchema: {
2540
4519
  };
2541
4520
  dialect: "pg";
2542
4521
  }>;
2543
- documents: import("drizzle-orm/pg-core").PgTableWithColumns<{
2544
- name: "cms_documents";
4522
+ domainEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
4523
+ name: "cms_domain_events";
2545
4524
  schema: undefined;
2546
4525
  columns: {
2547
4526
  id: import("drizzle-orm/pg-core").PgColumn<{
2548
4527
  name: "id";
2549
- tableName: "cms_documents";
4528
+ tableName: "cms_domain_events";
2550
4529
  dataType: "string";
2551
4530
  columnType: "PgUUID";
2552
4531
  data: string;
@@ -2563,7 +4542,7 @@ export declare const cmsSchema: {
2563
4542
  }, {}, {}>;
2564
4543
  organizationId: import("drizzle-orm/pg-core").PgColumn<{
2565
4544
  name: "organization_id";
2566
- tableName: "cms_documents";
4545
+ tableName: "cms_domain_events";
2567
4546
  dataType: "string";
2568
4547
  columnType: "PgUUID";
2569
4548
  data: string;
@@ -2580,7 +4559,7 @@ export declare const cmsSchema: {
2580
4559
  }, {}, {}>;
2581
4560
  type: import("drizzle-orm/pg-core").PgColumn<{
2582
4561
  name: "type";
2583
- tableName: "cms_documents";
4562
+ tableName: "cms_domain_events";
2584
4563
  dataType: "string";
2585
4564
  columnType: "PgVarchar";
2586
4565
  data: string;
@@ -2595,51 +4574,17 @@ export declare const cmsSchema: {
2595
4574
  identity: undefined;
2596
4575
  generated: undefined;
2597
4576
  }, {}, {
2598
- length: 100;
4577
+ length: 200;
2599
4578
  }>;
2600
- status: import("drizzle-orm/pg-core").PgColumn<{
2601
- name: "status";
2602
- tableName: "cms_documents";
2603
- dataType: "string";
2604
- columnType: "PgEnumColumn";
2605
- data: "draft" | "published" | "unpublished";
2606
- driverParam: string;
2607
- notNull: false;
2608
- hasDefault: true;
2609
- isPrimaryKey: false;
2610
- isAutoincrement: false;
2611
- hasRuntimeDefault: false;
2612
- enumValues: ["draft", "published", "unpublished"];
2613
- baseColumn: never;
2614
- identity: undefined;
2615
- generated: undefined;
2616
- }, {}, {}>;
2617
- draftData: import("drizzle-orm/pg-core").PgColumn<{
2618
- name: "draft_data";
2619
- tableName: "cms_documents";
2620
- dataType: "json";
2621
- columnType: "PgJsonb";
2622
- data: unknown;
2623
- driverParam: unknown;
2624
- notNull: false;
2625
- hasDefault: false;
2626
- isPrimaryKey: false;
2627
- isAutoincrement: false;
2628
- hasRuntimeDefault: false;
2629
- enumValues: undefined;
2630
- baseColumn: never;
2631
- identity: undefined;
2632
- generated: undefined;
2633
- }, {}, {}>;
2634
- publishedData: import("drizzle-orm/pg-core").PgColumn<{
2635
- name: "published_data";
2636
- tableName: "cms_documents";
4579
+ payload: import("drizzle-orm/pg-core").PgColumn<{
4580
+ name: "payload";
4581
+ tableName: "cms_domain_events";
2637
4582
  dataType: "json";
2638
4583
  columnType: "PgJsonb";
2639
- data: unknown;
4584
+ data: Record<string, unknown>;
2640
4585
  driverParam: unknown;
2641
- notNull: false;
2642
- hasDefault: false;
4586
+ notNull: true;
4587
+ hasDefault: true;
2643
4588
  isPrimaryKey: false;
2644
4589
  isAutoincrement: false;
2645
4590
  hasRuntimeDefault: false;
@@ -2647,29 +4592,12 @@ export declare const cmsSchema: {
2647
4592
  baseColumn: never;
2648
4593
  identity: undefined;
2649
4594
  generated: undefined;
2650
- }, {}, {}>;
2651
- publishedHash: import("drizzle-orm/pg-core").PgColumn<{
2652
- name: "published_hash";
2653
- tableName: "cms_documents";
2654
- dataType: "string";
2655
- columnType: "PgVarchar";
2656
- data: string;
2657
- driverParam: string;
2658
- notNull: false;
2659
- hasDefault: false;
2660
- isPrimaryKey: false;
2661
- isAutoincrement: false;
2662
- hasRuntimeDefault: false;
2663
- enumValues: [string, ...string[]];
2664
- baseColumn: never;
2665
- identity: undefined;
2666
- generated: undefined;
2667
4595
  }, {}, {
2668
- length: 20;
4596
+ $type: Record<string, unknown>;
2669
4597
  }>;
2670
- createdBy: import("drizzle-orm/pg-core").PgColumn<{
2671
- name: "created_by";
2672
- tableName: "cms_documents";
4598
+ correlationId: import("drizzle-orm/pg-core").PgColumn<{
4599
+ name: "correlation_id";
4600
+ tableName: "cms_domain_events";
2673
4601
  dataType: "string";
2674
4602
  columnType: "PgText";
2675
4603
  data: string;
@@ -2684,9 +4612,9 @@ export declare const cmsSchema: {
2684
4612
  identity: undefined;
2685
4613
  generated: undefined;
2686
4614
  }, {}, {}>;
2687
- updatedBy: import("drizzle-orm/pg-core").PgColumn<{
2688
- name: "updated_by";
2689
- tableName: "cms_documents";
4615
+ causationId: import("drizzle-orm/pg-core").PgColumn<{
4616
+ name: "causation_id";
4617
+ tableName: "cms_domain_events";
2690
4618
  dataType: "string";
2691
4619
  columnType: "PgText";
2692
4620
  data: string;
@@ -2701,48 +4629,31 @@ export declare const cmsSchema: {
2701
4629
  identity: undefined;
2702
4630
  generated: undefined;
2703
4631
  }, {}, {}>;
2704
- publishedAt: import("drizzle-orm/pg-core").PgColumn<{
2705
- name: "published_at";
2706
- tableName: "cms_documents";
2707
- dataType: "date";
2708
- columnType: "PgTimestamp";
2709
- data: Date;
2710
- driverParam: string;
2711
- notNull: false;
2712
- hasDefault: false;
2713
- isPrimaryKey: false;
2714
- isAutoincrement: false;
2715
- hasRuntimeDefault: false;
2716
- enumValues: undefined;
2717
- baseColumn: never;
2718
- identity: undefined;
2719
- generated: undefined;
2720
- }, {}, {}>;
2721
- createdAt: import("drizzle-orm/pg-core").PgColumn<{
2722
- name: "created_at";
2723
- tableName: "cms_documents";
2724
- dataType: "date";
2725
- columnType: "PgTimestamp";
2726
- data: Date;
4632
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
4633
+ name: "created_by";
4634
+ tableName: "cms_domain_events";
4635
+ dataType: "string";
4636
+ columnType: "PgText";
4637
+ data: string;
2727
4638
  driverParam: string;
2728
4639
  notNull: false;
2729
- hasDefault: true;
4640
+ hasDefault: false;
2730
4641
  isPrimaryKey: false;
2731
4642
  isAutoincrement: false;
2732
4643
  hasRuntimeDefault: false;
2733
- enumValues: undefined;
4644
+ enumValues: [string, ...string[]];
2734
4645
  baseColumn: never;
2735
4646
  identity: undefined;
2736
4647
  generated: undefined;
2737
4648
  }, {}, {}>;
2738
- updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2739
- name: "updated_at";
2740
- tableName: "cms_documents";
4649
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
4650
+ name: "created_at";
4651
+ tableName: "cms_domain_events";
2741
4652
  dataType: "date";
2742
4653
  columnType: "PgTimestamp";
2743
4654
  data: Date;
2744
4655
  driverParam: string;
2745
- notNull: false;
4656
+ notNull: true;
2746
4657
  hasDefault: true;
2747
4658
  isPrimaryKey: false;
2748
4659
  isAutoincrement: false;
@@ -2755,13 +4666,13 @@ export declare const cmsSchema: {
2755
4666
  };
2756
4667
  dialect: "pg";
2757
4668
  }>;
2758
- documentVersions: import("drizzle-orm/pg-core").PgTableWithColumns<{
2759
- name: "cms_document_versions";
4669
+ eventOutbox: import("drizzle-orm/pg-core").PgTableWithColumns<{
4670
+ name: "cms_event_outbox";
2760
4671
  schema: undefined;
2761
4672
  columns: {
2762
4673
  id: import("drizzle-orm/pg-core").PgColumn<{
2763
4674
  name: "id";
2764
- tableName: "cms_document_versions";
4675
+ tableName: "cms_event_outbox";
2765
4676
  dataType: "string";
2766
4677
  columnType: "PgUUID";
2767
4678
  data: string;
@@ -2776,9 +4687,9 @@ export declare const cmsSchema: {
2776
4687
  identity: undefined;
2777
4688
  generated: undefined;
2778
4689
  }, {}, {}>;
2779
- documentId: import("drizzle-orm/pg-core").PgColumn<{
2780
- name: "document_id";
2781
- tableName: "cms_document_versions";
4690
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
4691
+ name: "organization_id";
4692
+ tableName: "cms_event_outbox";
2782
4693
  dataType: "string";
2783
4694
  columnType: "PgUUID";
2784
4695
  data: string;
@@ -2793,9 +4704,9 @@ export declare const cmsSchema: {
2793
4704
  identity: undefined;
2794
4705
  generated: undefined;
2795
4706
  }, {}, {}>;
2796
- organizationId: import("drizzle-orm/pg-core").PgColumn<{
2797
- name: "organization_id";
2798
- tableName: "cms_document_versions";
4707
+ eventId: import("drizzle-orm/pg-core").PgColumn<{
4708
+ name: "event_id";
4709
+ tableName: "cms_event_outbox";
2799
4710
  dataType: "string";
2800
4711
  columnType: "PgUUID";
2801
4712
  data: string;
@@ -2810,49 +4721,34 @@ export declare const cmsSchema: {
2810
4721
  identity: undefined;
2811
4722
  generated: undefined;
2812
4723
  }, {}, {}>;
2813
- versionNumber: import("drizzle-orm/pg-core").PgColumn<{
2814
- name: "version_number";
2815
- tableName: "cms_document_versions";
2816
- dataType: "number";
2817
- columnType: "PgInteger";
2818
- data: number;
2819
- driverParam: string | number;
2820
- notNull: true;
2821
- hasDefault: false;
2822
- isPrimaryKey: false;
2823
- isAutoincrement: false;
2824
- hasRuntimeDefault: false;
2825
- enumValues: undefined;
2826
- baseColumn: never;
2827
- identity: undefined;
2828
- generated: undefined;
2829
- }, {}, {}>;
2830
4724
  eventType: import("drizzle-orm/pg-core").PgColumn<{
2831
4725
  name: "event_type";
2832
- tableName: "cms_document_versions";
4726
+ tableName: "cms_event_outbox";
2833
4727
  dataType: "string";
2834
- columnType: "PgEnumColumn";
2835
- data: "draft" | "publish";
4728
+ columnType: "PgVarchar";
4729
+ data: string;
2836
4730
  driverParam: string;
2837
4731
  notNull: true;
2838
4732
  hasDefault: false;
2839
4733
  isPrimaryKey: false;
2840
4734
  isAutoincrement: false;
2841
4735
  hasRuntimeDefault: false;
2842
- enumValues: ["draft", "publish"];
4736
+ enumValues: [string, ...string[]];
2843
4737
  baseColumn: never;
2844
4738
  identity: undefined;
2845
4739
  generated: undefined;
2846
- }, {}, {}>;
2847
- data: import("drizzle-orm/pg-core").PgColumn<{
2848
- name: "data";
2849
- tableName: "cms_document_versions";
4740
+ }, {}, {
4741
+ length: 200;
4742
+ }>;
4743
+ payload: import("drizzle-orm/pg-core").PgColumn<{
4744
+ name: "payload";
4745
+ tableName: "cms_event_outbox";
2850
4746
  dataType: "json";
2851
4747
  columnType: "PgJsonb";
2852
- data: unknown;
4748
+ data: Record<string, unknown>;
2853
4749
  driverParam: unknown;
2854
4750
  notNull: true;
2855
- hasDefault: false;
4751
+ hasDefault: true;
2856
4752
  isPrimaryKey: false;
2857
4753
  isAutoincrement: false;
2858
4754
  hasRuntimeDefault: false;
@@ -2860,10 +4756,12 @@ export declare const cmsSchema: {
2860
4756
  baseColumn: never;
2861
4757
  identity: undefined;
2862
4758
  generated: undefined;
2863
- }, {}, {}>;
2864
- createdBy: import("drizzle-orm/pg-core").PgColumn<{
2865
- name: "created_by";
2866
- tableName: "cms_document_versions";
4759
+ }, {}, {
4760
+ $type: Record<string, unknown>;
4761
+ }>;
4762
+ correlationId: import("drizzle-orm/pg-core").PgColumn<{
4763
+ name: "correlation_id";
4764
+ tableName: "cms_event_outbox";
2867
4765
  dataType: "string";
2868
4766
  columnType: "PgText";
2869
4767
  data: string;
@@ -2878,73 +4776,49 @@ export declare const cmsSchema: {
2878
4776
  identity: undefined;
2879
4777
  generated: undefined;
2880
4778
  }, {}, {}>;
2881
- createdAt: import("drizzle-orm/pg-core").PgColumn<{
2882
- name: "created_at";
2883
- tableName: "cms_document_versions";
2884
- dataType: "date";
2885
- columnType: "PgTimestamp";
2886
- data: Date;
2887
- driverParam: string;
2888
- notNull: true;
2889
- hasDefault: true;
2890
- isPrimaryKey: false;
2891
- isAutoincrement: false;
2892
- hasRuntimeDefault: false;
2893
- enumValues: undefined;
2894
- baseColumn: never;
2895
- identity: undefined;
2896
- generated: undefined;
2897
- }, {}, {}>;
2898
- };
2899
- dialect: "pg";
2900
- }>;
2901
- documentReferences: import("drizzle-orm/pg-core").PgTableWithColumns<{
2902
- name: "cms_document_references";
2903
- schema: undefined;
2904
- columns: {
2905
- referencerId: import("drizzle-orm/pg-core").PgColumn<{
2906
- name: "referencer_id";
2907
- tableName: "cms_document_references";
4779
+ causationId: import("drizzle-orm/pg-core").PgColumn<{
4780
+ name: "causation_id";
4781
+ tableName: "cms_event_outbox";
2908
4782
  dataType: "string";
2909
- columnType: "PgUUID";
4783
+ columnType: "PgText";
2910
4784
  data: string;
2911
4785
  driverParam: string;
2912
- notNull: true;
4786
+ notNull: false;
2913
4787
  hasDefault: false;
2914
4788
  isPrimaryKey: false;
2915
4789
  isAutoincrement: false;
2916
4790
  hasRuntimeDefault: false;
2917
- enumValues: undefined;
4791
+ enumValues: [string, ...string[]];
2918
4792
  baseColumn: never;
2919
4793
  identity: undefined;
2920
4794
  generated: undefined;
2921
4795
  }, {}, {}>;
2922
- refId: import("drizzle-orm/pg-core").PgColumn<{
2923
- name: "ref_id";
2924
- tableName: "cms_document_references";
4796
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
4797
+ name: "created_by";
4798
+ tableName: "cms_event_outbox";
2925
4799
  dataType: "string";
2926
- columnType: "PgUUID";
4800
+ columnType: "PgText";
2927
4801
  data: string;
2928
4802
  driverParam: string;
2929
- notNull: true;
4803
+ notNull: false;
2930
4804
  hasDefault: false;
2931
4805
  isPrimaryKey: false;
2932
4806
  isAutoincrement: false;
2933
4807
  hasRuntimeDefault: false;
2934
- enumValues: undefined;
4808
+ enumValues: [string, ...string[]];
2935
4809
  baseColumn: never;
2936
4810
  identity: undefined;
2937
4811
  generated: undefined;
2938
4812
  }, {}, {}>;
2939
- organizationId: import("drizzle-orm/pg-core").PgColumn<{
2940
- name: "organization_id";
2941
- tableName: "cms_document_references";
2942
- dataType: "string";
2943
- columnType: "PgUUID";
2944
- data: string;
4813
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
4814
+ name: "created_at";
4815
+ tableName: "cms_event_outbox";
4816
+ dataType: "date";
4817
+ columnType: "PgTimestamp";
4818
+ data: Date;
2945
4819
  driverParam: string;
2946
4820
  notNull: true;
2947
- hasDefault: false;
4821
+ hasDefault: true;
2948
4822
  isPrimaryKey: false;
2949
4823
  isAutoincrement: false;
2950
4824
  hasRuntimeDefault: false;
@@ -2953,15 +4827,15 @@ export declare const cmsSchema: {
2953
4827
  identity: undefined;
2954
4828
  generated: undefined;
2955
4829
  }, {}, {}>;
2956
- createdAt: import("drizzle-orm/pg-core").PgColumn<{
2957
- name: "created_at";
2958
- tableName: "cms_document_references";
4830
+ processedAt: import("drizzle-orm/pg-core").PgColumn<{
4831
+ name: "processed_at";
4832
+ tableName: "cms_event_outbox";
2959
4833
  dataType: "date";
2960
4834
  columnType: "PgTimestamp";
2961
4835
  data: Date;
2962
4836
  driverParam: string;
2963
- notNull: true;
2964
- hasDefault: true;
4837
+ notNull: false;
4838
+ hasDefault: false;
2965
4839
  isPrimaryKey: false;
2966
4840
  isAutoincrement: false;
2967
4841
  hasRuntimeDefault: false;
@@ -2973,13 +4847,13 @@ export declare const cmsSchema: {
2973
4847
  };
2974
4848
  dialect: "pg";
2975
4849
  }>;
2976
- assets: import("drizzle-orm/pg-core").PgTableWithColumns<{
2977
- name: "cms_assets";
4850
+ jobs: import("drizzle-orm/pg-core").PgTableWithColumns<{
4851
+ name: "cms_jobs";
2978
4852
  schema: undefined;
2979
4853
  columns: {
2980
4854
  id: import("drizzle-orm/pg-core").PgColumn<{
2981
4855
  name: "id";
2982
- tableName: "cms_assets";
4856
+ tableName: "cms_jobs";
2983
4857
  dataType: "string";
2984
4858
  columnType: "PgUUID";
2985
4859
  data: string;
@@ -2996,7 +4870,7 @@ export declare const cmsSchema: {
2996
4870
  }, {}, {}>;
2997
4871
  organizationId: import("drizzle-orm/pg-core").PgColumn<{
2998
4872
  name: "organization_id";
2999
- tableName: "cms_assets";
4873
+ tableName: "cms_jobs";
3000
4874
  dataType: "string";
3001
4875
  columnType: "PgUUID";
3002
4876
  data: string;
@@ -3011,47 +4885,9 @@ export declare const cmsSchema: {
3011
4885
  identity: undefined;
3012
4886
  generated: undefined;
3013
4887
  }, {}, {}>;
3014
- assetType: import("drizzle-orm/pg-core").PgColumn<{
3015
- name: "asset_type";
3016
- tableName: "cms_assets";
3017
- dataType: "string";
3018
- columnType: "PgVarchar";
3019
- data: string;
3020
- driverParam: string;
3021
- notNull: true;
3022
- hasDefault: false;
3023
- isPrimaryKey: false;
3024
- isAutoincrement: false;
3025
- hasRuntimeDefault: false;
3026
- enumValues: [string, ...string[]];
3027
- baseColumn: never;
3028
- identity: undefined;
3029
- generated: undefined;
3030
- }, {}, {
3031
- length: 20;
3032
- }>;
3033
- filename: import("drizzle-orm/pg-core").PgColumn<{
3034
- name: "filename";
3035
- tableName: "cms_assets";
3036
- dataType: "string";
3037
- columnType: "PgVarchar";
3038
- data: string;
3039
- driverParam: string;
3040
- notNull: true;
3041
- hasDefault: false;
3042
- isPrimaryKey: false;
3043
- isAutoincrement: false;
3044
- hasRuntimeDefault: false;
3045
- enumValues: [string, ...string[]];
3046
- baseColumn: never;
3047
- identity: undefined;
3048
- generated: undefined;
3049
- }, {}, {
3050
- length: 255;
3051
- }>;
3052
- originalFilename: import("drizzle-orm/pg-core").PgColumn<{
3053
- name: "original_filename";
3054
- tableName: "cms_assets";
4888
+ type: import("drizzle-orm/pg-core").PgColumn<{
4889
+ name: "type";
4890
+ tableName: "cms_jobs";
3055
4891
  dataType: "string";
3056
4892
  columnType: "PgVarchar";
3057
4893
  data: string;
@@ -3066,106 +4902,70 @@ export declare const cmsSchema: {
3066
4902
  identity: undefined;
3067
4903
  generated: undefined;
3068
4904
  }, {}, {
3069
- length: 255;
4905
+ length: 200;
3070
4906
  }>;
3071
- mimeType: import("drizzle-orm/pg-core").PgColumn<{
3072
- name: "mime_type";
3073
- tableName: "cms_assets";
3074
- dataType: "string";
3075
- columnType: "PgVarchar";
3076
- data: string;
3077
- driverParam: string;
4907
+ payload: import("drizzle-orm/pg-core").PgColumn<{
4908
+ name: "payload";
4909
+ tableName: "cms_jobs";
4910
+ dataType: "json";
4911
+ columnType: "PgJsonb";
4912
+ data: Record<string, unknown>;
4913
+ driverParam: unknown;
3078
4914
  notNull: true;
3079
- hasDefault: false;
4915
+ hasDefault: true;
3080
4916
  isPrimaryKey: false;
3081
4917
  isAutoincrement: false;
3082
4918
  hasRuntimeDefault: false;
3083
- enumValues: [string, ...string[]];
4919
+ enumValues: undefined;
3084
4920
  baseColumn: never;
3085
4921
  identity: undefined;
3086
4922
  generated: undefined;
3087
4923
  }, {}, {
3088
- length: 100;
4924
+ $type: Record<string, unknown>;
3089
4925
  }>;
3090
- size: import("drizzle-orm/pg-core").PgColumn<{
3091
- name: "size";
3092
- tableName: "cms_assets";
3093
- dataType: "number";
3094
- columnType: "PgInteger";
3095
- data: number;
3096
- driverParam: string | number;
3097
- notNull: true;
3098
- hasDefault: false;
3099
- isPrimaryKey: false;
3100
- isAutoincrement: false;
3101
- hasRuntimeDefault: false;
3102
- enumValues: undefined;
3103
- baseColumn: never;
3104
- identity: undefined;
3105
- generated: undefined;
3106
- }, {}, {}>;
3107
- url: import("drizzle-orm/pg-core").PgColumn<{
3108
- name: "url";
3109
- tableName: "cms_assets";
3110
- dataType: "string";
3111
- columnType: "PgText";
3112
- data: string;
3113
- driverParam: string;
3114
- notNull: true;
3115
- hasDefault: false;
3116
- isPrimaryKey: false;
3117
- isAutoincrement: false;
3118
- hasRuntimeDefault: false;
3119
- enumValues: [string, ...string[]];
3120
- baseColumn: never;
3121
- identity: undefined;
3122
- generated: undefined;
3123
- }, {}, {}>;
3124
- path: import("drizzle-orm/pg-core").PgColumn<{
3125
- name: "path";
3126
- tableName: "cms_assets";
4926
+ status: import("drizzle-orm/pg-core").PgColumn<{
4927
+ name: "status";
4928
+ tableName: "cms_jobs";
3127
4929
  dataType: "string";
3128
- columnType: "PgText";
3129
- data: string;
4930
+ columnType: "PgEnumColumn";
4931
+ data: "pending" | "leased" | "completed" | "failed" | "cancelled";
3130
4932
  driverParam: string;
3131
4933
  notNull: true;
3132
- hasDefault: false;
4934
+ hasDefault: true;
3133
4935
  isPrimaryKey: false;
3134
4936
  isAutoincrement: false;
3135
4937
  hasRuntimeDefault: false;
3136
- enumValues: [string, ...string[]];
4938
+ enumValues: ["pending", "leased", "completed", "failed", "cancelled"];
3137
4939
  baseColumn: never;
3138
4940
  identity: undefined;
3139
4941
  generated: undefined;
3140
4942
  }, {}, {}>;
3141
- storageAdapter: import("drizzle-orm/pg-core").PgColumn<{
3142
- name: "storage_adapter";
3143
- tableName: "cms_assets";
3144
- dataType: "string";
3145
- columnType: "PgVarchar";
3146
- data: string;
4943
+ runAt: import("drizzle-orm/pg-core").PgColumn<{
4944
+ name: "run_at";
4945
+ tableName: "cms_jobs";
4946
+ dataType: "date";
4947
+ columnType: "PgTimestamp";
4948
+ data: Date;
3147
4949
  driverParam: string;
3148
4950
  notNull: true;
3149
4951
  hasDefault: true;
3150
4952
  isPrimaryKey: false;
3151
4953
  isAutoincrement: false;
3152
- hasRuntimeDefault: false;
3153
- enumValues: [string, ...string[]];
3154
- baseColumn: never;
3155
- identity: undefined;
3156
- generated: undefined;
3157
- }, {}, {
3158
- length: 50;
3159
- }>;
3160
- width: import("drizzle-orm/pg-core").PgColumn<{
3161
- name: "width";
3162
- tableName: "cms_assets";
4954
+ hasRuntimeDefault: false;
4955
+ enumValues: undefined;
4956
+ baseColumn: never;
4957
+ identity: undefined;
4958
+ generated: undefined;
4959
+ }, {}, {}>;
4960
+ attempts: import("drizzle-orm/pg-core").PgColumn<{
4961
+ name: "attempts";
4962
+ tableName: "cms_jobs";
3163
4963
  dataType: "number";
3164
4964
  columnType: "PgInteger";
3165
4965
  data: number;
3166
4966
  driverParam: string | number;
3167
- notNull: false;
3168
- hasDefault: false;
4967
+ notNull: true;
4968
+ hasDefault: true;
3169
4969
  isPrimaryKey: false;
3170
4970
  isAutoincrement: false;
3171
4971
  hasRuntimeDefault: false;
@@ -3174,15 +4974,15 @@ export declare const cmsSchema: {
3174
4974
  identity: undefined;
3175
4975
  generated: undefined;
3176
4976
  }, {}, {}>;
3177
- height: import("drizzle-orm/pg-core").PgColumn<{
3178
- name: "height";
3179
- tableName: "cms_assets";
4977
+ maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
4978
+ name: "max_attempts";
4979
+ tableName: "cms_jobs";
3180
4980
  dataType: "number";
3181
4981
  columnType: "PgInteger";
3182
4982
  data: number;
3183
4983
  driverParam: string | number;
3184
- notNull: false;
3185
- hasDefault: false;
4984
+ notNull: true;
4985
+ hasDefault: true;
3186
4986
  isPrimaryKey: false;
3187
4987
  isAutoincrement: false;
3188
4988
  hasRuntimeDefault: false;
@@ -3191,45 +4991,43 @@ export declare const cmsSchema: {
3191
4991
  identity: undefined;
3192
4992
  generated: undefined;
3193
4993
  }, {}, {}>;
3194
- metadata: import("drizzle-orm/pg-core").PgColumn<{
3195
- name: "metadata";
3196
- tableName: "cms_assets";
3197
- dataType: "json";
3198
- columnType: "PgJsonb";
3199
- data: unknown;
3200
- driverParam: unknown;
4994
+ leaseOwner: import("drizzle-orm/pg-core").PgColumn<{
4995
+ name: "lease_owner";
4996
+ tableName: "cms_jobs";
4997
+ dataType: "string";
4998
+ columnType: "PgText";
4999
+ data: string;
5000
+ driverParam: string;
3201
5001
  notNull: false;
3202
5002
  hasDefault: false;
3203
5003
  isPrimaryKey: false;
3204
5004
  isAutoincrement: false;
3205
5005
  hasRuntimeDefault: false;
3206
- enumValues: undefined;
5006
+ enumValues: [string, ...string[]];
3207
5007
  baseColumn: never;
3208
5008
  identity: undefined;
3209
5009
  generated: undefined;
3210
5010
  }, {}, {}>;
3211
- title: import("drizzle-orm/pg-core").PgColumn<{
3212
- name: "title";
3213
- tableName: "cms_assets";
3214
- dataType: "string";
3215
- columnType: "PgVarchar";
3216
- data: string;
5011
+ leaseExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
5012
+ name: "lease_expires_at";
5013
+ tableName: "cms_jobs";
5014
+ dataType: "date";
5015
+ columnType: "PgTimestamp";
5016
+ data: Date;
3217
5017
  driverParam: string;
3218
5018
  notNull: false;
3219
5019
  hasDefault: false;
3220
5020
  isPrimaryKey: false;
3221
5021
  isAutoincrement: false;
3222
5022
  hasRuntimeDefault: false;
3223
- enumValues: [string, ...string[]];
5023
+ enumValues: undefined;
3224
5024
  baseColumn: never;
3225
5025
  identity: undefined;
3226
5026
  generated: undefined;
3227
- }, {}, {
3228
- length: 255;
3229
- }>;
3230
- description: import("drizzle-orm/pg-core").PgColumn<{
3231
- name: "description";
3232
- tableName: "cms_assets";
5027
+ }, {}, {}>;
5028
+ lastError: import("drizzle-orm/pg-core").PgColumn<{
5029
+ name: "last_error";
5030
+ tableName: "cms_jobs";
3233
5031
  dataType: "string";
3234
5032
  columnType: "PgText";
3235
5033
  data: string;
@@ -3244,9 +5042,9 @@ export declare const cmsSchema: {
3244
5042
  identity: undefined;
3245
5043
  generated: undefined;
3246
5044
  }, {}, {}>;
3247
- alt: import("drizzle-orm/pg-core").PgColumn<{
3248
- name: "alt";
3249
- tableName: "cms_assets";
5045
+ idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
5046
+ name: "idempotency_key";
5047
+ tableName: "cms_jobs";
3250
5048
  dataType: "string";
3251
5049
  columnType: "PgText";
3252
5050
  data: string;
@@ -3261,9 +5059,9 @@ export declare const cmsSchema: {
3261
5059
  identity: undefined;
3262
5060
  generated: undefined;
3263
5061
  }, {}, {}>;
3264
- creditLine: import("drizzle-orm/pg-core").PgColumn<{
3265
- name: "credit_line";
3266
- tableName: "cms_assets";
5062
+ correlationId: import("drizzle-orm/pg-core").PgColumn<{
5063
+ name: "correlation_id";
5064
+ tableName: "cms_jobs";
3267
5065
  dataType: "string";
3268
5066
  columnType: "PgText";
3269
5067
  data: string;
@@ -3278,9 +5076,9 @@ export declare const cmsSchema: {
3278
5076
  identity: undefined;
3279
5077
  generated: undefined;
3280
5078
  }, {}, {}>;
3281
- createdBy: import("drizzle-orm/pg-core").PgColumn<{
3282
- name: "created_by";
3283
- tableName: "cms_assets";
5079
+ causationId: import("drizzle-orm/pg-core").PgColumn<{
5080
+ name: "causation_id";
5081
+ tableName: "cms_jobs";
3284
5082
  dataType: "string";
3285
5083
  columnType: "PgText";
3286
5084
  data: string;
@@ -3295,9 +5093,9 @@ export declare const cmsSchema: {
3295
5093
  identity: undefined;
3296
5094
  generated: undefined;
3297
5095
  }, {}, {}>;
3298
- updatedBy: import("drizzle-orm/pg-core").PgColumn<{
3299
- name: "updated_by";
3300
- tableName: "cms_assets";
5096
+ createdBy: import("drizzle-orm/pg-core").PgColumn<{
5097
+ name: "created_by";
5098
+ tableName: "cms_jobs";
3301
5099
  dataType: "string";
3302
5100
  columnType: "PgText";
3303
5101
  data: string;
@@ -3314,12 +5112,12 @@ export declare const cmsSchema: {
3314
5112
  }, {}, {}>;
3315
5113
  createdAt: import("drizzle-orm/pg-core").PgColumn<{
3316
5114
  name: "created_at";
3317
- tableName: "cms_assets";
5115
+ tableName: "cms_jobs";
3318
5116
  dataType: "date";
3319
5117
  columnType: "PgTimestamp";
3320
5118
  data: Date;
3321
5119
  driverParam: string;
3322
- notNull: false;
5120
+ notNull: true;
3323
5121
  hasDefault: true;
3324
5122
  isPrimaryKey: false;
3325
5123
  isAutoincrement: false;
@@ -3331,12 +5129,12 @@ export declare const cmsSchema: {
3331
5129
  }, {}, {}>;
3332
5130
  updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3333
5131
  name: "updated_at";
3334
- tableName: "cms_assets";
5132
+ tableName: "cms_jobs";
3335
5133
  dataType: "date";
3336
5134
  columnType: "PgTimestamp";
3337
5135
  data: Date;
3338
5136
  driverParam: string;
3339
- notNull: false;
5137
+ notNull: true;
3340
5138
  hasDefault: true;
3341
5139
  isPrimaryKey: false;
3342
5140
  isAutoincrement: false;
@@ -3346,16 +5144,33 @@ export declare const cmsSchema: {
3346
5144
  identity: undefined;
3347
5145
  generated: undefined;
3348
5146
  }, {}, {}>;
5147
+ completedAt: import("drizzle-orm/pg-core").PgColumn<{
5148
+ name: "completed_at";
5149
+ tableName: "cms_jobs";
5150
+ dataType: "date";
5151
+ columnType: "PgTimestamp";
5152
+ data: Date;
5153
+ driverParam: string;
5154
+ notNull: false;
5155
+ hasDefault: false;
5156
+ isPrimaryKey: false;
5157
+ isAutoincrement: false;
5158
+ hasRuntimeDefault: false;
5159
+ enumValues: undefined;
5160
+ baseColumn: never;
5161
+ identity: undefined;
5162
+ generated: undefined;
5163
+ }, {}, {}>;
3349
5164
  };
3350
5165
  dialect: "pg";
3351
5166
  }>;
3352
- schemaTypes: import("drizzle-orm/pg-core").PgTableWithColumns<{
3353
- name: "cms_schema_types";
5167
+ pluginStorage: import("drizzle-orm/pg-core").PgTableWithColumns<{
5168
+ name: "cms_plugin_storage";
3354
5169
  schema: undefined;
3355
5170
  columns: {
3356
5171
  id: import("drizzle-orm/pg-core").PgColumn<{
3357
5172
  name: "id";
3358
- tableName: "cms_schema_types";
5173
+ tableName: "cms_plugin_storage";
3359
5174
  dataType: "string";
3360
5175
  columnType: "PgUUID";
3361
5176
  data: string;
@@ -3370,11 +5185,11 @@ export declare const cmsSchema: {
3370
5185
  identity: undefined;
3371
5186
  generated: undefined;
3372
5187
  }, {}, {}>;
3373
- name: import("drizzle-orm/pg-core").PgColumn<{
3374
- name: "name";
3375
- tableName: "cms_schema_types";
5188
+ organizationId: import("drizzle-orm/pg-core").PgColumn<{
5189
+ name: "organization_id";
5190
+ tableName: "cms_plugin_storage";
3376
5191
  dataType: "string";
3377
- columnType: "PgVarchar";
5192
+ columnType: "PgUUID";
3378
5193
  data: string;
3379
5194
  driverParam: string;
3380
5195
  notNull: true;
@@ -3382,16 +5197,14 @@ export declare const cmsSchema: {
3382
5197
  isPrimaryKey: false;
3383
5198
  isAutoincrement: false;
3384
5199
  hasRuntimeDefault: false;
3385
- enumValues: [string, ...string[]];
5200
+ enumValues: undefined;
3386
5201
  baseColumn: never;
3387
5202
  identity: undefined;
3388
5203
  generated: undefined;
3389
- }, {}, {
3390
- length: 100;
3391
- }>;
3392
- title: import("drizzle-orm/pg-core").PgColumn<{
3393
- name: "title";
3394
- tableName: "cms_schema_types";
5204
+ }, {}, {}>;
5205
+ plugin: import("drizzle-orm/pg-core").PgColumn<{
5206
+ name: "plugin";
5207
+ tableName: "cms_plugin_storage";
3395
5208
  dataType: "string";
3396
5209
  columnType: "PgVarchar";
3397
5210
  data: string;
@@ -3408,31 +5221,14 @@ export declare const cmsSchema: {
3408
5221
  }, {}, {
3409
5222
  length: 200;
3410
5223
  }>;
3411
- type: import("drizzle-orm/pg-core").PgColumn<{
3412
- name: "type";
3413
- tableName: "cms_schema_types";
3414
- dataType: "string";
3415
- columnType: "PgEnumColumn";
3416
- data: "object" | "document";
3417
- driverParam: string;
3418
- notNull: true;
3419
- hasDefault: false;
3420
- isPrimaryKey: false;
3421
- isAutoincrement: false;
3422
- hasRuntimeDefault: false;
3423
- enumValues: ["document", "object"];
3424
- baseColumn: never;
3425
- identity: undefined;
3426
- generated: undefined;
3427
- }, {}, {}>;
3428
- description: import("drizzle-orm/pg-core").PgColumn<{
3429
- name: "description";
3430
- tableName: "cms_schema_types";
5224
+ collection: import("drizzle-orm/pg-core").PgColumn<{
5225
+ name: "collection";
5226
+ tableName: "cms_plugin_storage";
3431
5227
  dataType: "string";
3432
- columnType: "PgText";
5228
+ columnType: "PgVarchar";
3433
5229
  data: string;
3434
5230
  driverParam: string;
3435
- notNull: false;
5231
+ notNull: true;
3436
5232
  hasDefault: false;
3437
5233
  isPrimaryKey: false;
3438
5234
  isAutoincrement: false;
@@ -3441,148 +5237,31 @@ export declare const cmsSchema: {
3441
5237
  baseColumn: never;
3442
5238
  identity: undefined;
3443
5239
  generated: undefined;
3444
- }, {}, {}>;
3445
- fields: import("drizzle-orm/pg-core").PgColumn<{
3446
- name: "fields";
3447
- tableName: "cms_schema_types";
5240
+ }, {}, {
5241
+ length: 200;
5242
+ }>;
5243
+ data: import("drizzle-orm/pg-core").PgColumn<{
5244
+ name: "data";
5245
+ tableName: "cms_plugin_storage";
3448
5246
  dataType: "json";
3449
5247
  columnType: "PgJsonb";
3450
- data: unknown;
5248
+ data: Record<string, unknown>;
3451
5249
  driverParam: unknown;
3452
5250
  notNull: true;
3453
- hasDefault: false;
3454
- isPrimaryKey: false;
3455
- isAutoincrement: false;
3456
- hasRuntimeDefault: false;
3457
- enumValues: undefined;
3458
- baseColumn: never;
3459
- identity: undefined;
3460
- generated: undefined;
3461
- }, {}, {}>;
3462
- createdAt: import("drizzle-orm/pg-core").PgColumn<{
3463
- name: "created_at";
3464
- tableName: "cms_schema_types";
3465
- dataType: "date";
3466
- columnType: "PgTimestamp";
3467
- data: Date;
3468
- driverParam: string;
3469
- notNull: false;
3470
- hasDefault: true;
3471
- isPrimaryKey: false;
3472
- isAutoincrement: false;
3473
- hasRuntimeDefault: false;
3474
- enumValues: undefined;
3475
- baseColumn: never;
3476
- identity: undefined;
3477
- generated: undefined;
3478
- }, {}, {}>;
3479
- updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3480
- name: "updated_at";
3481
- tableName: "cms_schema_types";
3482
- dataType: "date";
3483
- columnType: "PgTimestamp";
3484
- data: Date;
3485
- driverParam: string;
3486
- notNull: false;
3487
- hasDefault: true;
3488
- isPrimaryKey: false;
3489
- isAutoincrement: false;
3490
- hasRuntimeDefault: false;
3491
- enumValues: undefined;
3492
- baseColumn: never;
3493
- identity: undefined;
3494
- generated: undefined;
3495
- }, {}, {}>;
3496
- };
3497
- dialect: "pg";
3498
- }>;
3499
- userProfiles: import("drizzle-orm/pg-core").PgTableWithColumns<{
3500
- name: "cms_user_profiles";
3501
- schema: undefined;
3502
- columns: {
3503
- userId: import("drizzle-orm/pg-core").PgColumn<{
3504
- name: "user_id";
3505
- tableName: "cms_user_profiles";
3506
- dataType: "string";
3507
- columnType: "PgText";
3508
- data: string;
3509
- driverParam: string;
3510
- notNull: true;
3511
- hasDefault: false;
3512
- isPrimaryKey: true;
3513
- isAutoincrement: false;
3514
- hasRuntimeDefault: false;
3515
- enumValues: [string, ...string[]];
3516
- baseColumn: never;
3517
- identity: undefined;
3518
- generated: undefined;
3519
- }, {}, {}>;
3520
- role: import("drizzle-orm/pg-core").PgColumn<{
3521
- name: "role";
3522
- tableName: "cms_user_profiles";
3523
- dataType: "string";
3524
- columnType: "PgText";
3525
- data: "super_admin" | "admin" | "editor" | "viewer";
3526
- driverParam: string;
3527
- notNull: true;
3528
5251
  hasDefault: true;
3529
5252
  isPrimaryKey: false;
3530
5253
  isAutoincrement: false;
3531
5254
  hasRuntimeDefault: false;
3532
- enumValues: ["super_admin", "admin", "editor", "viewer"];
3533
- baseColumn: never;
3534
- identity: undefined;
3535
- generated: undefined;
3536
- }, {}, {}>;
3537
- preferences: import("drizzle-orm/pg-core").PgColumn<{
3538
- name: "preferences";
3539
- tableName: "cms_user_profiles";
3540
- dataType: "json";
3541
- columnType: "PgJsonb";
3542
- data: {
3543
- [key: string]: any;
3544
- theme?: "light" | "dark";
3545
- language?: string;
3546
- includeChildOrganizations?: boolean;
3547
- };
3548
- driverParam: unknown;
3549
- notNull: false;
3550
- hasDefault: false;
3551
- isPrimaryKey: false;
3552
- isAutoincrement: false;
3553
- hasRuntimeDefault: false;
3554
5255
  enumValues: undefined;
3555
5256
  baseColumn: never;
3556
5257
  identity: undefined;
3557
5258
  generated: undefined;
3558
5259
  }, {}, {
3559
- $type: {
3560
- [key: string]: any;
3561
- theme?: "light" | "dark";
3562
- language?: string;
3563
- includeChildOrganizations?: boolean;
3564
- };
5260
+ $type: Record<string, unknown>;
3565
5261
  }>;
3566
5262
  createdAt: import("drizzle-orm/pg-core").PgColumn<{
3567
5263
  name: "created_at";
3568
- tableName: "cms_user_profiles";
3569
- dataType: "date";
3570
- columnType: "PgTimestamp";
3571
- data: Date;
3572
- driverParam: string;
3573
- notNull: true;
3574
- hasDefault: true;
3575
- isPrimaryKey: false;
3576
- isAutoincrement: false;
3577
- hasRuntimeDefault: false;
3578
- enumValues: undefined;
3579
- baseColumn: never;
3580
- identity: undefined;
3581
- generated: undefined;
3582
- }, {}, {}>;
3583
- updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3584
- name: "updated_at";
3585
- tableName: "cms_user_profiles";
5264
+ tableName: "cms_plugin_storage";
3586
5265
  dataType: "date";
3587
5266
  columnType: "PgTimestamp";
3588
5267
  data: Date;
@@ -3603,6 +5282,7 @@ export declare const cmsSchema: {
3603
5282
  documentStatusEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "published", "unpublished"]>;
3604
5283
  versionEventEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "publish"]>;
3605
5284
  schemaTypeEnum: import("drizzle-orm/pg-core").PgEnum<["document", "object"]>;
5285
+ jobStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "leased", "completed", "failed", "cancelled"]>;
3606
5286
  };
3607
5287
  export type CMSSchema = typeof cmsSchema;
3608
5288
  export type Organization = typeof organizations.$inferSelect;
@@ -3615,4 +5295,12 @@ export type RoleRow = typeof roles.$inferSelect;
3615
5295
  export type NewRoleRow = typeof roles.$inferInsert;
3616
5296
  export type UserSession = typeof userSessions.$inferSelect;
3617
5297
  export type NewUserSession = typeof userSessions.$inferInsert;
5298
+ export type DomainEventRow = typeof domainEvents.$inferSelect;
5299
+ export type NewDomainEventRow = typeof domainEvents.$inferInsert;
5300
+ export type EventOutboxRow = typeof eventOutbox.$inferSelect;
5301
+ export type NewEventOutboxRow = typeof eventOutbox.$inferInsert;
5302
+ export type PluginStorageRow = typeof pluginStorage.$inferSelect;
5303
+ export type NewPluginStorageRow = typeof pluginStorage.$inferInsert;
5304
+ export type JobRow = typeof jobs.$inferSelect;
5305
+ export type NewJobRow = typeof jobs.$inferInsert;
3618
5306
  //# sourceMappingURL=schema.d.ts.map