@antasphere/chassis-db 0.0.0-stage → 1.0.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/LICENSE +82 -0
- package/dist/auth-schema.d.ts +2132 -0
- package/dist/auth-schema.d.ts.map +1 -0
- package/dist/auth-schema.js +251 -0
- package/dist/auth-schema.js.map +1 -0
- package/dist/client.d.ts +31 -0
- package/dist/client.d.ts.map +1 -0
- package/dist/client.js +24 -0
- package/dist/client.js.map +1 -0
- package/dist/index.d.ts +4 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +4 -0
- package/dist/index.js.map +1 -0
- package/dist/migrate.d.ts +50 -0
- package/dist/migrate.d.ts.map +1 -0
- package/dist/migrate.js +97 -0
- package/dist/migrate.js.map +1 -0
- package/dist/schema.d.ts +2804 -0
- package/dist/schema.d.ts.map +1 -0
- package/dist/schema.js +620 -0
- package/dist/schema.js.map +1 -0
- package/package.json +45 -3
- package/src/auth-schema.ts +300 -0
- package/src/client.ts +59 -0
- package/src/index.ts +3 -0
- package/src/migrate.ts +136 -0
- package/src/schema.ts +734 -0
- package/README.md +0 -3
package/dist/schema.d.ts
ADDED
|
@@ -0,0 +1,2804 @@
|
|
|
1
|
+
export * from './auth-schema.js';
|
|
2
|
+
/**
|
|
3
|
+
* Singleton instance row. Exactly one row (id = 'instance') exists after
|
|
4
|
+
* first-boot setup; its presence is what makes POST /api/v1/setup return 410.
|
|
5
|
+
* Inserted by the setup endpoint with ON CONFLICT DO NOTHING so concurrent
|
|
6
|
+
* setup calls cannot both win.
|
|
7
|
+
*/
|
|
8
|
+
export declare const instanceSettings: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
9
|
+
name: "instance_settings";
|
|
10
|
+
schema: undefined;
|
|
11
|
+
columns: {
|
|
12
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
13
|
+
name: "id";
|
|
14
|
+
tableName: "instance_settings";
|
|
15
|
+
dataType: "string";
|
|
16
|
+
columnType: "PgText";
|
|
17
|
+
data: string;
|
|
18
|
+
driverParam: string;
|
|
19
|
+
notNull: true;
|
|
20
|
+
hasDefault: false;
|
|
21
|
+
isPrimaryKey: true;
|
|
22
|
+
isAutoincrement: false;
|
|
23
|
+
hasRuntimeDefault: false;
|
|
24
|
+
enumValues: [string, ...string[]];
|
|
25
|
+
baseColumn: never;
|
|
26
|
+
identity: undefined;
|
|
27
|
+
generated: undefined;
|
|
28
|
+
}, {}, {}>;
|
|
29
|
+
instanceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
30
|
+
name: "instance_id";
|
|
31
|
+
tableName: "instance_settings";
|
|
32
|
+
dataType: "string";
|
|
33
|
+
columnType: "PgText";
|
|
34
|
+
data: string;
|
|
35
|
+
driverParam: string;
|
|
36
|
+
notNull: true;
|
|
37
|
+
hasDefault: false;
|
|
38
|
+
isPrimaryKey: false;
|
|
39
|
+
isAutoincrement: false;
|
|
40
|
+
hasRuntimeDefault: false;
|
|
41
|
+
enumValues: [string, ...string[]];
|
|
42
|
+
baseColumn: never;
|
|
43
|
+
identity: undefined;
|
|
44
|
+
generated: undefined;
|
|
45
|
+
}, {}, {}>;
|
|
46
|
+
name: import("drizzle-orm/pg-core").PgColumn<{
|
|
47
|
+
name: "name";
|
|
48
|
+
tableName: "instance_settings";
|
|
49
|
+
dataType: "string";
|
|
50
|
+
columnType: "PgText";
|
|
51
|
+
data: string;
|
|
52
|
+
driverParam: string;
|
|
53
|
+
notNull: true;
|
|
54
|
+
hasDefault: false;
|
|
55
|
+
isPrimaryKey: false;
|
|
56
|
+
isAutoincrement: false;
|
|
57
|
+
hasRuntimeDefault: false;
|
|
58
|
+
enumValues: [string, ...string[]];
|
|
59
|
+
baseColumn: never;
|
|
60
|
+
identity: undefined;
|
|
61
|
+
generated: undefined;
|
|
62
|
+
}, {}, {}>;
|
|
63
|
+
setupCompletedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
64
|
+
name: "setup_completed_at";
|
|
65
|
+
tableName: "instance_settings";
|
|
66
|
+
dataType: "date";
|
|
67
|
+
columnType: "PgTimestamp";
|
|
68
|
+
data: Date;
|
|
69
|
+
driverParam: string;
|
|
70
|
+
notNull: true;
|
|
71
|
+
hasDefault: true;
|
|
72
|
+
isPrimaryKey: false;
|
|
73
|
+
isAutoincrement: false;
|
|
74
|
+
hasRuntimeDefault: false;
|
|
75
|
+
enumValues: undefined;
|
|
76
|
+
baseColumn: never;
|
|
77
|
+
identity: undefined;
|
|
78
|
+
generated: undefined;
|
|
79
|
+
}, {}, {}>;
|
|
80
|
+
schemaVersion: import("drizzle-orm/pg-core").PgColumn<{
|
|
81
|
+
name: "schema_version";
|
|
82
|
+
tableName: "instance_settings";
|
|
83
|
+
dataType: "number";
|
|
84
|
+
columnType: "PgInteger";
|
|
85
|
+
data: number;
|
|
86
|
+
driverParam: string | number;
|
|
87
|
+
notNull: true;
|
|
88
|
+
hasDefault: true;
|
|
89
|
+
isPrimaryKey: false;
|
|
90
|
+
isAutoincrement: false;
|
|
91
|
+
hasRuntimeDefault: false;
|
|
92
|
+
enumValues: undefined;
|
|
93
|
+
baseColumn: never;
|
|
94
|
+
identity: undefined;
|
|
95
|
+
generated: undefined;
|
|
96
|
+
}, {}, {}>;
|
|
97
|
+
telemetryEnabled: import("drizzle-orm/pg-core").PgColumn<{
|
|
98
|
+
name: "telemetry_enabled";
|
|
99
|
+
tableName: "instance_settings";
|
|
100
|
+
dataType: "boolean";
|
|
101
|
+
columnType: "PgBoolean";
|
|
102
|
+
data: boolean;
|
|
103
|
+
driverParam: boolean;
|
|
104
|
+
notNull: true;
|
|
105
|
+
hasDefault: true;
|
|
106
|
+
isPrimaryKey: false;
|
|
107
|
+
isAutoincrement: false;
|
|
108
|
+
hasRuntimeDefault: false;
|
|
109
|
+
enumValues: undefined;
|
|
110
|
+
baseColumn: never;
|
|
111
|
+
identity: undefined;
|
|
112
|
+
generated: undefined;
|
|
113
|
+
}, {}, {}>;
|
|
114
|
+
edition: import("drizzle-orm/pg-core").PgColumn<{
|
|
115
|
+
name: "edition";
|
|
116
|
+
tableName: "instance_settings";
|
|
117
|
+
dataType: "string";
|
|
118
|
+
columnType: "PgText";
|
|
119
|
+
data: string;
|
|
120
|
+
driverParam: string;
|
|
121
|
+
notNull: true;
|
|
122
|
+
hasDefault: true;
|
|
123
|
+
isPrimaryKey: false;
|
|
124
|
+
isAutoincrement: false;
|
|
125
|
+
hasRuntimeDefault: false;
|
|
126
|
+
enumValues: [string, ...string[]];
|
|
127
|
+
baseColumn: never;
|
|
128
|
+
identity: undefined;
|
|
129
|
+
generated: undefined;
|
|
130
|
+
}, {}, {}>;
|
|
131
|
+
operatorUserId: import("drizzle-orm/pg-core").PgColumn<{
|
|
132
|
+
name: "operator_user_id";
|
|
133
|
+
tableName: "instance_settings";
|
|
134
|
+
dataType: "string";
|
|
135
|
+
columnType: "PgText";
|
|
136
|
+
data: string;
|
|
137
|
+
driverParam: string;
|
|
138
|
+
notNull: false;
|
|
139
|
+
hasDefault: false;
|
|
140
|
+
isPrimaryKey: false;
|
|
141
|
+
isAutoincrement: false;
|
|
142
|
+
hasRuntimeDefault: false;
|
|
143
|
+
enumValues: [string, ...string[]];
|
|
144
|
+
baseColumn: never;
|
|
145
|
+
identity: undefined;
|
|
146
|
+
generated: undefined;
|
|
147
|
+
}, {}, {}>;
|
|
148
|
+
};
|
|
149
|
+
dialect: "pg";
|
|
150
|
+
}>;
|
|
151
|
+
/**
|
|
152
|
+
* Multi-workspace schema AND runtime (ADR 014): setup creates the FIRST
|
|
153
|
+
* workspace, the cloud edition creates later ones through the registry's
|
|
154
|
+
* WorkspaceService, and every request is scoped to exactly ONE workspace —
|
|
155
|
+
* the one named by the presented credential. Every domain table carries a
|
|
156
|
+
* workspace_id and every read/write filters on the principal's.
|
|
157
|
+
*/
|
|
158
|
+
export declare const workspaceHubStatuses: readonly ["active", "suspended"];
|
|
159
|
+
export type WorkspaceHubStatus = (typeof workspaceHubStatuses)[number];
|
|
160
|
+
export declare const workspaces: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
161
|
+
name: "workspaces";
|
|
162
|
+
schema: undefined;
|
|
163
|
+
columns: {
|
|
164
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
165
|
+
name: "id";
|
|
166
|
+
tableName: "workspaces";
|
|
167
|
+
dataType: "string";
|
|
168
|
+
columnType: "PgUUID";
|
|
169
|
+
data: string;
|
|
170
|
+
driverParam: string;
|
|
171
|
+
notNull: true;
|
|
172
|
+
hasDefault: true;
|
|
173
|
+
isPrimaryKey: true;
|
|
174
|
+
isAutoincrement: false;
|
|
175
|
+
hasRuntimeDefault: false;
|
|
176
|
+
enumValues: undefined;
|
|
177
|
+
baseColumn: never;
|
|
178
|
+
identity: undefined;
|
|
179
|
+
generated: undefined;
|
|
180
|
+
}, {}, {}>;
|
|
181
|
+
name: import("drizzle-orm/pg-core").PgColumn<{
|
|
182
|
+
name: "name";
|
|
183
|
+
tableName: "workspaces";
|
|
184
|
+
dataType: "string";
|
|
185
|
+
columnType: "PgText";
|
|
186
|
+
data: string;
|
|
187
|
+
driverParam: string;
|
|
188
|
+
notNull: true;
|
|
189
|
+
hasDefault: false;
|
|
190
|
+
isPrimaryKey: false;
|
|
191
|
+
isAutoincrement: false;
|
|
192
|
+
hasRuntimeDefault: false;
|
|
193
|
+
enumValues: [string, ...string[]];
|
|
194
|
+
baseColumn: never;
|
|
195
|
+
identity: undefined;
|
|
196
|
+
generated: undefined;
|
|
197
|
+
}, {}, {}>;
|
|
198
|
+
centralAccountId: import("drizzle-orm/pg-core").PgColumn<{
|
|
199
|
+
name: "central_account_id";
|
|
200
|
+
tableName: "workspaces";
|
|
201
|
+
dataType: "string";
|
|
202
|
+
columnType: "PgText";
|
|
203
|
+
data: string;
|
|
204
|
+
driverParam: string;
|
|
205
|
+
notNull: false;
|
|
206
|
+
hasDefault: false;
|
|
207
|
+
isPrimaryKey: false;
|
|
208
|
+
isAutoincrement: false;
|
|
209
|
+
hasRuntimeDefault: false;
|
|
210
|
+
enumValues: [string, ...string[]];
|
|
211
|
+
baseColumn: never;
|
|
212
|
+
identity: undefined;
|
|
213
|
+
generated: undefined;
|
|
214
|
+
}, {}, {}>;
|
|
215
|
+
hubStatus: import("drizzle-orm/pg-core").PgColumn<{
|
|
216
|
+
name: "hub_status";
|
|
217
|
+
tableName: "workspaces";
|
|
218
|
+
dataType: "string";
|
|
219
|
+
columnType: "PgText";
|
|
220
|
+
data: "active" | "suspended";
|
|
221
|
+
driverParam: string;
|
|
222
|
+
notNull: true;
|
|
223
|
+
hasDefault: true;
|
|
224
|
+
isPrimaryKey: false;
|
|
225
|
+
isAutoincrement: false;
|
|
226
|
+
hasRuntimeDefault: false;
|
|
227
|
+
enumValues: ["active", "suspended"];
|
|
228
|
+
baseColumn: never;
|
|
229
|
+
identity: undefined;
|
|
230
|
+
generated: undefined;
|
|
231
|
+
}, {}, {}>;
|
|
232
|
+
lookTheme: import("drizzle-orm/pg-core").PgColumn<{
|
|
233
|
+
name: "look_theme";
|
|
234
|
+
tableName: "workspaces";
|
|
235
|
+
dataType: "string";
|
|
236
|
+
columnType: "PgText";
|
|
237
|
+
data: string;
|
|
238
|
+
driverParam: string;
|
|
239
|
+
notNull: false;
|
|
240
|
+
hasDefault: false;
|
|
241
|
+
isPrimaryKey: false;
|
|
242
|
+
isAutoincrement: false;
|
|
243
|
+
hasRuntimeDefault: false;
|
|
244
|
+
enumValues: [string, ...string[]];
|
|
245
|
+
baseColumn: never;
|
|
246
|
+
identity: undefined;
|
|
247
|
+
generated: undefined;
|
|
248
|
+
}, {}, {}>;
|
|
249
|
+
lookPattern: import("drizzle-orm/pg-core").PgColumn<{
|
|
250
|
+
name: "look_pattern";
|
|
251
|
+
tableName: "workspaces";
|
|
252
|
+
dataType: "string";
|
|
253
|
+
columnType: "PgText";
|
|
254
|
+
data: string;
|
|
255
|
+
driverParam: string;
|
|
256
|
+
notNull: false;
|
|
257
|
+
hasDefault: false;
|
|
258
|
+
isPrimaryKey: false;
|
|
259
|
+
isAutoincrement: false;
|
|
260
|
+
hasRuntimeDefault: false;
|
|
261
|
+
enumValues: [string, ...string[]];
|
|
262
|
+
baseColumn: never;
|
|
263
|
+
identity: undefined;
|
|
264
|
+
generated: undefined;
|
|
265
|
+
}, {}, {}>;
|
|
266
|
+
lookField: import("drizzle-orm/pg-core").PgColumn<{
|
|
267
|
+
name: "look_field";
|
|
268
|
+
tableName: "workspaces";
|
|
269
|
+
dataType: "number";
|
|
270
|
+
columnType: "PgDoublePrecision";
|
|
271
|
+
data: number;
|
|
272
|
+
driverParam: string | number;
|
|
273
|
+
notNull: false;
|
|
274
|
+
hasDefault: false;
|
|
275
|
+
isPrimaryKey: false;
|
|
276
|
+
isAutoincrement: false;
|
|
277
|
+
hasRuntimeDefault: false;
|
|
278
|
+
enumValues: undefined;
|
|
279
|
+
baseColumn: never;
|
|
280
|
+
identity: undefined;
|
|
281
|
+
generated: undefined;
|
|
282
|
+
}, {}, {}>;
|
|
283
|
+
lookGrain: import("drizzle-orm/pg-core").PgColumn<{
|
|
284
|
+
name: "look_grain";
|
|
285
|
+
tableName: "workspaces";
|
|
286
|
+
dataType: "number";
|
|
287
|
+
columnType: "PgDoublePrecision";
|
|
288
|
+
data: number;
|
|
289
|
+
driverParam: string | number;
|
|
290
|
+
notNull: false;
|
|
291
|
+
hasDefault: false;
|
|
292
|
+
isPrimaryKey: false;
|
|
293
|
+
isAutoincrement: false;
|
|
294
|
+
hasRuntimeDefault: false;
|
|
295
|
+
enumValues: undefined;
|
|
296
|
+
baseColumn: never;
|
|
297
|
+
identity: undefined;
|
|
298
|
+
generated: undefined;
|
|
299
|
+
}, {}, {}>;
|
|
300
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
301
|
+
name: "created_at";
|
|
302
|
+
tableName: "workspaces";
|
|
303
|
+
dataType: "date";
|
|
304
|
+
columnType: "PgTimestamp";
|
|
305
|
+
data: Date;
|
|
306
|
+
driverParam: string;
|
|
307
|
+
notNull: true;
|
|
308
|
+
hasDefault: true;
|
|
309
|
+
isPrimaryKey: false;
|
|
310
|
+
isAutoincrement: false;
|
|
311
|
+
hasRuntimeDefault: false;
|
|
312
|
+
enumValues: undefined;
|
|
313
|
+
baseColumn: never;
|
|
314
|
+
identity: undefined;
|
|
315
|
+
generated: undefined;
|
|
316
|
+
}, {}, {}>;
|
|
317
|
+
};
|
|
318
|
+
dialect: "pg";
|
|
319
|
+
}>;
|
|
320
|
+
export declare const workspaceRoles: readonly ["owner", "admin", "member"];
|
|
321
|
+
export type WorkspaceRole = (typeof workspaceRoles)[number];
|
|
322
|
+
/**
|
|
323
|
+
* Where a membership row came from — who its source of truth is (G2,
|
|
324
|
+
* the cloud-binding plan §5). Pure data in Phase 1 (no enforcement):
|
|
325
|
+
*
|
|
326
|
+
* - 'local': created by setup, workspace invitations, or admin surfaces —
|
|
327
|
+
* this instance owns it.
|
|
328
|
+
* - 'hub': created/updated ONLY by the cloud edition's SSO JIT projection
|
|
329
|
+
* and re-asserted against the hub (Phase 3+); local surfaces never mint it.
|
|
330
|
+
* - 'guest': created by the collaborator claim path — an external party
|
|
331
|
+
* invited to ONE resource whose membership exists only because principal
|
|
332
|
+
* resolution requires one. Excluded from hub re-assertion; guest
|
|
333
|
+
* capability limits arrive in Phase 6.
|
|
334
|
+
*
|
|
335
|
+
* No backfill needed: pre-launch, no production data — the default covers
|
|
336
|
+
* every existing row's honest origin.
|
|
337
|
+
*/
|
|
338
|
+
export declare const workspaceMemberOrigins: readonly ["local", "hub", "guest"];
|
|
339
|
+
export type WorkspaceMemberOrigin = (typeof workspaceMemberOrigins)[number];
|
|
340
|
+
export declare const workspaceMembers: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
341
|
+
name: "workspace_members";
|
|
342
|
+
schema: undefined;
|
|
343
|
+
columns: {
|
|
344
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
345
|
+
name: "id";
|
|
346
|
+
tableName: "workspace_members";
|
|
347
|
+
dataType: "string";
|
|
348
|
+
columnType: "PgUUID";
|
|
349
|
+
data: string;
|
|
350
|
+
driverParam: string;
|
|
351
|
+
notNull: true;
|
|
352
|
+
hasDefault: true;
|
|
353
|
+
isPrimaryKey: true;
|
|
354
|
+
isAutoincrement: false;
|
|
355
|
+
hasRuntimeDefault: false;
|
|
356
|
+
enumValues: undefined;
|
|
357
|
+
baseColumn: never;
|
|
358
|
+
identity: undefined;
|
|
359
|
+
generated: undefined;
|
|
360
|
+
}, {}, {}>;
|
|
361
|
+
workspaceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
362
|
+
name: "workspace_id";
|
|
363
|
+
tableName: "workspace_members";
|
|
364
|
+
dataType: "string";
|
|
365
|
+
columnType: "PgUUID";
|
|
366
|
+
data: string;
|
|
367
|
+
driverParam: string;
|
|
368
|
+
notNull: true;
|
|
369
|
+
hasDefault: false;
|
|
370
|
+
isPrimaryKey: false;
|
|
371
|
+
isAutoincrement: false;
|
|
372
|
+
hasRuntimeDefault: false;
|
|
373
|
+
enumValues: undefined;
|
|
374
|
+
baseColumn: never;
|
|
375
|
+
identity: undefined;
|
|
376
|
+
generated: undefined;
|
|
377
|
+
}, {}, {}>;
|
|
378
|
+
userId: import("drizzle-orm/pg-core").PgColumn<{
|
|
379
|
+
name: "user_id";
|
|
380
|
+
tableName: "workspace_members";
|
|
381
|
+
dataType: "string";
|
|
382
|
+
columnType: "PgText";
|
|
383
|
+
data: string;
|
|
384
|
+
driverParam: string;
|
|
385
|
+
notNull: true;
|
|
386
|
+
hasDefault: false;
|
|
387
|
+
isPrimaryKey: false;
|
|
388
|
+
isAutoincrement: false;
|
|
389
|
+
hasRuntimeDefault: false;
|
|
390
|
+
enumValues: [string, ...string[]];
|
|
391
|
+
baseColumn: never;
|
|
392
|
+
identity: undefined;
|
|
393
|
+
generated: undefined;
|
|
394
|
+
}, {}, {}>;
|
|
395
|
+
role: import("drizzle-orm/pg-core").PgColumn<{
|
|
396
|
+
name: "role";
|
|
397
|
+
tableName: "workspace_members";
|
|
398
|
+
dataType: "string";
|
|
399
|
+
columnType: "PgText";
|
|
400
|
+
data: "owner" | "admin" | "member";
|
|
401
|
+
driverParam: string;
|
|
402
|
+
notNull: true;
|
|
403
|
+
hasDefault: true;
|
|
404
|
+
isPrimaryKey: false;
|
|
405
|
+
isAutoincrement: false;
|
|
406
|
+
hasRuntimeDefault: false;
|
|
407
|
+
enumValues: ["owner", "admin", "member"];
|
|
408
|
+
baseColumn: never;
|
|
409
|
+
identity: undefined;
|
|
410
|
+
generated: undefined;
|
|
411
|
+
}, {}, {}>;
|
|
412
|
+
origin: import("drizzle-orm/pg-core").PgColumn<{
|
|
413
|
+
name: "origin";
|
|
414
|
+
tableName: "workspace_members";
|
|
415
|
+
dataType: "string";
|
|
416
|
+
columnType: "PgText";
|
|
417
|
+
data: "local" | "hub" | "guest";
|
|
418
|
+
driverParam: string;
|
|
419
|
+
notNull: true;
|
|
420
|
+
hasDefault: true;
|
|
421
|
+
isPrimaryKey: false;
|
|
422
|
+
isAutoincrement: false;
|
|
423
|
+
hasRuntimeDefault: false;
|
|
424
|
+
enumValues: ["local", "hub", "guest"];
|
|
425
|
+
baseColumn: never;
|
|
426
|
+
identity: undefined;
|
|
427
|
+
generated: undefined;
|
|
428
|
+
}, {}, {}>;
|
|
429
|
+
isActive: import("drizzle-orm/pg-core").PgColumn<{
|
|
430
|
+
name: "is_active";
|
|
431
|
+
tableName: "workspace_members";
|
|
432
|
+
dataType: "boolean";
|
|
433
|
+
columnType: "PgBoolean";
|
|
434
|
+
data: boolean;
|
|
435
|
+
driverParam: boolean;
|
|
436
|
+
notNull: true;
|
|
437
|
+
hasDefault: true;
|
|
438
|
+
isPrimaryKey: false;
|
|
439
|
+
isAutoincrement: false;
|
|
440
|
+
hasRuntimeDefault: false;
|
|
441
|
+
enumValues: undefined;
|
|
442
|
+
baseColumn: never;
|
|
443
|
+
identity: undefined;
|
|
444
|
+
generated: undefined;
|
|
445
|
+
}, {}, {}>;
|
|
446
|
+
isDefault: import("drizzle-orm/pg-core").PgColumn<{
|
|
447
|
+
name: "is_default";
|
|
448
|
+
tableName: "workspace_members";
|
|
449
|
+
dataType: "boolean";
|
|
450
|
+
columnType: "PgBoolean";
|
|
451
|
+
data: boolean;
|
|
452
|
+
driverParam: boolean;
|
|
453
|
+
notNull: true;
|
|
454
|
+
hasDefault: true;
|
|
455
|
+
isPrimaryKey: false;
|
|
456
|
+
isAutoincrement: false;
|
|
457
|
+
hasRuntimeDefault: false;
|
|
458
|
+
enumValues: undefined;
|
|
459
|
+
baseColumn: never;
|
|
460
|
+
identity: undefined;
|
|
461
|
+
generated: undefined;
|
|
462
|
+
}, {}, {}>;
|
|
463
|
+
invitedBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
464
|
+
name: "invited_by";
|
|
465
|
+
tableName: "workspace_members";
|
|
466
|
+
dataType: "string";
|
|
467
|
+
columnType: "PgText";
|
|
468
|
+
data: string;
|
|
469
|
+
driverParam: string;
|
|
470
|
+
notNull: false;
|
|
471
|
+
hasDefault: false;
|
|
472
|
+
isPrimaryKey: false;
|
|
473
|
+
isAutoincrement: false;
|
|
474
|
+
hasRuntimeDefault: false;
|
|
475
|
+
enumValues: [string, ...string[]];
|
|
476
|
+
baseColumn: never;
|
|
477
|
+
identity: undefined;
|
|
478
|
+
generated: undefined;
|
|
479
|
+
}, {}, {}>;
|
|
480
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
481
|
+
name: "created_at";
|
|
482
|
+
tableName: "workspace_members";
|
|
483
|
+
dataType: "date";
|
|
484
|
+
columnType: "PgTimestamp";
|
|
485
|
+
data: Date;
|
|
486
|
+
driverParam: string;
|
|
487
|
+
notNull: true;
|
|
488
|
+
hasDefault: true;
|
|
489
|
+
isPrimaryKey: false;
|
|
490
|
+
isAutoincrement: false;
|
|
491
|
+
hasRuntimeDefault: false;
|
|
492
|
+
enumValues: undefined;
|
|
493
|
+
baseColumn: never;
|
|
494
|
+
identity: undefined;
|
|
495
|
+
generated: undefined;
|
|
496
|
+
}, {}, {}>;
|
|
497
|
+
lastSeenAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
498
|
+
name: "last_seen_at";
|
|
499
|
+
tableName: "workspace_members";
|
|
500
|
+
dataType: "date";
|
|
501
|
+
columnType: "PgTimestamp";
|
|
502
|
+
data: Date;
|
|
503
|
+
driverParam: string;
|
|
504
|
+
notNull: false;
|
|
505
|
+
hasDefault: false;
|
|
506
|
+
isPrimaryKey: false;
|
|
507
|
+
isAutoincrement: false;
|
|
508
|
+
hasRuntimeDefault: false;
|
|
509
|
+
enumValues: undefined;
|
|
510
|
+
baseColumn: never;
|
|
511
|
+
identity: undefined;
|
|
512
|
+
generated: undefined;
|
|
513
|
+
}, {}, {}>;
|
|
514
|
+
};
|
|
515
|
+
dialect: "pg";
|
|
516
|
+
}>;
|
|
517
|
+
/**
|
|
518
|
+
* Token-bearing invitations. Tokens are never stored — only their sha256 —
|
|
519
|
+
* and the acceptance link always works without SMTP (copyable link).
|
|
520
|
+
*
|
|
521
|
+
* Two tokens per invitation, one row: `token_hash` is the admin-visible
|
|
522
|
+
* copyable link (always returned by the create response), `email_token_hash`
|
|
523
|
+
* is a SECOND token that appears ONLY in the invitation email. Accepting with
|
|
524
|
+
* the emailed token proves control of the invited address (the admin never
|
|
525
|
+
* saw it), so that accept path may honestly set `emailVerified`; accepting
|
|
526
|
+
* with the copyable link proves nothing about the address. Nullable because
|
|
527
|
+
* pre-existing invitations (and rows from products that disable the email
|
|
528
|
+
* leg) have no emailed token.
|
|
529
|
+
*/
|
|
530
|
+
export declare const invitations: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
531
|
+
name: "invitations";
|
|
532
|
+
schema: undefined;
|
|
533
|
+
columns: {
|
|
534
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
535
|
+
name: "id";
|
|
536
|
+
tableName: "invitations";
|
|
537
|
+
dataType: "string";
|
|
538
|
+
columnType: "PgUUID";
|
|
539
|
+
data: string;
|
|
540
|
+
driverParam: string;
|
|
541
|
+
notNull: true;
|
|
542
|
+
hasDefault: true;
|
|
543
|
+
isPrimaryKey: true;
|
|
544
|
+
isAutoincrement: false;
|
|
545
|
+
hasRuntimeDefault: false;
|
|
546
|
+
enumValues: undefined;
|
|
547
|
+
baseColumn: never;
|
|
548
|
+
identity: undefined;
|
|
549
|
+
generated: undefined;
|
|
550
|
+
}, {}, {}>;
|
|
551
|
+
workspaceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
552
|
+
name: "workspace_id";
|
|
553
|
+
tableName: "invitations";
|
|
554
|
+
dataType: "string";
|
|
555
|
+
columnType: "PgUUID";
|
|
556
|
+
data: string;
|
|
557
|
+
driverParam: string;
|
|
558
|
+
notNull: true;
|
|
559
|
+
hasDefault: false;
|
|
560
|
+
isPrimaryKey: false;
|
|
561
|
+
isAutoincrement: false;
|
|
562
|
+
hasRuntimeDefault: false;
|
|
563
|
+
enumValues: undefined;
|
|
564
|
+
baseColumn: never;
|
|
565
|
+
identity: undefined;
|
|
566
|
+
generated: undefined;
|
|
567
|
+
}, {}, {}>;
|
|
568
|
+
email: import("drizzle-orm/pg-core").PgColumn<{
|
|
569
|
+
name: "email";
|
|
570
|
+
tableName: "invitations";
|
|
571
|
+
dataType: "string";
|
|
572
|
+
columnType: "PgText";
|
|
573
|
+
data: string;
|
|
574
|
+
driverParam: string;
|
|
575
|
+
notNull: true;
|
|
576
|
+
hasDefault: false;
|
|
577
|
+
isPrimaryKey: false;
|
|
578
|
+
isAutoincrement: false;
|
|
579
|
+
hasRuntimeDefault: false;
|
|
580
|
+
enumValues: [string, ...string[]];
|
|
581
|
+
baseColumn: never;
|
|
582
|
+
identity: undefined;
|
|
583
|
+
generated: undefined;
|
|
584
|
+
}, {}, {}>;
|
|
585
|
+
role: import("drizzle-orm/pg-core").PgColumn<{
|
|
586
|
+
name: "role";
|
|
587
|
+
tableName: "invitations";
|
|
588
|
+
dataType: "string";
|
|
589
|
+
columnType: "PgText";
|
|
590
|
+
data: "owner" | "admin" | "member";
|
|
591
|
+
driverParam: string;
|
|
592
|
+
notNull: true;
|
|
593
|
+
hasDefault: true;
|
|
594
|
+
isPrimaryKey: false;
|
|
595
|
+
isAutoincrement: false;
|
|
596
|
+
hasRuntimeDefault: false;
|
|
597
|
+
enumValues: ["owner", "admin", "member"];
|
|
598
|
+
baseColumn: never;
|
|
599
|
+
identity: undefined;
|
|
600
|
+
generated: undefined;
|
|
601
|
+
}, {}, {}>;
|
|
602
|
+
tokenHash: import("drizzle-orm/pg-core").PgColumn<{
|
|
603
|
+
name: "token_hash";
|
|
604
|
+
tableName: "invitations";
|
|
605
|
+
dataType: "string";
|
|
606
|
+
columnType: "PgText";
|
|
607
|
+
data: string;
|
|
608
|
+
driverParam: string;
|
|
609
|
+
notNull: true;
|
|
610
|
+
hasDefault: false;
|
|
611
|
+
isPrimaryKey: false;
|
|
612
|
+
isAutoincrement: false;
|
|
613
|
+
hasRuntimeDefault: false;
|
|
614
|
+
enumValues: [string, ...string[]];
|
|
615
|
+
baseColumn: never;
|
|
616
|
+
identity: undefined;
|
|
617
|
+
generated: undefined;
|
|
618
|
+
}, {}, {}>;
|
|
619
|
+
emailTokenHash: import("drizzle-orm/pg-core").PgColumn<{
|
|
620
|
+
name: "email_token_hash";
|
|
621
|
+
tableName: "invitations";
|
|
622
|
+
dataType: "string";
|
|
623
|
+
columnType: "PgText";
|
|
624
|
+
data: string;
|
|
625
|
+
driverParam: string;
|
|
626
|
+
notNull: false;
|
|
627
|
+
hasDefault: false;
|
|
628
|
+
isPrimaryKey: false;
|
|
629
|
+
isAutoincrement: false;
|
|
630
|
+
hasRuntimeDefault: false;
|
|
631
|
+
enumValues: [string, ...string[]];
|
|
632
|
+
baseColumn: never;
|
|
633
|
+
identity: undefined;
|
|
634
|
+
generated: undefined;
|
|
635
|
+
}, {}, {}>;
|
|
636
|
+
invitedBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
637
|
+
name: "invited_by";
|
|
638
|
+
tableName: "invitations";
|
|
639
|
+
dataType: "string";
|
|
640
|
+
columnType: "PgText";
|
|
641
|
+
data: string;
|
|
642
|
+
driverParam: string;
|
|
643
|
+
notNull: true;
|
|
644
|
+
hasDefault: false;
|
|
645
|
+
isPrimaryKey: false;
|
|
646
|
+
isAutoincrement: false;
|
|
647
|
+
hasRuntimeDefault: false;
|
|
648
|
+
enumValues: [string, ...string[]];
|
|
649
|
+
baseColumn: never;
|
|
650
|
+
identity: undefined;
|
|
651
|
+
generated: undefined;
|
|
652
|
+
}, {}, {}>;
|
|
653
|
+
expiresAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
654
|
+
name: "expires_at";
|
|
655
|
+
tableName: "invitations";
|
|
656
|
+
dataType: "date";
|
|
657
|
+
columnType: "PgTimestamp";
|
|
658
|
+
data: Date;
|
|
659
|
+
driverParam: string;
|
|
660
|
+
notNull: true;
|
|
661
|
+
hasDefault: false;
|
|
662
|
+
isPrimaryKey: false;
|
|
663
|
+
isAutoincrement: false;
|
|
664
|
+
hasRuntimeDefault: false;
|
|
665
|
+
enumValues: undefined;
|
|
666
|
+
baseColumn: never;
|
|
667
|
+
identity: undefined;
|
|
668
|
+
generated: undefined;
|
|
669
|
+
}, {}, {}>;
|
|
670
|
+
acceptedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
671
|
+
name: "accepted_at";
|
|
672
|
+
tableName: "invitations";
|
|
673
|
+
dataType: "date";
|
|
674
|
+
columnType: "PgTimestamp";
|
|
675
|
+
data: Date;
|
|
676
|
+
driverParam: string;
|
|
677
|
+
notNull: false;
|
|
678
|
+
hasDefault: false;
|
|
679
|
+
isPrimaryKey: false;
|
|
680
|
+
isAutoincrement: false;
|
|
681
|
+
hasRuntimeDefault: false;
|
|
682
|
+
enumValues: undefined;
|
|
683
|
+
baseColumn: never;
|
|
684
|
+
identity: undefined;
|
|
685
|
+
generated: undefined;
|
|
686
|
+
}, {}, {}>;
|
|
687
|
+
revokedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
688
|
+
name: "revoked_at";
|
|
689
|
+
tableName: "invitations";
|
|
690
|
+
dataType: "date";
|
|
691
|
+
columnType: "PgTimestamp";
|
|
692
|
+
data: Date;
|
|
693
|
+
driverParam: string;
|
|
694
|
+
notNull: false;
|
|
695
|
+
hasDefault: false;
|
|
696
|
+
isPrimaryKey: false;
|
|
697
|
+
isAutoincrement: false;
|
|
698
|
+
hasRuntimeDefault: false;
|
|
699
|
+
enumValues: undefined;
|
|
700
|
+
baseColumn: never;
|
|
701
|
+
identity: undefined;
|
|
702
|
+
generated: undefined;
|
|
703
|
+
}, {}, {}>;
|
|
704
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
705
|
+
name: "created_at";
|
|
706
|
+
tableName: "invitations";
|
|
707
|
+
dataType: "date";
|
|
708
|
+
columnType: "PgTimestamp";
|
|
709
|
+
data: Date;
|
|
710
|
+
driverParam: string;
|
|
711
|
+
notNull: true;
|
|
712
|
+
hasDefault: true;
|
|
713
|
+
isPrimaryKey: false;
|
|
714
|
+
isAutoincrement: false;
|
|
715
|
+
hasRuntimeDefault: false;
|
|
716
|
+
enumValues: undefined;
|
|
717
|
+
baseColumn: never;
|
|
718
|
+
identity: undefined;
|
|
719
|
+
generated: undefined;
|
|
720
|
+
}, {}, {}>;
|
|
721
|
+
};
|
|
722
|
+
dialect: "pg";
|
|
723
|
+
}>;
|
|
724
|
+
/**
|
|
725
|
+
* Demo passes (the demo pass spec, section 3): a link an owner mints so that
|
|
726
|
+
* ONE member of the workspace is signed in without a password, for a
|
|
727
|
+
* demonstration. Only while DEMO_SIGN_IN is on, on the self-hosted edition.
|
|
728
|
+
* The secret is sign-in-equivalent, so it is stored nowhere: `secret_hash`
|
|
729
|
+
* is its sha256 hex, looked up through the unique index at redeem, the same
|
|
730
|
+
* shape as the invitation tokens. A pass is revoked, never deleted by a
|
|
731
|
+
* route; it goes with its workspace or its person.
|
|
732
|
+
*/
|
|
733
|
+
export declare const demoPasses: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
734
|
+
name: "demo_passes";
|
|
735
|
+
schema: undefined;
|
|
736
|
+
columns: {
|
|
737
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
738
|
+
name: "id";
|
|
739
|
+
tableName: "demo_passes";
|
|
740
|
+
dataType: "string";
|
|
741
|
+
columnType: "PgUUID";
|
|
742
|
+
data: string;
|
|
743
|
+
driverParam: string;
|
|
744
|
+
notNull: true;
|
|
745
|
+
hasDefault: true;
|
|
746
|
+
isPrimaryKey: true;
|
|
747
|
+
isAutoincrement: false;
|
|
748
|
+
hasRuntimeDefault: false;
|
|
749
|
+
enumValues: undefined;
|
|
750
|
+
baseColumn: never;
|
|
751
|
+
identity: undefined;
|
|
752
|
+
generated: undefined;
|
|
753
|
+
}, {}, {}>;
|
|
754
|
+
workspaceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
755
|
+
name: "workspace_id";
|
|
756
|
+
tableName: "demo_passes";
|
|
757
|
+
dataType: "string";
|
|
758
|
+
columnType: "PgUUID";
|
|
759
|
+
data: string;
|
|
760
|
+
driverParam: string;
|
|
761
|
+
notNull: true;
|
|
762
|
+
hasDefault: false;
|
|
763
|
+
isPrimaryKey: false;
|
|
764
|
+
isAutoincrement: false;
|
|
765
|
+
hasRuntimeDefault: false;
|
|
766
|
+
enumValues: undefined;
|
|
767
|
+
baseColumn: never;
|
|
768
|
+
identity: undefined;
|
|
769
|
+
generated: undefined;
|
|
770
|
+
}, {}, {}>;
|
|
771
|
+
userId: import("drizzle-orm/pg-core").PgColumn<{
|
|
772
|
+
name: "user_id";
|
|
773
|
+
tableName: "demo_passes";
|
|
774
|
+
dataType: "string";
|
|
775
|
+
columnType: "PgText";
|
|
776
|
+
data: string;
|
|
777
|
+
driverParam: string;
|
|
778
|
+
notNull: true;
|
|
779
|
+
hasDefault: false;
|
|
780
|
+
isPrimaryKey: false;
|
|
781
|
+
isAutoincrement: false;
|
|
782
|
+
hasRuntimeDefault: false;
|
|
783
|
+
enumValues: [string, ...string[]];
|
|
784
|
+
baseColumn: never;
|
|
785
|
+
identity: undefined;
|
|
786
|
+
generated: undefined;
|
|
787
|
+
}, {}, {}>;
|
|
788
|
+
targetPath: import("drizzle-orm/pg-core").PgColumn<{
|
|
789
|
+
name: "target_path";
|
|
790
|
+
tableName: "demo_passes";
|
|
791
|
+
dataType: "string";
|
|
792
|
+
columnType: "PgText";
|
|
793
|
+
data: string;
|
|
794
|
+
driverParam: string;
|
|
795
|
+
notNull: true;
|
|
796
|
+
hasDefault: true;
|
|
797
|
+
isPrimaryKey: false;
|
|
798
|
+
isAutoincrement: false;
|
|
799
|
+
hasRuntimeDefault: false;
|
|
800
|
+
enumValues: [string, ...string[]];
|
|
801
|
+
baseColumn: never;
|
|
802
|
+
identity: undefined;
|
|
803
|
+
generated: undefined;
|
|
804
|
+
}, {}, {}>;
|
|
805
|
+
secretHash: import("drizzle-orm/pg-core").PgColumn<{
|
|
806
|
+
name: "secret_hash";
|
|
807
|
+
tableName: "demo_passes";
|
|
808
|
+
dataType: "string";
|
|
809
|
+
columnType: "PgText";
|
|
810
|
+
data: string;
|
|
811
|
+
driverParam: string;
|
|
812
|
+
notNull: true;
|
|
813
|
+
hasDefault: false;
|
|
814
|
+
isPrimaryKey: false;
|
|
815
|
+
isAutoincrement: false;
|
|
816
|
+
hasRuntimeDefault: false;
|
|
817
|
+
enumValues: [string, ...string[]];
|
|
818
|
+
baseColumn: never;
|
|
819
|
+
identity: undefined;
|
|
820
|
+
generated: undefined;
|
|
821
|
+
}, {}, {}>;
|
|
822
|
+
createdBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
823
|
+
name: "created_by";
|
|
824
|
+
tableName: "demo_passes";
|
|
825
|
+
dataType: "string";
|
|
826
|
+
columnType: "PgText";
|
|
827
|
+
data: string;
|
|
828
|
+
driverParam: string;
|
|
829
|
+
notNull: false;
|
|
830
|
+
hasDefault: false;
|
|
831
|
+
isPrimaryKey: false;
|
|
832
|
+
isAutoincrement: false;
|
|
833
|
+
hasRuntimeDefault: false;
|
|
834
|
+
enumValues: [string, ...string[]];
|
|
835
|
+
baseColumn: never;
|
|
836
|
+
identity: undefined;
|
|
837
|
+
generated: undefined;
|
|
838
|
+
}, {}, {}>;
|
|
839
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
840
|
+
name: "created_at";
|
|
841
|
+
tableName: "demo_passes";
|
|
842
|
+
dataType: "date";
|
|
843
|
+
columnType: "PgTimestamp";
|
|
844
|
+
data: Date;
|
|
845
|
+
driverParam: string;
|
|
846
|
+
notNull: true;
|
|
847
|
+
hasDefault: true;
|
|
848
|
+
isPrimaryKey: false;
|
|
849
|
+
isAutoincrement: false;
|
|
850
|
+
hasRuntimeDefault: false;
|
|
851
|
+
enumValues: undefined;
|
|
852
|
+
baseColumn: never;
|
|
853
|
+
identity: undefined;
|
|
854
|
+
generated: undefined;
|
|
855
|
+
}, {}, {}>;
|
|
856
|
+
expiresAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
857
|
+
name: "expires_at";
|
|
858
|
+
tableName: "demo_passes";
|
|
859
|
+
dataType: "date";
|
|
860
|
+
columnType: "PgTimestamp";
|
|
861
|
+
data: Date;
|
|
862
|
+
driverParam: string;
|
|
863
|
+
notNull: true;
|
|
864
|
+
hasDefault: false;
|
|
865
|
+
isPrimaryKey: false;
|
|
866
|
+
isAutoincrement: false;
|
|
867
|
+
hasRuntimeDefault: false;
|
|
868
|
+
enumValues: undefined;
|
|
869
|
+
baseColumn: never;
|
|
870
|
+
identity: undefined;
|
|
871
|
+
generated: undefined;
|
|
872
|
+
}, {}, {}>;
|
|
873
|
+
revokedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
874
|
+
name: "revoked_at";
|
|
875
|
+
tableName: "demo_passes";
|
|
876
|
+
dataType: "date";
|
|
877
|
+
columnType: "PgTimestamp";
|
|
878
|
+
data: Date;
|
|
879
|
+
driverParam: string;
|
|
880
|
+
notNull: false;
|
|
881
|
+
hasDefault: false;
|
|
882
|
+
isPrimaryKey: false;
|
|
883
|
+
isAutoincrement: false;
|
|
884
|
+
hasRuntimeDefault: false;
|
|
885
|
+
enumValues: undefined;
|
|
886
|
+
baseColumn: never;
|
|
887
|
+
identity: undefined;
|
|
888
|
+
generated: undefined;
|
|
889
|
+
}, {}, {}>;
|
|
890
|
+
lastUsedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
891
|
+
name: "last_used_at";
|
|
892
|
+
tableName: "demo_passes";
|
|
893
|
+
dataType: "date";
|
|
894
|
+
columnType: "PgTimestamp";
|
|
895
|
+
data: Date;
|
|
896
|
+
driverParam: string;
|
|
897
|
+
notNull: false;
|
|
898
|
+
hasDefault: false;
|
|
899
|
+
isPrimaryKey: false;
|
|
900
|
+
isAutoincrement: false;
|
|
901
|
+
hasRuntimeDefault: false;
|
|
902
|
+
enumValues: undefined;
|
|
903
|
+
baseColumn: never;
|
|
904
|
+
identity: undefined;
|
|
905
|
+
generated: undefined;
|
|
906
|
+
}, {}, {}>;
|
|
907
|
+
useCount: import("drizzle-orm/pg-core").PgColumn<{
|
|
908
|
+
name: "use_count";
|
|
909
|
+
tableName: "demo_passes";
|
|
910
|
+
dataType: "number";
|
|
911
|
+
columnType: "PgInteger";
|
|
912
|
+
data: number;
|
|
913
|
+
driverParam: string | number;
|
|
914
|
+
notNull: true;
|
|
915
|
+
hasDefault: true;
|
|
916
|
+
isPrimaryKey: false;
|
|
917
|
+
isAutoincrement: false;
|
|
918
|
+
hasRuntimeDefault: false;
|
|
919
|
+
enumValues: undefined;
|
|
920
|
+
baseColumn: never;
|
|
921
|
+
identity: undefined;
|
|
922
|
+
generated: undefined;
|
|
923
|
+
}, {}, {}>;
|
|
924
|
+
};
|
|
925
|
+
dialect: "pg";
|
|
926
|
+
}>;
|
|
927
|
+
/**
|
|
928
|
+
* One row per session a demo pass opened (`session_id` is the Better Auth
|
|
929
|
+
* `session.id`). It is what marks the audit rows written under such a
|
|
930
|
+
* session with `metadata.demoPassId`, so a workspace's trail tells what was
|
|
931
|
+
* done through a demo link from what the person did themselves.
|
|
932
|
+
*/
|
|
933
|
+
export declare const demoPassSessions: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
934
|
+
name: "demo_pass_sessions";
|
|
935
|
+
schema: undefined;
|
|
936
|
+
columns: {
|
|
937
|
+
sessionId: import("drizzle-orm/pg-core").PgColumn<{
|
|
938
|
+
name: "session_id";
|
|
939
|
+
tableName: "demo_pass_sessions";
|
|
940
|
+
dataType: "string";
|
|
941
|
+
columnType: "PgText";
|
|
942
|
+
data: string;
|
|
943
|
+
driverParam: string;
|
|
944
|
+
notNull: true;
|
|
945
|
+
hasDefault: false;
|
|
946
|
+
isPrimaryKey: true;
|
|
947
|
+
isAutoincrement: false;
|
|
948
|
+
hasRuntimeDefault: false;
|
|
949
|
+
enumValues: [string, ...string[]];
|
|
950
|
+
baseColumn: never;
|
|
951
|
+
identity: undefined;
|
|
952
|
+
generated: undefined;
|
|
953
|
+
}, {}, {}>;
|
|
954
|
+
passId: import("drizzle-orm/pg-core").PgColumn<{
|
|
955
|
+
name: "pass_id";
|
|
956
|
+
tableName: "demo_pass_sessions";
|
|
957
|
+
dataType: "string";
|
|
958
|
+
columnType: "PgUUID";
|
|
959
|
+
data: string;
|
|
960
|
+
driverParam: string;
|
|
961
|
+
notNull: true;
|
|
962
|
+
hasDefault: false;
|
|
963
|
+
isPrimaryKey: false;
|
|
964
|
+
isAutoincrement: false;
|
|
965
|
+
hasRuntimeDefault: false;
|
|
966
|
+
enumValues: undefined;
|
|
967
|
+
baseColumn: never;
|
|
968
|
+
identity: undefined;
|
|
969
|
+
generated: undefined;
|
|
970
|
+
}, {}, {}>;
|
|
971
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
972
|
+
name: "created_at";
|
|
973
|
+
tableName: "demo_pass_sessions";
|
|
974
|
+
dataType: "date";
|
|
975
|
+
columnType: "PgTimestamp";
|
|
976
|
+
data: Date;
|
|
977
|
+
driverParam: string;
|
|
978
|
+
notNull: true;
|
|
979
|
+
hasDefault: true;
|
|
980
|
+
isPrimaryKey: false;
|
|
981
|
+
isAutoincrement: false;
|
|
982
|
+
hasRuntimeDefault: false;
|
|
983
|
+
enumValues: undefined;
|
|
984
|
+
baseColumn: never;
|
|
985
|
+
identity: undefined;
|
|
986
|
+
generated: undefined;
|
|
987
|
+
}, {}, {}>;
|
|
988
|
+
};
|
|
989
|
+
dialect: "pg";
|
|
990
|
+
}>;
|
|
991
|
+
/**
|
|
992
|
+
* API keys: `<prefix>_<keyId8>_<secret>`. keyId gives O(1) indexed lookup;
|
|
993
|
+
* the secret is stored as sha256(secret + server pepper) and compared in
|
|
994
|
+
* constant time. Minted by sessions only — a key never mints a key.
|
|
995
|
+
*
|
|
996
|
+
* A key is a USER credential (user-scoped credential model): it acts as its
|
|
997
|
+
* creator, and the target workspace is chosen per request (X-Workspace-Id /
|
|
998
|
+
* the user's default) against the creator's LIVE memberships. `workspace_id`
|
|
999
|
+
* is an OPTIONAL PIN, not the identity: NULL (the mint default) = the key
|
|
1000
|
+
* reaches any workspace its creator is an active member of; a value pins the
|
|
1001
|
+
* key to that ONE workspace forever (least privilege — and the grandfathered
|
|
1002
|
+
* behavior of every key minted before the model change, which stays exactly
|
|
1003
|
+
* as issued).
|
|
1004
|
+
*/
|
|
1005
|
+
export declare const apiKeys: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
1006
|
+
name: "api_keys";
|
|
1007
|
+
schema: undefined;
|
|
1008
|
+
columns: {
|
|
1009
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
1010
|
+
name: "id";
|
|
1011
|
+
tableName: "api_keys";
|
|
1012
|
+
dataType: "string";
|
|
1013
|
+
columnType: "PgUUID";
|
|
1014
|
+
data: string;
|
|
1015
|
+
driverParam: string;
|
|
1016
|
+
notNull: true;
|
|
1017
|
+
hasDefault: true;
|
|
1018
|
+
isPrimaryKey: true;
|
|
1019
|
+
isAutoincrement: false;
|
|
1020
|
+
hasRuntimeDefault: false;
|
|
1021
|
+
enumValues: undefined;
|
|
1022
|
+
baseColumn: never;
|
|
1023
|
+
identity: undefined;
|
|
1024
|
+
generated: undefined;
|
|
1025
|
+
}, {}, {}>;
|
|
1026
|
+
workspaceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1027
|
+
name: "workspace_id";
|
|
1028
|
+
tableName: "api_keys";
|
|
1029
|
+
dataType: "string";
|
|
1030
|
+
columnType: "PgUUID";
|
|
1031
|
+
data: string;
|
|
1032
|
+
driverParam: string;
|
|
1033
|
+
notNull: false;
|
|
1034
|
+
hasDefault: false;
|
|
1035
|
+
isPrimaryKey: false;
|
|
1036
|
+
isAutoincrement: false;
|
|
1037
|
+
hasRuntimeDefault: false;
|
|
1038
|
+
enumValues: undefined;
|
|
1039
|
+
baseColumn: never;
|
|
1040
|
+
identity: undefined;
|
|
1041
|
+
generated: undefined;
|
|
1042
|
+
}, {}, {}>;
|
|
1043
|
+
keyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1044
|
+
name: "key_id";
|
|
1045
|
+
tableName: "api_keys";
|
|
1046
|
+
dataType: "string";
|
|
1047
|
+
columnType: "PgText";
|
|
1048
|
+
data: string;
|
|
1049
|
+
driverParam: string;
|
|
1050
|
+
notNull: true;
|
|
1051
|
+
hasDefault: false;
|
|
1052
|
+
isPrimaryKey: false;
|
|
1053
|
+
isAutoincrement: false;
|
|
1054
|
+
hasRuntimeDefault: false;
|
|
1055
|
+
enumValues: [string, ...string[]];
|
|
1056
|
+
baseColumn: never;
|
|
1057
|
+
identity: undefined;
|
|
1058
|
+
generated: undefined;
|
|
1059
|
+
}, {}, {}>;
|
|
1060
|
+
secretHash: import("drizzle-orm/pg-core").PgColumn<{
|
|
1061
|
+
name: "secret_hash";
|
|
1062
|
+
tableName: "api_keys";
|
|
1063
|
+
dataType: "string";
|
|
1064
|
+
columnType: "PgText";
|
|
1065
|
+
data: string;
|
|
1066
|
+
driverParam: string;
|
|
1067
|
+
notNull: true;
|
|
1068
|
+
hasDefault: false;
|
|
1069
|
+
isPrimaryKey: false;
|
|
1070
|
+
isAutoincrement: false;
|
|
1071
|
+
hasRuntimeDefault: false;
|
|
1072
|
+
enumValues: [string, ...string[]];
|
|
1073
|
+
baseColumn: never;
|
|
1074
|
+
identity: undefined;
|
|
1075
|
+
generated: undefined;
|
|
1076
|
+
}, {}, {}>;
|
|
1077
|
+
pepperVersion: import("drizzle-orm/pg-core").PgColumn<{
|
|
1078
|
+
name: "pepper_version";
|
|
1079
|
+
tableName: "api_keys";
|
|
1080
|
+
dataType: "number";
|
|
1081
|
+
columnType: "PgSmallInt";
|
|
1082
|
+
data: number;
|
|
1083
|
+
driverParam: string | number;
|
|
1084
|
+
notNull: true;
|
|
1085
|
+
hasDefault: true;
|
|
1086
|
+
isPrimaryKey: false;
|
|
1087
|
+
isAutoincrement: false;
|
|
1088
|
+
hasRuntimeDefault: false;
|
|
1089
|
+
enumValues: undefined;
|
|
1090
|
+
baseColumn: never;
|
|
1091
|
+
identity: undefined;
|
|
1092
|
+
generated: undefined;
|
|
1093
|
+
}, {}, {}>;
|
|
1094
|
+
name: import("drizzle-orm/pg-core").PgColumn<{
|
|
1095
|
+
name: "name";
|
|
1096
|
+
tableName: "api_keys";
|
|
1097
|
+
dataType: "string";
|
|
1098
|
+
columnType: "PgText";
|
|
1099
|
+
data: string;
|
|
1100
|
+
driverParam: string;
|
|
1101
|
+
notNull: true;
|
|
1102
|
+
hasDefault: false;
|
|
1103
|
+
isPrimaryKey: false;
|
|
1104
|
+
isAutoincrement: false;
|
|
1105
|
+
hasRuntimeDefault: false;
|
|
1106
|
+
enumValues: [string, ...string[]];
|
|
1107
|
+
baseColumn: never;
|
|
1108
|
+
identity: undefined;
|
|
1109
|
+
generated: undefined;
|
|
1110
|
+
}, {}, {}>;
|
|
1111
|
+
scopes: import("drizzle-orm/pg-core").PgColumn<{
|
|
1112
|
+
name: "scopes";
|
|
1113
|
+
tableName: "api_keys";
|
|
1114
|
+
dataType: "array";
|
|
1115
|
+
columnType: "PgArray";
|
|
1116
|
+
data: string[];
|
|
1117
|
+
driverParam: string | string[];
|
|
1118
|
+
notNull: true;
|
|
1119
|
+
hasDefault: false;
|
|
1120
|
+
isPrimaryKey: false;
|
|
1121
|
+
isAutoincrement: false;
|
|
1122
|
+
hasRuntimeDefault: false;
|
|
1123
|
+
enumValues: [string, ...string[]];
|
|
1124
|
+
baseColumn: import("drizzle-orm").Column<{
|
|
1125
|
+
name: "scopes";
|
|
1126
|
+
tableName: "api_keys";
|
|
1127
|
+
dataType: "string";
|
|
1128
|
+
columnType: "PgText";
|
|
1129
|
+
data: string;
|
|
1130
|
+
driverParam: string;
|
|
1131
|
+
notNull: false;
|
|
1132
|
+
hasDefault: false;
|
|
1133
|
+
isPrimaryKey: false;
|
|
1134
|
+
isAutoincrement: false;
|
|
1135
|
+
hasRuntimeDefault: false;
|
|
1136
|
+
enumValues: [string, ...string[]];
|
|
1137
|
+
baseColumn: never;
|
|
1138
|
+
identity: undefined;
|
|
1139
|
+
generated: undefined;
|
|
1140
|
+
}, {}, {}>;
|
|
1141
|
+
identity: undefined;
|
|
1142
|
+
generated: undefined;
|
|
1143
|
+
}, {}, {
|
|
1144
|
+
baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
|
|
1145
|
+
name: "scopes";
|
|
1146
|
+
dataType: "string";
|
|
1147
|
+
columnType: "PgText";
|
|
1148
|
+
data: string;
|
|
1149
|
+
enumValues: [string, ...string[]];
|
|
1150
|
+
driverParam: string;
|
|
1151
|
+
}, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
|
|
1152
|
+
size: undefined;
|
|
1153
|
+
}>;
|
|
1154
|
+
createdBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
1155
|
+
name: "created_by";
|
|
1156
|
+
tableName: "api_keys";
|
|
1157
|
+
dataType: "string";
|
|
1158
|
+
columnType: "PgText";
|
|
1159
|
+
data: string;
|
|
1160
|
+
driverParam: string;
|
|
1161
|
+
notNull: true;
|
|
1162
|
+
hasDefault: false;
|
|
1163
|
+
isPrimaryKey: false;
|
|
1164
|
+
isAutoincrement: false;
|
|
1165
|
+
hasRuntimeDefault: false;
|
|
1166
|
+
enumValues: [string, ...string[]];
|
|
1167
|
+
baseColumn: never;
|
|
1168
|
+
identity: undefined;
|
|
1169
|
+
generated: undefined;
|
|
1170
|
+
}, {}, {}>;
|
|
1171
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1172
|
+
name: "created_at";
|
|
1173
|
+
tableName: "api_keys";
|
|
1174
|
+
dataType: "date";
|
|
1175
|
+
columnType: "PgTimestamp";
|
|
1176
|
+
data: Date;
|
|
1177
|
+
driverParam: string;
|
|
1178
|
+
notNull: true;
|
|
1179
|
+
hasDefault: true;
|
|
1180
|
+
isPrimaryKey: false;
|
|
1181
|
+
isAutoincrement: false;
|
|
1182
|
+
hasRuntimeDefault: false;
|
|
1183
|
+
enumValues: undefined;
|
|
1184
|
+
baseColumn: never;
|
|
1185
|
+
identity: undefined;
|
|
1186
|
+
generated: undefined;
|
|
1187
|
+
}, {}, {}>;
|
|
1188
|
+
lastUsedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1189
|
+
name: "last_used_at";
|
|
1190
|
+
tableName: "api_keys";
|
|
1191
|
+
dataType: "date";
|
|
1192
|
+
columnType: "PgTimestamp";
|
|
1193
|
+
data: Date;
|
|
1194
|
+
driverParam: string;
|
|
1195
|
+
notNull: false;
|
|
1196
|
+
hasDefault: false;
|
|
1197
|
+
isPrimaryKey: false;
|
|
1198
|
+
isAutoincrement: false;
|
|
1199
|
+
hasRuntimeDefault: false;
|
|
1200
|
+
enumValues: undefined;
|
|
1201
|
+
baseColumn: never;
|
|
1202
|
+
identity: undefined;
|
|
1203
|
+
generated: undefined;
|
|
1204
|
+
}, {}, {}>;
|
|
1205
|
+
revokedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1206
|
+
name: "revoked_at";
|
|
1207
|
+
tableName: "api_keys";
|
|
1208
|
+
dataType: "date";
|
|
1209
|
+
columnType: "PgTimestamp";
|
|
1210
|
+
data: Date;
|
|
1211
|
+
driverParam: string;
|
|
1212
|
+
notNull: false;
|
|
1213
|
+
hasDefault: false;
|
|
1214
|
+
isPrimaryKey: false;
|
|
1215
|
+
isAutoincrement: false;
|
|
1216
|
+
hasRuntimeDefault: false;
|
|
1217
|
+
enumValues: undefined;
|
|
1218
|
+
baseColumn: never;
|
|
1219
|
+
identity: undefined;
|
|
1220
|
+
generated: undefined;
|
|
1221
|
+
}, {}, {}>;
|
|
1222
|
+
expiresAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1223
|
+
name: "expires_at";
|
|
1224
|
+
tableName: "api_keys";
|
|
1225
|
+
dataType: "date";
|
|
1226
|
+
columnType: "PgTimestamp";
|
|
1227
|
+
data: Date;
|
|
1228
|
+
driverParam: string;
|
|
1229
|
+
notNull: false;
|
|
1230
|
+
hasDefault: false;
|
|
1231
|
+
isPrimaryKey: false;
|
|
1232
|
+
isAutoincrement: false;
|
|
1233
|
+
hasRuntimeDefault: false;
|
|
1234
|
+
enumValues: undefined;
|
|
1235
|
+
baseColumn: never;
|
|
1236
|
+
identity: undefined;
|
|
1237
|
+
generated: undefined;
|
|
1238
|
+
}, {}, {}>;
|
|
1239
|
+
};
|
|
1240
|
+
dialect: "pg";
|
|
1241
|
+
}>;
|
|
1242
|
+
/**
|
|
1243
|
+
* Idempotency-Key replay store for the non-idempotent create POSTs. One row
|
|
1244
|
+
* per (workspace, user, client key): claimed (insert-first) before the
|
|
1245
|
+
* handler runs, then filled with the response so a retried create replays
|
|
1246
|
+
* instead of double-creating. The body is stored AES-256-GCM encrypted
|
|
1247
|
+
* (see apps/server middleware/idempotency.ts) because these responses carry
|
|
1248
|
+
* one-shot secrets — the full API key, the invitation accept token, the
|
|
1249
|
+
* reset link — whose plaintext is deliberately never persisted anywhere
|
|
1250
|
+
* else. Rows live 24h; a nightly purge deletes expired ones.
|
|
1251
|
+
*/
|
|
1252
|
+
export declare const idempotencyKeys: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
1253
|
+
name: "idempotency_keys";
|
|
1254
|
+
schema: undefined;
|
|
1255
|
+
columns: {
|
|
1256
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
1257
|
+
name: "id";
|
|
1258
|
+
tableName: "idempotency_keys";
|
|
1259
|
+
dataType: "string";
|
|
1260
|
+
columnType: "PgUUID";
|
|
1261
|
+
data: string;
|
|
1262
|
+
driverParam: string;
|
|
1263
|
+
notNull: true;
|
|
1264
|
+
hasDefault: true;
|
|
1265
|
+
isPrimaryKey: true;
|
|
1266
|
+
isAutoincrement: false;
|
|
1267
|
+
hasRuntimeDefault: false;
|
|
1268
|
+
enumValues: undefined;
|
|
1269
|
+
baseColumn: never;
|
|
1270
|
+
identity: undefined;
|
|
1271
|
+
generated: undefined;
|
|
1272
|
+
}, {}, {}>;
|
|
1273
|
+
workspaceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1274
|
+
name: "workspace_id";
|
|
1275
|
+
tableName: "idempotency_keys";
|
|
1276
|
+
dataType: "string";
|
|
1277
|
+
columnType: "PgUUID";
|
|
1278
|
+
data: string;
|
|
1279
|
+
driverParam: string;
|
|
1280
|
+
notNull: true;
|
|
1281
|
+
hasDefault: false;
|
|
1282
|
+
isPrimaryKey: false;
|
|
1283
|
+
isAutoincrement: false;
|
|
1284
|
+
hasRuntimeDefault: false;
|
|
1285
|
+
enumValues: undefined;
|
|
1286
|
+
baseColumn: never;
|
|
1287
|
+
identity: undefined;
|
|
1288
|
+
generated: undefined;
|
|
1289
|
+
}, {}, {}>;
|
|
1290
|
+
userId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1291
|
+
name: "user_id";
|
|
1292
|
+
tableName: "idempotency_keys";
|
|
1293
|
+
dataType: "string";
|
|
1294
|
+
columnType: "PgText";
|
|
1295
|
+
data: string;
|
|
1296
|
+
driverParam: string;
|
|
1297
|
+
notNull: true;
|
|
1298
|
+
hasDefault: false;
|
|
1299
|
+
isPrimaryKey: false;
|
|
1300
|
+
isAutoincrement: false;
|
|
1301
|
+
hasRuntimeDefault: false;
|
|
1302
|
+
enumValues: [string, ...string[]];
|
|
1303
|
+
baseColumn: never;
|
|
1304
|
+
identity: undefined;
|
|
1305
|
+
generated: undefined;
|
|
1306
|
+
}, {}, {}>;
|
|
1307
|
+
key: import("drizzle-orm/pg-core").PgColumn<{
|
|
1308
|
+
name: "key";
|
|
1309
|
+
tableName: "idempotency_keys";
|
|
1310
|
+
dataType: "string";
|
|
1311
|
+
columnType: "PgText";
|
|
1312
|
+
data: string;
|
|
1313
|
+
driverParam: string;
|
|
1314
|
+
notNull: true;
|
|
1315
|
+
hasDefault: false;
|
|
1316
|
+
isPrimaryKey: false;
|
|
1317
|
+
isAutoincrement: false;
|
|
1318
|
+
hasRuntimeDefault: false;
|
|
1319
|
+
enumValues: [string, ...string[]];
|
|
1320
|
+
baseColumn: never;
|
|
1321
|
+
identity: undefined;
|
|
1322
|
+
generated: undefined;
|
|
1323
|
+
}, {}, {}>;
|
|
1324
|
+
requestHash: import("drizzle-orm/pg-core").PgColumn<{
|
|
1325
|
+
name: "request_hash";
|
|
1326
|
+
tableName: "idempotency_keys";
|
|
1327
|
+
dataType: "string";
|
|
1328
|
+
columnType: "PgText";
|
|
1329
|
+
data: string;
|
|
1330
|
+
driverParam: string;
|
|
1331
|
+
notNull: true;
|
|
1332
|
+
hasDefault: false;
|
|
1333
|
+
isPrimaryKey: false;
|
|
1334
|
+
isAutoincrement: false;
|
|
1335
|
+
hasRuntimeDefault: false;
|
|
1336
|
+
enumValues: [string, ...string[]];
|
|
1337
|
+
baseColumn: never;
|
|
1338
|
+
identity: undefined;
|
|
1339
|
+
generated: undefined;
|
|
1340
|
+
}, {}, {}>;
|
|
1341
|
+
responseStatus: import("drizzle-orm/pg-core").PgColumn<{
|
|
1342
|
+
name: "response_status";
|
|
1343
|
+
tableName: "idempotency_keys";
|
|
1344
|
+
dataType: "number";
|
|
1345
|
+
columnType: "PgInteger";
|
|
1346
|
+
data: number;
|
|
1347
|
+
driverParam: string | number;
|
|
1348
|
+
notNull: false;
|
|
1349
|
+
hasDefault: false;
|
|
1350
|
+
isPrimaryKey: false;
|
|
1351
|
+
isAutoincrement: false;
|
|
1352
|
+
hasRuntimeDefault: false;
|
|
1353
|
+
enumValues: undefined;
|
|
1354
|
+
baseColumn: never;
|
|
1355
|
+
identity: undefined;
|
|
1356
|
+
generated: undefined;
|
|
1357
|
+
}, {}, {}>;
|
|
1358
|
+
responseBodyEnc: import("drizzle-orm/pg-core").PgColumn<{
|
|
1359
|
+
name: "response_body_enc";
|
|
1360
|
+
tableName: "idempotency_keys";
|
|
1361
|
+
dataType: "string";
|
|
1362
|
+
columnType: "PgText";
|
|
1363
|
+
data: string;
|
|
1364
|
+
driverParam: string;
|
|
1365
|
+
notNull: false;
|
|
1366
|
+
hasDefault: false;
|
|
1367
|
+
isPrimaryKey: false;
|
|
1368
|
+
isAutoincrement: false;
|
|
1369
|
+
hasRuntimeDefault: false;
|
|
1370
|
+
enumValues: [string, ...string[]];
|
|
1371
|
+
baseColumn: never;
|
|
1372
|
+
identity: undefined;
|
|
1373
|
+
generated: undefined;
|
|
1374
|
+
}, {}, {}>;
|
|
1375
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1376
|
+
name: "created_at";
|
|
1377
|
+
tableName: "idempotency_keys";
|
|
1378
|
+
dataType: "date";
|
|
1379
|
+
columnType: "PgTimestamp";
|
|
1380
|
+
data: Date;
|
|
1381
|
+
driverParam: string;
|
|
1382
|
+
notNull: true;
|
|
1383
|
+
hasDefault: true;
|
|
1384
|
+
isPrimaryKey: false;
|
|
1385
|
+
isAutoincrement: false;
|
|
1386
|
+
hasRuntimeDefault: false;
|
|
1387
|
+
enumValues: undefined;
|
|
1388
|
+
baseColumn: never;
|
|
1389
|
+
identity: undefined;
|
|
1390
|
+
generated: undefined;
|
|
1391
|
+
}, {}, {}>;
|
|
1392
|
+
expiresAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1393
|
+
name: "expires_at";
|
|
1394
|
+
tableName: "idempotency_keys";
|
|
1395
|
+
dataType: "date";
|
|
1396
|
+
columnType: "PgTimestamp";
|
|
1397
|
+
data: Date;
|
|
1398
|
+
driverParam: string;
|
|
1399
|
+
notNull: true;
|
|
1400
|
+
hasDefault: false;
|
|
1401
|
+
isPrimaryKey: false;
|
|
1402
|
+
isAutoincrement: false;
|
|
1403
|
+
hasRuntimeDefault: false;
|
|
1404
|
+
enumValues: undefined;
|
|
1405
|
+
baseColumn: never;
|
|
1406
|
+
identity: undefined;
|
|
1407
|
+
generated: undefined;
|
|
1408
|
+
}, {}, {}>;
|
|
1409
|
+
};
|
|
1410
|
+
dialect: "pg";
|
|
1411
|
+
}>;
|
|
1412
|
+
/**
|
|
1413
|
+
* One-time-use ledger for hub→tool exchange JWTs (`POST /sso/cli-connect`,
|
|
1414
|
+
* cloud edition only — internal/federation.md P5). The hub mints every 120 s
|
|
1415
|
+
* exchange token with a unique `jti`; consuming a token INSERTs its jti
|
|
1416
|
+
* here first, and the primary-key conflict IS the replay detection — a
|
|
1417
|
+
* replayed token inside its TTL loses the insert and is rejected before it
|
|
1418
|
+
* can mint a second key. Postgres-backed so the guard is MULTI-REPLICA
|
|
1419
|
+
* SAFE by construction (every replica races the same table), unlike any
|
|
1420
|
+
* in-memory set. Rows are inert once `expires_at` passes (the token itself
|
|
1421
|
+
* is expired then — the hub never re-mints a jti) and are swept
|
|
1422
|
+
* best-effort on later exchanges; the table stays tiny (rows live ~2 min,
|
|
1423
|
+
* arrivals are rate-limited), so the sweep needs no index.
|
|
1424
|
+
*/
|
|
1425
|
+
export declare const ssoConnectJtis: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
1426
|
+
name: "sso_connect_jtis";
|
|
1427
|
+
schema: undefined;
|
|
1428
|
+
columns: {
|
|
1429
|
+
jti: import("drizzle-orm/pg-core").PgColumn<{
|
|
1430
|
+
name: "jti";
|
|
1431
|
+
tableName: "sso_connect_jtis";
|
|
1432
|
+
dataType: "string";
|
|
1433
|
+
columnType: "PgText";
|
|
1434
|
+
data: string;
|
|
1435
|
+
driverParam: string;
|
|
1436
|
+
notNull: true;
|
|
1437
|
+
hasDefault: false;
|
|
1438
|
+
isPrimaryKey: true;
|
|
1439
|
+
isAutoincrement: false;
|
|
1440
|
+
hasRuntimeDefault: false;
|
|
1441
|
+
enumValues: [string, ...string[]];
|
|
1442
|
+
baseColumn: never;
|
|
1443
|
+
identity: undefined;
|
|
1444
|
+
generated: undefined;
|
|
1445
|
+
}, {}, {}>;
|
|
1446
|
+
expiresAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1447
|
+
name: "expires_at";
|
|
1448
|
+
tableName: "sso_connect_jtis";
|
|
1449
|
+
dataType: "date";
|
|
1450
|
+
columnType: "PgTimestamp";
|
|
1451
|
+
data: Date;
|
|
1452
|
+
driverParam: string;
|
|
1453
|
+
notNull: true;
|
|
1454
|
+
hasDefault: false;
|
|
1455
|
+
isPrimaryKey: false;
|
|
1456
|
+
isAutoincrement: false;
|
|
1457
|
+
hasRuntimeDefault: false;
|
|
1458
|
+
enumValues: undefined;
|
|
1459
|
+
baseColumn: never;
|
|
1460
|
+
identity: undefined;
|
|
1461
|
+
generated: undefined;
|
|
1462
|
+
}, {}, {}>;
|
|
1463
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1464
|
+
name: "created_at";
|
|
1465
|
+
tableName: "sso_connect_jtis";
|
|
1466
|
+
dataType: "date";
|
|
1467
|
+
columnType: "PgTimestamp";
|
|
1468
|
+
data: Date;
|
|
1469
|
+
driverParam: string;
|
|
1470
|
+
notNull: true;
|
|
1471
|
+
hasDefault: true;
|
|
1472
|
+
isPrimaryKey: false;
|
|
1473
|
+
isAutoincrement: false;
|
|
1474
|
+
hasRuntimeDefault: false;
|
|
1475
|
+
enumValues: undefined;
|
|
1476
|
+
baseColumn: never;
|
|
1477
|
+
identity: undefined;
|
|
1478
|
+
generated: undefined;
|
|
1479
|
+
}, {}, {}>;
|
|
1480
|
+
};
|
|
1481
|
+
dialect: "pg";
|
|
1482
|
+
}>;
|
|
1483
|
+
/**
|
|
1484
|
+
* The hub-grant PRESENTATION marker (PRDCT-1370, internal/federation.md
|
|
1485
|
+
* "Ambiguous refresh outcomes"): written by HubGrantService immediately
|
|
1486
|
+
* BEFORE it presents a user's refresh token to the hub's token endpoint,
|
|
1487
|
+
* cleared once the hub's answer is known (a rotation, or a definitive
|
|
1488
|
+
* refusal). A row that survives therefore means "this exact token was
|
|
1489
|
+
* presented and its answer never arrived" — a client-side timeout, a lost
|
|
1490
|
+
* response, a socket reset after the hub committed. The hub rotates BEFORE
|
|
1491
|
+
* it answers and cannot roll back, so blindly re-presenting that token
|
|
1492
|
+
* would trip the hub's RFC 9700 reuse detection and tear down the user's
|
|
1493
|
+
* whole (client, user) grant family, the CLI grant included. With the
|
|
1494
|
+
* marker in place the next refresh PROBES the token through the hub's
|
|
1495
|
+
* RFC 7662 introspection endpoint first (read-only: it never rotates and
|
|
1496
|
+
* never tears down) and only presents a token the hub still calls active.
|
|
1497
|
+
*
|
|
1498
|
+
* Keyed by the `account` row (one hub link per user); `refresh_token` is
|
|
1499
|
+
* the ciphertext presented, so a browser re-login that re-seeds the row
|
|
1500
|
+
* mid-flight invalidates the marker by construction (the ciphertext no
|
|
1501
|
+
* longer matches). Postgres-backed so every replica sees it — the refresh
|
|
1502
|
+
* lock is cross-replica, and so must the memory of an unanswered
|
|
1503
|
+
* presentation be.
|
|
1504
|
+
*/
|
|
1505
|
+
export declare const hubGrantPresentations: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
1506
|
+
name: "hub_grant_presentations";
|
|
1507
|
+
schema: undefined;
|
|
1508
|
+
columns: {
|
|
1509
|
+
accountId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1510
|
+
name: "account_id";
|
|
1511
|
+
tableName: "hub_grant_presentations";
|
|
1512
|
+
dataType: "string";
|
|
1513
|
+
columnType: "PgText";
|
|
1514
|
+
data: string;
|
|
1515
|
+
driverParam: string;
|
|
1516
|
+
notNull: true;
|
|
1517
|
+
hasDefault: false;
|
|
1518
|
+
isPrimaryKey: true;
|
|
1519
|
+
isAutoincrement: false;
|
|
1520
|
+
hasRuntimeDefault: false;
|
|
1521
|
+
enumValues: [string, ...string[]];
|
|
1522
|
+
baseColumn: never;
|
|
1523
|
+
identity: undefined;
|
|
1524
|
+
generated: undefined;
|
|
1525
|
+
}, {}, {}>;
|
|
1526
|
+
refreshToken: import("drizzle-orm/pg-core").PgColumn<{
|
|
1527
|
+
name: "refresh_token";
|
|
1528
|
+
tableName: "hub_grant_presentations";
|
|
1529
|
+
dataType: "string";
|
|
1530
|
+
columnType: "PgText";
|
|
1531
|
+
data: string;
|
|
1532
|
+
driverParam: string;
|
|
1533
|
+
notNull: true;
|
|
1534
|
+
hasDefault: false;
|
|
1535
|
+
isPrimaryKey: false;
|
|
1536
|
+
isAutoincrement: false;
|
|
1537
|
+
hasRuntimeDefault: false;
|
|
1538
|
+
enumValues: [string, ...string[]];
|
|
1539
|
+
baseColumn: never;
|
|
1540
|
+
identity: undefined;
|
|
1541
|
+
generated: undefined;
|
|
1542
|
+
}, {}, {}>;
|
|
1543
|
+
presentedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1544
|
+
name: "presented_at";
|
|
1545
|
+
tableName: "hub_grant_presentations";
|
|
1546
|
+
dataType: "date";
|
|
1547
|
+
columnType: "PgTimestamp";
|
|
1548
|
+
data: Date;
|
|
1549
|
+
driverParam: string;
|
|
1550
|
+
notNull: true;
|
|
1551
|
+
hasDefault: true;
|
|
1552
|
+
isPrimaryKey: false;
|
|
1553
|
+
isAutoincrement: false;
|
|
1554
|
+
hasRuntimeDefault: false;
|
|
1555
|
+
enumValues: undefined;
|
|
1556
|
+
baseColumn: never;
|
|
1557
|
+
identity: undefined;
|
|
1558
|
+
generated: undefined;
|
|
1559
|
+
}, {}, {}>;
|
|
1560
|
+
};
|
|
1561
|
+
dialect: "pg";
|
|
1562
|
+
}>;
|
|
1563
|
+
/**
|
|
1564
|
+
* TOOL-LOCAL first-run onboarding state (SL-6; written on the cloud
|
|
1565
|
+
* edition's SSO login path, read by /me). An APP domain table, not a
|
|
1566
|
+
* Better Auth column — no drift-guard involvement. The welcome-banner
|
|
1567
|
+
* decision reads ONLY this table and is RETRY-SAFE BY CONSTRUCTION:
|
|
1568
|
+
* `firstRunPending := NOT EXISTS (row WHERE dismissed_at IS NOT NULL)` —
|
|
1569
|
+
* the absence of a DISMISSAL means the welcome is still owed, so a
|
|
1570
|
+
* transiently-failed first-login insert self-heals on the next login and
|
|
1571
|
+
* only an explicit dismissal ever hides the banner. The hub's advisory
|
|
1572
|
+
* `tool_first_login` id_token claim is deliberately ignored for behavior
|
|
1573
|
+
* (the hub's user_tool_usage table stays the ECOSYSTEM analytics truth;
|
|
1574
|
+
* this table owns the banner). The deploy-time backfill migration inserts
|
|
1575
|
+
* DISMISSED rows for every pre-existing user — nobody gets a retroactive
|
|
1576
|
+
* welcome.
|
|
1577
|
+
*/
|
|
1578
|
+
export declare const userOnboarding: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
1579
|
+
name: "user_onboarding";
|
|
1580
|
+
schema: undefined;
|
|
1581
|
+
columns: {
|
|
1582
|
+
userId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1583
|
+
name: "user_id";
|
|
1584
|
+
tableName: "user_onboarding";
|
|
1585
|
+
dataType: "string";
|
|
1586
|
+
columnType: "PgText";
|
|
1587
|
+
data: string;
|
|
1588
|
+
driverParam: string;
|
|
1589
|
+
notNull: true;
|
|
1590
|
+
hasDefault: false;
|
|
1591
|
+
isPrimaryKey: true;
|
|
1592
|
+
isAutoincrement: false;
|
|
1593
|
+
hasRuntimeDefault: false;
|
|
1594
|
+
enumValues: [string, ...string[]];
|
|
1595
|
+
baseColumn: never;
|
|
1596
|
+
identity: undefined;
|
|
1597
|
+
generated: undefined;
|
|
1598
|
+
}, {}, {}>;
|
|
1599
|
+
firstLoginAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1600
|
+
name: "first_login_at";
|
|
1601
|
+
tableName: "user_onboarding";
|
|
1602
|
+
dataType: "date";
|
|
1603
|
+
columnType: "PgTimestamp";
|
|
1604
|
+
data: Date;
|
|
1605
|
+
driverParam: string;
|
|
1606
|
+
notNull: true;
|
|
1607
|
+
hasDefault: true;
|
|
1608
|
+
isPrimaryKey: false;
|
|
1609
|
+
isAutoincrement: false;
|
|
1610
|
+
hasRuntimeDefault: false;
|
|
1611
|
+
enumValues: undefined;
|
|
1612
|
+
baseColumn: never;
|
|
1613
|
+
identity: undefined;
|
|
1614
|
+
generated: undefined;
|
|
1615
|
+
}, {}, {}>;
|
|
1616
|
+
dismissedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1617
|
+
name: "dismissed_at";
|
|
1618
|
+
tableName: "user_onboarding";
|
|
1619
|
+
dataType: "date";
|
|
1620
|
+
columnType: "PgTimestamp";
|
|
1621
|
+
data: Date;
|
|
1622
|
+
driverParam: string;
|
|
1623
|
+
notNull: false;
|
|
1624
|
+
hasDefault: false;
|
|
1625
|
+
isPrimaryKey: false;
|
|
1626
|
+
isAutoincrement: false;
|
|
1627
|
+
hasRuntimeDefault: false;
|
|
1628
|
+
enumValues: undefined;
|
|
1629
|
+
baseColumn: never;
|
|
1630
|
+
identity: undefined;
|
|
1631
|
+
generated: undefined;
|
|
1632
|
+
}, {}, {}>;
|
|
1633
|
+
};
|
|
1634
|
+
dialect: "pg";
|
|
1635
|
+
}>;
|
|
1636
|
+
/**
|
|
1637
|
+
* Audit log: who did what to which resource, when, with which credential.
|
|
1638
|
+
* Append-only; bigint identity keeps inserts cheap on the hot path.
|
|
1639
|
+
*/
|
|
1640
|
+
export declare const auditLog: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
1641
|
+
name: "audit_log";
|
|
1642
|
+
schema: undefined;
|
|
1643
|
+
columns: {
|
|
1644
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
1645
|
+
name: "id";
|
|
1646
|
+
tableName: "audit_log";
|
|
1647
|
+
dataType: "number";
|
|
1648
|
+
columnType: "PgBigInt53";
|
|
1649
|
+
data: number;
|
|
1650
|
+
driverParam: string | number;
|
|
1651
|
+
notNull: true;
|
|
1652
|
+
hasDefault: true;
|
|
1653
|
+
isPrimaryKey: true;
|
|
1654
|
+
isAutoincrement: false;
|
|
1655
|
+
hasRuntimeDefault: false;
|
|
1656
|
+
enumValues: undefined;
|
|
1657
|
+
baseColumn: never;
|
|
1658
|
+
identity: "always";
|
|
1659
|
+
generated: undefined;
|
|
1660
|
+
}, {}, {}>;
|
|
1661
|
+
workspaceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1662
|
+
name: "workspace_id";
|
|
1663
|
+
tableName: "audit_log";
|
|
1664
|
+
dataType: "string";
|
|
1665
|
+
columnType: "PgUUID";
|
|
1666
|
+
data: string;
|
|
1667
|
+
driverParam: string;
|
|
1668
|
+
notNull: false;
|
|
1669
|
+
hasDefault: false;
|
|
1670
|
+
isPrimaryKey: false;
|
|
1671
|
+
isAutoincrement: false;
|
|
1672
|
+
hasRuntimeDefault: false;
|
|
1673
|
+
enumValues: undefined;
|
|
1674
|
+
baseColumn: never;
|
|
1675
|
+
identity: undefined;
|
|
1676
|
+
generated: undefined;
|
|
1677
|
+
}, {}, {}>;
|
|
1678
|
+
actorUserId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1679
|
+
name: "actor_user_id";
|
|
1680
|
+
tableName: "audit_log";
|
|
1681
|
+
dataType: "string";
|
|
1682
|
+
columnType: "PgText";
|
|
1683
|
+
data: string;
|
|
1684
|
+
driverParam: string;
|
|
1685
|
+
notNull: false;
|
|
1686
|
+
hasDefault: false;
|
|
1687
|
+
isPrimaryKey: false;
|
|
1688
|
+
isAutoincrement: false;
|
|
1689
|
+
hasRuntimeDefault: false;
|
|
1690
|
+
enumValues: [string, ...string[]];
|
|
1691
|
+
baseColumn: never;
|
|
1692
|
+
identity: undefined;
|
|
1693
|
+
generated: undefined;
|
|
1694
|
+
}, {}, {}>;
|
|
1695
|
+
actorVia: import("drizzle-orm/pg-core").PgColumn<{
|
|
1696
|
+
name: "actor_via";
|
|
1697
|
+
tableName: "audit_log";
|
|
1698
|
+
dataType: "string";
|
|
1699
|
+
columnType: "PgText";
|
|
1700
|
+
data: "session" | "api_key" | "oauth" | "system";
|
|
1701
|
+
driverParam: string;
|
|
1702
|
+
notNull: true;
|
|
1703
|
+
hasDefault: false;
|
|
1704
|
+
isPrimaryKey: false;
|
|
1705
|
+
isAutoincrement: false;
|
|
1706
|
+
hasRuntimeDefault: false;
|
|
1707
|
+
enumValues: ["session", "api_key", "oauth", "system"];
|
|
1708
|
+
baseColumn: never;
|
|
1709
|
+
identity: undefined;
|
|
1710
|
+
generated: undefined;
|
|
1711
|
+
}, {}, {}>;
|
|
1712
|
+
apiKeyId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1713
|
+
name: "api_key_id";
|
|
1714
|
+
tableName: "audit_log";
|
|
1715
|
+
dataType: "string";
|
|
1716
|
+
columnType: "PgUUID";
|
|
1717
|
+
data: string;
|
|
1718
|
+
driverParam: string;
|
|
1719
|
+
notNull: false;
|
|
1720
|
+
hasDefault: false;
|
|
1721
|
+
isPrimaryKey: false;
|
|
1722
|
+
isAutoincrement: false;
|
|
1723
|
+
hasRuntimeDefault: false;
|
|
1724
|
+
enumValues: undefined;
|
|
1725
|
+
baseColumn: never;
|
|
1726
|
+
identity: undefined;
|
|
1727
|
+
generated: undefined;
|
|
1728
|
+
}, {}, {}>;
|
|
1729
|
+
action: import("drizzle-orm/pg-core").PgColumn<{
|
|
1730
|
+
name: "action";
|
|
1731
|
+
tableName: "audit_log";
|
|
1732
|
+
dataType: "string";
|
|
1733
|
+
columnType: "PgText";
|
|
1734
|
+
data: string;
|
|
1735
|
+
driverParam: string;
|
|
1736
|
+
notNull: true;
|
|
1737
|
+
hasDefault: false;
|
|
1738
|
+
isPrimaryKey: false;
|
|
1739
|
+
isAutoincrement: false;
|
|
1740
|
+
hasRuntimeDefault: false;
|
|
1741
|
+
enumValues: [string, ...string[]];
|
|
1742
|
+
baseColumn: never;
|
|
1743
|
+
identity: undefined;
|
|
1744
|
+
generated: undefined;
|
|
1745
|
+
}, {}, {}>;
|
|
1746
|
+
resourceType: import("drizzle-orm/pg-core").PgColumn<{
|
|
1747
|
+
name: "resource_type";
|
|
1748
|
+
tableName: "audit_log";
|
|
1749
|
+
dataType: "string";
|
|
1750
|
+
columnType: "PgText";
|
|
1751
|
+
data: string;
|
|
1752
|
+
driverParam: string;
|
|
1753
|
+
notNull: true;
|
|
1754
|
+
hasDefault: false;
|
|
1755
|
+
isPrimaryKey: false;
|
|
1756
|
+
isAutoincrement: false;
|
|
1757
|
+
hasRuntimeDefault: false;
|
|
1758
|
+
enumValues: [string, ...string[]];
|
|
1759
|
+
baseColumn: never;
|
|
1760
|
+
identity: undefined;
|
|
1761
|
+
generated: undefined;
|
|
1762
|
+
}, {}, {}>;
|
|
1763
|
+
resourceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1764
|
+
name: "resource_id";
|
|
1765
|
+
tableName: "audit_log";
|
|
1766
|
+
dataType: "string";
|
|
1767
|
+
columnType: "PgText";
|
|
1768
|
+
data: string;
|
|
1769
|
+
driverParam: string;
|
|
1770
|
+
notNull: false;
|
|
1771
|
+
hasDefault: false;
|
|
1772
|
+
isPrimaryKey: false;
|
|
1773
|
+
isAutoincrement: false;
|
|
1774
|
+
hasRuntimeDefault: false;
|
|
1775
|
+
enumValues: [string, ...string[]];
|
|
1776
|
+
baseColumn: never;
|
|
1777
|
+
identity: undefined;
|
|
1778
|
+
generated: undefined;
|
|
1779
|
+
}, {}, {}>;
|
|
1780
|
+
requestId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1781
|
+
name: "request_id";
|
|
1782
|
+
tableName: "audit_log";
|
|
1783
|
+
dataType: "string";
|
|
1784
|
+
columnType: "PgText";
|
|
1785
|
+
data: string;
|
|
1786
|
+
driverParam: string;
|
|
1787
|
+
notNull: false;
|
|
1788
|
+
hasDefault: false;
|
|
1789
|
+
isPrimaryKey: false;
|
|
1790
|
+
isAutoincrement: false;
|
|
1791
|
+
hasRuntimeDefault: false;
|
|
1792
|
+
enumValues: [string, ...string[]];
|
|
1793
|
+
baseColumn: never;
|
|
1794
|
+
identity: undefined;
|
|
1795
|
+
generated: undefined;
|
|
1796
|
+
}, {}, {}>;
|
|
1797
|
+
ip: import("drizzle-orm/pg-core").PgColumn<{
|
|
1798
|
+
name: "ip";
|
|
1799
|
+
tableName: "audit_log";
|
|
1800
|
+
dataType: "string";
|
|
1801
|
+
columnType: "PgText";
|
|
1802
|
+
data: string;
|
|
1803
|
+
driverParam: string;
|
|
1804
|
+
notNull: false;
|
|
1805
|
+
hasDefault: false;
|
|
1806
|
+
isPrimaryKey: false;
|
|
1807
|
+
isAutoincrement: false;
|
|
1808
|
+
hasRuntimeDefault: false;
|
|
1809
|
+
enumValues: [string, ...string[]];
|
|
1810
|
+
baseColumn: never;
|
|
1811
|
+
identity: undefined;
|
|
1812
|
+
generated: undefined;
|
|
1813
|
+
}, {}, {}>;
|
|
1814
|
+
metadata: import("drizzle-orm/pg-core").PgColumn<{
|
|
1815
|
+
name: "metadata";
|
|
1816
|
+
tableName: "audit_log";
|
|
1817
|
+
dataType: "json";
|
|
1818
|
+
columnType: "PgJsonb";
|
|
1819
|
+
data: unknown;
|
|
1820
|
+
driverParam: unknown;
|
|
1821
|
+
notNull: false;
|
|
1822
|
+
hasDefault: false;
|
|
1823
|
+
isPrimaryKey: false;
|
|
1824
|
+
isAutoincrement: false;
|
|
1825
|
+
hasRuntimeDefault: false;
|
|
1826
|
+
enumValues: undefined;
|
|
1827
|
+
baseColumn: never;
|
|
1828
|
+
identity: undefined;
|
|
1829
|
+
generated: undefined;
|
|
1830
|
+
}, {}, {}>;
|
|
1831
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1832
|
+
name: "created_at";
|
|
1833
|
+
tableName: "audit_log";
|
|
1834
|
+
dataType: "date";
|
|
1835
|
+
columnType: "PgTimestamp";
|
|
1836
|
+
data: Date;
|
|
1837
|
+
driverParam: string;
|
|
1838
|
+
notNull: true;
|
|
1839
|
+
hasDefault: true;
|
|
1840
|
+
isPrimaryKey: false;
|
|
1841
|
+
isAutoincrement: false;
|
|
1842
|
+
hasRuntimeDefault: false;
|
|
1843
|
+
enumValues: undefined;
|
|
1844
|
+
baseColumn: never;
|
|
1845
|
+
identity: undefined;
|
|
1846
|
+
generated: undefined;
|
|
1847
|
+
}, {}, {}>;
|
|
1848
|
+
};
|
|
1849
|
+
dialect: "pg";
|
|
1850
|
+
}>;
|
|
1851
|
+
/**
|
|
1852
|
+
* File metadata over the content-addressed StorageDriver. Rows are
|
|
1853
|
+
* workspace-scoped; blobs are stored once per (workspace, sha256).
|
|
1854
|
+
*
|
|
1855
|
+
* `created_by` is nullable with `set null` on user delete (migration 0008):
|
|
1856
|
+
* files are WORKSPACE data, not the uploader's personal data — deleting the
|
|
1857
|
+
* account anonymizes the uploader (like audit_log.actor_user_id) while the
|
|
1858
|
+
* file stays with the workspace (ADR 006).
|
|
1859
|
+
*/
|
|
1860
|
+
export declare const files: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
1861
|
+
name: "files";
|
|
1862
|
+
schema: undefined;
|
|
1863
|
+
columns: {
|
|
1864
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
1865
|
+
name: "id";
|
|
1866
|
+
tableName: "files";
|
|
1867
|
+
dataType: "string";
|
|
1868
|
+
columnType: "PgUUID";
|
|
1869
|
+
data: string;
|
|
1870
|
+
driverParam: string;
|
|
1871
|
+
notNull: true;
|
|
1872
|
+
hasDefault: true;
|
|
1873
|
+
isPrimaryKey: true;
|
|
1874
|
+
isAutoincrement: false;
|
|
1875
|
+
hasRuntimeDefault: false;
|
|
1876
|
+
enumValues: undefined;
|
|
1877
|
+
baseColumn: never;
|
|
1878
|
+
identity: undefined;
|
|
1879
|
+
generated: undefined;
|
|
1880
|
+
}, {}, {}>;
|
|
1881
|
+
workspaceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
1882
|
+
name: "workspace_id";
|
|
1883
|
+
tableName: "files";
|
|
1884
|
+
dataType: "string";
|
|
1885
|
+
columnType: "PgUUID";
|
|
1886
|
+
data: string;
|
|
1887
|
+
driverParam: string;
|
|
1888
|
+
notNull: true;
|
|
1889
|
+
hasDefault: false;
|
|
1890
|
+
isPrimaryKey: false;
|
|
1891
|
+
isAutoincrement: false;
|
|
1892
|
+
hasRuntimeDefault: false;
|
|
1893
|
+
enumValues: undefined;
|
|
1894
|
+
baseColumn: never;
|
|
1895
|
+
identity: undefined;
|
|
1896
|
+
generated: undefined;
|
|
1897
|
+
}, {}, {}>;
|
|
1898
|
+
sha256: import("drizzle-orm/pg-core").PgColumn<{
|
|
1899
|
+
name: "sha256";
|
|
1900
|
+
tableName: "files";
|
|
1901
|
+
dataType: "string";
|
|
1902
|
+
columnType: "PgText";
|
|
1903
|
+
data: string;
|
|
1904
|
+
driverParam: string;
|
|
1905
|
+
notNull: true;
|
|
1906
|
+
hasDefault: false;
|
|
1907
|
+
isPrimaryKey: false;
|
|
1908
|
+
isAutoincrement: false;
|
|
1909
|
+
hasRuntimeDefault: false;
|
|
1910
|
+
enumValues: [string, ...string[]];
|
|
1911
|
+
baseColumn: never;
|
|
1912
|
+
identity: undefined;
|
|
1913
|
+
generated: undefined;
|
|
1914
|
+
}, {}, {}>;
|
|
1915
|
+
sizeBytes: import("drizzle-orm/pg-core").PgColumn<{
|
|
1916
|
+
name: "size_bytes";
|
|
1917
|
+
tableName: "files";
|
|
1918
|
+
dataType: "number";
|
|
1919
|
+
columnType: "PgBigInt53";
|
|
1920
|
+
data: number;
|
|
1921
|
+
driverParam: string | number;
|
|
1922
|
+
notNull: true;
|
|
1923
|
+
hasDefault: false;
|
|
1924
|
+
isPrimaryKey: false;
|
|
1925
|
+
isAutoincrement: false;
|
|
1926
|
+
hasRuntimeDefault: false;
|
|
1927
|
+
enumValues: undefined;
|
|
1928
|
+
baseColumn: never;
|
|
1929
|
+
identity: undefined;
|
|
1930
|
+
generated: undefined;
|
|
1931
|
+
}, {}, {}>;
|
|
1932
|
+
contentType: import("drizzle-orm/pg-core").PgColumn<{
|
|
1933
|
+
name: "content_type";
|
|
1934
|
+
tableName: "files";
|
|
1935
|
+
dataType: "string";
|
|
1936
|
+
columnType: "PgText";
|
|
1937
|
+
data: string;
|
|
1938
|
+
driverParam: string;
|
|
1939
|
+
notNull: true;
|
|
1940
|
+
hasDefault: false;
|
|
1941
|
+
isPrimaryKey: false;
|
|
1942
|
+
isAutoincrement: false;
|
|
1943
|
+
hasRuntimeDefault: false;
|
|
1944
|
+
enumValues: [string, ...string[]];
|
|
1945
|
+
baseColumn: never;
|
|
1946
|
+
identity: undefined;
|
|
1947
|
+
generated: undefined;
|
|
1948
|
+
}, {}, {}>;
|
|
1949
|
+
originalName: import("drizzle-orm/pg-core").PgColumn<{
|
|
1950
|
+
name: "original_name";
|
|
1951
|
+
tableName: "files";
|
|
1952
|
+
dataType: "string";
|
|
1953
|
+
columnType: "PgText";
|
|
1954
|
+
data: string;
|
|
1955
|
+
driverParam: string;
|
|
1956
|
+
notNull: true;
|
|
1957
|
+
hasDefault: false;
|
|
1958
|
+
isPrimaryKey: false;
|
|
1959
|
+
isAutoincrement: false;
|
|
1960
|
+
hasRuntimeDefault: false;
|
|
1961
|
+
enumValues: [string, ...string[]];
|
|
1962
|
+
baseColumn: never;
|
|
1963
|
+
identity: undefined;
|
|
1964
|
+
generated: undefined;
|
|
1965
|
+
}, {}, {}>;
|
|
1966
|
+
createdBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
1967
|
+
name: "created_by";
|
|
1968
|
+
tableName: "files";
|
|
1969
|
+
dataType: "string";
|
|
1970
|
+
columnType: "PgText";
|
|
1971
|
+
data: string;
|
|
1972
|
+
driverParam: string;
|
|
1973
|
+
notNull: false;
|
|
1974
|
+
hasDefault: false;
|
|
1975
|
+
isPrimaryKey: false;
|
|
1976
|
+
isAutoincrement: false;
|
|
1977
|
+
hasRuntimeDefault: false;
|
|
1978
|
+
enumValues: [string, ...string[]];
|
|
1979
|
+
baseColumn: never;
|
|
1980
|
+
identity: undefined;
|
|
1981
|
+
generated: undefined;
|
|
1982
|
+
}, {}, {}>;
|
|
1983
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
1984
|
+
name: "created_at";
|
|
1985
|
+
tableName: "files";
|
|
1986
|
+
dataType: "date";
|
|
1987
|
+
columnType: "PgTimestamp";
|
|
1988
|
+
data: Date;
|
|
1989
|
+
driverParam: string;
|
|
1990
|
+
notNull: true;
|
|
1991
|
+
hasDefault: true;
|
|
1992
|
+
isPrimaryKey: false;
|
|
1993
|
+
isAutoincrement: false;
|
|
1994
|
+
hasRuntimeDefault: false;
|
|
1995
|
+
enumValues: undefined;
|
|
1996
|
+
baseColumn: never;
|
|
1997
|
+
identity: undefined;
|
|
1998
|
+
generated: undefined;
|
|
1999
|
+
}, {}, {}>;
|
|
2000
|
+
deletedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2001
|
+
name: "deleted_at";
|
|
2002
|
+
tableName: "files";
|
|
2003
|
+
dataType: "date";
|
|
2004
|
+
columnType: "PgTimestamp";
|
|
2005
|
+
data: Date;
|
|
2006
|
+
driverParam: string;
|
|
2007
|
+
notNull: false;
|
|
2008
|
+
hasDefault: false;
|
|
2009
|
+
isPrimaryKey: false;
|
|
2010
|
+
isAutoincrement: false;
|
|
2011
|
+
hasRuntimeDefault: false;
|
|
2012
|
+
enumValues: undefined;
|
|
2013
|
+
baseColumn: never;
|
|
2014
|
+
identity: undefined;
|
|
2015
|
+
generated: undefined;
|
|
2016
|
+
}, {}, {}>;
|
|
2017
|
+
};
|
|
2018
|
+
dialect: "pg";
|
|
2019
|
+
}>;
|
|
2020
|
+
/**
|
|
2021
|
+
* Proof of possession: every user who has PUSHED these exact bytes into the
|
|
2022
|
+
* workspace, not just the first one (SL-B1 / ADR 013 on the blob surface).
|
|
2023
|
+
*
|
|
2024
|
+
* `files` is content-addressed and unique per (workspace, sha256), so a
|
|
2025
|
+
* second uploader of identical bytes deduplicates onto the FIRST uploader's
|
|
2026
|
+
* row and `files.created_by` keeps naming that first uploader. Once blob
|
|
2027
|
+
* reads are per-resource authorized, that single column is no longer a truthful
|
|
2028
|
+
* answer to "may this principal see these bytes": a member who uploaded a
|
|
2029
|
+
* shared logo that another member had uploaded first would be locked out of
|
|
2030
|
+
* a blob they demonstrably hold — and their version commit, which must only
|
|
2031
|
+
* bind shas they may read, would be refused. This table records each
|
|
2032
|
+
* distinct uploader so possession survives deduplication.
|
|
2033
|
+
*
|
|
2034
|
+
* `on delete cascade` on both sides: attribution is personal data (it dies
|
|
2035
|
+
* with the account, like the anonymized `files.created_by`) and carries no
|
|
2036
|
+
* value once the file row is gone.
|
|
2037
|
+
*/
|
|
2038
|
+
export declare const fileUploaders: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2039
|
+
name: "file_uploaders";
|
|
2040
|
+
schema: undefined;
|
|
2041
|
+
columns: {
|
|
2042
|
+
fileId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2043
|
+
name: "file_id";
|
|
2044
|
+
tableName: "file_uploaders";
|
|
2045
|
+
dataType: "string";
|
|
2046
|
+
columnType: "PgUUID";
|
|
2047
|
+
data: string;
|
|
2048
|
+
driverParam: string;
|
|
2049
|
+
notNull: true;
|
|
2050
|
+
hasDefault: false;
|
|
2051
|
+
isPrimaryKey: false;
|
|
2052
|
+
isAutoincrement: false;
|
|
2053
|
+
hasRuntimeDefault: false;
|
|
2054
|
+
enumValues: undefined;
|
|
2055
|
+
baseColumn: never;
|
|
2056
|
+
identity: undefined;
|
|
2057
|
+
generated: undefined;
|
|
2058
|
+
}, {}, {}>;
|
|
2059
|
+
userId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2060
|
+
name: "user_id";
|
|
2061
|
+
tableName: "file_uploaders";
|
|
2062
|
+
dataType: "string";
|
|
2063
|
+
columnType: "PgText";
|
|
2064
|
+
data: string;
|
|
2065
|
+
driverParam: string;
|
|
2066
|
+
notNull: true;
|
|
2067
|
+
hasDefault: false;
|
|
2068
|
+
isPrimaryKey: false;
|
|
2069
|
+
isAutoincrement: false;
|
|
2070
|
+
hasRuntimeDefault: false;
|
|
2071
|
+
enumValues: [string, ...string[]];
|
|
2072
|
+
baseColumn: never;
|
|
2073
|
+
identity: undefined;
|
|
2074
|
+
generated: undefined;
|
|
2075
|
+
}, {}, {}>;
|
|
2076
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2077
|
+
name: "created_at";
|
|
2078
|
+
tableName: "file_uploaders";
|
|
2079
|
+
dataType: "date";
|
|
2080
|
+
columnType: "PgTimestamp";
|
|
2081
|
+
data: Date;
|
|
2082
|
+
driverParam: string;
|
|
2083
|
+
notNull: true;
|
|
2084
|
+
hasDefault: true;
|
|
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
|
+
/**
|
|
2097
|
+
* A PROJECT is a subgroup of a workspace: a name, a description, members with
|
|
2098
|
+
* a role, and whatever the tool links to it through a table of ITS OWN. The
|
|
2099
|
+
* chassis owns the concept; it knows none of the tool's resources, and no
|
|
2100
|
+
* tool ever needs a column here: `metadata` is the opaque, owner-defined seam
|
|
2101
|
+
* (the same shape and size rules as the tool's own resource metadata).
|
|
2102
|
+
*
|
|
2103
|
+
* A project is ARCHIVED, never deleted: there is no delete route and no
|
|
2104
|
+
* `deleted_at`. `archived_at` takes it out of the default list and makes it
|
|
2105
|
+
* read-only; nothing cascades onto what is linked to it.
|
|
2106
|
+
*/
|
|
2107
|
+
export declare const projects: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2108
|
+
name: "projects";
|
|
2109
|
+
schema: undefined;
|
|
2110
|
+
columns: {
|
|
2111
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
2112
|
+
name: "id";
|
|
2113
|
+
tableName: "projects";
|
|
2114
|
+
dataType: "string";
|
|
2115
|
+
columnType: "PgUUID";
|
|
2116
|
+
data: string;
|
|
2117
|
+
driverParam: string;
|
|
2118
|
+
notNull: true;
|
|
2119
|
+
hasDefault: true;
|
|
2120
|
+
isPrimaryKey: true;
|
|
2121
|
+
isAutoincrement: false;
|
|
2122
|
+
hasRuntimeDefault: false;
|
|
2123
|
+
enumValues: undefined;
|
|
2124
|
+
baseColumn: never;
|
|
2125
|
+
identity: undefined;
|
|
2126
|
+
generated: undefined;
|
|
2127
|
+
}, {}, {}>;
|
|
2128
|
+
workspaceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2129
|
+
name: "workspace_id";
|
|
2130
|
+
tableName: "projects";
|
|
2131
|
+
dataType: "string";
|
|
2132
|
+
columnType: "PgUUID";
|
|
2133
|
+
data: string;
|
|
2134
|
+
driverParam: string;
|
|
2135
|
+
notNull: true;
|
|
2136
|
+
hasDefault: false;
|
|
2137
|
+
isPrimaryKey: false;
|
|
2138
|
+
isAutoincrement: false;
|
|
2139
|
+
hasRuntimeDefault: false;
|
|
2140
|
+
enumValues: undefined;
|
|
2141
|
+
baseColumn: never;
|
|
2142
|
+
identity: undefined;
|
|
2143
|
+
generated: undefined;
|
|
2144
|
+
}, {}, {}>;
|
|
2145
|
+
name: import("drizzle-orm/pg-core").PgColumn<{
|
|
2146
|
+
name: "name";
|
|
2147
|
+
tableName: "projects";
|
|
2148
|
+
dataType: "string";
|
|
2149
|
+
columnType: "PgText";
|
|
2150
|
+
data: string;
|
|
2151
|
+
driverParam: string;
|
|
2152
|
+
notNull: true;
|
|
2153
|
+
hasDefault: false;
|
|
2154
|
+
isPrimaryKey: false;
|
|
2155
|
+
isAutoincrement: false;
|
|
2156
|
+
hasRuntimeDefault: false;
|
|
2157
|
+
enumValues: [string, ...string[]];
|
|
2158
|
+
baseColumn: never;
|
|
2159
|
+
identity: undefined;
|
|
2160
|
+
generated: undefined;
|
|
2161
|
+
}, {}, {}>;
|
|
2162
|
+
description: import("drizzle-orm/pg-core").PgColumn<{
|
|
2163
|
+
name: "description";
|
|
2164
|
+
tableName: "projects";
|
|
2165
|
+
dataType: "string";
|
|
2166
|
+
columnType: "PgText";
|
|
2167
|
+
data: string;
|
|
2168
|
+
driverParam: string;
|
|
2169
|
+
notNull: false;
|
|
2170
|
+
hasDefault: false;
|
|
2171
|
+
isPrimaryKey: false;
|
|
2172
|
+
isAutoincrement: false;
|
|
2173
|
+
hasRuntimeDefault: false;
|
|
2174
|
+
enumValues: [string, ...string[]];
|
|
2175
|
+
baseColumn: never;
|
|
2176
|
+
identity: undefined;
|
|
2177
|
+
generated: undefined;
|
|
2178
|
+
}, {}, {}>;
|
|
2179
|
+
metadata: import("drizzle-orm/pg-core").PgColumn<{
|
|
2180
|
+
name: "metadata";
|
|
2181
|
+
tableName: "projects";
|
|
2182
|
+
dataType: "json";
|
|
2183
|
+
columnType: "PgJsonb";
|
|
2184
|
+
data: Record<string, unknown>;
|
|
2185
|
+
driverParam: unknown;
|
|
2186
|
+
notNull: true;
|
|
2187
|
+
hasDefault: true;
|
|
2188
|
+
isPrimaryKey: false;
|
|
2189
|
+
isAutoincrement: false;
|
|
2190
|
+
hasRuntimeDefault: false;
|
|
2191
|
+
enumValues: undefined;
|
|
2192
|
+
baseColumn: never;
|
|
2193
|
+
identity: undefined;
|
|
2194
|
+
generated: undefined;
|
|
2195
|
+
}, {}, {
|
|
2196
|
+
$type: Record<string, unknown>;
|
|
2197
|
+
}>;
|
|
2198
|
+
archivedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2199
|
+
name: "archived_at";
|
|
2200
|
+
tableName: "projects";
|
|
2201
|
+
dataType: "date";
|
|
2202
|
+
columnType: "PgTimestamp";
|
|
2203
|
+
data: Date;
|
|
2204
|
+
driverParam: string;
|
|
2205
|
+
notNull: false;
|
|
2206
|
+
hasDefault: false;
|
|
2207
|
+
isPrimaryKey: false;
|
|
2208
|
+
isAutoincrement: false;
|
|
2209
|
+
hasRuntimeDefault: false;
|
|
2210
|
+
enumValues: undefined;
|
|
2211
|
+
baseColumn: never;
|
|
2212
|
+
identity: undefined;
|
|
2213
|
+
generated: undefined;
|
|
2214
|
+
}, {}, {}>;
|
|
2215
|
+
createdBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
2216
|
+
name: "created_by";
|
|
2217
|
+
tableName: "projects";
|
|
2218
|
+
dataType: "string";
|
|
2219
|
+
columnType: "PgText";
|
|
2220
|
+
data: string;
|
|
2221
|
+
driverParam: string;
|
|
2222
|
+
notNull: false;
|
|
2223
|
+
hasDefault: false;
|
|
2224
|
+
isPrimaryKey: false;
|
|
2225
|
+
isAutoincrement: false;
|
|
2226
|
+
hasRuntimeDefault: false;
|
|
2227
|
+
enumValues: [string, ...string[]];
|
|
2228
|
+
baseColumn: never;
|
|
2229
|
+
identity: undefined;
|
|
2230
|
+
generated: undefined;
|
|
2231
|
+
}, {}, {}>;
|
|
2232
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2233
|
+
name: "created_at";
|
|
2234
|
+
tableName: "projects";
|
|
2235
|
+
dataType: "date";
|
|
2236
|
+
columnType: "PgTimestamp";
|
|
2237
|
+
data: Date;
|
|
2238
|
+
driverParam: string;
|
|
2239
|
+
notNull: true;
|
|
2240
|
+
hasDefault: true;
|
|
2241
|
+
isPrimaryKey: false;
|
|
2242
|
+
isAutoincrement: false;
|
|
2243
|
+
hasRuntimeDefault: false;
|
|
2244
|
+
enumValues: undefined;
|
|
2245
|
+
baseColumn: never;
|
|
2246
|
+
identity: undefined;
|
|
2247
|
+
generated: undefined;
|
|
2248
|
+
}, {}, {}>;
|
|
2249
|
+
updatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2250
|
+
name: "updated_at";
|
|
2251
|
+
tableName: "projects";
|
|
2252
|
+
dataType: "date";
|
|
2253
|
+
columnType: "PgTimestamp";
|
|
2254
|
+
data: Date;
|
|
2255
|
+
driverParam: string;
|
|
2256
|
+
notNull: true;
|
|
2257
|
+
hasDefault: true;
|
|
2258
|
+
isPrimaryKey: false;
|
|
2259
|
+
isAutoincrement: false;
|
|
2260
|
+
hasRuntimeDefault: false;
|
|
2261
|
+
enumValues: undefined;
|
|
2262
|
+
baseColumn: never;
|
|
2263
|
+
identity: undefined;
|
|
2264
|
+
generated: undefined;
|
|
2265
|
+
}, {}, {}>;
|
|
2266
|
+
};
|
|
2267
|
+
dialect: "pg";
|
|
2268
|
+
}>;
|
|
2269
|
+
/**
|
|
2270
|
+
* The three project roles. A SECURITY vocabulary read by SQL predicates
|
|
2271
|
+
* (`projects/access.ts`), so a stray value must be impossible: text + CHECK,
|
|
2272
|
+
* never a free string.
|
|
2273
|
+
*/
|
|
2274
|
+
export declare const projectRoles: readonly ["manager", "editor", "viewer"];
|
|
2275
|
+
export type ProjectRole = (typeof projectRoles)[number];
|
|
2276
|
+
/**
|
|
2277
|
+
* One row per (project, person). **The grant rides on the workspace
|
|
2278
|
+
* membership and dies with it**: `member_id` references the
|
|
2279
|
+
* `workspace_members` row with ON DELETE CASCADE, so a removed member (a
|
|
2280
|
+
* local delete, or the hub reconcile sweeping a membership) loses every
|
|
2281
|
+
* project grant, and a later re-invite starts with none. The person and the
|
|
2282
|
+
* workspace are READ THROUGH that row, never copied beside it: a copy could
|
|
2283
|
+
* drift, and every predicate joins the membership anyway for its two live
|
|
2284
|
+
* facts (`is_active`, `origin <> 'guest'`).
|
|
2285
|
+
*/
|
|
2286
|
+
export declare const projectMembers: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2287
|
+
name: "project_members";
|
|
2288
|
+
schema: undefined;
|
|
2289
|
+
columns: {
|
|
2290
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
2291
|
+
name: "id";
|
|
2292
|
+
tableName: "project_members";
|
|
2293
|
+
dataType: "string";
|
|
2294
|
+
columnType: "PgUUID";
|
|
2295
|
+
data: string;
|
|
2296
|
+
driverParam: string;
|
|
2297
|
+
notNull: true;
|
|
2298
|
+
hasDefault: true;
|
|
2299
|
+
isPrimaryKey: true;
|
|
2300
|
+
isAutoincrement: false;
|
|
2301
|
+
hasRuntimeDefault: false;
|
|
2302
|
+
enumValues: undefined;
|
|
2303
|
+
baseColumn: never;
|
|
2304
|
+
identity: undefined;
|
|
2305
|
+
generated: undefined;
|
|
2306
|
+
}, {}, {}>;
|
|
2307
|
+
projectId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2308
|
+
name: "project_id";
|
|
2309
|
+
tableName: "project_members";
|
|
2310
|
+
dataType: "string";
|
|
2311
|
+
columnType: "PgUUID";
|
|
2312
|
+
data: string;
|
|
2313
|
+
driverParam: string;
|
|
2314
|
+
notNull: true;
|
|
2315
|
+
hasDefault: false;
|
|
2316
|
+
isPrimaryKey: false;
|
|
2317
|
+
isAutoincrement: false;
|
|
2318
|
+
hasRuntimeDefault: false;
|
|
2319
|
+
enumValues: undefined;
|
|
2320
|
+
baseColumn: never;
|
|
2321
|
+
identity: undefined;
|
|
2322
|
+
generated: undefined;
|
|
2323
|
+
}, {}, {}>;
|
|
2324
|
+
memberId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2325
|
+
name: "member_id";
|
|
2326
|
+
tableName: "project_members";
|
|
2327
|
+
dataType: "string";
|
|
2328
|
+
columnType: "PgUUID";
|
|
2329
|
+
data: string;
|
|
2330
|
+
driverParam: string;
|
|
2331
|
+
notNull: true;
|
|
2332
|
+
hasDefault: false;
|
|
2333
|
+
isPrimaryKey: false;
|
|
2334
|
+
isAutoincrement: false;
|
|
2335
|
+
hasRuntimeDefault: false;
|
|
2336
|
+
enumValues: undefined;
|
|
2337
|
+
baseColumn: never;
|
|
2338
|
+
identity: undefined;
|
|
2339
|
+
generated: undefined;
|
|
2340
|
+
}, {}, {}>;
|
|
2341
|
+
role: import("drizzle-orm/pg-core").PgColumn<{
|
|
2342
|
+
name: "role";
|
|
2343
|
+
tableName: "project_members";
|
|
2344
|
+
dataType: "string";
|
|
2345
|
+
columnType: "PgText";
|
|
2346
|
+
data: "manager" | "editor" | "viewer";
|
|
2347
|
+
driverParam: string;
|
|
2348
|
+
notNull: true;
|
|
2349
|
+
hasDefault: false;
|
|
2350
|
+
isPrimaryKey: false;
|
|
2351
|
+
isAutoincrement: false;
|
|
2352
|
+
hasRuntimeDefault: false;
|
|
2353
|
+
enumValues: ["manager", "editor", "viewer"];
|
|
2354
|
+
baseColumn: never;
|
|
2355
|
+
identity: undefined;
|
|
2356
|
+
generated: undefined;
|
|
2357
|
+
}, {}, {}>;
|
|
2358
|
+
addedBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
2359
|
+
name: "added_by";
|
|
2360
|
+
tableName: "project_members";
|
|
2361
|
+
dataType: "string";
|
|
2362
|
+
columnType: "PgText";
|
|
2363
|
+
data: string;
|
|
2364
|
+
driverParam: string;
|
|
2365
|
+
notNull: false;
|
|
2366
|
+
hasDefault: false;
|
|
2367
|
+
isPrimaryKey: false;
|
|
2368
|
+
isAutoincrement: false;
|
|
2369
|
+
hasRuntimeDefault: false;
|
|
2370
|
+
enumValues: [string, ...string[]];
|
|
2371
|
+
baseColumn: never;
|
|
2372
|
+
identity: undefined;
|
|
2373
|
+
generated: undefined;
|
|
2374
|
+
}, {}, {}>;
|
|
2375
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2376
|
+
name: "created_at";
|
|
2377
|
+
tableName: "project_members";
|
|
2378
|
+
dataType: "date";
|
|
2379
|
+
columnType: "PgTimestamp";
|
|
2380
|
+
data: Date;
|
|
2381
|
+
driverParam: string;
|
|
2382
|
+
notNull: true;
|
|
2383
|
+
hasDefault: true;
|
|
2384
|
+
isPrimaryKey: false;
|
|
2385
|
+
isAutoincrement: false;
|
|
2386
|
+
hasRuntimeDefault: false;
|
|
2387
|
+
enumValues: undefined;
|
|
2388
|
+
baseColumn: never;
|
|
2389
|
+
identity: undefined;
|
|
2390
|
+
generated: undefined;
|
|
2391
|
+
}, {}, {}>;
|
|
2392
|
+
};
|
|
2393
|
+
dialect: "pg";
|
|
2394
|
+
}>;
|
|
2395
|
+
/**
|
|
2396
|
+
* Teams: named groups of the workspace's people, a concept of the chassis on
|
|
2397
|
+
* BOTH editions with the same tables, routes and screens; only the SOURCE
|
|
2398
|
+
* differs (Romain's rule of 27 September 2026, PRDCT-2813).
|
|
2399
|
+
*
|
|
2400
|
+
* - On the self-hosted edition, and in a cloud-LOCAL workspace, a team is
|
|
2401
|
+
* the tool's own: `hub_team_id` is NULL, owners and admins create, rename
|
|
2402
|
+
* and delete it and seat members through `api/teams.ts`. Its slug is
|
|
2403
|
+
* unique within the workspace (the partial index below).
|
|
2404
|
+
* - In a hub-origin workspace (cloud) a team is the hub's, projected:
|
|
2405
|
+
* `hub_team_id` carries the hub's team id (unique: a team belongs to one
|
|
2406
|
+
* hub organization, so it projects into one workspace), and its slug and
|
|
2407
|
+
* name follow the hub on drift. The reconciler (`identity/hub-reconcile.ts`)
|
|
2408
|
+
* writes the organization's whole team list as the signed-in person reads
|
|
2409
|
+
* it, and the person's own seats from `GET /orgs`; the routes refuse every
|
|
2410
|
+
* local write there (`hub_managed`, the members' pattern). Its slug is
|
|
2411
|
+
* unique at the hub, never re-checked here: two projections read at
|
|
2412
|
+
* different moments may hold the same slug for an instant.
|
|
2413
|
+
*
|
|
2414
|
+
* A team is never a principal: it holds no credential and no role of its
|
|
2415
|
+
* own. What it does hold is a place on a project (`project_teams`, ADR 026),
|
|
2416
|
+
* which its members inherit through the one access rule.
|
|
2417
|
+
*/
|
|
2418
|
+
export declare const workspaceTeams: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2419
|
+
name: "workspace_teams";
|
|
2420
|
+
schema: undefined;
|
|
2421
|
+
columns: {
|
|
2422
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
2423
|
+
name: "id";
|
|
2424
|
+
tableName: "workspace_teams";
|
|
2425
|
+
dataType: "string";
|
|
2426
|
+
columnType: "PgUUID";
|
|
2427
|
+
data: string;
|
|
2428
|
+
driverParam: string;
|
|
2429
|
+
notNull: true;
|
|
2430
|
+
hasDefault: true;
|
|
2431
|
+
isPrimaryKey: true;
|
|
2432
|
+
isAutoincrement: false;
|
|
2433
|
+
hasRuntimeDefault: false;
|
|
2434
|
+
enumValues: undefined;
|
|
2435
|
+
baseColumn: never;
|
|
2436
|
+
identity: undefined;
|
|
2437
|
+
generated: undefined;
|
|
2438
|
+
}, {}, {}>;
|
|
2439
|
+
workspaceId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2440
|
+
name: "workspace_id";
|
|
2441
|
+
tableName: "workspace_teams";
|
|
2442
|
+
dataType: "string";
|
|
2443
|
+
columnType: "PgUUID";
|
|
2444
|
+
data: string;
|
|
2445
|
+
driverParam: string;
|
|
2446
|
+
notNull: true;
|
|
2447
|
+
hasDefault: false;
|
|
2448
|
+
isPrimaryKey: false;
|
|
2449
|
+
isAutoincrement: false;
|
|
2450
|
+
hasRuntimeDefault: false;
|
|
2451
|
+
enumValues: undefined;
|
|
2452
|
+
baseColumn: never;
|
|
2453
|
+
identity: undefined;
|
|
2454
|
+
generated: undefined;
|
|
2455
|
+
}, {}, {}>;
|
|
2456
|
+
hubTeamId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2457
|
+
name: "hub_team_id";
|
|
2458
|
+
tableName: "workspace_teams";
|
|
2459
|
+
dataType: "string";
|
|
2460
|
+
columnType: "PgText";
|
|
2461
|
+
data: string;
|
|
2462
|
+
driverParam: string;
|
|
2463
|
+
notNull: false;
|
|
2464
|
+
hasDefault: false;
|
|
2465
|
+
isPrimaryKey: false;
|
|
2466
|
+
isAutoincrement: false;
|
|
2467
|
+
hasRuntimeDefault: false;
|
|
2468
|
+
enumValues: [string, ...string[]];
|
|
2469
|
+
baseColumn: never;
|
|
2470
|
+
identity: undefined;
|
|
2471
|
+
generated: undefined;
|
|
2472
|
+
}, {}, {}>;
|
|
2473
|
+
slug: import("drizzle-orm/pg-core").PgColumn<{
|
|
2474
|
+
name: "slug";
|
|
2475
|
+
tableName: "workspace_teams";
|
|
2476
|
+
dataType: "string";
|
|
2477
|
+
columnType: "PgText";
|
|
2478
|
+
data: string;
|
|
2479
|
+
driverParam: string;
|
|
2480
|
+
notNull: true;
|
|
2481
|
+
hasDefault: false;
|
|
2482
|
+
isPrimaryKey: false;
|
|
2483
|
+
isAutoincrement: false;
|
|
2484
|
+
hasRuntimeDefault: false;
|
|
2485
|
+
enumValues: [string, ...string[]];
|
|
2486
|
+
baseColumn: never;
|
|
2487
|
+
identity: undefined;
|
|
2488
|
+
generated: undefined;
|
|
2489
|
+
}, {}, {}>;
|
|
2490
|
+
name: import("drizzle-orm/pg-core").PgColumn<{
|
|
2491
|
+
name: "name";
|
|
2492
|
+
tableName: "workspace_teams";
|
|
2493
|
+
dataType: "string";
|
|
2494
|
+
columnType: "PgText";
|
|
2495
|
+
data: string;
|
|
2496
|
+
driverParam: string;
|
|
2497
|
+
notNull: true;
|
|
2498
|
+
hasDefault: false;
|
|
2499
|
+
isPrimaryKey: false;
|
|
2500
|
+
isAutoincrement: false;
|
|
2501
|
+
hasRuntimeDefault: false;
|
|
2502
|
+
enumValues: [string, ...string[]];
|
|
2503
|
+
baseColumn: never;
|
|
2504
|
+
identity: undefined;
|
|
2505
|
+
generated: undefined;
|
|
2506
|
+
}, {}, {}>;
|
|
2507
|
+
createdBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
2508
|
+
name: "created_by";
|
|
2509
|
+
tableName: "workspace_teams";
|
|
2510
|
+
dataType: "string";
|
|
2511
|
+
columnType: "PgText";
|
|
2512
|
+
data: string;
|
|
2513
|
+
driverParam: string;
|
|
2514
|
+
notNull: false;
|
|
2515
|
+
hasDefault: false;
|
|
2516
|
+
isPrimaryKey: false;
|
|
2517
|
+
isAutoincrement: false;
|
|
2518
|
+
hasRuntimeDefault: false;
|
|
2519
|
+
enumValues: [string, ...string[]];
|
|
2520
|
+
baseColumn: never;
|
|
2521
|
+
identity: undefined;
|
|
2522
|
+
generated: undefined;
|
|
2523
|
+
}, {}, {}>;
|
|
2524
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2525
|
+
name: "created_at";
|
|
2526
|
+
tableName: "workspace_teams";
|
|
2527
|
+
dataType: "date";
|
|
2528
|
+
columnType: "PgTimestamp";
|
|
2529
|
+
data: Date;
|
|
2530
|
+
driverParam: string;
|
|
2531
|
+
notNull: true;
|
|
2532
|
+
hasDefault: true;
|
|
2533
|
+
isPrimaryKey: false;
|
|
2534
|
+
isAutoincrement: false;
|
|
2535
|
+
hasRuntimeDefault: false;
|
|
2536
|
+
enumValues: undefined;
|
|
2537
|
+
baseColumn: never;
|
|
2538
|
+
identity: undefined;
|
|
2539
|
+
generated: undefined;
|
|
2540
|
+
}, {}, {}>;
|
|
2541
|
+
updatedAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2542
|
+
name: "updated_at";
|
|
2543
|
+
tableName: "workspace_teams";
|
|
2544
|
+
dataType: "date";
|
|
2545
|
+
columnType: "PgTimestamp";
|
|
2546
|
+
data: Date;
|
|
2547
|
+
driverParam: string;
|
|
2548
|
+
notNull: true;
|
|
2549
|
+
hasDefault: true;
|
|
2550
|
+
isPrimaryKey: false;
|
|
2551
|
+
isAutoincrement: false;
|
|
2552
|
+
hasRuntimeDefault: false;
|
|
2553
|
+
enumValues: undefined;
|
|
2554
|
+
baseColumn: never;
|
|
2555
|
+
identity: undefined;
|
|
2556
|
+
generated: undefined;
|
|
2557
|
+
}, {}, {}>;
|
|
2558
|
+
};
|
|
2559
|
+
dialect: "pg";
|
|
2560
|
+
}>;
|
|
2561
|
+
/**
|
|
2562
|
+
* One row per (team, person): a seat. **The seat rides on the workspace
|
|
2563
|
+
* membership**, like a project grant: `member_id` references the
|
|
2564
|
+
* `workspace_members` row with ON DELETE CASCADE, so a team can only hold
|
|
2565
|
+
* its own workspace's people and a membership that goes takes every seat
|
|
2566
|
+
* with it. A deactivated membership keeps its seats (a pause; the access
|
|
2567
|
+
* predicates refuse it anyway); only an active one can be seated.
|
|
2568
|
+
*
|
|
2569
|
+
* On a local team the routes write the seats (an owner or admin, `added_by`
|
|
2570
|
+
* set). On a projected team the reconciler writes the PERSON's own seats as
|
|
2571
|
+
* the hub asserted them at their last pass, and deletes the seats of a team
|
|
2572
|
+
* the hub no longer lists for them; the hub sweep deletes the seats with the
|
|
2573
|
+
* membership it deactivates (a removal is a removal). A projected roster is
|
|
2574
|
+
* therefore the seats of the people who have signed in here, never the
|
|
2575
|
+
* hub's whole one.
|
|
2576
|
+
*/
|
|
2577
|
+
export declare const workspaceTeamMembers: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2578
|
+
name: "workspace_team_members";
|
|
2579
|
+
schema: undefined;
|
|
2580
|
+
columns: {
|
|
2581
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
2582
|
+
name: "id";
|
|
2583
|
+
tableName: "workspace_team_members";
|
|
2584
|
+
dataType: "string";
|
|
2585
|
+
columnType: "PgUUID";
|
|
2586
|
+
data: string;
|
|
2587
|
+
driverParam: string;
|
|
2588
|
+
notNull: true;
|
|
2589
|
+
hasDefault: true;
|
|
2590
|
+
isPrimaryKey: true;
|
|
2591
|
+
isAutoincrement: false;
|
|
2592
|
+
hasRuntimeDefault: false;
|
|
2593
|
+
enumValues: undefined;
|
|
2594
|
+
baseColumn: never;
|
|
2595
|
+
identity: undefined;
|
|
2596
|
+
generated: undefined;
|
|
2597
|
+
}, {}, {}>;
|
|
2598
|
+
teamId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2599
|
+
name: "team_id";
|
|
2600
|
+
tableName: "workspace_team_members";
|
|
2601
|
+
dataType: "string";
|
|
2602
|
+
columnType: "PgUUID";
|
|
2603
|
+
data: string;
|
|
2604
|
+
driverParam: string;
|
|
2605
|
+
notNull: true;
|
|
2606
|
+
hasDefault: false;
|
|
2607
|
+
isPrimaryKey: false;
|
|
2608
|
+
isAutoincrement: false;
|
|
2609
|
+
hasRuntimeDefault: false;
|
|
2610
|
+
enumValues: undefined;
|
|
2611
|
+
baseColumn: never;
|
|
2612
|
+
identity: undefined;
|
|
2613
|
+
generated: undefined;
|
|
2614
|
+
}, {}, {}>;
|
|
2615
|
+
memberId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2616
|
+
name: "member_id";
|
|
2617
|
+
tableName: "workspace_team_members";
|
|
2618
|
+
dataType: "string";
|
|
2619
|
+
columnType: "PgUUID";
|
|
2620
|
+
data: string;
|
|
2621
|
+
driverParam: string;
|
|
2622
|
+
notNull: true;
|
|
2623
|
+
hasDefault: false;
|
|
2624
|
+
isPrimaryKey: false;
|
|
2625
|
+
isAutoincrement: false;
|
|
2626
|
+
hasRuntimeDefault: false;
|
|
2627
|
+
enumValues: undefined;
|
|
2628
|
+
baseColumn: never;
|
|
2629
|
+
identity: undefined;
|
|
2630
|
+
generated: undefined;
|
|
2631
|
+
}, {}, {}>;
|
|
2632
|
+
addedBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
2633
|
+
name: "added_by";
|
|
2634
|
+
tableName: "workspace_team_members";
|
|
2635
|
+
dataType: "string";
|
|
2636
|
+
columnType: "PgText";
|
|
2637
|
+
data: string;
|
|
2638
|
+
driverParam: string;
|
|
2639
|
+
notNull: false;
|
|
2640
|
+
hasDefault: false;
|
|
2641
|
+
isPrimaryKey: false;
|
|
2642
|
+
isAutoincrement: false;
|
|
2643
|
+
hasRuntimeDefault: false;
|
|
2644
|
+
enumValues: [string, ...string[]];
|
|
2645
|
+
baseColumn: never;
|
|
2646
|
+
identity: undefined;
|
|
2647
|
+
generated: undefined;
|
|
2648
|
+
}, {}, {}>;
|
|
2649
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2650
|
+
name: "created_at";
|
|
2651
|
+
tableName: "workspace_team_members";
|
|
2652
|
+
dataType: "date";
|
|
2653
|
+
columnType: "PgTimestamp";
|
|
2654
|
+
data: Date;
|
|
2655
|
+
driverParam: string;
|
|
2656
|
+
notNull: true;
|
|
2657
|
+
hasDefault: true;
|
|
2658
|
+
isPrimaryKey: false;
|
|
2659
|
+
isAutoincrement: false;
|
|
2660
|
+
hasRuntimeDefault: false;
|
|
2661
|
+
enumValues: undefined;
|
|
2662
|
+
baseColumn: never;
|
|
2663
|
+
identity: undefined;
|
|
2664
|
+
generated: undefined;
|
|
2665
|
+
}, {}, {}>;
|
|
2666
|
+
};
|
|
2667
|
+
dialect: "pg";
|
|
2668
|
+
}>;
|
|
2669
|
+
/**
|
|
2670
|
+
* One row per (project, team): a team's place on a project, with a role, like
|
|
2671
|
+
* a person's (PRDCT-2794, ADR 026). Every active non-guest member of the
|
|
2672
|
+
* team holds the role through it, resolved live by the one access rule
|
|
2673
|
+
* (`projects/access.ts`), so a person seated after the grant reads the
|
|
2674
|
+
* project at once and a person unseated loses it at once; the effective role
|
|
2675
|
+
* is the highest of the person's direct grant and their teams' grants. Both
|
|
2676
|
+
* ends cascade: a deleted team, or an archived-then-deleted project, takes
|
|
2677
|
+
* the row. The same on both editions: on cloud the team is the hub's
|
|
2678
|
+
* projection, on self-hosted the tool's own.
|
|
2679
|
+
*/
|
|
2680
|
+
export declare const projectTeams: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
2681
|
+
name: "project_teams";
|
|
2682
|
+
schema: undefined;
|
|
2683
|
+
columns: {
|
|
2684
|
+
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
2685
|
+
name: "id";
|
|
2686
|
+
tableName: "project_teams";
|
|
2687
|
+
dataType: "string";
|
|
2688
|
+
columnType: "PgUUID";
|
|
2689
|
+
data: string;
|
|
2690
|
+
driverParam: string;
|
|
2691
|
+
notNull: true;
|
|
2692
|
+
hasDefault: true;
|
|
2693
|
+
isPrimaryKey: true;
|
|
2694
|
+
isAutoincrement: false;
|
|
2695
|
+
hasRuntimeDefault: false;
|
|
2696
|
+
enumValues: undefined;
|
|
2697
|
+
baseColumn: never;
|
|
2698
|
+
identity: undefined;
|
|
2699
|
+
generated: undefined;
|
|
2700
|
+
}, {}, {}>;
|
|
2701
|
+
projectId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2702
|
+
name: "project_id";
|
|
2703
|
+
tableName: "project_teams";
|
|
2704
|
+
dataType: "string";
|
|
2705
|
+
columnType: "PgUUID";
|
|
2706
|
+
data: string;
|
|
2707
|
+
driverParam: string;
|
|
2708
|
+
notNull: true;
|
|
2709
|
+
hasDefault: false;
|
|
2710
|
+
isPrimaryKey: false;
|
|
2711
|
+
isAutoincrement: false;
|
|
2712
|
+
hasRuntimeDefault: false;
|
|
2713
|
+
enumValues: undefined;
|
|
2714
|
+
baseColumn: never;
|
|
2715
|
+
identity: undefined;
|
|
2716
|
+
generated: undefined;
|
|
2717
|
+
}, {}, {}>;
|
|
2718
|
+
teamId: import("drizzle-orm/pg-core").PgColumn<{
|
|
2719
|
+
name: "team_id";
|
|
2720
|
+
tableName: "project_teams";
|
|
2721
|
+
dataType: "string";
|
|
2722
|
+
columnType: "PgUUID";
|
|
2723
|
+
data: string;
|
|
2724
|
+
driverParam: string;
|
|
2725
|
+
notNull: true;
|
|
2726
|
+
hasDefault: false;
|
|
2727
|
+
isPrimaryKey: false;
|
|
2728
|
+
isAutoincrement: false;
|
|
2729
|
+
hasRuntimeDefault: false;
|
|
2730
|
+
enumValues: undefined;
|
|
2731
|
+
baseColumn: never;
|
|
2732
|
+
identity: undefined;
|
|
2733
|
+
generated: undefined;
|
|
2734
|
+
}, {}, {}>;
|
|
2735
|
+
role: import("drizzle-orm/pg-core").PgColumn<{
|
|
2736
|
+
name: "role";
|
|
2737
|
+
tableName: "project_teams";
|
|
2738
|
+
dataType: "string";
|
|
2739
|
+
columnType: "PgText";
|
|
2740
|
+
data: "manager" | "editor" | "viewer";
|
|
2741
|
+
driverParam: string;
|
|
2742
|
+
notNull: true;
|
|
2743
|
+
hasDefault: false;
|
|
2744
|
+
isPrimaryKey: false;
|
|
2745
|
+
isAutoincrement: false;
|
|
2746
|
+
hasRuntimeDefault: false;
|
|
2747
|
+
enumValues: ["manager", "editor", "viewer"];
|
|
2748
|
+
baseColumn: never;
|
|
2749
|
+
identity: undefined;
|
|
2750
|
+
generated: undefined;
|
|
2751
|
+
}, {}, {}>;
|
|
2752
|
+
addedBy: import("drizzle-orm/pg-core").PgColumn<{
|
|
2753
|
+
name: "added_by";
|
|
2754
|
+
tableName: "project_teams";
|
|
2755
|
+
dataType: "string";
|
|
2756
|
+
columnType: "PgText";
|
|
2757
|
+
data: string;
|
|
2758
|
+
driverParam: string;
|
|
2759
|
+
notNull: false;
|
|
2760
|
+
hasDefault: false;
|
|
2761
|
+
isPrimaryKey: false;
|
|
2762
|
+
isAutoincrement: false;
|
|
2763
|
+
hasRuntimeDefault: false;
|
|
2764
|
+
enumValues: [string, ...string[]];
|
|
2765
|
+
baseColumn: never;
|
|
2766
|
+
identity: undefined;
|
|
2767
|
+
generated: undefined;
|
|
2768
|
+
}, {}, {}>;
|
|
2769
|
+
createdAt: import("drizzle-orm/pg-core").PgColumn<{
|
|
2770
|
+
name: "created_at";
|
|
2771
|
+
tableName: "project_teams";
|
|
2772
|
+
dataType: "date";
|
|
2773
|
+
columnType: "PgTimestamp";
|
|
2774
|
+
data: Date;
|
|
2775
|
+
driverParam: string;
|
|
2776
|
+
notNull: true;
|
|
2777
|
+
hasDefault: true;
|
|
2778
|
+
isPrimaryKey: false;
|
|
2779
|
+
isAutoincrement: false;
|
|
2780
|
+
hasRuntimeDefault: false;
|
|
2781
|
+
enumValues: undefined;
|
|
2782
|
+
baseColumn: never;
|
|
2783
|
+
identity: undefined;
|
|
2784
|
+
generated: undefined;
|
|
2785
|
+
}, {}, {}>;
|
|
2786
|
+
};
|
|
2787
|
+
dialect: "pg";
|
|
2788
|
+
}>;
|
|
2789
|
+
export type InstanceSettings = typeof instanceSettings.$inferSelect;
|
|
2790
|
+
export type Workspace = typeof workspaces.$inferSelect;
|
|
2791
|
+
export type WorkspaceMember = typeof workspaceMembers.$inferSelect;
|
|
2792
|
+
export type Invitation = typeof invitations.$inferSelect;
|
|
2793
|
+
export type DemoPassRow = typeof demoPasses.$inferSelect;
|
|
2794
|
+
export type ApiKey = typeof apiKeys.$inferSelect;
|
|
2795
|
+
export type IdempotencyKey = typeof idempotencyKeys.$inferSelect;
|
|
2796
|
+
export type AuditEntry = typeof auditLog.$inferSelect;
|
|
2797
|
+
export type FileRow = typeof files.$inferSelect;
|
|
2798
|
+
export type FileUploaderRow = typeof fileUploaders.$inferSelect;
|
|
2799
|
+
export type ProjectRow = typeof projects.$inferSelect;
|
|
2800
|
+
export type ProjectMemberRow = typeof projectMembers.$inferSelect;
|
|
2801
|
+
export type WorkspaceTeamRow = typeof workspaceTeams.$inferSelect;
|
|
2802
|
+
export type WorkspaceTeamMemberRow = typeof workspaceTeamMembers.$inferSelect;
|
|
2803
|
+
export type ProjectTeamRow = typeof projectTeams.$inferSelect;
|
|
2804
|
+
//# sourceMappingURL=schema.d.ts.map
|