bopodev-db 0.1.23 → 0.1.25
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/.turbo/turbo-build.log +1 -1
- package/.turbo/turbo-lint.log +4 -0
- package/.turbo/turbo-typecheck.log +1 -1
- package/dist/repositories.d.ts +393 -7
- package/dist/schema.d.ts +1357 -207
- package/package.json +1 -1
- package/src/bootstrap.ts +99 -0
- package/src/repositories.ts +605 -13
- package/src/schema.ts +55 -0
package/dist/schema.d.ts
CHANGED
|
@@ -179,6 +179,57 @@ export declare const projects: import("drizzle-orm/pg-core").PgTableWithColumns<
|
|
|
179
179
|
identity: undefined;
|
|
180
180
|
generated: undefined;
|
|
181
181
|
}, {}, {}>;
|
|
182
|
+
monthlyBudgetUsd: import("drizzle-orm/pg-core").PgColumn<{
|
|
183
|
+
name: "monthly_budget_usd";
|
|
184
|
+
tableName: "projects";
|
|
185
|
+
dataType: "string";
|
|
186
|
+
columnType: "PgNumeric";
|
|
187
|
+
data: string;
|
|
188
|
+
driverParam: string;
|
|
189
|
+
notNull: true;
|
|
190
|
+
hasDefault: true;
|
|
191
|
+
isPrimaryKey: false;
|
|
192
|
+
isAutoincrement: false;
|
|
193
|
+
hasRuntimeDefault: false;
|
|
194
|
+
enumValues: undefined;
|
|
195
|
+
baseColumn: never;
|
|
196
|
+
identity: undefined;
|
|
197
|
+
generated: undefined;
|
|
198
|
+
}, {}, {}>;
|
|
199
|
+
usedBudgetUsd: import("drizzle-orm/pg-core").PgColumn<{
|
|
200
|
+
name: "used_budget_usd";
|
|
201
|
+
tableName: "projects";
|
|
202
|
+
dataType: "string";
|
|
203
|
+
columnType: "PgNumeric";
|
|
204
|
+
data: string;
|
|
205
|
+
driverParam: string;
|
|
206
|
+
notNull: true;
|
|
207
|
+
hasDefault: true;
|
|
208
|
+
isPrimaryKey: false;
|
|
209
|
+
isAutoincrement: false;
|
|
210
|
+
hasRuntimeDefault: false;
|
|
211
|
+
enumValues: undefined;
|
|
212
|
+
baseColumn: never;
|
|
213
|
+
identity: undefined;
|
|
214
|
+
generated: undefined;
|
|
215
|
+
}, {}, {}>;
|
|
216
|
+
budgetWindowStartAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
217
|
+
name: "budget_window_start_at";
|
|
218
|
+
tableName: "projects";
|
|
219
|
+
dataType: "date";
|
|
220
|
+
columnType: "PgTimestamp";
|
|
221
|
+
data: Date;
|
|
222
|
+
driverParam: string;
|
|
223
|
+
notNull: true;
|
|
224
|
+
hasDefault: true;
|
|
225
|
+
isPrimaryKey: false;
|
|
226
|
+
isAutoincrement: false;
|
|
227
|
+
hasRuntimeDefault: false;
|
|
228
|
+
enumValues: undefined;
|
|
229
|
+
baseColumn: never;
|
|
230
|
+
identity: undefined;
|
|
231
|
+
generated: undefined;
|
|
232
|
+
}, {}, {}>;
|
|
182
233
|
executionWorkspacePolicy: import("drizzle-orm/pg-core").PgColumn<{
|
|
183
234
|
name: "execution_workspace_policy";
|
|
184
235
|
tableName: "projects";
|
|
@@ -659,6 +710,40 @@ export declare const agents: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
|
659
710
|
identity: undefined;
|
|
660
711
|
generated: undefined;
|
|
661
712
|
}, {}, {}>;
|
|
713
|
+
roleKey: import("drizzle-orm/pg-core").PgColumn<{
|
|
714
|
+
name: "role_key";
|
|
715
|
+
tableName: "agents";
|
|
716
|
+
dataType: "string";
|
|
717
|
+
columnType: "PgText";
|
|
718
|
+
data: string;
|
|
719
|
+
driverParam: string;
|
|
720
|
+
notNull: false;
|
|
721
|
+
hasDefault: false;
|
|
722
|
+
isPrimaryKey: false;
|
|
723
|
+
isAutoincrement: false;
|
|
724
|
+
hasRuntimeDefault: false;
|
|
725
|
+
enumValues: [string, ...string[]];
|
|
726
|
+
baseColumn: never;
|
|
727
|
+
identity: undefined;
|
|
728
|
+
generated: undefined;
|
|
729
|
+
}, {}, {}>;
|
|
730
|
+
title: import("drizzle-orm/pg-core").PgColumn<{
|
|
731
|
+
name: "title";
|
|
732
|
+
tableName: "agents";
|
|
733
|
+
dataType: "string";
|
|
734
|
+
columnType: "PgText";
|
|
735
|
+
data: string;
|
|
736
|
+
driverParam: string;
|
|
737
|
+
notNull: false;
|
|
738
|
+
hasDefault: false;
|
|
739
|
+
isPrimaryKey: false;
|
|
740
|
+
isAutoincrement: false;
|
|
741
|
+
hasRuntimeDefault: false;
|
|
742
|
+
enumValues: [string, ...string[]];
|
|
743
|
+
baseColumn: never;
|
|
744
|
+
identity: undefined;
|
|
745
|
+
generated: undefined;
|
|
746
|
+
}, {}, {}>;
|
|
662
747
|
name: import("drizzle-orm/pg-core").PgColumn<{
|
|
663
748
|
name: "name";
|
|
664
749
|
tableName: "agents";
|
|
@@ -1387,6 +1472,40 @@ export declare const issueComments: import("drizzle-orm/pg-core").PgTableWithCol
|
|
|
1387
1472
|
identity: undefined;
|
|
1388
1473
|
generated: undefined;
|
|
1389
1474
|
}, {}, {}>;
|
|
1475
|
+
recipientsJson: import("drizzle-orm/pg-core").PgColumn<{
|
|
1476
|
+
name: "recipients_json";
|
|
1477
|
+
tableName: "issue_comments";
|
|
1478
|
+
dataType: "string";
|
|
1479
|
+
columnType: "PgText";
|
|
1480
|
+
data: string;
|
|
1481
|
+
driverParam: string;
|
|
1482
|
+
notNull: true;
|
|
1483
|
+
hasDefault: true;
|
|
1484
|
+
isPrimaryKey: false;
|
|
1485
|
+
isAutoincrement: false;
|
|
1486
|
+
hasRuntimeDefault: false;
|
|
1487
|
+
enumValues: [string, ...string[]];
|
|
1488
|
+
baseColumn: never;
|
|
1489
|
+
identity: undefined;
|
|
1490
|
+
generated: undefined;
|
|
1491
|
+
}, {}, {}>;
|
|
1492
|
+
runId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1493
|
+
name: "run_id";
|
|
1494
|
+
tableName: "issue_comments";
|
|
1495
|
+
dataType: "string";
|
|
1496
|
+
columnType: "PgText";
|
|
1497
|
+
data: string;
|
|
1498
|
+
driverParam: string;
|
|
1499
|
+
notNull: false;
|
|
1500
|
+
hasDefault: false;
|
|
1501
|
+
isPrimaryKey: false;
|
|
1502
|
+
isAutoincrement: false;
|
|
1503
|
+
hasRuntimeDefault: false;
|
|
1504
|
+
enumValues: [string, ...string[]];
|
|
1505
|
+
baseColumn: never;
|
|
1506
|
+
identity: undefined;
|
|
1507
|
+
generated: undefined;
|
|
1508
|
+
}, {}, {}>;
|
|
1390
1509
|
body: import("drizzle-orm/pg-core").PgColumn<{
|
|
1391
1510
|
name: "body";
|
|
1392
1511
|
tableName: "issue_comments";
|
|
@@ -1887,13 +2006,13 @@ export declare const heartbeatRuns: import("drizzle-orm/pg-core").PgTableWithCol
|
|
|
1887
2006
|
};
|
|
1888
2007
|
dialect: "pg";
|
|
1889
2008
|
}>;
|
|
1890
|
-
export declare const
|
|
1891
|
-
name: "
|
|
2009
|
+
export declare const heartbeatRunQueue: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2010
|
+
name: "heartbeat_run_queue";
|
|
1892
2011
|
schema: undefined;
|
|
1893
2012
|
columns: {
|
|
1894
2013
|
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
1895
2014
|
name: "id";
|
|
1896
|
-
tableName: "
|
|
2015
|
+
tableName: "heartbeat_run_queue";
|
|
1897
2016
|
dataType: "string";
|
|
1898
2017
|
columnType: "PgText";
|
|
1899
2018
|
data: string;
|
|
@@ -1910,7 +2029,7 @@ export declare const heartbeatRunMessages: import("drizzle-orm/pg-core").PgTable
|
|
|
1910
2029
|
}, {}, {}>;
|
|
1911
2030
|
companyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1912
2031
|
name: "company_id";
|
|
1913
|
-
tableName: "
|
|
2032
|
+
tableName: "heartbeat_run_queue";
|
|
1914
2033
|
dataType: "string";
|
|
1915
2034
|
columnType: "PgText";
|
|
1916
2035
|
data: string;
|
|
@@ -1925,9 +2044,9 @@ export declare const heartbeatRunMessages: import("drizzle-orm/pg-core").PgTable
|
|
|
1925
2044
|
identity: undefined;
|
|
1926
2045
|
generated: undefined;
|
|
1927
2046
|
}, {}, {}>;
|
|
1928
|
-
|
|
1929
|
-
name: "
|
|
1930
|
-
tableName: "
|
|
2047
|
+
agentId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2048
|
+
name: "agent_id";
|
|
2049
|
+
tableName: "heartbeat_run_queue";
|
|
1931
2050
|
dataType: "string";
|
|
1932
2051
|
columnType: "PgText";
|
|
1933
2052
|
data: string;
|
|
@@ -1942,32 +2061,32 @@ export declare const heartbeatRunMessages: import("drizzle-orm/pg-core").PgTable
|
|
|
1942
2061
|
identity: undefined;
|
|
1943
2062
|
generated: undefined;
|
|
1944
2063
|
}, {}, {}>;
|
|
1945
|
-
|
|
1946
|
-
name: "
|
|
1947
|
-
tableName: "
|
|
1948
|
-
dataType: "
|
|
1949
|
-
columnType: "
|
|
1950
|
-
data:
|
|
1951
|
-
driverParam: string
|
|
2064
|
+
jobType: import("drizzle-orm/pg-core").PgColumn<{
|
|
2065
|
+
name: "job_type";
|
|
2066
|
+
tableName: "heartbeat_run_queue";
|
|
2067
|
+
dataType: "string";
|
|
2068
|
+
columnType: "PgText";
|
|
2069
|
+
data: string;
|
|
2070
|
+
driverParam: string;
|
|
1952
2071
|
notNull: true;
|
|
1953
2072
|
hasDefault: false;
|
|
1954
2073
|
isPrimaryKey: false;
|
|
1955
2074
|
isAutoincrement: false;
|
|
1956
2075
|
hasRuntimeDefault: false;
|
|
1957
|
-
enumValues:
|
|
2076
|
+
enumValues: [string, ...string[]];
|
|
1958
2077
|
baseColumn: never;
|
|
1959
2078
|
identity: undefined;
|
|
1960
2079
|
generated: undefined;
|
|
1961
2080
|
}, {}, {}>;
|
|
1962
|
-
|
|
1963
|
-
name: "
|
|
1964
|
-
tableName: "
|
|
2081
|
+
payloadJson: import("drizzle-orm/pg-core").PgColumn<{
|
|
2082
|
+
name: "payload_json";
|
|
2083
|
+
tableName: "heartbeat_run_queue";
|
|
1965
2084
|
dataType: "string";
|
|
1966
2085
|
columnType: "PgText";
|
|
1967
2086
|
data: string;
|
|
1968
2087
|
driverParam: string;
|
|
1969
2088
|
notNull: true;
|
|
1970
|
-
hasDefault:
|
|
2089
|
+
hasDefault: true;
|
|
1971
2090
|
isPrimaryKey: false;
|
|
1972
2091
|
isAutoincrement: false;
|
|
1973
2092
|
hasRuntimeDefault: false;
|
|
@@ -1976,15 +2095,15 @@ export declare const heartbeatRunMessages: import("drizzle-orm/pg-core").PgTable
|
|
|
1976
2095
|
identity: undefined;
|
|
1977
2096
|
generated: undefined;
|
|
1978
2097
|
}, {}, {}>;
|
|
1979
|
-
|
|
1980
|
-
name: "
|
|
1981
|
-
tableName: "
|
|
2098
|
+
status: import("drizzle-orm/pg-core").PgColumn<{
|
|
2099
|
+
name: "status";
|
|
2100
|
+
tableName: "heartbeat_run_queue";
|
|
1982
2101
|
dataType: "string";
|
|
1983
2102
|
columnType: "PgText";
|
|
1984
2103
|
data: string;
|
|
1985
2104
|
driverParam: string;
|
|
1986
|
-
notNull:
|
|
1987
|
-
hasDefault:
|
|
2105
|
+
notNull: true;
|
|
2106
|
+
hasDefault: true;
|
|
1988
2107
|
isPrimaryKey: false;
|
|
1989
2108
|
isAutoincrement: false;
|
|
1990
2109
|
hasRuntimeDefault: false;
|
|
@@ -1993,9 +2112,26 @@ export declare const heartbeatRunMessages: import("drizzle-orm/pg-core").PgTable
|
|
|
1993
2112
|
identity: undefined;
|
|
1994
2113
|
generated: undefined;
|
|
1995
2114
|
}, {}, {}>;
|
|
1996
|
-
|
|
1997
|
-
name: "
|
|
1998
|
-
tableName: "
|
|
2115
|
+
priority: import("drizzle-orm/pg-core").PgColumn<{
|
|
2116
|
+
name: "priority";
|
|
2117
|
+
tableName: "heartbeat_run_queue";
|
|
2118
|
+
dataType: "number";
|
|
2119
|
+
columnType: "PgInteger";
|
|
2120
|
+
data: number;
|
|
2121
|
+
driverParam: string | number;
|
|
2122
|
+
notNull: true;
|
|
2123
|
+
hasDefault: true;
|
|
2124
|
+
isPrimaryKey: false;
|
|
2125
|
+
isAutoincrement: false;
|
|
2126
|
+
hasRuntimeDefault: false;
|
|
2127
|
+
enumValues: undefined;
|
|
2128
|
+
baseColumn: never;
|
|
2129
|
+
identity: undefined;
|
|
2130
|
+
generated: undefined;
|
|
2131
|
+
}, {}, {}>;
|
|
2132
|
+
idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
|
|
2133
|
+
name: "idempotency_key";
|
|
2134
|
+
tableName: "heartbeat_run_queue";
|
|
1999
2135
|
dataType: "string";
|
|
2000
2136
|
columnType: "PgText";
|
|
2001
2137
|
data: string;
|
|
@@ -2010,9 +2146,60 @@ export declare const heartbeatRunMessages: import("drizzle-orm/pg-core").PgTable
|
|
|
2010
2146
|
identity: undefined;
|
|
2011
2147
|
generated: undefined;
|
|
2012
2148
|
}, {}, {}>;
|
|
2013
|
-
|
|
2014
|
-
name: "
|
|
2015
|
-
tableName: "
|
|
2149
|
+
availableAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2150
|
+
name: "available_at";
|
|
2151
|
+
tableName: "heartbeat_run_queue";
|
|
2152
|
+
dataType: "date";
|
|
2153
|
+
columnType: "PgTimestamp";
|
|
2154
|
+
data: Date;
|
|
2155
|
+
driverParam: string;
|
|
2156
|
+
notNull: true;
|
|
2157
|
+
hasDefault: true;
|
|
2158
|
+
isPrimaryKey: false;
|
|
2159
|
+
isAutoincrement: false;
|
|
2160
|
+
hasRuntimeDefault: false;
|
|
2161
|
+
enumValues: undefined;
|
|
2162
|
+
baseColumn: never;
|
|
2163
|
+
identity: undefined;
|
|
2164
|
+
generated: undefined;
|
|
2165
|
+
}, {}, {}>;
|
|
2166
|
+
attemptCount: import("drizzle-orm/pg-core").PgColumn<{
|
|
2167
|
+
name: "attempt_count";
|
|
2168
|
+
tableName: "heartbeat_run_queue";
|
|
2169
|
+
dataType: "number";
|
|
2170
|
+
columnType: "PgInteger";
|
|
2171
|
+
data: number;
|
|
2172
|
+
driverParam: string | number;
|
|
2173
|
+
notNull: true;
|
|
2174
|
+
hasDefault: true;
|
|
2175
|
+
isPrimaryKey: false;
|
|
2176
|
+
isAutoincrement: false;
|
|
2177
|
+
hasRuntimeDefault: false;
|
|
2178
|
+
enumValues: undefined;
|
|
2179
|
+
baseColumn: never;
|
|
2180
|
+
identity: undefined;
|
|
2181
|
+
generated: undefined;
|
|
2182
|
+
}, {}, {}>;
|
|
2183
|
+
maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
|
|
2184
|
+
name: "max_attempts";
|
|
2185
|
+
tableName: "heartbeat_run_queue";
|
|
2186
|
+
dataType: "number";
|
|
2187
|
+
columnType: "PgInteger";
|
|
2188
|
+
data: number;
|
|
2189
|
+
driverParam: string | number;
|
|
2190
|
+
notNull: true;
|
|
2191
|
+
hasDefault: true;
|
|
2192
|
+
isPrimaryKey: false;
|
|
2193
|
+
isAutoincrement: false;
|
|
2194
|
+
hasRuntimeDefault: false;
|
|
2195
|
+
enumValues: undefined;
|
|
2196
|
+
baseColumn: never;
|
|
2197
|
+
identity: undefined;
|
|
2198
|
+
generated: undefined;
|
|
2199
|
+
}, {}, {}>;
|
|
2200
|
+
lastError: import("drizzle-orm/pg-core").PgColumn<{
|
|
2201
|
+
name: "last_error";
|
|
2202
|
+
tableName: "heartbeat_run_queue";
|
|
2016
2203
|
dataType: "string";
|
|
2017
2204
|
columnType: "PgText";
|
|
2018
2205
|
data: string;
|
|
@@ -2027,43 +2214,43 @@ export declare const heartbeatRunMessages: import("drizzle-orm/pg-core").PgTable
|
|
|
2027
2214
|
identity: undefined;
|
|
2028
2215
|
generated: undefined;
|
|
2029
2216
|
}, {}, {}>;
|
|
2030
|
-
|
|
2031
|
-
name: "
|
|
2032
|
-
tableName: "
|
|
2033
|
-
dataType: "
|
|
2034
|
-
columnType: "
|
|
2035
|
-
data:
|
|
2217
|
+
startedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2218
|
+
name: "started_at";
|
|
2219
|
+
tableName: "heartbeat_run_queue";
|
|
2220
|
+
dataType: "date";
|
|
2221
|
+
columnType: "PgTimestamp";
|
|
2222
|
+
data: Date;
|
|
2036
2223
|
driverParam: string;
|
|
2037
2224
|
notNull: false;
|
|
2038
2225
|
hasDefault: false;
|
|
2039
2226
|
isPrimaryKey: false;
|
|
2040
2227
|
isAutoincrement: false;
|
|
2041
2228
|
hasRuntimeDefault: false;
|
|
2042
|
-
enumValues:
|
|
2229
|
+
enumValues: undefined;
|
|
2043
2230
|
baseColumn: never;
|
|
2044
2231
|
identity: undefined;
|
|
2045
2232
|
generated: undefined;
|
|
2046
2233
|
}, {}, {}>;
|
|
2047
|
-
|
|
2048
|
-
name: "
|
|
2049
|
-
tableName: "
|
|
2050
|
-
dataType: "
|
|
2051
|
-
columnType: "
|
|
2052
|
-
data:
|
|
2234
|
+
finishedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2235
|
+
name: "finished_at";
|
|
2236
|
+
tableName: "heartbeat_run_queue";
|
|
2237
|
+
dataType: "date";
|
|
2238
|
+
columnType: "PgTimestamp";
|
|
2239
|
+
data: Date;
|
|
2053
2240
|
driverParam: string;
|
|
2054
2241
|
notNull: false;
|
|
2055
2242
|
hasDefault: false;
|
|
2056
2243
|
isPrimaryKey: false;
|
|
2057
2244
|
isAutoincrement: false;
|
|
2058
2245
|
hasRuntimeDefault: false;
|
|
2059
|
-
enumValues:
|
|
2246
|
+
enumValues: undefined;
|
|
2060
2247
|
baseColumn: never;
|
|
2061
2248
|
identity: undefined;
|
|
2062
2249
|
generated: undefined;
|
|
2063
2250
|
}, {}, {}>;
|
|
2064
|
-
|
|
2065
|
-
name: "
|
|
2066
|
-
tableName: "
|
|
2251
|
+
heartbeatRunId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2252
|
+
name: "heartbeat_run_id";
|
|
2253
|
+
tableName: "heartbeat_run_queue";
|
|
2067
2254
|
dataType: "string";
|
|
2068
2255
|
columnType: "PgText";
|
|
2069
2256
|
data: string;
|
|
@@ -2080,7 +2267,7 @@ export declare const heartbeatRunMessages: import("drizzle-orm/pg-core").PgTable
|
|
|
2080
2267
|
}, {}, {}>;
|
|
2081
2268
|
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2082
2269
|
name: "created_at";
|
|
2083
|
-
tableName: "
|
|
2270
|
+
tableName: "heartbeat_run_queue";
|
|
2084
2271
|
dataType: "date";
|
|
2085
2272
|
columnType: "PgTimestamp";
|
|
2086
2273
|
data: Date;
|
|
@@ -2095,17 +2282,245 @@ export declare const heartbeatRunMessages: import("drizzle-orm/pg-core").PgTable
|
|
|
2095
2282
|
identity: undefined;
|
|
2096
2283
|
generated: undefined;
|
|
2097
2284
|
}, {}, {}>;
|
|
2098
|
-
|
|
2099
|
-
|
|
2100
|
-
|
|
2101
|
-
|
|
2102
|
-
|
|
2103
|
-
|
|
2104
|
-
|
|
2105
|
-
|
|
2106
|
-
|
|
2107
|
-
|
|
2108
|
-
|
|
2285
|
+
updatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2286
|
+
name: "updated_at";
|
|
2287
|
+
tableName: "heartbeat_run_queue";
|
|
2288
|
+
dataType: "date";
|
|
2289
|
+
columnType: "PgTimestamp";
|
|
2290
|
+
data: Date;
|
|
2291
|
+
driverParam: string;
|
|
2292
|
+
notNull: true;
|
|
2293
|
+
hasDefault: true;
|
|
2294
|
+
isPrimaryKey: false;
|
|
2295
|
+
isAutoincrement: false;
|
|
2296
|
+
hasRuntimeDefault: false;
|
|
2297
|
+
enumValues: undefined;
|
|
2298
|
+
baseColumn: never;
|
|
2299
|
+
identity: undefined;
|
|
2300
|
+
generated: undefined;
|
|
2301
|
+
}, {}, {}>;
|
|
2302
|
+
};
|
|
2303
|
+
dialect: "pg";
|
|
2304
|
+
}>;
|
|
2305
|
+
export declare const heartbeatRunMessages: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2306
|
+
name: "heartbeat_run_messages";
|
|
2307
|
+
schema: undefined;
|
|
2308
|
+
columns: {
|
|
2309
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
2310
|
+
name: "id";
|
|
2311
|
+
tableName: "heartbeat_run_messages";
|
|
2312
|
+
dataType: "string";
|
|
2313
|
+
columnType: "PgText";
|
|
2314
|
+
data: string;
|
|
2315
|
+
driverParam: string;
|
|
2316
|
+
notNull: true;
|
|
2317
|
+
hasDefault: false;
|
|
2318
|
+
isPrimaryKey: true;
|
|
2319
|
+
isAutoincrement: false;
|
|
2320
|
+
hasRuntimeDefault: false;
|
|
2321
|
+
enumValues: [string, ...string[]];
|
|
2322
|
+
baseColumn: never;
|
|
2323
|
+
identity: undefined;
|
|
2324
|
+
generated: undefined;
|
|
2325
|
+
}, {}, {}>;
|
|
2326
|
+
companyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2327
|
+
name: "company_id";
|
|
2328
|
+
tableName: "heartbeat_run_messages";
|
|
2329
|
+
dataType: "string";
|
|
2330
|
+
columnType: "PgText";
|
|
2331
|
+
data: string;
|
|
2332
|
+
driverParam: string;
|
|
2333
|
+
notNull: true;
|
|
2334
|
+
hasDefault: false;
|
|
2335
|
+
isPrimaryKey: false;
|
|
2336
|
+
isAutoincrement: false;
|
|
2337
|
+
hasRuntimeDefault: false;
|
|
2338
|
+
enumValues: [string, ...string[]];
|
|
2339
|
+
baseColumn: never;
|
|
2340
|
+
identity: undefined;
|
|
2341
|
+
generated: undefined;
|
|
2342
|
+
}, {}, {}>;
|
|
2343
|
+
runId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2344
|
+
name: "run_id";
|
|
2345
|
+
tableName: "heartbeat_run_messages";
|
|
2346
|
+
dataType: "string";
|
|
2347
|
+
columnType: "PgText";
|
|
2348
|
+
data: string;
|
|
2349
|
+
driverParam: string;
|
|
2350
|
+
notNull: true;
|
|
2351
|
+
hasDefault: false;
|
|
2352
|
+
isPrimaryKey: false;
|
|
2353
|
+
isAutoincrement: false;
|
|
2354
|
+
hasRuntimeDefault: false;
|
|
2355
|
+
enumValues: [string, ...string[]];
|
|
2356
|
+
baseColumn: never;
|
|
2357
|
+
identity: undefined;
|
|
2358
|
+
generated: undefined;
|
|
2359
|
+
}, {}, {}>;
|
|
2360
|
+
sequence: import("drizzle-orm/pg-core").PgColumn<{
|
|
2361
|
+
name: "sequence";
|
|
2362
|
+
tableName: "heartbeat_run_messages";
|
|
2363
|
+
dataType: "number";
|
|
2364
|
+
columnType: "PgInteger";
|
|
2365
|
+
data: number;
|
|
2366
|
+
driverParam: string | number;
|
|
2367
|
+
notNull: true;
|
|
2368
|
+
hasDefault: false;
|
|
2369
|
+
isPrimaryKey: false;
|
|
2370
|
+
isAutoincrement: false;
|
|
2371
|
+
hasRuntimeDefault: false;
|
|
2372
|
+
enumValues: undefined;
|
|
2373
|
+
baseColumn: never;
|
|
2374
|
+
identity: undefined;
|
|
2375
|
+
generated: undefined;
|
|
2376
|
+
}, {}, {}>;
|
|
2377
|
+
kind: import("drizzle-orm/pg-core").PgColumn<{
|
|
2378
|
+
name: "kind";
|
|
2379
|
+
tableName: "heartbeat_run_messages";
|
|
2380
|
+
dataType: "string";
|
|
2381
|
+
columnType: "PgText";
|
|
2382
|
+
data: string;
|
|
2383
|
+
driverParam: string;
|
|
2384
|
+
notNull: true;
|
|
2385
|
+
hasDefault: false;
|
|
2386
|
+
isPrimaryKey: false;
|
|
2387
|
+
isAutoincrement: false;
|
|
2388
|
+
hasRuntimeDefault: false;
|
|
2389
|
+
enumValues: [string, ...string[]];
|
|
2390
|
+
baseColumn: never;
|
|
2391
|
+
identity: undefined;
|
|
2392
|
+
generated: undefined;
|
|
2393
|
+
}, {}, {}>;
|
|
2394
|
+
label: import("drizzle-orm/pg-core").PgColumn<{
|
|
2395
|
+
name: "label";
|
|
2396
|
+
tableName: "heartbeat_run_messages";
|
|
2397
|
+
dataType: "string";
|
|
2398
|
+
columnType: "PgText";
|
|
2399
|
+
data: string;
|
|
2400
|
+
driverParam: string;
|
|
2401
|
+
notNull: false;
|
|
2402
|
+
hasDefault: false;
|
|
2403
|
+
isPrimaryKey: false;
|
|
2404
|
+
isAutoincrement: false;
|
|
2405
|
+
hasRuntimeDefault: false;
|
|
2406
|
+
enumValues: [string, ...string[]];
|
|
2407
|
+
baseColumn: never;
|
|
2408
|
+
identity: undefined;
|
|
2409
|
+
generated: undefined;
|
|
2410
|
+
}, {}, {}>;
|
|
2411
|
+
text: import("drizzle-orm/pg-core").PgColumn<{
|
|
2412
|
+
name: "text";
|
|
2413
|
+
tableName: "heartbeat_run_messages";
|
|
2414
|
+
dataType: "string";
|
|
2415
|
+
columnType: "PgText";
|
|
2416
|
+
data: string;
|
|
2417
|
+
driverParam: string;
|
|
2418
|
+
notNull: false;
|
|
2419
|
+
hasDefault: false;
|
|
2420
|
+
isPrimaryKey: false;
|
|
2421
|
+
isAutoincrement: false;
|
|
2422
|
+
hasRuntimeDefault: false;
|
|
2423
|
+
enumValues: [string, ...string[]];
|
|
2424
|
+
baseColumn: never;
|
|
2425
|
+
identity: undefined;
|
|
2426
|
+
generated: undefined;
|
|
2427
|
+
}, {}, {}>;
|
|
2428
|
+
payloadJson: import("drizzle-orm/pg-core").PgColumn<{
|
|
2429
|
+
name: "payload_json";
|
|
2430
|
+
tableName: "heartbeat_run_messages";
|
|
2431
|
+
dataType: "string";
|
|
2432
|
+
columnType: "PgText";
|
|
2433
|
+
data: string;
|
|
2434
|
+
driverParam: string;
|
|
2435
|
+
notNull: false;
|
|
2436
|
+
hasDefault: false;
|
|
2437
|
+
isPrimaryKey: false;
|
|
2438
|
+
isAutoincrement: false;
|
|
2439
|
+
hasRuntimeDefault: false;
|
|
2440
|
+
enumValues: [string, ...string[]];
|
|
2441
|
+
baseColumn: never;
|
|
2442
|
+
identity: undefined;
|
|
2443
|
+
generated: undefined;
|
|
2444
|
+
}, {}, {}>;
|
|
2445
|
+
signalLevel: import("drizzle-orm/pg-core").PgColumn<{
|
|
2446
|
+
name: "signal_level";
|
|
2447
|
+
tableName: "heartbeat_run_messages";
|
|
2448
|
+
dataType: "string";
|
|
2449
|
+
columnType: "PgText";
|
|
2450
|
+
data: string;
|
|
2451
|
+
driverParam: string;
|
|
2452
|
+
notNull: false;
|
|
2453
|
+
hasDefault: false;
|
|
2454
|
+
isPrimaryKey: false;
|
|
2455
|
+
isAutoincrement: false;
|
|
2456
|
+
hasRuntimeDefault: false;
|
|
2457
|
+
enumValues: [string, ...string[]];
|
|
2458
|
+
baseColumn: never;
|
|
2459
|
+
identity: undefined;
|
|
2460
|
+
generated: undefined;
|
|
2461
|
+
}, {}, {}>;
|
|
2462
|
+
groupKey: import("drizzle-orm/pg-core").PgColumn<{
|
|
2463
|
+
name: "group_key";
|
|
2464
|
+
tableName: "heartbeat_run_messages";
|
|
2465
|
+
dataType: "string";
|
|
2466
|
+
columnType: "PgText";
|
|
2467
|
+
data: string;
|
|
2468
|
+
driverParam: string;
|
|
2469
|
+
notNull: false;
|
|
2470
|
+
hasDefault: false;
|
|
2471
|
+
isPrimaryKey: false;
|
|
2472
|
+
isAutoincrement: false;
|
|
2473
|
+
hasRuntimeDefault: false;
|
|
2474
|
+
enumValues: [string, ...string[]];
|
|
2475
|
+
baseColumn: never;
|
|
2476
|
+
identity: undefined;
|
|
2477
|
+
generated: undefined;
|
|
2478
|
+
}, {}, {}>;
|
|
2479
|
+
source: import("drizzle-orm/pg-core").PgColumn<{
|
|
2480
|
+
name: "source";
|
|
2481
|
+
tableName: "heartbeat_run_messages";
|
|
2482
|
+
dataType: "string";
|
|
2483
|
+
columnType: "PgText";
|
|
2484
|
+
data: string;
|
|
2485
|
+
driverParam: string;
|
|
2486
|
+
notNull: false;
|
|
2487
|
+
hasDefault: false;
|
|
2488
|
+
isPrimaryKey: false;
|
|
2489
|
+
isAutoincrement: false;
|
|
2490
|
+
hasRuntimeDefault: false;
|
|
2491
|
+
enumValues: [string, ...string[]];
|
|
2492
|
+
baseColumn: never;
|
|
2493
|
+
identity: undefined;
|
|
2494
|
+
generated: undefined;
|
|
2495
|
+
}, {}, {}>;
|
|
2496
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2497
|
+
name: "created_at";
|
|
2498
|
+
tableName: "heartbeat_run_messages";
|
|
2499
|
+
dataType: "date";
|
|
2500
|
+
columnType: "PgTimestamp";
|
|
2501
|
+
data: Date;
|
|
2502
|
+
driverParam: string;
|
|
2503
|
+
notNull: true;
|
|
2504
|
+
hasDefault: true;
|
|
2505
|
+
isPrimaryKey: false;
|
|
2506
|
+
isAutoincrement: false;
|
|
2507
|
+
hasRuntimeDefault: false;
|
|
2508
|
+
enumValues: undefined;
|
|
2509
|
+
baseColumn: never;
|
|
2510
|
+
identity: undefined;
|
|
2511
|
+
generated: undefined;
|
|
2512
|
+
}, {}, {}>;
|
|
2513
|
+
};
|
|
2514
|
+
dialect: "pg";
|
|
2515
|
+
}>;
|
|
2516
|
+
export declare const approvalRequests: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2517
|
+
name: "approval_requests";
|
|
2518
|
+
schema: undefined;
|
|
2519
|
+
columns: {
|
|
2520
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
2521
|
+
name: "id";
|
|
2522
|
+
tableName: "approval_requests";
|
|
2523
|
+
dataType: "string";
|
|
2109
2524
|
columnType: "PgText";
|
|
2110
2525
|
data: string;
|
|
2111
2526
|
driverParam: string;
|
|
@@ -2367,6 +2782,166 @@ export declare const approvalInboxStates: import("drizzle-orm/pg-core").PgTableW
|
|
|
2367
2782
|
};
|
|
2368
2783
|
dialect: "pg";
|
|
2369
2784
|
}>;
|
|
2785
|
+
export declare const attentionInboxStates: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2786
|
+
name: "attention_inbox_states";
|
|
2787
|
+
schema: undefined;
|
|
2788
|
+
columns: {
|
|
2789
|
+
companyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2790
|
+
name: "company_id";
|
|
2791
|
+
tableName: "attention_inbox_states";
|
|
2792
|
+
dataType: "string";
|
|
2793
|
+
columnType: "PgText";
|
|
2794
|
+
data: string;
|
|
2795
|
+
driverParam: string;
|
|
2796
|
+
notNull: true;
|
|
2797
|
+
hasDefault: false;
|
|
2798
|
+
isPrimaryKey: false;
|
|
2799
|
+
isAutoincrement: false;
|
|
2800
|
+
hasRuntimeDefault: false;
|
|
2801
|
+
enumValues: [string, ...string[]];
|
|
2802
|
+
baseColumn: never;
|
|
2803
|
+
identity: undefined;
|
|
2804
|
+
generated: undefined;
|
|
2805
|
+
}, {}, {}>;
|
|
2806
|
+
actorId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2807
|
+
name: "actor_id";
|
|
2808
|
+
tableName: "attention_inbox_states";
|
|
2809
|
+
dataType: "string";
|
|
2810
|
+
columnType: "PgText";
|
|
2811
|
+
data: string;
|
|
2812
|
+
driverParam: string;
|
|
2813
|
+
notNull: true;
|
|
2814
|
+
hasDefault: false;
|
|
2815
|
+
isPrimaryKey: false;
|
|
2816
|
+
isAutoincrement: false;
|
|
2817
|
+
hasRuntimeDefault: false;
|
|
2818
|
+
enumValues: [string, ...string[]];
|
|
2819
|
+
baseColumn: never;
|
|
2820
|
+
identity: undefined;
|
|
2821
|
+
generated: undefined;
|
|
2822
|
+
}, {}, {}>;
|
|
2823
|
+
itemKey: import("drizzle-orm/pg-core").PgColumn<{
|
|
2824
|
+
name: "item_key";
|
|
2825
|
+
tableName: "attention_inbox_states";
|
|
2826
|
+
dataType: "string";
|
|
2827
|
+
columnType: "PgText";
|
|
2828
|
+
data: string;
|
|
2829
|
+
driverParam: string;
|
|
2830
|
+
notNull: true;
|
|
2831
|
+
hasDefault: false;
|
|
2832
|
+
isPrimaryKey: false;
|
|
2833
|
+
isAutoincrement: false;
|
|
2834
|
+
hasRuntimeDefault: false;
|
|
2835
|
+
enumValues: [string, ...string[]];
|
|
2836
|
+
baseColumn: never;
|
|
2837
|
+
identity: undefined;
|
|
2838
|
+
generated: undefined;
|
|
2839
|
+
}, {}, {}>;
|
|
2840
|
+
seenAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2841
|
+
name: "seen_at";
|
|
2842
|
+
tableName: "attention_inbox_states";
|
|
2843
|
+
dataType: "date";
|
|
2844
|
+
columnType: "PgTimestamp";
|
|
2845
|
+
data: Date;
|
|
2846
|
+
driverParam: string;
|
|
2847
|
+
notNull: false;
|
|
2848
|
+
hasDefault: false;
|
|
2849
|
+
isPrimaryKey: false;
|
|
2850
|
+
isAutoincrement: false;
|
|
2851
|
+
hasRuntimeDefault: false;
|
|
2852
|
+
enumValues: undefined;
|
|
2853
|
+
baseColumn: never;
|
|
2854
|
+
identity: undefined;
|
|
2855
|
+
generated: undefined;
|
|
2856
|
+
}, {}, {}>;
|
|
2857
|
+
acknowledgedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2858
|
+
name: "acknowledged_at";
|
|
2859
|
+
tableName: "attention_inbox_states";
|
|
2860
|
+
dataType: "date";
|
|
2861
|
+
columnType: "PgTimestamp";
|
|
2862
|
+
data: Date;
|
|
2863
|
+
driverParam: string;
|
|
2864
|
+
notNull: false;
|
|
2865
|
+
hasDefault: false;
|
|
2866
|
+
isPrimaryKey: false;
|
|
2867
|
+
isAutoincrement: false;
|
|
2868
|
+
hasRuntimeDefault: false;
|
|
2869
|
+
enumValues: undefined;
|
|
2870
|
+
baseColumn: never;
|
|
2871
|
+
identity: undefined;
|
|
2872
|
+
generated: undefined;
|
|
2873
|
+
}, {}, {}>;
|
|
2874
|
+
dismissedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2875
|
+
name: "dismissed_at";
|
|
2876
|
+
tableName: "attention_inbox_states";
|
|
2877
|
+
dataType: "date";
|
|
2878
|
+
columnType: "PgTimestamp";
|
|
2879
|
+
data: Date;
|
|
2880
|
+
driverParam: string;
|
|
2881
|
+
notNull: false;
|
|
2882
|
+
hasDefault: false;
|
|
2883
|
+
isPrimaryKey: false;
|
|
2884
|
+
isAutoincrement: false;
|
|
2885
|
+
hasRuntimeDefault: false;
|
|
2886
|
+
enumValues: undefined;
|
|
2887
|
+
baseColumn: never;
|
|
2888
|
+
identity: undefined;
|
|
2889
|
+
generated: undefined;
|
|
2890
|
+
}, {}, {}>;
|
|
2891
|
+
resolvedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2892
|
+
name: "resolved_at";
|
|
2893
|
+
tableName: "attention_inbox_states";
|
|
2894
|
+
dataType: "date";
|
|
2895
|
+
columnType: "PgTimestamp";
|
|
2896
|
+
data: Date;
|
|
2897
|
+
driverParam: string;
|
|
2898
|
+
notNull: false;
|
|
2899
|
+
hasDefault: false;
|
|
2900
|
+
isPrimaryKey: false;
|
|
2901
|
+
isAutoincrement: false;
|
|
2902
|
+
hasRuntimeDefault: false;
|
|
2903
|
+
enumValues: undefined;
|
|
2904
|
+
baseColumn: never;
|
|
2905
|
+
identity: undefined;
|
|
2906
|
+
generated: undefined;
|
|
2907
|
+
}, {}, {}>;
|
|
2908
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2909
|
+
name: "created_at";
|
|
2910
|
+
tableName: "attention_inbox_states";
|
|
2911
|
+
dataType: "date";
|
|
2912
|
+
columnType: "PgTimestamp";
|
|
2913
|
+
data: Date;
|
|
2914
|
+
driverParam: string;
|
|
2915
|
+
notNull: true;
|
|
2916
|
+
hasDefault: true;
|
|
2917
|
+
isPrimaryKey: false;
|
|
2918
|
+
isAutoincrement: false;
|
|
2919
|
+
hasRuntimeDefault: false;
|
|
2920
|
+
enumValues: undefined;
|
|
2921
|
+
baseColumn: never;
|
|
2922
|
+
identity: undefined;
|
|
2923
|
+
generated: undefined;
|
|
2924
|
+
}, {}, {}>;
|
|
2925
|
+
updatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2926
|
+
name: "updated_at";
|
|
2927
|
+
tableName: "attention_inbox_states";
|
|
2928
|
+
dataType: "date";
|
|
2929
|
+
columnType: "PgTimestamp";
|
|
2930
|
+
data: Date;
|
|
2931
|
+
driverParam: string;
|
|
2932
|
+
notNull: true;
|
|
2933
|
+
hasDefault: true;
|
|
2934
|
+
isPrimaryKey: false;
|
|
2935
|
+
isAutoincrement: false;
|
|
2936
|
+
hasRuntimeDefault: false;
|
|
2937
|
+
enumValues: undefined;
|
|
2938
|
+
baseColumn: never;
|
|
2939
|
+
identity: undefined;
|
|
2940
|
+
generated: undefined;
|
|
2941
|
+
}, {}, {}>;
|
|
2942
|
+
};
|
|
2943
|
+
dialect: "pg";
|
|
2944
|
+
}>;
|
|
2370
2945
|
export declare const costLedger: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2371
2946
|
name: "cost_ledger";
|
|
2372
2947
|
schema: undefined;
|
|
@@ -4149,6 +4724,57 @@ export declare const schema: {
|
|
|
4149
4724
|
identity: undefined;
|
|
4150
4725
|
generated: undefined;
|
|
4151
4726
|
}, {}, {}>;
|
|
4727
|
+
monthlyBudgetUsd: import("drizzle-orm/pg-core").PgColumn<{
|
|
4728
|
+
name: "monthly_budget_usd";
|
|
4729
|
+
tableName: "projects";
|
|
4730
|
+
dataType: "string";
|
|
4731
|
+
columnType: "PgNumeric";
|
|
4732
|
+
data: string;
|
|
4733
|
+
driverParam: string;
|
|
4734
|
+
notNull: true;
|
|
4735
|
+
hasDefault: true;
|
|
4736
|
+
isPrimaryKey: false;
|
|
4737
|
+
isAutoincrement: false;
|
|
4738
|
+
hasRuntimeDefault: false;
|
|
4739
|
+
enumValues: undefined;
|
|
4740
|
+
baseColumn: never;
|
|
4741
|
+
identity: undefined;
|
|
4742
|
+
generated: undefined;
|
|
4743
|
+
}, {}, {}>;
|
|
4744
|
+
usedBudgetUsd: import("drizzle-orm/pg-core").PgColumn<{
|
|
4745
|
+
name: "used_budget_usd";
|
|
4746
|
+
tableName: "projects";
|
|
4747
|
+
dataType: "string";
|
|
4748
|
+
columnType: "PgNumeric";
|
|
4749
|
+
data: string;
|
|
4750
|
+
driverParam: string;
|
|
4751
|
+
notNull: true;
|
|
4752
|
+
hasDefault: true;
|
|
4753
|
+
isPrimaryKey: false;
|
|
4754
|
+
isAutoincrement: false;
|
|
4755
|
+
hasRuntimeDefault: false;
|
|
4756
|
+
enumValues: undefined;
|
|
4757
|
+
baseColumn: never;
|
|
4758
|
+
identity: undefined;
|
|
4759
|
+
generated: undefined;
|
|
4760
|
+
}, {}, {}>;
|
|
4761
|
+
budgetWindowStartAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
4762
|
+
name: "budget_window_start_at";
|
|
4763
|
+
tableName: "projects";
|
|
4764
|
+
dataType: "date";
|
|
4765
|
+
columnType: "PgTimestamp";
|
|
4766
|
+
data: Date;
|
|
4767
|
+
driverParam: string;
|
|
4768
|
+
notNull: true;
|
|
4769
|
+
hasDefault: true;
|
|
4770
|
+
isPrimaryKey: false;
|
|
4771
|
+
isAutoincrement: false;
|
|
4772
|
+
hasRuntimeDefault: false;
|
|
4773
|
+
enumValues: undefined;
|
|
4774
|
+
baseColumn: never;
|
|
4775
|
+
identity: undefined;
|
|
4776
|
+
generated: undefined;
|
|
4777
|
+
}, {}, {}>;
|
|
4152
4778
|
executionWorkspacePolicy: import("drizzle-orm/pg-core").PgColumn<{
|
|
4153
4779
|
name: "execution_workspace_policy";
|
|
4154
4780
|
tableName: "projects";
|
|
@@ -4452,6 +5078,40 @@ export declare const schema: {
|
|
|
4452
5078
|
identity: undefined;
|
|
4453
5079
|
generated: undefined;
|
|
4454
5080
|
}, {}, {}>;
|
|
5081
|
+
roleKey: import("drizzle-orm/pg-core").PgColumn<{
|
|
5082
|
+
name: "role_key";
|
|
5083
|
+
tableName: "agents";
|
|
5084
|
+
dataType: "string";
|
|
5085
|
+
columnType: "PgText";
|
|
5086
|
+
data: string;
|
|
5087
|
+
driverParam: string;
|
|
5088
|
+
notNull: false;
|
|
5089
|
+
hasDefault: false;
|
|
5090
|
+
isPrimaryKey: false;
|
|
5091
|
+
isAutoincrement: false;
|
|
5092
|
+
hasRuntimeDefault: false;
|
|
5093
|
+
enumValues: [string, ...string[]];
|
|
5094
|
+
baseColumn: never;
|
|
5095
|
+
identity: undefined;
|
|
5096
|
+
generated: undefined;
|
|
5097
|
+
}, {}, {}>;
|
|
5098
|
+
title: import("drizzle-orm/pg-core").PgColumn<{
|
|
5099
|
+
name: "title";
|
|
5100
|
+
tableName: "agents";
|
|
5101
|
+
dataType: "string";
|
|
5102
|
+
columnType: "PgText";
|
|
5103
|
+
data: string;
|
|
5104
|
+
driverParam: string;
|
|
5105
|
+
notNull: false;
|
|
5106
|
+
hasDefault: false;
|
|
5107
|
+
isPrimaryKey: false;
|
|
5108
|
+
isAutoincrement: false;
|
|
5109
|
+
hasRuntimeDefault: false;
|
|
5110
|
+
enumValues: [string, ...string[]];
|
|
5111
|
+
baseColumn: never;
|
|
5112
|
+
identity: undefined;
|
|
5113
|
+
generated: undefined;
|
|
5114
|
+
}, {}, {}>;
|
|
4455
5115
|
name: import("drizzle-orm/pg-core").PgColumn<{
|
|
4456
5116
|
name: "name";
|
|
4457
5117
|
tableName: "agents";
|
|
@@ -5104,7 +5764,235 @@ export declare const schema: {
|
|
|
5104
5764
|
driverParam: string;
|
|
5105
5765
|
notNull: true;
|
|
5106
5766
|
hasDefault: false;
|
|
5107
|
-
isPrimaryKey: true;
|
|
5767
|
+
isPrimaryKey: true;
|
|
5768
|
+
isAutoincrement: false;
|
|
5769
|
+
hasRuntimeDefault: false;
|
|
5770
|
+
enumValues: [string, ...string[]];
|
|
5771
|
+
baseColumn: never;
|
|
5772
|
+
identity: undefined;
|
|
5773
|
+
generated: undefined;
|
|
5774
|
+
}, {}, {}>;
|
|
5775
|
+
issueId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5776
|
+
name: "issue_id";
|
|
5777
|
+
tableName: "issue_comments";
|
|
5778
|
+
dataType: "string";
|
|
5779
|
+
columnType: "PgText";
|
|
5780
|
+
data: string;
|
|
5781
|
+
driverParam: string;
|
|
5782
|
+
notNull: true;
|
|
5783
|
+
hasDefault: false;
|
|
5784
|
+
isPrimaryKey: false;
|
|
5785
|
+
isAutoincrement: false;
|
|
5786
|
+
hasRuntimeDefault: false;
|
|
5787
|
+
enumValues: [string, ...string[]];
|
|
5788
|
+
baseColumn: never;
|
|
5789
|
+
identity: undefined;
|
|
5790
|
+
generated: undefined;
|
|
5791
|
+
}, {}, {}>;
|
|
5792
|
+
companyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5793
|
+
name: "company_id";
|
|
5794
|
+
tableName: "issue_comments";
|
|
5795
|
+
dataType: "string";
|
|
5796
|
+
columnType: "PgText";
|
|
5797
|
+
data: string;
|
|
5798
|
+
driverParam: string;
|
|
5799
|
+
notNull: true;
|
|
5800
|
+
hasDefault: false;
|
|
5801
|
+
isPrimaryKey: false;
|
|
5802
|
+
isAutoincrement: false;
|
|
5803
|
+
hasRuntimeDefault: false;
|
|
5804
|
+
enumValues: [string, ...string[]];
|
|
5805
|
+
baseColumn: never;
|
|
5806
|
+
identity: undefined;
|
|
5807
|
+
generated: undefined;
|
|
5808
|
+
}, {}, {}>;
|
|
5809
|
+
authorType: import("drizzle-orm/pg-core").PgColumn<{
|
|
5810
|
+
name: "author_type";
|
|
5811
|
+
tableName: "issue_comments";
|
|
5812
|
+
dataType: "string";
|
|
5813
|
+
columnType: "PgText";
|
|
5814
|
+
data: string;
|
|
5815
|
+
driverParam: string;
|
|
5816
|
+
notNull: true;
|
|
5817
|
+
hasDefault: false;
|
|
5818
|
+
isPrimaryKey: false;
|
|
5819
|
+
isAutoincrement: false;
|
|
5820
|
+
hasRuntimeDefault: false;
|
|
5821
|
+
enumValues: [string, ...string[]];
|
|
5822
|
+
baseColumn: never;
|
|
5823
|
+
identity: undefined;
|
|
5824
|
+
generated: undefined;
|
|
5825
|
+
}, {}, {}>;
|
|
5826
|
+
authorId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5827
|
+
name: "author_id";
|
|
5828
|
+
tableName: "issue_comments";
|
|
5829
|
+
dataType: "string";
|
|
5830
|
+
columnType: "PgText";
|
|
5831
|
+
data: string;
|
|
5832
|
+
driverParam: string;
|
|
5833
|
+
notNull: false;
|
|
5834
|
+
hasDefault: false;
|
|
5835
|
+
isPrimaryKey: false;
|
|
5836
|
+
isAutoincrement: false;
|
|
5837
|
+
hasRuntimeDefault: false;
|
|
5838
|
+
enumValues: [string, ...string[]];
|
|
5839
|
+
baseColumn: never;
|
|
5840
|
+
identity: undefined;
|
|
5841
|
+
generated: undefined;
|
|
5842
|
+
}, {}, {}>;
|
|
5843
|
+
recipientsJson: import("drizzle-orm/pg-core").PgColumn<{
|
|
5844
|
+
name: "recipients_json";
|
|
5845
|
+
tableName: "issue_comments";
|
|
5846
|
+
dataType: "string";
|
|
5847
|
+
columnType: "PgText";
|
|
5848
|
+
data: string;
|
|
5849
|
+
driverParam: string;
|
|
5850
|
+
notNull: true;
|
|
5851
|
+
hasDefault: true;
|
|
5852
|
+
isPrimaryKey: false;
|
|
5853
|
+
isAutoincrement: false;
|
|
5854
|
+
hasRuntimeDefault: false;
|
|
5855
|
+
enumValues: [string, ...string[]];
|
|
5856
|
+
baseColumn: never;
|
|
5857
|
+
identity: undefined;
|
|
5858
|
+
generated: undefined;
|
|
5859
|
+
}, {}, {}>;
|
|
5860
|
+
runId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5861
|
+
name: "run_id";
|
|
5862
|
+
tableName: "issue_comments";
|
|
5863
|
+
dataType: "string";
|
|
5864
|
+
columnType: "PgText";
|
|
5865
|
+
data: string;
|
|
5866
|
+
driverParam: string;
|
|
5867
|
+
notNull: false;
|
|
5868
|
+
hasDefault: false;
|
|
5869
|
+
isPrimaryKey: false;
|
|
5870
|
+
isAutoincrement: false;
|
|
5871
|
+
hasRuntimeDefault: false;
|
|
5872
|
+
enumValues: [string, ...string[]];
|
|
5873
|
+
baseColumn: never;
|
|
5874
|
+
identity: undefined;
|
|
5875
|
+
generated: undefined;
|
|
5876
|
+
}, {}, {}>;
|
|
5877
|
+
body: import("drizzle-orm/pg-core").PgColumn<{
|
|
5878
|
+
name: "body";
|
|
5879
|
+
tableName: "issue_comments";
|
|
5880
|
+
dataType: "string";
|
|
5881
|
+
columnType: "PgText";
|
|
5882
|
+
data: string;
|
|
5883
|
+
driverParam: string;
|
|
5884
|
+
notNull: true;
|
|
5885
|
+
hasDefault: false;
|
|
5886
|
+
isPrimaryKey: false;
|
|
5887
|
+
isAutoincrement: false;
|
|
5888
|
+
hasRuntimeDefault: false;
|
|
5889
|
+
enumValues: [string, ...string[]];
|
|
5890
|
+
baseColumn: never;
|
|
5891
|
+
identity: undefined;
|
|
5892
|
+
generated: undefined;
|
|
5893
|
+
}, {}, {}>;
|
|
5894
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
5895
|
+
name: "created_at";
|
|
5896
|
+
tableName: "issue_comments";
|
|
5897
|
+
dataType: "date";
|
|
5898
|
+
columnType: "PgTimestamp";
|
|
5899
|
+
data: Date;
|
|
5900
|
+
driverParam: string;
|
|
5901
|
+
notNull: true;
|
|
5902
|
+
hasDefault: true;
|
|
5903
|
+
isPrimaryKey: false;
|
|
5904
|
+
isAutoincrement: false;
|
|
5905
|
+
hasRuntimeDefault: false;
|
|
5906
|
+
enumValues: undefined;
|
|
5907
|
+
baseColumn: never;
|
|
5908
|
+
identity: undefined;
|
|
5909
|
+
generated: undefined;
|
|
5910
|
+
}, {}, {}>;
|
|
5911
|
+
};
|
|
5912
|
+
dialect: "pg";
|
|
5913
|
+
}>;
|
|
5914
|
+
issueAttachments: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
5915
|
+
name: "issue_attachments";
|
|
5916
|
+
schema: undefined;
|
|
5917
|
+
columns: {
|
|
5918
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
5919
|
+
name: "id";
|
|
5920
|
+
tableName: "issue_attachments";
|
|
5921
|
+
dataType: "string";
|
|
5922
|
+
columnType: "PgText";
|
|
5923
|
+
data: string;
|
|
5924
|
+
driverParam: string;
|
|
5925
|
+
notNull: true;
|
|
5926
|
+
hasDefault: false;
|
|
5927
|
+
isPrimaryKey: true;
|
|
5928
|
+
isAutoincrement: false;
|
|
5929
|
+
hasRuntimeDefault: false;
|
|
5930
|
+
enumValues: [string, ...string[]];
|
|
5931
|
+
baseColumn: never;
|
|
5932
|
+
identity: undefined;
|
|
5933
|
+
generated: undefined;
|
|
5934
|
+
}, {}, {}>;
|
|
5935
|
+
companyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5936
|
+
name: "company_id";
|
|
5937
|
+
tableName: "issue_attachments";
|
|
5938
|
+
dataType: "string";
|
|
5939
|
+
columnType: "PgText";
|
|
5940
|
+
data: string;
|
|
5941
|
+
driverParam: string;
|
|
5942
|
+
notNull: true;
|
|
5943
|
+
hasDefault: false;
|
|
5944
|
+
isPrimaryKey: false;
|
|
5945
|
+
isAutoincrement: false;
|
|
5946
|
+
hasRuntimeDefault: false;
|
|
5947
|
+
enumValues: [string, ...string[]];
|
|
5948
|
+
baseColumn: never;
|
|
5949
|
+
identity: undefined;
|
|
5950
|
+
generated: undefined;
|
|
5951
|
+
}, {}, {}>;
|
|
5952
|
+
issueId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5953
|
+
name: "issue_id";
|
|
5954
|
+
tableName: "issue_attachments";
|
|
5955
|
+
dataType: "string";
|
|
5956
|
+
columnType: "PgText";
|
|
5957
|
+
data: string;
|
|
5958
|
+
driverParam: string;
|
|
5959
|
+
notNull: true;
|
|
5960
|
+
hasDefault: false;
|
|
5961
|
+
isPrimaryKey: false;
|
|
5962
|
+
isAutoincrement: false;
|
|
5963
|
+
hasRuntimeDefault: false;
|
|
5964
|
+
enumValues: [string, ...string[]];
|
|
5965
|
+
baseColumn: never;
|
|
5966
|
+
identity: undefined;
|
|
5967
|
+
generated: undefined;
|
|
5968
|
+
}, {}, {}>;
|
|
5969
|
+
projectId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5970
|
+
name: "project_id";
|
|
5971
|
+
tableName: "issue_attachments";
|
|
5972
|
+
dataType: "string";
|
|
5973
|
+
columnType: "PgText";
|
|
5974
|
+
data: string;
|
|
5975
|
+
driverParam: string;
|
|
5976
|
+
notNull: true;
|
|
5977
|
+
hasDefault: false;
|
|
5978
|
+
isPrimaryKey: false;
|
|
5979
|
+
isAutoincrement: false;
|
|
5980
|
+
hasRuntimeDefault: false;
|
|
5981
|
+
enumValues: [string, ...string[]];
|
|
5982
|
+
baseColumn: never;
|
|
5983
|
+
identity: undefined;
|
|
5984
|
+
generated: undefined;
|
|
5985
|
+
}, {}, {}>;
|
|
5986
|
+
fileName: import("drizzle-orm/pg-core").PgColumn<{
|
|
5987
|
+
name: "file_name";
|
|
5988
|
+
tableName: "issue_attachments";
|
|
5989
|
+
dataType: "string";
|
|
5990
|
+
columnType: "PgText";
|
|
5991
|
+
data: string;
|
|
5992
|
+
driverParam: string;
|
|
5993
|
+
notNull: true;
|
|
5994
|
+
hasDefault: false;
|
|
5995
|
+
isPrimaryKey: false;
|
|
5108
5996
|
isAutoincrement: false;
|
|
5109
5997
|
hasRuntimeDefault: false;
|
|
5110
5998
|
enumValues: [string, ...string[]];
|
|
@@ -5112,14 +6000,14 @@ export declare const schema: {
|
|
|
5112
6000
|
identity: undefined;
|
|
5113
6001
|
generated: undefined;
|
|
5114
6002
|
}, {}, {}>;
|
|
5115
|
-
|
|
5116
|
-
name: "
|
|
5117
|
-
tableName: "
|
|
6003
|
+
mimeType: import("drizzle-orm/pg-core").PgColumn<{
|
|
6004
|
+
name: "mime_type";
|
|
6005
|
+
tableName: "issue_attachments";
|
|
5118
6006
|
dataType: "string";
|
|
5119
6007
|
columnType: "PgText";
|
|
5120
6008
|
data: string;
|
|
5121
6009
|
driverParam: string;
|
|
5122
|
-
notNull:
|
|
6010
|
+
notNull: false;
|
|
5123
6011
|
hasDefault: false;
|
|
5124
6012
|
isPrimaryKey: false;
|
|
5125
6013
|
isAutoincrement: false;
|
|
@@ -5129,26 +6017,26 @@ export declare const schema: {
|
|
|
5129
6017
|
identity: undefined;
|
|
5130
6018
|
generated: undefined;
|
|
5131
6019
|
}, {}, {}>;
|
|
5132
|
-
|
|
5133
|
-
name: "
|
|
5134
|
-
tableName: "
|
|
5135
|
-
dataType: "
|
|
5136
|
-
columnType: "
|
|
5137
|
-
data:
|
|
5138
|
-
driverParam: string;
|
|
6020
|
+
fileSizeBytes: import("drizzle-orm/pg-core").PgColumn<{
|
|
6021
|
+
name: "file_size_bytes";
|
|
6022
|
+
tableName: "issue_attachments";
|
|
6023
|
+
dataType: "number";
|
|
6024
|
+
columnType: "PgInteger";
|
|
6025
|
+
data: number;
|
|
6026
|
+
driverParam: string | number;
|
|
5139
6027
|
notNull: true;
|
|
5140
6028
|
hasDefault: false;
|
|
5141
6029
|
isPrimaryKey: false;
|
|
5142
6030
|
isAutoincrement: false;
|
|
5143
6031
|
hasRuntimeDefault: false;
|
|
5144
|
-
enumValues:
|
|
6032
|
+
enumValues: undefined;
|
|
5145
6033
|
baseColumn: never;
|
|
5146
6034
|
identity: undefined;
|
|
5147
6035
|
generated: undefined;
|
|
5148
6036
|
}, {}, {}>;
|
|
5149
|
-
|
|
5150
|
-
name: "
|
|
5151
|
-
tableName: "
|
|
6037
|
+
relativePath: import("drizzle-orm/pg-core").PgColumn<{
|
|
6038
|
+
name: "relative_path";
|
|
6039
|
+
tableName: "issue_attachments";
|
|
5152
6040
|
dataType: "string";
|
|
5153
6041
|
columnType: "PgText";
|
|
5154
6042
|
data: string;
|
|
@@ -5163,15 +6051,15 @@ export declare const schema: {
|
|
|
5163
6051
|
identity: undefined;
|
|
5164
6052
|
generated: undefined;
|
|
5165
6053
|
}, {}, {}>;
|
|
5166
|
-
|
|
5167
|
-
name: "
|
|
5168
|
-
tableName: "
|
|
6054
|
+
uploadedByActorType: import("drizzle-orm/pg-core").PgColumn<{
|
|
6055
|
+
name: "uploaded_by_actor_type";
|
|
6056
|
+
tableName: "issue_attachments";
|
|
5169
6057
|
dataType: "string";
|
|
5170
6058
|
columnType: "PgText";
|
|
5171
6059
|
data: string;
|
|
5172
6060
|
driverParam: string;
|
|
5173
|
-
notNull:
|
|
5174
|
-
hasDefault:
|
|
6061
|
+
notNull: true;
|
|
6062
|
+
hasDefault: true;
|
|
5175
6063
|
isPrimaryKey: false;
|
|
5176
6064
|
isAutoincrement: false;
|
|
5177
6065
|
hasRuntimeDefault: false;
|
|
@@ -5180,14 +6068,14 @@ export declare const schema: {
|
|
|
5180
6068
|
identity: undefined;
|
|
5181
6069
|
generated: undefined;
|
|
5182
6070
|
}, {}, {}>;
|
|
5183
|
-
|
|
5184
|
-
name: "
|
|
5185
|
-
tableName: "
|
|
6071
|
+
uploadedByActorId: import("drizzle-orm/pg-core").PgColumn<{
|
|
6072
|
+
name: "uploaded_by_actor_id";
|
|
6073
|
+
tableName: "issue_attachments";
|
|
5186
6074
|
dataType: "string";
|
|
5187
6075
|
columnType: "PgText";
|
|
5188
6076
|
data: string;
|
|
5189
6077
|
driverParam: string;
|
|
5190
|
-
notNull:
|
|
6078
|
+
notNull: false;
|
|
5191
6079
|
hasDefault: false;
|
|
5192
6080
|
isPrimaryKey: false;
|
|
5193
6081
|
isAutoincrement: false;
|
|
@@ -5199,7 +6087,7 @@ export declare const schema: {
|
|
|
5199
6087
|
}, {}, {}>;
|
|
5200
6088
|
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
5201
6089
|
name: "created_at";
|
|
5202
|
-
tableName: "
|
|
6090
|
+
tableName: "issue_attachments";
|
|
5203
6091
|
dataType: "date";
|
|
5204
6092
|
columnType: "PgTimestamp";
|
|
5205
6093
|
data: Date;
|
|
@@ -5217,13 +6105,13 @@ export declare const schema: {
|
|
|
5217
6105
|
};
|
|
5218
6106
|
dialect: "pg";
|
|
5219
6107
|
}>;
|
|
5220
|
-
|
|
5221
|
-
name: "
|
|
6108
|
+
activityLogs: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
6109
|
+
name: "activity_logs";
|
|
5222
6110
|
schema: undefined;
|
|
5223
6111
|
columns: {
|
|
5224
6112
|
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
5225
6113
|
name: "id";
|
|
5226
|
-
tableName: "
|
|
6114
|
+
tableName: "activity_logs";
|
|
5227
6115
|
dataType: "string";
|
|
5228
6116
|
columnType: "PgText";
|
|
5229
6117
|
data: string;
|
|
@@ -5240,7 +6128,7 @@ export declare const schema: {
|
|
|
5240
6128
|
}, {}, {}>;
|
|
5241
6129
|
companyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5242
6130
|
name: "company_id";
|
|
5243
|
-
tableName: "
|
|
6131
|
+
tableName: "activity_logs";
|
|
5244
6132
|
dataType: "string";
|
|
5245
6133
|
columnType: "PgText";
|
|
5246
6134
|
data: string;
|
|
@@ -5257,12 +6145,12 @@ export declare const schema: {
|
|
|
5257
6145
|
}, {}, {}>;
|
|
5258
6146
|
issueId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5259
6147
|
name: "issue_id";
|
|
5260
|
-
tableName: "
|
|
6148
|
+
tableName: "activity_logs";
|
|
5261
6149
|
dataType: "string";
|
|
5262
6150
|
columnType: "PgText";
|
|
5263
6151
|
data: string;
|
|
5264
6152
|
driverParam: string;
|
|
5265
|
-
notNull:
|
|
6153
|
+
notNull: false;
|
|
5266
6154
|
hasDefault: false;
|
|
5267
6155
|
isPrimaryKey: false;
|
|
5268
6156
|
isAutoincrement: false;
|
|
@@ -5272,9 +6160,9 @@ export declare const schema: {
|
|
|
5272
6160
|
identity: undefined;
|
|
5273
6161
|
generated: undefined;
|
|
5274
6162
|
}, {}, {}>;
|
|
5275
|
-
|
|
5276
|
-
name: "
|
|
5277
|
-
tableName: "
|
|
6163
|
+
actorType: import("drizzle-orm/pg-core").PgColumn<{
|
|
6164
|
+
name: "actor_type";
|
|
6165
|
+
tableName: "activity_logs";
|
|
5278
6166
|
dataType: "string";
|
|
5279
6167
|
columnType: "PgText";
|
|
5280
6168
|
data: string;
|
|
@@ -5289,14 +6177,14 @@ export declare const schema: {
|
|
|
5289
6177
|
identity: undefined;
|
|
5290
6178
|
generated: undefined;
|
|
5291
6179
|
}, {}, {}>;
|
|
5292
|
-
|
|
5293
|
-
name: "
|
|
5294
|
-
tableName: "
|
|
6180
|
+
actorId: import("drizzle-orm/pg-core").PgColumn<{
|
|
6181
|
+
name: "actor_id";
|
|
6182
|
+
tableName: "activity_logs";
|
|
5295
6183
|
dataType: "string";
|
|
5296
6184
|
columnType: "PgText";
|
|
5297
6185
|
data: string;
|
|
5298
6186
|
driverParam: string;
|
|
5299
|
-
notNull:
|
|
6187
|
+
notNull: false;
|
|
5300
6188
|
hasDefault: false;
|
|
5301
6189
|
isPrimaryKey: false;
|
|
5302
6190
|
isAutoincrement: false;
|
|
@@ -5306,14 +6194,14 @@ export declare const schema: {
|
|
|
5306
6194
|
identity: undefined;
|
|
5307
6195
|
generated: undefined;
|
|
5308
6196
|
}, {}, {}>;
|
|
5309
|
-
|
|
5310
|
-
name: "
|
|
5311
|
-
tableName: "
|
|
6197
|
+
eventType: import("drizzle-orm/pg-core").PgColumn<{
|
|
6198
|
+
name: "event_type";
|
|
6199
|
+
tableName: "activity_logs";
|
|
5312
6200
|
dataType: "string";
|
|
5313
6201
|
columnType: "PgText";
|
|
5314
6202
|
data: string;
|
|
5315
6203
|
driverParam: string;
|
|
5316
|
-
notNull:
|
|
6204
|
+
notNull: true;
|
|
5317
6205
|
hasDefault: false;
|
|
5318
6206
|
isPrimaryKey: false;
|
|
5319
6207
|
isAutoincrement: false;
|
|
@@ -5323,15 +6211,32 @@ export declare const schema: {
|
|
|
5323
6211
|
identity: undefined;
|
|
5324
6212
|
generated: undefined;
|
|
5325
6213
|
}, {}, {}>;
|
|
5326
|
-
|
|
5327
|
-
name: "
|
|
5328
|
-
tableName: "
|
|
5329
|
-
dataType: "
|
|
5330
|
-
columnType: "
|
|
5331
|
-
data:
|
|
5332
|
-
driverParam: string
|
|
6214
|
+
payloadJson: import("drizzle-orm/pg-core").PgColumn<{
|
|
6215
|
+
name: "payload_json";
|
|
6216
|
+
tableName: "activity_logs";
|
|
6217
|
+
dataType: "string";
|
|
6218
|
+
columnType: "PgText";
|
|
6219
|
+
data: string;
|
|
6220
|
+
driverParam: string;
|
|
5333
6221
|
notNull: true;
|
|
5334
|
-
hasDefault:
|
|
6222
|
+
hasDefault: true;
|
|
6223
|
+
isPrimaryKey: false;
|
|
6224
|
+
isAutoincrement: false;
|
|
6225
|
+
hasRuntimeDefault: false;
|
|
6226
|
+
enumValues: [string, ...string[]];
|
|
6227
|
+
baseColumn: never;
|
|
6228
|
+
identity: undefined;
|
|
6229
|
+
generated: undefined;
|
|
6230
|
+
}, {}, {}>;
|
|
6231
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
6232
|
+
name: "created_at";
|
|
6233
|
+
tableName: "activity_logs";
|
|
6234
|
+
dataType: "date";
|
|
6235
|
+
columnType: "PgTimestamp";
|
|
6236
|
+
data: Date;
|
|
6237
|
+
driverParam: string;
|
|
6238
|
+
notNull: true;
|
|
6239
|
+
hasDefault: true;
|
|
5335
6240
|
isPrimaryKey: false;
|
|
5336
6241
|
isAutoincrement: false;
|
|
5337
6242
|
hasRuntimeDefault: false;
|
|
@@ -5340,16 +6245,23 @@ export declare const schema: {
|
|
|
5340
6245
|
identity: undefined;
|
|
5341
6246
|
generated: undefined;
|
|
5342
6247
|
}, {}, {}>;
|
|
5343
|
-
|
|
5344
|
-
|
|
5345
|
-
|
|
6248
|
+
};
|
|
6249
|
+
dialect: "pg";
|
|
6250
|
+
}>;
|
|
6251
|
+
heartbeatRuns: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
6252
|
+
name: "heartbeat_runs";
|
|
6253
|
+
schema: undefined;
|
|
6254
|
+
columns: {
|
|
6255
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
6256
|
+
name: "id";
|
|
6257
|
+
tableName: "heartbeat_runs";
|
|
5346
6258
|
dataType: "string";
|
|
5347
6259
|
columnType: "PgText";
|
|
5348
6260
|
data: string;
|
|
5349
6261
|
driverParam: string;
|
|
5350
6262
|
notNull: true;
|
|
5351
6263
|
hasDefault: false;
|
|
5352
|
-
isPrimaryKey:
|
|
6264
|
+
isPrimaryKey: true;
|
|
5353
6265
|
isAutoincrement: false;
|
|
5354
6266
|
hasRuntimeDefault: false;
|
|
5355
6267
|
enumValues: [string, ...string[]];
|
|
@@ -5357,15 +6269,15 @@ export declare const schema: {
|
|
|
5357
6269
|
identity: undefined;
|
|
5358
6270
|
generated: undefined;
|
|
5359
6271
|
}, {}, {}>;
|
|
5360
|
-
|
|
5361
|
-
name: "
|
|
5362
|
-
tableName: "
|
|
6272
|
+
companyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
6273
|
+
name: "company_id";
|
|
6274
|
+
tableName: "heartbeat_runs";
|
|
5363
6275
|
dataType: "string";
|
|
5364
6276
|
columnType: "PgText";
|
|
5365
6277
|
data: string;
|
|
5366
6278
|
driverParam: string;
|
|
5367
6279
|
notNull: true;
|
|
5368
|
-
hasDefault:
|
|
6280
|
+
hasDefault: false;
|
|
5369
6281
|
isPrimaryKey: false;
|
|
5370
6282
|
isAutoincrement: false;
|
|
5371
6283
|
hasRuntimeDefault: false;
|
|
@@ -5374,14 +6286,14 @@ export declare const schema: {
|
|
|
5374
6286
|
identity: undefined;
|
|
5375
6287
|
generated: undefined;
|
|
5376
6288
|
}, {}, {}>;
|
|
5377
|
-
|
|
5378
|
-
name: "
|
|
5379
|
-
tableName: "
|
|
6289
|
+
agentId: import("drizzle-orm/pg-core").PgColumn<{
|
|
6290
|
+
name: "agent_id";
|
|
6291
|
+
tableName: "heartbeat_runs";
|
|
5380
6292
|
dataType: "string";
|
|
5381
6293
|
columnType: "PgText";
|
|
5382
6294
|
data: string;
|
|
5383
6295
|
driverParam: string;
|
|
5384
|
-
notNull:
|
|
6296
|
+
notNull: true;
|
|
5385
6297
|
hasDefault: false;
|
|
5386
6298
|
isPrimaryKey: false;
|
|
5387
6299
|
isAutoincrement: false;
|
|
@@ -5391,9 +6303,26 @@ export declare const schema: {
|
|
|
5391
6303
|
identity: undefined;
|
|
5392
6304
|
generated: undefined;
|
|
5393
6305
|
}, {}, {}>;
|
|
5394
|
-
|
|
5395
|
-
name: "
|
|
5396
|
-
tableName: "
|
|
6306
|
+
status: import("drizzle-orm/pg-core").PgColumn<{
|
|
6307
|
+
name: "status";
|
|
6308
|
+
tableName: "heartbeat_runs";
|
|
6309
|
+
dataType: "string";
|
|
6310
|
+
columnType: "PgText";
|
|
6311
|
+
data: string;
|
|
6312
|
+
driverParam: string;
|
|
6313
|
+
notNull: true;
|
|
6314
|
+
hasDefault: true;
|
|
6315
|
+
isPrimaryKey: false;
|
|
6316
|
+
isAutoincrement: false;
|
|
6317
|
+
hasRuntimeDefault: false;
|
|
6318
|
+
enumValues: [string, ...string[]];
|
|
6319
|
+
baseColumn: never;
|
|
6320
|
+
identity: undefined;
|
|
6321
|
+
generated: undefined;
|
|
6322
|
+
}, {}, {}>;
|
|
6323
|
+
startedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
6324
|
+
name: "started_at";
|
|
6325
|
+
tableName: "heartbeat_runs";
|
|
5397
6326
|
dataType: "date";
|
|
5398
6327
|
columnType: "PgTimestamp";
|
|
5399
6328
|
data: Date;
|
|
@@ -5408,16 +6337,50 @@ export declare const schema: {
|
|
|
5408
6337
|
identity: undefined;
|
|
5409
6338
|
generated: undefined;
|
|
5410
6339
|
}, {}, {}>;
|
|
6340
|
+
finishedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
6341
|
+
name: "finished_at";
|
|
6342
|
+
tableName: "heartbeat_runs";
|
|
6343
|
+
dataType: "date";
|
|
6344
|
+
columnType: "PgTimestamp";
|
|
6345
|
+
data: Date;
|
|
6346
|
+
driverParam: string;
|
|
6347
|
+
notNull: false;
|
|
6348
|
+
hasDefault: false;
|
|
6349
|
+
isPrimaryKey: false;
|
|
6350
|
+
isAutoincrement: false;
|
|
6351
|
+
hasRuntimeDefault: false;
|
|
6352
|
+
enumValues: undefined;
|
|
6353
|
+
baseColumn: never;
|
|
6354
|
+
identity: undefined;
|
|
6355
|
+
generated: undefined;
|
|
6356
|
+
}, {}, {}>;
|
|
6357
|
+
message: import("drizzle-orm/pg-core").PgColumn<{
|
|
6358
|
+
name: "message";
|
|
6359
|
+
tableName: "heartbeat_runs";
|
|
6360
|
+
dataType: "string";
|
|
6361
|
+
columnType: "PgText";
|
|
6362
|
+
data: string;
|
|
6363
|
+
driverParam: string;
|
|
6364
|
+
notNull: false;
|
|
6365
|
+
hasDefault: false;
|
|
6366
|
+
isPrimaryKey: false;
|
|
6367
|
+
isAutoincrement: false;
|
|
6368
|
+
hasRuntimeDefault: false;
|
|
6369
|
+
enumValues: [string, ...string[]];
|
|
6370
|
+
baseColumn: never;
|
|
6371
|
+
identity: undefined;
|
|
6372
|
+
generated: undefined;
|
|
6373
|
+
}, {}, {}>;
|
|
5411
6374
|
};
|
|
5412
6375
|
dialect: "pg";
|
|
5413
6376
|
}>;
|
|
5414
|
-
|
|
5415
|
-
name: "
|
|
6377
|
+
heartbeatRunQueue: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
6378
|
+
name: "heartbeat_run_queue";
|
|
5416
6379
|
schema: undefined;
|
|
5417
6380
|
columns: {
|
|
5418
6381
|
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
5419
6382
|
name: "id";
|
|
5420
|
-
tableName: "
|
|
6383
|
+
tableName: "heartbeat_run_queue";
|
|
5421
6384
|
dataType: "string";
|
|
5422
6385
|
columnType: "PgText";
|
|
5423
6386
|
data: string;
|
|
@@ -5434,7 +6397,7 @@ export declare const schema: {
|
|
|
5434
6397
|
}, {}, {}>;
|
|
5435
6398
|
companyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5436
6399
|
name: "company_id";
|
|
5437
|
-
tableName: "
|
|
6400
|
+
tableName: "heartbeat_run_queue";
|
|
5438
6401
|
dataType: "string";
|
|
5439
6402
|
columnType: "PgText";
|
|
5440
6403
|
data: string;
|
|
@@ -5449,14 +6412,14 @@ export declare const schema: {
|
|
|
5449
6412
|
identity: undefined;
|
|
5450
6413
|
generated: undefined;
|
|
5451
6414
|
}, {}, {}>;
|
|
5452
|
-
|
|
5453
|
-
name: "
|
|
5454
|
-
tableName: "
|
|
6415
|
+
agentId: import("drizzle-orm/pg-core").PgColumn<{
|
|
6416
|
+
name: "agent_id";
|
|
6417
|
+
tableName: "heartbeat_run_queue";
|
|
5455
6418
|
dataType: "string";
|
|
5456
6419
|
columnType: "PgText";
|
|
5457
6420
|
data: string;
|
|
5458
6421
|
driverParam: string;
|
|
5459
|
-
notNull:
|
|
6422
|
+
notNull: true;
|
|
5460
6423
|
hasDefault: false;
|
|
5461
6424
|
isPrimaryKey: false;
|
|
5462
6425
|
isAutoincrement: false;
|
|
@@ -5466,9 +6429,9 @@ export declare const schema: {
|
|
|
5466
6429
|
identity: undefined;
|
|
5467
6430
|
generated: undefined;
|
|
5468
6431
|
}, {}, {}>;
|
|
5469
|
-
|
|
5470
|
-
name: "
|
|
5471
|
-
tableName: "
|
|
6432
|
+
jobType: import("drizzle-orm/pg-core").PgColumn<{
|
|
6433
|
+
name: "job_type";
|
|
6434
|
+
tableName: "heartbeat_run_queue";
|
|
5472
6435
|
dataType: "string";
|
|
5473
6436
|
columnType: "PgText";
|
|
5474
6437
|
data: string;
|
|
@@ -5483,15 +6446,15 @@ export declare const schema: {
|
|
|
5483
6446
|
identity: undefined;
|
|
5484
6447
|
generated: undefined;
|
|
5485
6448
|
}, {}, {}>;
|
|
5486
|
-
|
|
5487
|
-
name: "
|
|
5488
|
-
tableName: "
|
|
6449
|
+
payloadJson: import("drizzle-orm/pg-core").PgColumn<{
|
|
6450
|
+
name: "payload_json";
|
|
6451
|
+
tableName: "heartbeat_run_queue";
|
|
5489
6452
|
dataType: "string";
|
|
5490
6453
|
columnType: "PgText";
|
|
5491
6454
|
data: string;
|
|
5492
6455
|
driverParam: string;
|
|
5493
|
-
notNull:
|
|
5494
|
-
hasDefault:
|
|
6456
|
+
notNull: true;
|
|
6457
|
+
hasDefault: true;
|
|
5495
6458
|
isPrimaryKey: false;
|
|
5496
6459
|
isAutoincrement: false;
|
|
5497
6460
|
hasRuntimeDefault: false;
|
|
@@ -5500,15 +6463,15 @@ export declare const schema: {
|
|
|
5500
6463
|
identity: undefined;
|
|
5501
6464
|
generated: undefined;
|
|
5502
6465
|
}, {}, {}>;
|
|
5503
|
-
|
|
5504
|
-
name: "
|
|
5505
|
-
tableName: "
|
|
6466
|
+
status: import("drizzle-orm/pg-core").PgColumn<{
|
|
6467
|
+
name: "status";
|
|
6468
|
+
tableName: "heartbeat_run_queue";
|
|
5506
6469
|
dataType: "string";
|
|
5507
6470
|
columnType: "PgText";
|
|
5508
6471
|
data: string;
|
|
5509
6472
|
driverParam: string;
|
|
5510
6473
|
notNull: true;
|
|
5511
|
-
hasDefault:
|
|
6474
|
+
hasDefault: true;
|
|
5512
6475
|
isPrimaryKey: false;
|
|
5513
6476
|
isAutoincrement: false;
|
|
5514
6477
|
hasRuntimeDefault: false;
|
|
@@ -5517,15 +6480,32 @@ export declare const schema: {
|
|
|
5517
6480
|
identity: undefined;
|
|
5518
6481
|
generated: undefined;
|
|
5519
6482
|
}, {}, {}>;
|
|
5520
|
-
|
|
5521
|
-
name: "
|
|
5522
|
-
tableName: "
|
|
6483
|
+
priority: import("drizzle-orm/pg-core").PgColumn<{
|
|
6484
|
+
name: "priority";
|
|
6485
|
+
tableName: "heartbeat_run_queue";
|
|
6486
|
+
dataType: "number";
|
|
6487
|
+
columnType: "PgInteger";
|
|
6488
|
+
data: number;
|
|
6489
|
+
driverParam: string | number;
|
|
6490
|
+
notNull: true;
|
|
6491
|
+
hasDefault: true;
|
|
6492
|
+
isPrimaryKey: false;
|
|
6493
|
+
isAutoincrement: false;
|
|
6494
|
+
hasRuntimeDefault: false;
|
|
6495
|
+
enumValues: undefined;
|
|
6496
|
+
baseColumn: never;
|
|
6497
|
+
identity: undefined;
|
|
6498
|
+
generated: undefined;
|
|
6499
|
+
}, {}, {}>;
|
|
6500
|
+
idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
|
|
6501
|
+
name: "idempotency_key";
|
|
6502
|
+
tableName: "heartbeat_run_queue";
|
|
5523
6503
|
dataType: "string";
|
|
5524
6504
|
columnType: "PgText";
|
|
5525
6505
|
data: string;
|
|
5526
6506
|
driverParam: string;
|
|
5527
|
-
notNull:
|
|
5528
|
-
hasDefault:
|
|
6507
|
+
notNull: false;
|
|
6508
|
+
hasDefault: false;
|
|
5529
6509
|
isPrimaryKey: false;
|
|
5530
6510
|
isAutoincrement: false;
|
|
5531
6511
|
hasRuntimeDefault: false;
|
|
@@ -5534,9 +6514,9 @@ export declare const schema: {
|
|
|
5534
6514
|
identity: undefined;
|
|
5535
6515
|
generated: undefined;
|
|
5536
6516
|
}, {}, {}>;
|
|
5537
|
-
|
|
5538
|
-
name: "
|
|
5539
|
-
tableName: "
|
|
6517
|
+
availableAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
6518
|
+
name: "available_at";
|
|
6519
|
+
tableName: "heartbeat_run_queue";
|
|
5540
6520
|
dataType: "date";
|
|
5541
6521
|
columnType: "PgTimestamp";
|
|
5542
6522
|
data: Date;
|
|
@@ -5551,73 +6531,49 @@ export declare const schema: {
|
|
|
5551
6531
|
identity: undefined;
|
|
5552
6532
|
generated: undefined;
|
|
5553
6533
|
}, {}, {}>;
|
|
5554
|
-
|
|
5555
|
-
|
|
5556
|
-
|
|
5557
|
-
|
|
5558
|
-
|
|
5559
|
-
|
|
5560
|
-
|
|
5561
|
-
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
5562
|
-
name: "id";
|
|
5563
|
-
tableName: "heartbeat_runs";
|
|
5564
|
-
dataType: "string";
|
|
5565
|
-
columnType: "PgText";
|
|
5566
|
-
data: string;
|
|
5567
|
-
driverParam: string;
|
|
5568
|
-
notNull: true;
|
|
5569
|
-
hasDefault: false;
|
|
5570
|
-
isPrimaryKey: true;
|
|
5571
|
-
isAutoincrement: false;
|
|
5572
|
-
hasRuntimeDefault: false;
|
|
5573
|
-
enumValues: [string, ...string[]];
|
|
5574
|
-
baseColumn: never;
|
|
5575
|
-
identity: undefined;
|
|
5576
|
-
generated: undefined;
|
|
5577
|
-
}, {}, {}>;
|
|
5578
|
-
companyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
5579
|
-
name: "company_id";
|
|
5580
|
-
tableName: "heartbeat_runs";
|
|
5581
|
-
dataType: "string";
|
|
5582
|
-
columnType: "PgText";
|
|
5583
|
-
data: string;
|
|
5584
|
-
driverParam: string;
|
|
6534
|
+
attemptCount: import("drizzle-orm/pg-core").PgColumn<{
|
|
6535
|
+
name: "attempt_count";
|
|
6536
|
+
tableName: "heartbeat_run_queue";
|
|
6537
|
+
dataType: "number";
|
|
6538
|
+
columnType: "PgInteger";
|
|
6539
|
+
data: number;
|
|
6540
|
+
driverParam: string | number;
|
|
5585
6541
|
notNull: true;
|
|
5586
|
-
hasDefault:
|
|
6542
|
+
hasDefault: true;
|
|
5587
6543
|
isPrimaryKey: false;
|
|
5588
6544
|
isAutoincrement: false;
|
|
5589
6545
|
hasRuntimeDefault: false;
|
|
5590
|
-
enumValues:
|
|
6546
|
+
enumValues: undefined;
|
|
5591
6547
|
baseColumn: never;
|
|
5592
6548
|
identity: undefined;
|
|
5593
6549
|
generated: undefined;
|
|
5594
6550
|
}, {}, {}>;
|
|
5595
|
-
|
|
5596
|
-
name: "
|
|
5597
|
-
tableName: "
|
|
5598
|
-
dataType: "
|
|
5599
|
-
columnType: "
|
|
5600
|
-
data:
|
|
5601
|
-
driverParam: string;
|
|
6551
|
+
maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
|
|
6552
|
+
name: "max_attempts";
|
|
6553
|
+
tableName: "heartbeat_run_queue";
|
|
6554
|
+
dataType: "number";
|
|
6555
|
+
columnType: "PgInteger";
|
|
6556
|
+
data: number;
|
|
6557
|
+
driverParam: string | number;
|
|
5602
6558
|
notNull: true;
|
|
5603
|
-
hasDefault:
|
|
6559
|
+
hasDefault: true;
|
|
5604
6560
|
isPrimaryKey: false;
|
|
5605
6561
|
isAutoincrement: false;
|
|
5606
6562
|
hasRuntimeDefault: false;
|
|
5607
|
-
enumValues:
|
|
6563
|
+
enumValues: undefined;
|
|
5608
6564
|
baseColumn: never;
|
|
5609
6565
|
identity: undefined;
|
|
5610
6566
|
generated: undefined;
|
|
5611
6567
|
}, {}, {}>;
|
|
5612
|
-
|
|
5613
|
-
name: "
|
|
5614
|
-
tableName: "
|
|
6568
|
+
lastError: import("drizzle-orm/pg-core").PgColumn<{
|
|
6569
|
+
name: "last_error";
|
|
6570
|
+
tableName: "heartbeat_run_queue";
|
|
5615
6571
|
dataType: "string";
|
|
5616
6572
|
columnType: "PgText";
|
|
5617
6573
|
data: string;
|
|
5618
6574
|
driverParam: string;
|
|
5619
|
-
notNull:
|
|
5620
|
-
hasDefault:
|
|
6575
|
+
notNull: false;
|
|
6576
|
+
hasDefault: false;
|
|
5621
6577
|
isPrimaryKey: false;
|
|
5622
6578
|
isAutoincrement: false;
|
|
5623
6579
|
hasRuntimeDefault: false;
|
|
@@ -5628,13 +6584,13 @@ export declare const schema: {
|
|
|
5628
6584
|
}, {}, {}>;
|
|
5629
6585
|
startedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
5630
6586
|
name: "started_at";
|
|
5631
|
-
tableName: "
|
|
6587
|
+
tableName: "heartbeat_run_queue";
|
|
5632
6588
|
dataType: "date";
|
|
5633
6589
|
columnType: "PgTimestamp";
|
|
5634
6590
|
data: Date;
|
|
5635
6591
|
driverParam: string;
|
|
5636
|
-
notNull:
|
|
5637
|
-
hasDefault:
|
|
6592
|
+
notNull: false;
|
|
6593
|
+
hasDefault: false;
|
|
5638
6594
|
isPrimaryKey: false;
|
|
5639
6595
|
isAutoincrement: false;
|
|
5640
6596
|
hasRuntimeDefault: false;
|
|
@@ -5645,7 +6601,7 @@ export declare const schema: {
|
|
|
5645
6601
|
}, {}, {}>;
|
|
5646
6602
|
finishedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
5647
6603
|
name: "finished_at";
|
|
5648
|
-
tableName: "
|
|
6604
|
+
tableName: "heartbeat_run_queue";
|
|
5649
6605
|
dataType: "date";
|
|
5650
6606
|
columnType: "PgTimestamp";
|
|
5651
6607
|
data: Date;
|
|
@@ -5660,9 +6616,9 @@ export declare const schema: {
|
|
|
5660
6616
|
identity: undefined;
|
|
5661
6617
|
generated: undefined;
|
|
5662
6618
|
}, {}, {}>;
|
|
5663
|
-
|
|
5664
|
-
name: "
|
|
5665
|
-
tableName: "
|
|
6619
|
+
heartbeatRunId: import("drizzle-orm/pg-core").PgColumn<{
|
|
6620
|
+
name: "heartbeat_run_id";
|
|
6621
|
+
tableName: "heartbeat_run_queue";
|
|
5666
6622
|
dataType: "string";
|
|
5667
6623
|
columnType: "PgText";
|
|
5668
6624
|
data: string;
|
|
@@ -5677,6 +6633,40 @@ export declare const schema: {
|
|
|
5677
6633
|
identity: undefined;
|
|
5678
6634
|
generated: undefined;
|
|
5679
6635
|
}, {}, {}>;
|
|
6636
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
6637
|
+
name: "created_at";
|
|
6638
|
+
tableName: "heartbeat_run_queue";
|
|
6639
|
+
dataType: "date";
|
|
6640
|
+
columnType: "PgTimestamp";
|
|
6641
|
+
data: Date;
|
|
6642
|
+
driverParam: string;
|
|
6643
|
+
notNull: true;
|
|
6644
|
+
hasDefault: true;
|
|
6645
|
+
isPrimaryKey: false;
|
|
6646
|
+
isAutoincrement: false;
|
|
6647
|
+
hasRuntimeDefault: false;
|
|
6648
|
+
enumValues: undefined;
|
|
6649
|
+
baseColumn: never;
|
|
6650
|
+
identity: undefined;
|
|
6651
|
+
generated: undefined;
|
|
6652
|
+
}, {}, {}>;
|
|
6653
|
+
updatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
6654
|
+
name: "updated_at";
|
|
6655
|
+
tableName: "heartbeat_run_queue";
|
|
6656
|
+
dataType: "date";
|
|
6657
|
+
columnType: "PgTimestamp";
|
|
6658
|
+
data: Date;
|
|
6659
|
+
driverParam: string;
|
|
6660
|
+
notNull: true;
|
|
6661
|
+
hasDefault: true;
|
|
6662
|
+
isPrimaryKey: false;
|
|
6663
|
+
isAutoincrement: false;
|
|
6664
|
+
hasRuntimeDefault: false;
|
|
6665
|
+
enumValues: undefined;
|
|
6666
|
+
baseColumn: never;
|
|
6667
|
+
identity: undefined;
|
|
6668
|
+
generated: undefined;
|
|
6669
|
+
}, {}, {}>;
|
|
5680
6670
|
};
|
|
5681
6671
|
dialect: "pg";
|
|
5682
6672
|
}>;
|
|
@@ -6160,6 +7150,166 @@ export declare const schema: {
|
|
|
6160
7150
|
};
|
|
6161
7151
|
dialect: "pg";
|
|
6162
7152
|
}>;
|
|
7153
|
+
attentionInboxStates: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
7154
|
+
name: "attention_inbox_states";
|
|
7155
|
+
schema: undefined;
|
|
7156
|
+
columns: {
|
|
7157
|
+
companyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
7158
|
+
name: "company_id";
|
|
7159
|
+
tableName: "attention_inbox_states";
|
|
7160
|
+
dataType: "string";
|
|
7161
|
+
columnType: "PgText";
|
|
7162
|
+
data: string;
|
|
7163
|
+
driverParam: string;
|
|
7164
|
+
notNull: true;
|
|
7165
|
+
hasDefault: false;
|
|
7166
|
+
isPrimaryKey: false;
|
|
7167
|
+
isAutoincrement: false;
|
|
7168
|
+
hasRuntimeDefault: false;
|
|
7169
|
+
enumValues: [string, ...string[]];
|
|
7170
|
+
baseColumn: never;
|
|
7171
|
+
identity: undefined;
|
|
7172
|
+
generated: undefined;
|
|
7173
|
+
}, {}, {}>;
|
|
7174
|
+
actorId: import("drizzle-orm/pg-core").PgColumn<{
|
|
7175
|
+
name: "actor_id";
|
|
7176
|
+
tableName: "attention_inbox_states";
|
|
7177
|
+
dataType: "string";
|
|
7178
|
+
columnType: "PgText";
|
|
7179
|
+
data: string;
|
|
7180
|
+
driverParam: string;
|
|
7181
|
+
notNull: true;
|
|
7182
|
+
hasDefault: false;
|
|
7183
|
+
isPrimaryKey: false;
|
|
7184
|
+
isAutoincrement: false;
|
|
7185
|
+
hasRuntimeDefault: false;
|
|
7186
|
+
enumValues: [string, ...string[]];
|
|
7187
|
+
baseColumn: never;
|
|
7188
|
+
identity: undefined;
|
|
7189
|
+
generated: undefined;
|
|
7190
|
+
}, {}, {}>;
|
|
7191
|
+
itemKey: import("drizzle-orm/pg-core").PgColumn<{
|
|
7192
|
+
name: "item_key";
|
|
7193
|
+
tableName: "attention_inbox_states";
|
|
7194
|
+
dataType: "string";
|
|
7195
|
+
columnType: "PgText";
|
|
7196
|
+
data: string;
|
|
7197
|
+
driverParam: string;
|
|
7198
|
+
notNull: true;
|
|
7199
|
+
hasDefault: false;
|
|
7200
|
+
isPrimaryKey: false;
|
|
7201
|
+
isAutoincrement: false;
|
|
7202
|
+
hasRuntimeDefault: false;
|
|
7203
|
+
enumValues: [string, ...string[]];
|
|
7204
|
+
baseColumn: never;
|
|
7205
|
+
identity: undefined;
|
|
7206
|
+
generated: undefined;
|
|
7207
|
+
}, {}, {}>;
|
|
7208
|
+
seenAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
7209
|
+
name: "seen_at";
|
|
7210
|
+
tableName: "attention_inbox_states";
|
|
7211
|
+
dataType: "date";
|
|
7212
|
+
columnType: "PgTimestamp";
|
|
7213
|
+
data: Date;
|
|
7214
|
+
driverParam: string;
|
|
7215
|
+
notNull: false;
|
|
7216
|
+
hasDefault: false;
|
|
7217
|
+
isPrimaryKey: false;
|
|
7218
|
+
isAutoincrement: false;
|
|
7219
|
+
hasRuntimeDefault: false;
|
|
7220
|
+
enumValues: undefined;
|
|
7221
|
+
baseColumn: never;
|
|
7222
|
+
identity: undefined;
|
|
7223
|
+
generated: undefined;
|
|
7224
|
+
}, {}, {}>;
|
|
7225
|
+
acknowledgedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
7226
|
+
name: "acknowledged_at";
|
|
7227
|
+
tableName: "attention_inbox_states";
|
|
7228
|
+
dataType: "date";
|
|
7229
|
+
columnType: "PgTimestamp";
|
|
7230
|
+
data: Date;
|
|
7231
|
+
driverParam: string;
|
|
7232
|
+
notNull: false;
|
|
7233
|
+
hasDefault: false;
|
|
7234
|
+
isPrimaryKey: false;
|
|
7235
|
+
isAutoincrement: false;
|
|
7236
|
+
hasRuntimeDefault: false;
|
|
7237
|
+
enumValues: undefined;
|
|
7238
|
+
baseColumn: never;
|
|
7239
|
+
identity: undefined;
|
|
7240
|
+
generated: undefined;
|
|
7241
|
+
}, {}, {}>;
|
|
7242
|
+
dismissedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
7243
|
+
name: "dismissed_at";
|
|
7244
|
+
tableName: "attention_inbox_states";
|
|
7245
|
+
dataType: "date";
|
|
7246
|
+
columnType: "PgTimestamp";
|
|
7247
|
+
data: Date;
|
|
7248
|
+
driverParam: string;
|
|
7249
|
+
notNull: false;
|
|
7250
|
+
hasDefault: false;
|
|
7251
|
+
isPrimaryKey: false;
|
|
7252
|
+
isAutoincrement: false;
|
|
7253
|
+
hasRuntimeDefault: false;
|
|
7254
|
+
enumValues: undefined;
|
|
7255
|
+
baseColumn: never;
|
|
7256
|
+
identity: undefined;
|
|
7257
|
+
generated: undefined;
|
|
7258
|
+
}, {}, {}>;
|
|
7259
|
+
resolvedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
7260
|
+
name: "resolved_at";
|
|
7261
|
+
tableName: "attention_inbox_states";
|
|
7262
|
+
dataType: "date";
|
|
7263
|
+
columnType: "PgTimestamp";
|
|
7264
|
+
data: Date;
|
|
7265
|
+
driverParam: string;
|
|
7266
|
+
notNull: false;
|
|
7267
|
+
hasDefault: false;
|
|
7268
|
+
isPrimaryKey: false;
|
|
7269
|
+
isAutoincrement: false;
|
|
7270
|
+
hasRuntimeDefault: false;
|
|
7271
|
+
enumValues: undefined;
|
|
7272
|
+
baseColumn: never;
|
|
7273
|
+
identity: undefined;
|
|
7274
|
+
generated: undefined;
|
|
7275
|
+
}, {}, {}>;
|
|
7276
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
7277
|
+
name: "created_at";
|
|
7278
|
+
tableName: "attention_inbox_states";
|
|
7279
|
+
dataType: "date";
|
|
7280
|
+
columnType: "PgTimestamp";
|
|
7281
|
+
data: Date;
|
|
7282
|
+
driverParam: string;
|
|
7283
|
+
notNull: true;
|
|
7284
|
+
hasDefault: true;
|
|
7285
|
+
isPrimaryKey: false;
|
|
7286
|
+
isAutoincrement: false;
|
|
7287
|
+
hasRuntimeDefault: false;
|
|
7288
|
+
enumValues: undefined;
|
|
7289
|
+
baseColumn: never;
|
|
7290
|
+
identity: undefined;
|
|
7291
|
+
generated: undefined;
|
|
7292
|
+
}, {}, {}>;
|
|
7293
|
+
updatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
7294
|
+
name: "updated_at";
|
|
7295
|
+
tableName: "attention_inbox_states";
|
|
7296
|
+
dataType: "date";
|
|
7297
|
+
columnType: "PgTimestamp";
|
|
7298
|
+
data: Date;
|
|
7299
|
+
driverParam: string;
|
|
7300
|
+
notNull: true;
|
|
7301
|
+
hasDefault: true;
|
|
7302
|
+
isPrimaryKey: false;
|
|
7303
|
+
isAutoincrement: false;
|
|
7304
|
+
hasRuntimeDefault: false;
|
|
7305
|
+
enumValues: undefined;
|
|
7306
|
+
baseColumn: never;
|
|
7307
|
+
identity: undefined;
|
|
7308
|
+
generated: undefined;
|
|
7309
|
+
}, {}, {}>;
|
|
7310
|
+
};
|
|
7311
|
+
dialect: "pg";
|
|
7312
|
+
}>;
|
|
6163
7313
|
costLedger: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
6164
7314
|
name: "cost_ledger";
|
|
6165
7315
|
schema: undefined;
|