@verdict-ai/db 0.0.0-stage → 0.2.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.
Files changed (65) hide show
  1. package/LICENSE +9 -0
  2. package/README.md +21 -2
  3. package/dist/auth.d.ts +44 -0
  4. package/dist/auth.js +81 -0
  5. package/dist/auth.js.map +1 -0
  6. package/dist/control.d.ts +58 -0
  7. package/dist/control.js +305 -0
  8. package/dist/control.js.map +1 -0
  9. package/dist/d1.d.ts +2235 -0
  10. package/dist/d1.js +21 -0
  11. package/dist/d1.js.map +1 -0
  12. package/dist/dialects.d.ts +21 -0
  13. package/dist/dialects.js +83 -0
  14. package/dist/dialects.js.map +1 -0
  15. package/dist/documents.d.ts +89 -0
  16. package/dist/documents.js +45 -0
  17. package/dist/documents.js.map +1 -0
  18. package/dist/errors.d.ts +7 -0
  19. package/dist/errors.js +21 -0
  20. package/dist/errors.js.map +1 -0
  21. package/dist/index.d.ts +9 -0
  22. package/dist/index.js +12 -0
  23. package/dist/index.js.map +1 -0
  24. package/dist/postgres.d.ts +4111 -0
  25. package/dist/postgres.js +63 -0
  26. package/dist/postgres.js.map +1 -0
  27. package/dist/queries.d.ts +33 -0
  28. package/dist/queries.js +72 -0
  29. package/dist/queries.js.map +1 -0
  30. package/dist/schema/control.d.ts +71 -0
  31. package/dist/schema/control.js +29 -0
  32. package/dist/schema/control.js.map +1 -0
  33. package/dist/schema/pg.d.ts +4083 -0
  34. package/dist/schema/pg.js +132 -0
  35. package/dist/schema/pg.js.map +1 -0
  36. package/dist/schema/sqlite.d.ts +4457 -0
  37. package/dist/schema/sqlite.js +132 -0
  38. package/dist/schema/sqlite.js.map +1 -0
  39. package/dist/sqlite.d.ts +25 -0
  40. package/dist/sqlite.js +64 -0
  41. package/dist/sqlite.js.map +1 -0
  42. package/dist/store.d.ts +55 -0
  43. package/dist/store.js +220 -0
  44. package/dist/store.js.map +1 -0
  45. package/drizzle/0000_init.sql +66 -0
  46. package/drizzle/0001_idempotency.sql +12 -0
  47. package/drizzle/0002_publications.sql +20 -0
  48. package/drizzle/0003_publishers.sql +9 -0
  49. package/drizzle/0004_control_plane.sql +75 -0
  50. package/drizzle/meta/0000_snapshot.json +452 -0
  51. package/drizzle/meta/0001_snapshot.json +527 -0
  52. package/drizzle/meta/0002_snapshot.json +659 -0
  53. package/drizzle/meta/0003_snapshot.json +712 -0
  54. package/drizzle/meta/0004_snapshot.json +1191 -0
  55. package/drizzle/meta/_journal.json +41 -0
  56. package/drizzle/pg/0000_init.sql +78 -0
  57. package/drizzle/pg/0001_publications.sql +20 -0
  58. package/drizzle/pg/0002_publishers.sql +9 -0
  59. package/drizzle/pg/0003_control_plane.sql +75 -0
  60. package/drizzle/pg/meta/0000_snapshot.json +605 -0
  61. package/drizzle/pg/meta/0001_snapshot.json +769 -0
  62. package/drizzle/pg/meta/0002_snapshot.json +828 -0
  63. package/drizzle/pg/meta/0003_snapshot.json +1381 -0
  64. package/drizzle/pg/meta/_journal.json +34 -0
  65. package/package.json +82 -3
package/dist/postgres.d.ts ADDED
@@ -0,0 +1,4111 @@
1
+ /**
2
+ * Opens Postgres or embedded PGlite and applies generated migrations.
3
+ * Failed startup releases its connection; migration tracking preserves ordered, once-only application.
4
+ */
5
+ import type { SQL } from "drizzle-orm";
6
+ import { PgStore } from "./store.js";
7
+ import { DrizzleAuth, type KeyAuth } from "./auth.js";
8
+ /** Node-only entry point. Drivers are loaded only when a connection is requested. */
9
+ export declare function fromPostgres(connectionString: string, fallbackAuth?: KeyAuth, loadDriver?: () => Promise<typeof import("pg")>): Promise<{
10
+ db: import("drizzle-orm/node-postgres").NodePgDatabase<{
11
+ rubrics: import("drizzle-orm/pg-core").PgTableWithColumns<{
12
+ name: "rubrics";
13
+ schema: undefined;
14
+ columns: {
15
+ id: import("drizzle-orm/pg-core").PgColumn<{
16
+ name: "id";
17
+ tableName: "rubrics";
18
+ dataType: "string";
19
+ columnType: "PgText";
20
+ data: string;
21
+ driverParam: string;
22
+ notNull: true;
23
+ hasDefault: false;
24
+ isPrimaryKey: true;
25
+ isAutoincrement: false;
26
+ hasRuntimeDefault: false;
27
+ enumValues: [string, ...string[]];
28
+ baseColumn: never;
29
+ identity: undefined;
30
+ generated: undefined;
31
+ }, {}, {}>;
32
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
33
+ name: "tenant_id";
34
+ tableName: "rubrics";
35
+ dataType: "string";
36
+ columnType: "PgText";
37
+ data: string;
38
+ driverParam: string;
39
+ notNull: false;
40
+ hasDefault: false;
41
+ isPrimaryKey: false;
42
+ isAutoincrement: false;
43
+ hasRuntimeDefault: false;
44
+ enumValues: [string, ...string[]];
45
+ baseColumn: never;
46
+ identity: undefined;
47
+ generated: undefined;
48
+ }, {}, {}>;
49
+ name: import("drizzle-orm/pg-core").PgColumn<{
50
+ name: "name";
51
+ tableName: "rubrics";
52
+ dataType: "string";
53
+ columnType: "PgText";
54
+ data: string;
55
+ driverParam: string;
56
+ notNull: true;
57
+ hasDefault: false;
58
+ isPrimaryKey: false;
59
+ isAutoincrement: false;
60
+ hasRuntimeDefault: false;
61
+ enumValues: [string, ...string[]];
62
+ baseColumn: never;
63
+ identity: undefined;
64
+ generated: undefined;
65
+ }, {}, {}>;
66
+ version: import("drizzle-orm/pg-core").PgColumn<{
67
+ name: "version";
68
+ tableName: "rubrics";
69
+ dataType: "string";
70
+ columnType: "PgText";
71
+ data: string;
72
+ driverParam: string;
73
+ notNull: true;
74
+ hasDefault: true;
75
+ isPrimaryKey: false;
76
+ isAutoincrement: false;
77
+ hasRuntimeDefault: false;
78
+ enumValues: [string, ...string[]];
79
+ baseColumn: never;
80
+ identity: undefined;
81
+ generated: undefined;
82
+ }, {}, {}>;
83
+ doc: import("drizzle-orm/pg-core").PgColumn<{
84
+ name: "doc";
85
+ tableName: "rubrics";
86
+ dataType: "json";
87
+ columnType: "PgJsonb";
88
+ data: Record<string, unknown>;
89
+ driverParam: unknown;
90
+ notNull: true;
91
+ hasDefault: false;
92
+ isPrimaryKey: false;
93
+ isAutoincrement: false;
94
+ hasRuntimeDefault: false;
95
+ enumValues: undefined;
96
+ baseColumn: never;
97
+ identity: undefined;
98
+ generated: undefined;
99
+ }, {}, {
100
+ $type: Record<string, unknown>;
101
+ }>;
102
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
103
+ name: "created_at";
104
+ tableName: "rubrics";
105
+ dataType: "string";
106
+ columnType: "PgText";
107
+ data: string;
108
+ driverParam: string;
109
+ notNull: true;
110
+ hasDefault: false;
111
+ isPrimaryKey: false;
112
+ isAutoincrement: false;
113
+ hasRuntimeDefault: false;
114
+ enumValues: [string, ...string[]];
115
+ baseColumn: never;
116
+ identity: undefined;
117
+ generated: undefined;
118
+ }, {}, {}>;
119
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
120
+ name: "updated_at";
121
+ tableName: "rubrics";
122
+ dataType: "string";
123
+ columnType: "PgText";
124
+ data: string;
125
+ driverParam: string;
126
+ notNull: true;
127
+ hasDefault: false;
128
+ isPrimaryKey: false;
129
+ isAutoincrement: false;
130
+ hasRuntimeDefault: false;
131
+ enumValues: [string, ...string[]];
132
+ baseColumn: never;
133
+ identity: undefined;
134
+ generated: undefined;
135
+ }, {}, {}>;
136
+ };
137
+ dialect: "pg";
138
+ }>;
139
+ evaluations: import("drizzle-orm/pg-core").PgTableWithColumns<{
140
+ name: "evaluations";
141
+ schema: undefined;
142
+ columns: {
143
+ id: import("drizzle-orm/pg-core").PgColumn<{
144
+ name: "id";
145
+ tableName: "evaluations";
146
+ dataType: "string";
147
+ columnType: "PgText";
148
+ data: string;
149
+ driverParam: string;
150
+ notNull: true;
151
+ hasDefault: false;
152
+ isPrimaryKey: true;
153
+ isAutoincrement: false;
154
+ hasRuntimeDefault: false;
155
+ enumValues: [string, ...string[]];
156
+ baseColumn: never;
157
+ identity: undefined;
158
+ generated: undefined;
159
+ }, {}, {}>;
160
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
161
+ name: "tenant_id";
162
+ tableName: "evaluations";
163
+ dataType: "string";
164
+ columnType: "PgText";
165
+ data: string;
166
+ driverParam: string;
167
+ notNull: false;
168
+ hasDefault: false;
169
+ isPrimaryKey: false;
170
+ isAutoincrement: false;
171
+ hasRuntimeDefault: false;
172
+ enumValues: [string, ...string[]];
173
+ baseColumn: never;
174
+ identity: undefined;
175
+ generated: undefined;
176
+ }, {}, {}>;
177
+ rubricId: import("drizzle-orm/pg-core").PgColumn<{
178
+ name: "rubric_id";
179
+ tableName: "evaluations";
180
+ dataType: "string";
181
+ columnType: "PgText";
182
+ data: string;
183
+ driverParam: string;
184
+ notNull: false;
185
+ hasDefault: false;
186
+ isPrimaryKey: false;
187
+ isAutoincrement: false;
188
+ hasRuntimeDefault: false;
189
+ enumValues: [string, ...string[]];
190
+ baseColumn: never;
191
+ identity: undefined;
192
+ generated: undefined;
193
+ }, {}, {}>;
194
+ rubricName: import("drizzle-orm/pg-core").PgColumn<{
195
+ name: "rubric_name";
196
+ tableName: "evaluations";
197
+ dataType: "string";
198
+ columnType: "PgText";
199
+ data: string;
200
+ driverParam: string;
201
+ notNull: true;
202
+ hasDefault: false;
203
+ isPrimaryKey: false;
204
+ isAutoincrement: false;
205
+ hasRuntimeDefault: false;
206
+ enumValues: [string, ...string[]];
207
+ baseColumn: never;
208
+ identity: undefined;
209
+ generated: undefined;
210
+ }, {}, {}>;
211
+ subjectName: import("drizzle-orm/pg-core").PgColumn<{
212
+ name: "subject_name";
213
+ tableName: "evaluations";
214
+ dataType: "string";
215
+ columnType: "PgText";
216
+ data: string;
217
+ driverParam: string;
218
+ notNull: false;
219
+ hasDefault: false;
220
+ isPrimaryKey: false;
221
+ isAutoincrement: false;
222
+ hasRuntimeDefault: false;
223
+ enumValues: [string, ...string[]];
224
+ baseColumn: never;
225
+ identity: undefined;
226
+ generated: undefined;
227
+ }, {}, {}>;
228
+ status: import("drizzle-orm/pg-core").PgColumn<{
229
+ name: "status";
230
+ tableName: "evaluations";
231
+ dataType: "string";
232
+ columnType: "PgText";
233
+ data: string;
234
+ driverParam: string;
235
+ notNull: true;
236
+ hasDefault: false;
237
+ isPrimaryKey: false;
238
+ isAutoincrement: false;
239
+ hasRuntimeDefault: false;
240
+ enumValues: [string, ...string[]];
241
+ baseColumn: never;
242
+ identity: undefined;
243
+ generated: undefined;
244
+ }, {}, {}>;
245
+ score: import("drizzle-orm/pg-core").PgColumn<{
246
+ name: "score";
247
+ tableName: "evaluations";
248
+ dataType: "number";
249
+ columnType: "PgDoublePrecision";
250
+ data: number;
251
+ driverParam: string | number;
252
+ notNull: false;
253
+ hasDefault: false;
254
+ isPrimaryKey: false;
255
+ isAutoincrement: false;
256
+ hasRuntimeDefault: false;
257
+ enumValues: undefined;
258
+ baseColumn: never;
259
+ identity: undefined;
260
+ generated: undefined;
261
+ }, {}, {}>;
262
+ grade: import("drizzle-orm/pg-core").PgColumn<{
263
+ name: "grade";
264
+ tableName: "evaluations";
265
+ dataType: "string";
266
+ columnType: "PgText";
267
+ data: string;
268
+ driverParam: string;
269
+ notNull: false;
270
+ hasDefault: false;
271
+ isPrimaryKey: false;
272
+ isAutoincrement: false;
273
+ hasRuntimeDefault: false;
274
+ enumValues: [string, ...string[]];
275
+ baseColumn: never;
276
+ identity: undefined;
277
+ generated: undefined;
278
+ }, {}, {}>;
279
+ passed: import("drizzle-orm/pg-core").PgColumn<{
280
+ name: "passed";
281
+ tableName: "evaluations";
282
+ dataType: "boolean";
283
+ columnType: "PgBoolean";
284
+ data: boolean;
285
+ driverParam: boolean;
286
+ notNull: false;
287
+ hasDefault: false;
288
+ isPrimaryKey: false;
289
+ isAutoincrement: false;
290
+ hasRuntimeDefault: false;
291
+ enumValues: undefined;
292
+ baseColumn: never;
293
+ identity: undefined;
294
+ generated: undefined;
295
+ }, {}, {}>;
296
+ pendingHuman: import("drizzle-orm/pg-core").PgColumn<{
297
+ name: "pending_human";
298
+ tableName: "evaluations";
299
+ dataType: "number";
300
+ columnType: "PgInteger";
301
+ data: number;
302
+ driverParam: string | number;
303
+ notNull: true;
304
+ hasDefault: true;
305
+ isPrimaryKey: false;
306
+ isAutoincrement: false;
307
+ hasRuntimeDefault: false;
308
+ enumValues: undefined;
309
+ baseColumn: never;
310
+ identity: undefined;
311
+ generated: undefined;
312
+ }, {}, {}>;
313
+ decisionCalls: import("drizzle-orm/pg-core").PgColumn<{
314
+ name: "decision_calls";
315
+ tableName: "evaluations";
316
+ dataType: "number";
317
+ columnType: "PgInteger";
318
+ data: number;
319
+ driverParam: string | number;
320
+ notNull: true;
321
+ hasDefault: true;
322
+ isPrimaryKey: false;
323
+ isAutoincrement: false;
324
+ hasRuntimeDefault: false;
325
+ enumValues: undefined;
326
+ baseColumn: never;
327
+ identity: undefined;
328
+ generated: undefined;
329
+ }, {}, {}>;
330
+ llmCalls: import("drizzle-orm/pg-core").PgColumn<{
331
+ name: "llm_calls";
332
+ tableName: "evaluations";
333
+ dataType: "number";
334
+ columnType: "PgInteger";
335
+ data: number;
336
+ driverParam: string | number;
337
+ notNull: true;
338
+ hasDefault: true;
339
+ isPrimaryKey: false;
340
+ isAutoincrement: false;
341
+ hasRuntimeDefault: false;
342
+ enumValues: undefined;
343
+ baseColumn: never;
344
+ identity: undefined;
345
+ generated: undefined;
346
+ }, {}, {}>;
347
+ inputTokens: import("drizzle-orm/pg-core").PgColumn<{
348
+ name: "input_tokens";
349
+ tableName: "evaluations";
350
+ dataType: "number";
351
+ columnType: "PgInteger";
352
+ data: number;
353
+ driverParam: string | number;
354
+ notNull: true;
355
+ hasDefault: true;
356
+ isPrimaryKey: false;
357
+ isAutoincrement: false;
358
+ hasRuntimeDefault: false;
359
+ enumValues: undefined;
360
+ baseColumn: never;
361
+ identity: undefined;
362
+ generated: undefined;
363
+ }, {}, {}>;
364
+ durationMs: import("drizzle-orm/pg-core").PgColumn<{
365
+ name: "duration_ms";
366
+ tableName: "evaluations";
367
+ dataType: "number";
368
+ columnType: "PgInteger";
369
+ data: number;
370
+ driverParam: string | number;
371
+ notNull: true;
372
+ hasDefault: true;
373
+ isPrimaryKey: false;
374
+ isAutoincrement: false;
375
+ hasRuntimeDefault: false;
376
+ enumValues: undefined;
377
+ baseColumn: never;
378
+ identity: undefined;
379
+ generated: undefined;
380
+ }, {}, {}>;
381
+ doc: import("drizzle-orm/pg-core").PgColumn<{
382
+ name: "doc";
383
+ tableName: "evaluations";
384
+ dataType: "json";
385
+ columnType: "PgJsonb";
386
+ data: Record<string, unknown>;
387
+ driverParam: unknown;
388
+ notNull: true;
389
+ hasDefault: false;
390
+ isPrimaryKey: false;
391
+ isAutoincrement: false;
392
+ hasRuntimeDefault: false;
393
+ enumValues: undefined;
394
+ baseColumn: never;
395
+ identity: undefined;
396
+ generated: undefined;
397
+ }, {}, {
398
+ $type: Record<string, unknown>;
399
+ }>;
400
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
401
+ name: "created_at";
402
+ tableName: "evaluations";
403
+ dataType: "string";
404
+ columnType: "PgText";
405
+ data: string;
406
+ driverParam: string;
407
+ notNull: true;
408
+ hasDefault: false;
409
+ isPrimaryKey: false;
410
+ isAutoincrement: false;
411
+ hasRuntimeDefault: false;
412
+ enumValues: [string, ...string[]];
413
+ baseColumn: never;
414
+ identity: undefined;
415
+ generated: undefined;
416
+ }, {}, {}>;
417
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
418
+ name: "updated_at";
419
+ tableName: "evaluations";
420
+ dataType: "string";
421
+ columnType: "PgText";
422
+ data: string;
423
+ driverParam: string;
424
+ notNull: true;
425
+ hasDefault: false;
426
+ isPrimaryKey: false;
427
+ isAutoincrement: false;
428
+ hasRuntimeDefault: false;
429
+ enumValues: [string, ...string[]];
430
+ baseColumn: never;
431
+ identity: undefined;
432
+ generated: undefined;
433
+ }, {}, {}>;
434
+ };
435
+ dialect: "pg";
436
+ }>;
437
+ ratings: import("drizzle-orm/pg-core").PgTableWithColumns<{
438
+ name: "ratings";
439
+ schema: undefined;
440
+ columns: {
441
+ id: import("drizzle-orm/pg-core").PgColumn<{
442
+ name: "id";
443
+ tableName: "ratings";
444
+ dataType: "string";
445
+ columnType: "PgText";
446
+ data: string;
447
+ driverParam: string;
448
+ notNull: true;
449
+ hasDefault: false;
450
+ isPrimaryKey: true;
451
+ isAutoincrement: false;
452
+ hasRuntimeDefault: false;
453
+ enumValues: [string, ...string[]];
454
+ baseColumn: never;
455
+ identity: undefined;
456
+ generated: undefined;
457
+ }, {}, {}>;
458
+ evaluationId: import("drizzle-orm/pg-core").PgColumn<{
459
+ name: "evaluation_id";
460
+ tableName: "ratings";
461
+ dataType: "string";
462
+ columnType: "PgText";
463
+ data: string;
464
+ driverParam: string;
465
+ notNull: true;
466
+ hasDefault: false;
467
+ isPrimaryKey: false;
468
+ isAutoincrement: false;
469
+ hasRuntimeDefault: false;
470
+ enumValues: [string, ...string[]];
471
+ baseColumn: never;
472
+ identity: undefined;
473
+ generated: undefined;
474
+ }, {}, {}>;
475
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
476
+ name: "tenant_id";
477
+ tableName: "ratings";
478
+ dataType: "string";
479
+ columnType: "PgText";
480
+ data: string;
481
+ driverParam: string;
482
+ notNull: false;
483
+ hasDefault: false;
484
+ isPrimaryKey: false;
485
+ isAutoincrement: false;
486
+ hasRuntimeDefault: false;
487
+ enumValues: [string, ...string[]];
488
+ baseColumn: never;
489
+ identity: undefined;
490
+ generated: undefined;
491
+ }, {}, {}>;
492
+ rubricId: import("drizzle-orm/pg-core").PgColumn<{
493
+ name: "rubric_id";
494
+ tableName: "ratings";
495
+ dataType: "string";
496
+ columnType: "PgText";
497
+ data: string;
498
+ driverParam: string;
499
+ notNull: false;
500
+ hasDefault: false;
501
+ isPrimaryKey: false;
502
+ isAutoincrement: false;
503
+ hasRuntimeDefault: false;
504
+ enumValues: [string, ...string[]];
505
+ baseColumn: never;
506
+ identity: undefined;
507
+ generated: undefined;
508
+ }, {}, {}>;
509
+ criterionId: import("drizzle-orm/pg-core").PgColumn<{
510
+ name: "criterion_id";
511
+ tableName: "ratings";
512
+ dataType: "string";
513
+ columnType: "PgText";
514
+ data: string;
515
+ driverParam: string;
516
+ notNull: true;
517
+ hasDefault: false;
518
+ isPrimaryKey: false;
519
+ isAutoincrement: false;
520
+ hasRuntimeDefault: false;
521
+ enumValues: [string, ...string[]];
522
+ baseColumn: never;
523
+ identity: undefined;
524
+ generated: undefined;
525
+ }, {}, {}>;
526
+ raterId: import("drizzle-orm/pg-core").PgColumn<{
527
+ name: "rater_id";
528
+ tableName: "ratings";
529
+ dataType: "string";
530
+ columnType: "PgText";
531
+ data: string;
532
+ driverParam: string;
533
+ notNull: true;
534
+ hasDefault: false;
535
+ isPrimaryKey: false;
536
+ isAutoincrement: false;
537
+ hasRuntimeDefault: false;
538
+ enumValues: [string, ...string[]];
539
+ baseColumn: never;
540
+ identity: undefined;
541
+ generated: undefined;
542
+ }, {}, {}>;
543
+ judgeType: import("drizzle-orm/pg-core").PgColumn<{
544
+ name: "judge_type";
545
+ tableName: "ratings";
546
+ dataType: "string";
547
+ columnType: "PgText";
548
+ data: string;
549
+ driverParam: string;
550
+ notNull: true;
551
+ hasDefault: false;
552
+ isPrimaryKey: false;
553
+ isAutoincrement: false;
554
+ hasRuntimeDefault: false;
555
+ enumValues: [string, ...string[]];
556
+ baseColumn: never;
557
+ identity: undefined;
558
+ generated: undefined;
559
+ }, {}, {}>;
560
+ status: import("drizzle-orm/pg-core").PgColumn<{
561
+ name: "status";
562
+ tableName: "ratings";
563
+ dataType: "string";
564
+ columnType: "PgText";
565
+ data: string;
566
+ driverParam: string;
567
+ notNull: true;
568
+ hasDefault: false;
569
+ isPrimaryKey: false;
570
+ isAutoincrement: false;
571
+ hasRuntimeDefault: false;
572
+ enumValues: [string, ...string[]];
573
+ baseColumn: never;
574
+ identity: undefined;
575
+ generated: undefined;
576
+ }, {}, {}>;
577
+ score: import("drizzle-orm/pg-core").PgColumn<{
578
+ name: "score";
579
+ tableName: "ratings";
580
+ dataType: "number";
581
+ columnType: "PgDoublePrecision";
582
+ data: number;
583
+ driverParam: string | number;
584
+ notNull: false;
585
+ hasDefault: false;
586
+ isPrimaryKey: false;
587
+ isAutoincrement: false;
588
+ hasRuntimeDefault: false;
589
+ enumValues: undefined;
590
+ baseColumn: never;
591
+ identity: undefined;
592
+ generated: undefined;
593
+ }, {}, {}>;
594
+ normalized: import("drizzle-orm/pg-core").PgColumn<{
595
+ name: "normalized";
596
+ tableName: "ratings";
597
+ dataType: "number";
598
+ columnType: "PgDoublePrecision";
599
+ data: number;
600
+ driverParam: string | number;
601
+ notNull: false;
602
+ hasDefault: false;
603
+ isPrimaryKey: false;
604
+ isAutoincrement: false;
605
+ hasRuntimeDefault: false;
606
+ enumValues: undefined;
607
+ baseColumn: never;
608
+ identity: undefined;
609
+ generated: undefined;
610
+ }, {}, {}>;
611
+ confidence: import("drizzle-orm/pg-core").PgColumn<{
612
+ name: "confidence";
613
+ tableName: "ratings";
614
+ dataType: "number";
615
+ columnType: "PgDoublePrecision";
616
+ data: number;
617
+ driverParam: string | number;
618
+ notNull: false;
619
+ hasDefault: false;
620
+ isPrimaryKey: false;
621
+ isAutoincrement: false;
622
+ hasRuntimeDefault: false;
623
+ enumValues: undefined;
624
+ baseColumn: never;
625
+ identity: undefined;
626
+ generated: undefined;
627
+ }, {}, {}>;
628
+ model: import("drizzle-orm/pg-core").PgColumn<{
629
+ name: "model";
630
+ tableName: "ratings";
631
+ dataType: "string";
632
+ columnType: "PgText";
633
+ data: string;
634
+ driverParam: string;
635
+ notNull: false;
636
+ hasDefault: false;
637
+ isPrimaryKey: false;
638
+ isAutoincrement: false;
639
+ hasRuntimeDefault: false;
640
+ enumValues: [string, ...string[]];
641
+ baseColumn: never;
642
+ identity: undefined;
643
+ generated: undefined;
644
+ }, {}, {}>;
645
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
646
+ name: "created_at";
647
+ tableName: "ratings";
648
+ dataType: "string";
649
+ columnType: "PgText";
650
+ data: string;
651
+ driverParam: string;
652
+ notNull: true;
653
+ hasDefault: false;
654
+ isPrimaryKey: false;
655
+ isAutoincrement: false;
656
+ hasRuntimeDefault: false;
657
+ enumValues: [string, ...string[]];
658
+ baseColumn: never;
659
+ identity: undefined;
660
+ generated: undefined;
661
+ }, {}, {}>;
662
+ };
663
+ dialect: "pg";
664
+ }>;
665
+ apiKeys: import("drizzle-orm/pg-core").PgTableWithColumns<{
666
+ name: "api_keys";
667
+ schema: undefined;
668
+ columns: {
669
+ id: import("drizzle-orm/pg-core").PgColumn<{
670
+ name: "id";
671
+ tableName: "api_keys";
672
+ dataType: "string";
673
+ columnType: "PgText";
674
+ data: string;
675
+ driverParam: string;
676
+ notNull: true;
677
+ hasDefault: false;
678
+ isPrimaryKey: true;
679
+ isAutoincrement: false;
680
+ hasRuntimeDefault: false;
681
+ enumValues: [string, ...string[]];
682
+ baseColumn: never;
683
+ identity: undefined;
684
+ generated: undefined;
685
+ }, {}, {}>;
686
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
687
+ name: "tenant_id";
688
+ tableName: "api_keys";
689
+ dataType: "string";
690
+ columnType: "PgText";
691
+ data: string;
692
+ driverParam: string;
693
+ notNull: true;
694
+ hasDefault: false;
695
+ isPrimaryKey: false;
696
+ isAutoincrement: false;
697
+ hasRuntimeDefault: false;
698
+ enumValues: [string, ...string[]];
699
+ baseColumn: never;
700
+ identity: undefined;
701
+ generated: undefined;
702
+ }, {}, {}>;
703
+ name: import("drizzle-orm/pg-core").PgColumn<{
704
+ name: "name";
705
+ tableName: "api_keys";
706
+ dataType: "string";
707
+ columnType: "PgText";
708
+ data: string;
709
+ driverParam: string;
710
+ notNull: true;
711
+ hasDefault: false;
712
+ isPrimaryKey: false;
713
+ isAutoincrement: false;
714
+ hasRuntimeDefault: false;
715
+ enumValues: [string, ...string[]];
716
+ baseColumn: never;
717
+ identity: undefined;
718
+ generated: undefined;
719
+ }, {}, {}>;
720
+ keyHash: import("drizzle-orm/pg-core").PgColumn<{
721
+ name: "key_hash";
722
+ tableName: "api_keys";
723
+ dataType: "string";
724
+ columnType: "PgText";
725
+ data: string;
726
+ driverParam: string;
727
+ notNull: true;
728
+ hasDefault: false;
729
+ isPrimaryKey: false;
730
+ isAutoincrement: false;
731
+ hasRuntimeDefault: false;
732
+ enumValues: [string, ...string[]];
733
+ baseColumn: never;
734
+ identity: undefined;
735
+ generated: undefined;
736
+ }, {}, {}>;
737
+ prefix: import("drizzle-orm/pg-core").PgColumn<{
738
+ name: "prefix";
739
+ tableName: "api_keys";
740
+ dataType: "string";
741
+ columnType: "PgText";
742
+ data: string;
743
+ driverParam: string;
744
+ notNull: true;
745
+ hasDefault: false;
746
+ isPrimaryKey: false;
747
+ isAutoincrement: false;
748
+ hasRuntimeDefault: false;
749
+ enumValues: [string, ...string[]];
750
+ baseColumn: never;
751
+ identity: undefined;
752
+ generated: undefined;
753
+ }, {}, {}>;
754
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
755
+ name: "created_at";
756
+ tableName: "api_keys";
757
+ dataType: "string";
758
+ columnType: "PgText";
759
+ data: string;
760
+ driverParam: string;
761
+ notNull: true;
762
+ hasDefault: false;
763
+ isPrimaryKey: false;
764
+ isAutoincrement: false;
765
+ hasRuntimeDefault: false;
766
+ enumValues: [string, ...string[]];
767
+ baseColumn: never;
768
+ identity: undefined;
769
+ generated: undefined;
770
+ }, {}, {}>;
771
+ lastUsedAt: import("drizzle-orm/pg-core").PgColumn<{
772
+ name: "last_used_at";
773
+ tableName: "api_keys";
774
+ dataType: "string";
775
+ columnType: "PgText";
776
+ data: string;
777
+ driverParam: string;
778
+ notNull: false;
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
+ revokedAt: import("drizzle-orm/pg-core").PgColumn<{
789
+ name: "revoked_at";
790
+ tableName: "api_keys";
791
+ dataType: "string";
792
+ columnType: "PgText";
793
+ data: string;
794
+ driverParam: string;
795
+ notNull: false;
796
+ hasDefault: false;
797
+ isPrimaryKey: false;
798
+ isAutoincrement: false;
799
+ hasRuntimeDefault: false;
800
+ enumValues: [string, ...string[]];
801
+ baseColumn: never;
802
+ identity: undefined;
803
+ generated: undefined;
804
+ }, {}, {}>;
805
+ };
806
+ dialect: "pg";
807
+ }>;
808
+ idempotencyKeys: import("drizzle-orm/pg-core").PgTableWithColumns<{
809
+ name: "idempotency_keys";
810
+ schema: undefined;
811
+ columns: {
812
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
813
+ name: "tenant_id";
814
+ tableName: "idempotency_keys";
815
+ dataType: "string";
816
+ columnType: "PgText";
817
+ data: string;
818
+ driverParam: string;
819
+ notNull: false;
820
+ hasDefault: false;
821
+ isPrimaryKey: false;
822
+ isAutoincrement: false;
823
+ hasRuntimeDefault: false;
824
+ enumValues: [string, ...string[]];
825
+ baseColumn: never;
826
+ identity: undefined;
827
+ generated: undefined;
828
+ }, {}, {}>;
829
+ key: import("drizzle-orm/pg-core").PgColumn<{
830
+ name: "key";
831
+ tableName: "idempotency_keys";
832
+ dataType: "string";
833
+ columnType: "PgText";
834
+ data: string;
835
+ driverParam: string;
836
+ notNull: true;
837
+ hasDefault: false;
838
+ isPrimaryKey: false;
839
+ isAutoincrement: false;
840
+ hasRuntimeDefault: false;
841
+ enumValues: [string, ...string[]];
842
+ baseColumn: never;
843
+ identity: undefined;
844
+ generated: undefined;
845
+ }, {}, {}>;
846
+ fingerprint: import("drizzle-orm/pg-core").PgColumn<{
847
+ name: "fingerprint";
848
+ tableName: "idempotency_keys";
849
+ dataType: "string";
850
+ columnType: "PgText";
851
+ data: string;
852
+ driverParam: string;
853
+ notNull: true;
854
+ hasDefault: false;
855
+ isPrimaryKey: false;
856
+ isAutoincrement: false;
857
+ hasRuntimeDefault: false;
858
+ enumValues: [string, ...string[]];
859
+ baseColumn: never;
860
+ identity: undefined;
861
+ generated: undefined;
862
+ }, {}, {}>;
863
+ targetType: import("drizzle-orm/pg-core").PgColumn<{
864
+ name: "target_type";
865
+ tableName: "idempotency_keys";
866
+ dataType: "string";
867
+ columnType: "PgText";
868
+ data: "evaluation" | "batch";
869
+ driverParam: string;
870
+ notNull: true;
871
+ hasDefault: false;
872
+ isPrimaryKey: false;
873
+ isAutoincrement: false;
874
+ hasRuntimeDefault: false;
875
+ enumValues: [string, ...string[]];
876
+ baseColumn: never;
877
+ identity: undefined;
878
+ generated: undefined;
879
+ }, {}, {
880
+ $type: "evaluation" | "batch";
881
+ }>;
882
+ targetId: import("drizzle-orm/pg-core").PgColumn<{
883
+ name: "target_id";
884
+ tableName: "idempotency_keys";
885
+ dataType: "string";
886
+ columnType: "PgText";
887
+ data: string;
888
+ driverParam: string;
889
+ notNull: false;
890
+ hasDefault: false;
891
+ isPrimaryKey: false;
892
+ isAutoincrement: false;
893
+ hasRuntimeDefault: false;
894
+ enumValues: [string, ...string[]];
895
+ baseColumn: never;
896
+ identity: undefined;
897
+ generated: undefined;
898
+ }, {}, {}>;
899
+ targetIds: import("drizzle-orm/pg-core").PgColumn<{
900
+ name: "target_ids";
901
+ tableName: "idempotency_keys";
902
+ dataType: "json";
903
+ columnType: "PgJsonb";
904
+ data: string[];
905
+ driverParam: unknown;
906
+ notNull: false;
907
+ hasDefault: false;
908
+ isPrimaryKey: false;
909
+ isAutoincrement: false;
910
+ hasRuntimeDefault: false;
911
+ enumValues: undefined;
912
+ baseColumn: never;
913
+ identity: undefined;
914
+ generated: undefined;
915
+ }, {}, {
916
+ $type: string[];
917
+ }>;
918
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
919
+ name: "created_at";
920
+ tableName: "idempotency_keys";
921
+ dataType: "string";
922
+ columnType: "PgText";
923
+ data: string;
924
+ driverParam: string;
925
+ notNull: true;
926
+ hasDefault: false;
927
+ isPrimaryKey: false;
928
+ isAutoincrement: false;
929
+ hasRuntimeDefault: false;
930
+ enumValues: [string, ...string[]];
931
+ baseColumn: never;
932
+ identity: undefined;
933
+ generated: undefined;
934
+ }, {}, {}>;
935
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
936
+ name: "expires_at";
937
+ tableName: "idempotency_keys";
938
+ dataType: "string";
939
+ columnType: "PgText";
940
+ data: string;
941
+ driverParam: string;
942
+ notNull: true;
943
+ hasDefault: false;
944
+ isPrimaryKey: false;
945
+ isAutoincrement: false;
946
+ hasRuntimeDefault: false;
947
+ enumValues: [string, ...string[]];
948
+ baseColumn: never;
949
+ identity: undefined;
950
+ generated: undefined;
951
+ }, {}, {}>;
952
+ };
953
+ dialect: "pg";
954
+ }>;
955
+ publications: import("drizzle-orm/pg-core").PgTableWithColumns<{
956
+ name: "publications";
957
+ schema: undefined;
958
+ columns: {
959
+ id: import("drizzle-orm/pg-core").PgColumn<{
960
+ name: "id";
961
+ tableName: "publications";
962
+ dataType: "string";
963
+ columnType: "PgText";
964
+ data: string;
965
+ driverParam: string;
966
+ notNull: true;
967
+ hasDefault: false;
968
+ isPrimaryKey: true;
969
+ isAutoincrement: false;
970
+ hasRuntimeDefault: false;
971
+ enumValues: [string, ...string[]];
972
+ baseColumn: never;
973
+ identity: undefined;
974
+ generated: undefined;
975
+ }, {}, {}>;
976
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
977
+ name: "tenant_id";
978
+ tableName: "publications";
979
+ dataType: "string";
980
+ columnType: "PgText";
981
+ data: string;
982
+ driverParam: string;
983
+ notNull: false;
984
+ hasDefault: false;
985
+ isPrimaryKey: false;
986
+ isAutoincrement: false;
987
+ hasRuntimeDefault: false;
988
+ enumValues: [string, ...string[]];
989
+ baseColumn: never;
990
+ identity: undefined;
991
+ generated: undefined;
992
+ }, {}, {}>;
993
+ owner: import("drizzle-orm/pg-core").PgColumn<{
994
+ name: "owner";
995
+ tableName: "publications";
996
+ dataType: "string";
997
+ columnType: "PgText";
998
+ data: string;
999
+ driverParam: string;
1000
+ notNull: true;
1001
+ hasDefault: false;
1002
+ isPrimaryKey: false;
1003
+ isAutoincrement: false;
1004
+ hasRuntimeDefault: false;
1005
+ enumValues: [string, ...string[]];
1006
+ baseColumn: never;
1007
+ identity: undefined;
1008
+ generated: undefined;
1009
+ }, {}, {}>;
1010
+ slug: import("drizzle-orm/pg-core").PgColumn<{
1011
+ name: "slug";
1012
+ tableName: "publications";
1013
+ dataType: "string";
1014
+ columnType: "PgText";
1015
+ data: string;
1016
+ driverParam: string;
1017
+ notNull: true;
1018
+ hasDefault: false;
1019
+ isPrimaryKey: false;
1020
+ isAutoincrement: false;
1021
+ hasRuntimeDefault: false;
1022
+ enumValues: [string, ...string[]];
1023
+ baseColumn: never;
1024
+ identity: undefined;
1025
+ generated: undefined;
1026
+ }, {}, {}>;
1027
+ versionId: import("drizzle-orm/pg-core").PgColumn<{
1028
+ name: "version_id";
1029
+ tableName: "publications";
1030
+ dataType: "string";
1031
+ columnType: "PgText";
1032
+ data: string;
1033
+ driverParam: string;
1034
+ notNull: true;
1035
+ hasDefault: false;
1036
+ isPrimaryKey: false;
1037
+ isAutoincrement: false;
1038
+ hasRuntimeDefault: false;
1039
+ enumValues: [string, ...string[]];
1040
+ baseColumn: never;
1041
+ identity: undefined;
1042
+ generated: undefined;
1043
+ }, {}, {}>;
1044
+ title: import("drizzle-orm/pg-core").PgColumn<{
1045
+ name: "title";
1046
+ tableName: "publications";
1047
+ dataType: "string";
1048
+ columnType: "PgText";
1049
+ data: string;
1050
+ driverParam: string;
1051
+ notNull: true;
1052
+ hasDefault: false;
1053
+ isPrimaryKey: false;
1054
+ isAutoincrement: false;
1055
+ hasRuntimeDefault: false;
1056
+ enumValues: [string, ...string[]];
1057
+ baseColumn: never;
1058
+ identity: undefined;
1059
+ generated: undefined;
1060
+ }, {}, {}>;
1061
+ domain: import("drizzle-orm/pg-core").PgColumn<{
1062
+ name: "domain";
1063
+ tableName: "publications";
1064
+ dataType: "string";
1065
+ columnType: "PgText";
1066
+ data: string;
1067
+ driverParam: string;
1068
+ notNull: false;
1069
+ hasDefault: false;
1070
+ isPrimaryKey: false;
1071
+ isAutoincrement: false;
1072
+ hasRuntimeDefault: false;
1073
+ enumValues: [string, ...string[]];
1074
+ baseColumn: never;
1075
+ identity: undefined;
1076
+ generated: undefined;
1077
+ }, {}, {}>;
1078
+ locale: import("drizzle-orm/pg-core").PgColumn<{
1079
+ name: "locale";
1080
+ tableName: "publications";
1081
+ dataType: "string";
1082
+ columnType: "PgText";
1083
+ data: string;
1084
+ driverParam: string;
1085
+ notNull: false;
1086
+ hasDefault: false;
1087
+ isPrimaryKey: false;
1088
+ isAutoincrement: false;
1089
+ hasRuntimeDefault: false;
1090
+ enumValues: [string, ...string[]];
1091
+ baseColumn: never;
1092
+ identity: undefined;
1093
+ generated: undefined;
1094
+ }, {}, {}>;
1095
+ judgmentType: import("drizzle-orm/pg-core").PgColumn<{
1096
+ name: "judgment_type";
1097
+ tableName: "publications";
1098
+ dataType: "string";
1099
+ columnType: "PgText";
1100
+ data: string;
1101
+ driverParam: string;
1102
+ notNull: true;
1103
+ hasDefault: false;
1104
+ isPrimaryKey: false;
1105
+ isAutoincrement: false;
1106
+ hasRuntimeDefault: false;
1107
+ enumValues: [string, ...string[]];
1108
+ baseColumn: never;
1109
+ identity: undefined;
1110
+ generated: undefined;
1111
+ }, {}, {}>;
1112
+ license: import("drizzle-orm/pg-core").PgColumn<{
1113
+ name: "license";
1114
+ tableName: "publications";
1115
+ dataType: "string";
1116
+ columnType: "PgText";
1117
+ data: string;
1118
+ driverParam: string;
1119
+ notNull: true;
1120
+ hasDefault: false;
1121
+ isPrimaryKey: false;
1122
+ isAutoincrement: false;
1123
+ hasRuntimeDefault: false;
1124
+ enumValues: [string, ...string[]];
1125
+ baseColumn: never;
1126
+ identity: undefined;
1127
+ generated: undefined;
1128
+ }, {}, {}>;
1129
+ doc: import("drizzle-orm/pg-core").PgColumn<{
1130
+ name: "doc";
1131
+ tableName: "publications";
1132
+ dataType: "json";
1133
+ columnType: "PgJsonb";
1134
+ data: Record<string, unknown>;
1135
+ driverParam: unknown;
1136
+ notNull: true;
1137
+ hasDefault: false;
1138
+ isPrimaryKey: false;
1139
+ isAutoincrement: false;
1140
+ hasRuntimeDefault: false;
1141
+ enumValues: undefined;
1142
+ baseColumn: never;
1143
+ identity: undefined;
1144
+ generated: undefined;
1145
+ }, {}, {
1146
+ $type: Record<string, unknown>;
1147
+ }>;
1148
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1149
+ name: "created_at";
1150
+ tableName: "publications";
1151
+ dataType: "string";
1152
+ columnType: "PgText";
1153
+ data: string;
1154
+ driverParam: string;
1155
+ notNull: true;
1156
+ hasDefault: false;
1157
+ isPrimaryKey: false;
1158
+ isAutoincrement: false;
1159
+ hasRuntimeDefault: false;
1160
+ enumValues: [string, ...string[]];
1161
+ baseColumn: never;
1162
+ identity: undefined;
1163
+ generated: undefined;
1164
+ }, {}, {}>;
1165
+ withdrawnAt: import("drizzle-orm/pg-core").PgColumn<{
1166
+ name: "withdrawn_at";
1167
+ tableName: "publications";
1168
+ dataType: "string";
1169
+ columnType: "PgText";
1170
+ data: string;
1171
+ driverParam: string;
1172
+ notNull: false;
1173
+ hasDefault: false;
1174
+ isPrimaryKey: false;
1175
+ isAutoincrement: false;
1176
+ hasRuntimeDefault: false;
1177
+ enumValues: [string, ...string[]];
1178
+ baseColumn: never;
1179
+ identity: undefined;
1180
+ generated: undefined;
1181
+ }, {}, {}>;
1182
+ };
1183
+ dialect: "pg";
1184
+ }>;
1185
+ publishers: import("drizzle-orm/pg-core").PgTableWithColumns<{
1186
+ name: "publishers";
1187
+ schema: undefined;
1188
+ columns: {
1189
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
1190
+ name: "tenant_id";
1191
+ tableName: "publishers";
1192
+ dataType: "string";
1193
+ columnType: "PgText";
1194
+ data: string;
1195
+ driverParam: string;
1196
+ notNull: true;
1197
+ hasDefault: false;
1198
+ isPrimaryKey: true;
1199
+ isAutoincrement: false;
1200
+ hasRuntimeDefault: false;
1201
+ enumValues: [string, ...string[]];
1202
+ baseColumn: never;
1203
+ identity: undefined;
1204
+ generated: undefined;
1205
+ }, {}, {}>;
1206
+ githubId: import("drizzle-orm/pg-core").PgColumn<{
1207
+ name: "github_id";
1208
+ tableName: "publishers";
1209
+ dataType: "number";
1210
+ columnType: "PgInteger";
1211
+ data: number;
1212
+ driverParam: string | number;
1213
+ notNull: true;
1214
+ hasDefault: false;
1215
+ isPrimaryKey: false;
1216
+ isAutoincrement: false;
1217
+ hasRuntimeDefault: false;
1218
+ enumValues: undefined;
1219
+ baseColumn: never;
1220
+ identity: undefined;
1221
+ generated: undefined;
1222
+ }, {}, {}>;
1223
+ login: import("drizzle-orm/pg-core").PgColumn<{
1224
+ name: "login";
1225
+ tableName: "publishers";
1226
+ dataType: "string";
1227
+ columnType: "PgText";
1228
+ data: string;
1229
+ driverParam: string;
1230
+ notNull: true;
1231
+ hasDefault: false;
1232
+ isPrimaryKey: false;
1233
+ isAutoincrement: false;
1234
+ hasRuntimeDefault: false;
1235
+ enumValues: [string, ...string[]];
1236
+ baseColumn: never;
1237
+ identity: undefined;
1238
+ generated: undefined;
1239
+ }, {}, {}>;
1240
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1241
+ name: "created_at";
1242
+ tableName: "publishers";
1243
+ dataType: "string";
1244
+ columnType: "PgText";
1245
+ data: string;
1246
+ driverParam: string;
1247
+ notNull: true;
1248
+ hasDefault: false;
1249
+ isPrimaryKey: false;
1250
+ isAutoincrement: false;
1251
+ hasRuntimeDefault: false;
1252
+ enumValues: [string, ...string[]];
1253
+ baseColumn: never;
1254
+ identity: undefined;
1255
+ generated: undefined;
1256
+ }, {}, {}>;
1257
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1258
+ name: "updated_at";
1259
+ tableName: "publishers";
1260
+ dataType: "string";
1261
+ columnType: "PgText";
1262
+ data: string;
1263
+ driverParam: string;
1264
+ notNull: true;
1265
+ hasDefault: false;
1266
+ isPrimaryKey: false;
1267
+ isAutoincrement: false;
1268
+ hasRuntimeDefault: false;
1269
+ enumValues: [string, ...string[]];
1270
+ baseColumn: never;
1271
+ identity: undefined;
1272
+ generated: undefined;
1273
+ }, {}, {}>;
1274
+ };
1275
+ dialect: "pg";
1276
+ }>;
1277
+ projects: import("drizzle-orm/pg-core").PgTableWithColumns<{
1278
+ name: "projects";
1279
+ schema: undefined;
1280
+ columns: {
1281
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
1282
+ name: string;
1283
+ tableName: "projects";
1284
+ dataType: "string";
1285
+ columnType: "PgText";
1286
+ data: string;
1287
+ driverParam: string;
1288
+ notNull: true;
1289
+ hasDefault: false;
1290
+ isPrimaryKey: false;
1291
+ isAutoincrement: false;
1292
+ hasRuntimeDefault: false;
1293
+ enumValues: [string, ...string[]];
1294
+ baseColumn: never;
1295
+ identity: undefined;
1296
+ generated: undefined;
1297
+ }, {}, {}>;
1298
+ name: import("drizzle-orm/pg-core").PgColumn<{
1299
+ name: string;
1300
+ tableName: "projects";
1301
+ dataType: "string";
1302
+ columnType: "PgText";
1303
+ data: string;
1304
+ driverParam: string;
1305
+ notNull: true;
1306
+ hasDefault: false;
1307
+ isPrimaryKey: false;
1308
+ isAutoincrement: false;
1309
+ hasRuntimeDefault: false;
1310
+ enumValues: [string, ...string[]];
1311
+ baseColumn: never;
1312
+ identity: undefined;
1313
+ generated: undefined;
1314
+ }, {}, {}>;
1315
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1316
+ name: string;
1317
+ tableName: "projects";
1318
+ dataType: "string";
1319
+ columnType: "PgText";
1320
+ data: string;
1321
+ driverParam: string;
1322
+ notNull: true;
1323
+ hasDefault: false;
1324
+ isPrimaryKey: false;
1325
+ isAutoincrement: false;
1326
+ hasRuntimeDefault: false;
1327
+ enumValues: [string, ...string[]];
1328
+ baseColumn: never;
1329
+ identity: undefined;
1330
+ generated: undefined;
1331
+ }, {}, {}>;
1332
+ };
1333
+ dialect: "pg";
1334
+ }>;
1335
+ environments: import("drizzle-orm/pg-core").PgTableWithColumns<{
1336
+ name: "environments";
1337
+ schema: undefined;
1338
+ columns: {
1339
+ name: import("drizzle-orm/pg-core").PgColumn<{
1340
+ name: string;
1341
+ tableName: "environments";
1342
+ dataType: "string";
1343
+ columnType: "PgText";
1344
+ data: string;
1345
+ driverParam: string;
1346
+ notNull: true;
1347
+ hasDefault: false;
1348
+ isPrimaryKey: false;
1349
+ isAutoincrement: false;
1350
+ hasRuntimeDefault: false;
1351
+ enumValues: [string, ...string[]];
1352
+ baseColumn: never;
1353
+ identity: undefined;
1354
+ generated: undefined;
1355
+ }, {}, {}>;
1356
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1357
+ name: string;
1358
+ tableName: "environments";
1359
+ dataType: "string";
1360
+ columnType: "PgText";
1361
+ data: string;
1362
+ driverParam: string;
1363
+ notNull: true;
1364
+ hasDefault: false;
1365
+ isPrimaryKey: false;
1366
+ isAutoincrement: false;
1367
+ hasRuntimeDefault: false;
1368
+ enumValues: [string, ...string[]];
1369
+ baseColumn: never;
1370
+ identity: undefined;
1371
+ generated: undefined;
1372
+ }, {}, {}>;
1373
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
1374
+ name: string;
1375
+ tableName: "environments";
1376
+ dataType: "string";
1377
+ columnType: "PgText";
1378
+ data: string;
1379
+ driverParam: string;
1380
+ notNull: true;
1381
+ hasDefault: false;
1382
+ isPrimaryKey: false;
1383
+ isAutoincrement: false;
1384
+ hasRuntimeDefault: false;
1385
+ enumValues: [string, ...string[]];
1386
+ baseColumn: never;
1387
+ identity: undefined;
1388
+ generated: undefined;
1389
+ }, {}, {}>;
1390
+ project: import("drizzle-orm/pg-core").PgColumn<{
1391
+ name: string;
1392
+ tableName: "environments";
1393
+ dataType: "string";
1394
+ columnType: "PgText";
1395
+ data: string;
1396
+ driverParam: string;
1397
+ notNull: true;
1398
+ hasDefault: false;
1399
+ isPrimaryKey: false;
1400
+ isAutoincrement: false;
1401
+ hasRuntimeDefault: false;
1402
+ enumValues: [string, ...string[]];
1403
+ baseColumn: never;
1404
+ identity: undefined;
1405
+ generated: undefined;
1406
+ }, {}, {}>;
1407
+ };
1408
+ dialect: "pg";
1409
+ }>;
1410
+ projectVersions: import("drizzle-orm/pg-core").PgTableWithColumns<{
1411
+ name: "project_versions";
1412
+ schema: undefined;
1413
+ columns: {
1414
+ name: import("drizzle-orm/pg-core").PgColumn<{
1415
+ name: string;
1416
+ tableName: "project_versions";
1417
+ dataType: "string";
1418
+ columnType: "PgText";
1419
+ data: string;
1420
+ driverParam: string;
1421
+ notNull: true;
1422
+ hasDefault: false;
1423
+ isPrimaryKey: false;
1424
+ isAutoincrement: false;
1425
+ hasRuntimeDefault: false;
1426
+ enumValues: [string, ...string[]];
1427
+ baseColumn: never;
1428
+ identity: undefined;
1429
+ generated: undefined;
1430
+ }, {}, {}>;
1431
+ id: import("drizzle-orm/pg-core").PgColumn<{
1432
+ name: string;
1433
+ tableName: "project_versions";
1434
+ dataType: "string";
1435
+ columnType: "PgText";
1436
+ data: string;
1437
+ driverParam: string;
1438
+ notNull: true;
1439
+ hasDefault: false;
1440
+ isPrimaryKey: false;
1441
+ isAutoincrement: false;
1442
+ hasRuntimeDefault: false;
1443
+ enumValues: [string, ...string[]];
1444
+ baseColumn: never;
1445
+ identity: undefined;
1446
+ generated: undefined;
1447
+ }, {}, {}>;
1448
+ doc: import("drizzle-orm/pg-core").PgColumn<{
1449
+ name: "doc";
1450
+ tableName: "project_versions";
1451
+ dataType: "json";
1452
+ columnType: "PgJsonb";
1453
+ data: Record<string, unknown>;
1454
+ driverParam: unknown;
1455
+ notNull: true;
1456
+ hasDefault: false;
1457
+ isPrimaryKey: false;
1458
+ isAutoincrement: false;
1459
+ hasRuntimeDefault: false;
1460
+ enumValues: undefined;
1461
+ baseColumn: never;
1462
+ identity: undefined;
1463
+ generated: undefined;
1464
+ }, {}, {
1465
+ $type: Record<string, unknown>;
1466
+ }>;
1467
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1468
+ name: string;
1469
+ tableName: "project_versions";
1470
+ dataType: "string";
1471
+ columnType: "PgText";
1472
+ data: string;
1473
+ driverParam: string;
1474
+ notNull: true;
1475
+ hasDefault: false;
1476
+ isPrimaryKey: false;
1477
+ isAutoincrement: false;
1478
+ hasRuntimeDefault: false;
1479
+ enumValues: [string, ...string[]];
1480
+ baseColumn: never;
1481
+ identity: undefined;
1482
+ generated: undefined;
1483
+ }, {}, {}>;
1484
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
1485
+ name: string;
1486
+ tableName: "project_versions";
1487
+ dataType: "string";
1488
+ columnType: "PgText";
1489
+ data: string;
1490
+ driverParam: string;
1491
+ notNull: true;
1492
+ hasDefault: false;
1493
+ isPrimaryKey: false;
1494
+ isAutoincrement: false;
1495
+ hasRuntimeDefault: false;
1496
+ enumValues: [string, ...string[]];
1497
+ baseColumn: never;
1498
+ identity: undefined;
1499
+ generated: undefined;
1500
+ }, {}, {}>;
1501
+ project: import("drizzle-orm/pg-core").PgColumn<{
1502
+ name: string;
1503
+ tableName: "project_versions";
1504
+ dataType: "string";
1505
+ columnType: "PgText";
1506
+ data: string;
1507
+ driverParam: string;
1508
+ notNull: true;
1509
+ hasDefault: false;
1510
+ isPrimaryKey: false;
1511
+ isAutoincrement: false;
1512
+ hasRuntimeDefault: false;
1513
+ enumValues: [string, ...string[]];
1514
+ baseColumn: never;
1515
+ identity: undefined;
1516
+ generated: undefined;
1517
+ }, {}, {}>;
1518
+ };
1519
+ dialect: "pg";
1520
+ }>;
1521
+ pointers: import("drizzle-orm/pg-core").PgTableWithColumns<{
1522
+ name: "pointers";
1523
+ schema: undefined;
1524
+ columns: {
1525
+ environment: import("drizzle-orm/pg-core").PgColumn<{
1526
+ name: string;
1527
+ tableName: "pointers";
1528
+ dataType: "string";
1529
+ columnType: "PgText";
1530
+ data: string;
1531
+ driverParam: string;
1532
+ notNull: true;
1533
+ hasDefault: false;
1534
+ isPrimaryKey: false;
1535
+ isAutoincrement: false;
1536
+ hasRuntimeDefault: false;
1537
+ enumValues: [string, ...string[]];
1538
+ baseColumn: never;
1539
+ identity: undefined;
1540
+ generated: undefined;
1541
+ }, {}, {}>;
1542
+ name: import("drizzle-orm/pg-core").PgColumn<{
1543
+ name: string;
1544
+ tableName: "pointers";
1545
+ dataType: "string";
1546
+ columnType: "PgText";
1547
+ data: string;
1548
+ driverParam: string;
1549
+ notNull: true;
1550
+ hasDefault: false;
1551
+ isPrimaryKey: false;
1552
+ isAutoincrement: false;
1553
+ hasRuntimeDefault: false;
1554
+ enumValues: [string, ...string[]];
1555
+ baseColumn: never;
1556
+ identity: undefined;
1557
+ generated: undefined;
1558
+ }, {}, {}>;
1559
+ versionId: import("drizzle-orm/pg-core").PgColumn<{
1560
+ name: string;
1561
+ tableName: "pointers";
1562
+ dataType: "string";
1563
+ columnType: "PgText";
1564
+ data: string;
1565
+ driverParam: string;
1566
+ notNull: true;
1567
+ hasDefault: false;
1568
+ isPrimaryKey: false;
1569
+ isAutoincrement: false;
1570
+ hasRuntimeDefault: false;
1571
+ enumValues: [string, ...string[]];
1572
+ baseColumn: never;
1573
+ identity: undefined;
1574
+ generated: undefined;
1575
+ }, {}, {}>;
1576
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
1577
+ name: string;
1578
+ tableName: "pointers";
1579
+ dataType: "string";
1580
+ columnType: "PgText";
1581
+ data: string;
1582
+ driverParam: string;
1583
+ notNull: true;
1584
+ hasDefault: false;
1585
+ isPrimaryKey: false;
1586
+ isAutoincrement: false;
1587
+ hasRuntimeDefault: false;
1588
+ enumValues: [string, ...string[]];
1589
+ baseColumn: never;
1590
+ identity: undefined;
1591
+ generated: undefined;
1592
+ }, {}, {}>;
1593
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
1594
+ name: string;
1595
+ tableName: "pointers";
1596
+ dataType: "string";
1597
+ columnType: "PgText";
1598
+ data: string;
1599
+ driverParam: string;
1600
+ notNull: true;
1601
+ hasDefault: false;
1602
+ isPrimaryKey: false;
1603
+ isAutoincrement: false;
1604
+ hasRuntimeDefault: false;
1605
+ enumValues: [string, ...string[]];
1606
+ baseColumn: never;
1607
+ identity: undefined;
1608
+ generated: undefined;
1609
+ }, {}, {}>;
1610
+ project: import("drizzle-orm/pg-core").PgColumn<{
1611
+ name: string;
1612
+ tableName: "pointers";
1613
+ dataType: "string";
1614
+ columnType: "PgText";
1615
+ data: string;
1616
+ driverParam: string;
1617
+ notNull: true;
1618
+ hasDefault: false;
1619
+ isPrimaryKey: false;
1620
+ isAutoincrement: false;
1621
+ hasRuntimeDefault: false;
1622
+ enumValues: [string, ...string[]];
1623
+ baseColumn: never;
1624
+ identity: undefined;
1625
+ generated: undefined;
1626
+ }, {}, {}>;
1627
+ };
1628
+ dialect: "pg";
1629
+ }>;
1630
+ promotions: import("drizzle-orm/pg-core").PgTableWithColumns<{
1631
+ name: "promotions";
1632
+ schema: undefined;
1633
+ columns: {
1634
+ id: import("drizzle-orm/pg-core").PgColumn<{
1635
+ name: string;
1636
+ tableName: "promotions";
1637
+ dataType: "string";
1638
+ columnType: "PgText";
1639
+ data: string;
1640
+ driverParam: string;
1641
+ notNull: true;
1642
+ hasDefault: false;
1643
+ isPrimaryKey: false;
1644
+ isAutoincrement: false;
1645
+ hasRuntimeDefault: false;
1646
+ enumValues: [string, ...string[]];
1647
+ baseColumn: never;
1648
+ identity: undefined;
1649
+ generated: undefined;
1650
+ }, {}, {}>;
1651
+ environment: import("drizzle-orm/pg-core").PgColumn<{
1652
+ name: string;
1653
+ tableName: "promotions";
1654
+ dataType: "string";
1655
+ columnType: "PgText";
1656
+ data: string;
1657
+ driverParam: string;
1658
+ notNull: true;
1659
+ hasDefault: false;
1660
+ isPrimaryKey: false;
1661
+ isAutoincrement: false;
1662
+ hasRuntimeDefault: false;
1663
+ enumValues: [string, ...string[]];
1664
+ baseColumn: never;
1665
+ identity: undefined;
1666
+ generated: undefined;
1667
+ }, {}, {}>;
1668
+ name: import("drizzle-orm/pg-core").PgColumn<{
1669
+ name: string;
1670
+ tableName: "promotions";
1671
+ dataType: "string";
1672
+ columnType: "PgText";
1673
+ data: string;
1674
+ driverParam: string;
1675
+ notNull: true;
1676
+ hasDefault: false;
1677
+ isPrimaryKey: false;
1678
+ isAutoincrement: false;
1679
+ hasRuntimeDefault: false;
1680
+ enumValues: [string, ...string[]];
1681
+ baseColumn: never;
1682
+ identity: undefined;
1683
+ generated: undefined;
1684
+ }, {}, {}>;
1685
+ doc: import("drizzle-orm/pg-core").PgColumn<{
1686
+ name: "doc";
1687
+ tableName: "promotions";
1688
+ dataType: "json";
1689
+ columnType: "PgJsonb";
1690
+ data: Record<string, unknown>;
1691
+ driverParam: unknown;
1692
+ notNull: true;
1693
+ hasDefault: false;
1694
+ isPrimaryKey: false;
1695
+ isAutoincrement: false;
1696
+ hasRuntimeDefault: false;
1697
+ enumValues: undefined;
1698
+ baseColumn: never;
1699
+ identity: undefined;
1700
+ generated: undefined;
1701
+ }, {}, {
1702
+ $type: Record<string, unknown>;
1703
+ }>;
1704
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1705
+ name: string;
1706
+ tableName: "promotions";
1707
+ dataType: "string";
1708
+ columnType: "PgText";
1709
+ data: string;
1710
+ driverParam: string;
1711
+ notNull: true;
1712
+ hasDefault: false;
1713
+ isPrimaryKey: false;
1714
+ isAutoincrement: false;
1715
+ hasRuntimeDefault: false;
1716
+ enumValues: [string, ...string[]];
1717
+ baseColumn: never;
1718
+ identity: undefined;
1719
+ generated: undefined;
1720
+ }, {}, {}>;
1721
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
1722
+ name: string;
1723
+ tableName: "promotions";
1724
+ dataType: "string";
1725
+ columnType: "PgText";
1726
+ data: string;
1727
+ driverParam: string;
1728
+ notNull: true;
1729
+ hasDefault: false;
1730
+ isPrimaryKey: false;
1731
+ isAutoincrement: false;
1732
+ hasRuntimeDefault: false;
1733
+ enumValues: [string, ...string[]];
1734
+ baseColumn: never;
1735
+ identity: undefined;
1736
+ generated: undefined;
1737
+ }, {}, {}>;
1738
+ project: import("drizzle-orm/pg-core").PgColumn<{
1739
+ name: string;
1740
+ tableName: "promotions";
1741
+ dataType: "string";
1742
+ columnType: "PgText";
1743
+ data: string;
1744
+ driverParam: string;
1745
+ notNull: true;
1746
+ hasDefault: false;
1747
+ isPrimaryKey: false;
1748
+ isAutoincrement: false;
1749
+ hasRuntimeDefault: false;
1750
+ enumValues: [string, ...string[]];
1751
+ baseColumn: never;
1752
+ identity: undefined;
1753
+ generated: undefined;
1754
+ }, {}, {}>;
1755
+ };
1756
+ dialect: "pg";
1757
+ }>;
1758
+ runReports: import("drizzle-orm/pg-core").PgTableWithColumns<{
1759
+ name: "run_reports";
1760
+ schema: undefined;
1761
+ columns: {
1762
+ runId: import("drizzle-orm/pg-core").PgColumn<{
1763
+ name: string;
1764
+ tableName: "run_reports";
1765
+ dataType: "string";
1766
+ columnType: "PgText";
1767
+ data: string;
1768
+ driverParam: string;
1769
+ notNull: true;
1770
+ hasDefault: false;
1771
+ isPrimaryKey: false;
1772
+ isAutoincrement: false;
1773
+ hasRuntimeDefault: false;
1774
+ enumValues: [string, ...string[]];
1775
+ baseColumn: never;
1776
+ identity: undefined;
1777
+ generated: undefined;
1778
+ }, {}, {}>;
1779
+ name: import("drizzle-orm/pg-core").PgColumn<{
1780
+ name: string;
1781
+ tableName: "run_reports";
1782
+ dataType: "string";
1783
+ columnType: "PgText";
1784
+ data: string;
1785
+ driverParam: string;
1786
+ notNull: true;
1787
+ hasDefault: false;
1788
+ isPrimaryKey: false;
1789
+ isAutoincrement: false;
1790
+ hasRuntimeDefault: false;
1791
+ enumValues: [string, ...string[]];
1792
+ baseColumn: never;
1793
+ identity: undefined;
1794
+ generated: undefined;
1795
+ }, {}, {}>;
1796
+ versionId: import("drizzle-orm/pg-core").PgColumn<{
1797
+ name: string;
1798
+ tableName: "run_reports";
1799
+ dataType: "string";
1800
+ columnType: "PgText";
1801
+ data: string;
1802
+ driverParam: string;
1803
+ notNull: true;
1804
+ hasDefault: false;
1805
+ isPrimaryKey: false;
1806
+ isAutoincrement: false;
1807
+ hasRuntimeDefault: false;
1808
+ enumValues: [string, ...string[]];
1809
+ baseColumn: never;
1810
+ identity: undefined;
1811
+ generated: undefined;
1812
+ }, {}, {}>;
1813
+ datasetName: import("drizzle-orm/pg-core").PgColumn<{
1814
+ name: string;
1815
+ tableName: "run_reports";
1816
+ dataType: "string";
1817
+ columnType: "PgText";
1818
+ data: string;
1819
+ driverParam: string;
1820
+ notNull: false;
1821
+ hasDefault: false;
1822
+ isPrimaryKey: false;
1823
+ isAutoincrement: false;
1824
+ hasRuntimeDefault: false;
1825
+ enumValues: [string, ...string[]];
1826
+ baseColumn: never;
1827
+ identity: undefined;
1828
+ generated: undefined;
1829
+ }, {}, {}>;
1830
+ startedAt: import("drizzle-orm/pg-core").PgColumn<{
1831
+ name: string;
1832
+ tableName: "run_reports";
1833
+ dataType: "string";
1834
+ columnType: "PgText";
1835
+ data: string;
1836
+ driverParam: string;
1837
+ notNull: true;
1838
+ hasDefault: false;
1839
+ isPrimaryKey: false;
1840
+ isAutoincrement: false;
1841
+ hasRuntimeDefault: false;
1842
+ enumValues: [string, ...string[]];
1843
+ baseColumn: never;
1844
+ identity: undefined;
1845
+ generated: undefined;
1846
+ }, {}, {}>;
1847
+ doc: import("drizzle-orm/pg-core").PgColumn<{
1848
+ name: "doc";
1849
+ tableName: "run_reports";
1850
+ dataType: "json";
1851
+ columnType: "PgJsonb";
1852
+ data: Record<string, unknown>;
1853
+ driverParam: unknown;
1854
+ notNull: true;
1855
+ hasDefault: false;
1856
+ isPrimaryKey: false;
1857
+ isAutoincrement: false;
1858
+ hasRuntimeDefault: false;
1859
+ enumValues: undefined;
1860
+ baseColumn: never;
1861
+ identity: undefined;
1862
+ generated: undefined;
1863
+ }, {}, {
1864
+ $type: Record<string, unknown>;
1865
+ }>;
1866
+ reportedAt: import("drizzle-orm/pg-core").PgColumn<{
1867
+ name: string;
1868
+ tableName: "run_reports";
1869
+ dataType: "string";
1870
+ columnType: "PgText";
1871
+ data: string;
1872
+ driverParam: string;
1873
+ notNull: true;
1874
+ hasDefault: false;
1875
+ isPrimaryKey: false;
1876
+ isAutoincrement: false;
1877
+ hasRuntimeDefault: false;
1878
+ enumValues: [string, ...string[]];
1879
+ baseColumn: never;
1880
+ identity: undefined;
1881
+ generated: undefined;
1882
+ }, {}, {}>;
1883
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
1884
+ name: string;
1885
+ tableName: "run_reports";
1886
+ dataType: "string";
1887
+ columnType: "PgText";
1888
+ data: string;
1889
+ driverParam: string;
1890
+ notNull: true;
1891
+ hasDefault: false;
1892
+ isPrimaryKey: false;
1893
+ isAutoincrement: false;
1894
+ hasRuntimeDefault: false;
1895
+ enumValues: [string, ...string[]];
1896
+ baseColumn: never;
1897
+ identity: undefined;
1898
+ generated: undefined;
1899
+ }, {}, {}>;
1900
+ project: import("drizzle-orm/pg-core").PgColumn<{
1901
+ name: string;
1902
+ tableName: "run_reports";
1903
+ dataType: "string";
1904
+ columnType: "PgText";
1905
+ data: string;
1906
+ driverParam: string;
1907
+ notNull: true;
1908
+ hasDefault: false;
1909
+ isPrimaryKey: false;
1910
+ isAutoincrement: false;
1911
+ hasRuntimeDefault: false;
1912
+ enumValues: [string, ...string[]];
1913
+ baseColumn: never;
1914
+ identity: undefined;
1915
+ generated: undefined;
1916
+ }, {}, {}>;
1917
+ };
1918
+ dialect: "pg";
1919
+ }>;
1920
+ comparisonReports: import("drizzle-orm/pg-core").PgTableWithColumns<{
1921
+ name: "comparison_reports";
1922
+ schema: undefined;
1923
+ columns: {
1924
+ id: import("drizzle-orm/pg-core").PgColumn<{
1925
+ name: string;
1926
+ tableName: "comparison_reports";
1927
+ dataType: "string";
1928
+ columnType: "PgText";
1929
+ data: string;
1930
+ driverParam: string;
1931
+ notNull: true;
1932
+ hasDefault: false;
1933
+ isPrimaryKey: false;
1934
+ isAutoincrement: false;
1935
+ hasRuntimeDefault: false;
1936
+ enumValues: [string, ...string[]];
1937
+ baseColumn: never;
1938
+ identity: undefined;
1939
+ generated: undefined;
1940
+ }, {}, {}>;
1941
+ name: import("drizzle-orm/pg-core").PgColumn<{
1942
+ name: string;
1943
+ tableName: "comparison_reports";
1944
+ dataType: "string";
1945
+ columnType: "PgText";
1946
+ data: string;
1947
+ driverParam: string;
1948
+ notNull: true;
1949
+ hasDefault: false;
1950
+ isPrimaryKey: false;
1951
+ isAutoincrement: false;
1952
+ hasRuntimeDefault: false;
1953
+ enumValues: [string, ...string[]];
1954
+ baseColumn: never;
1955
+ identity: undefined;
1956
+ generated: undefined;
1957
+ }, {}, {}>;
1958
+ headVersionId: import("drizzle-orm/pg-core").PgColumn<{
1959
+ name: string;
1960
+ tableName: "comparison_reports";
1961
+ dataType: "string";
1962
+ columnType: "PgText";
1963
+ data: string;
1964
+ driverParam: string;
1965
+ notNull: true;
1966
+ hasDefault: false;
1967
+ isPrimaryKey: false;
1968
+ isAutoincrement: false;
1969
+ hasRuntimeDefault: false;
1970
+ enumValues: [string, ...string[]];
1971
+ baseColumn: never;
1972
+ identity: undefined;
1973
+ generated: undefined;
1974
+ }, {}, {}>;
1975
+ doc: import("drizzle-orm/pg-core").PgColumn<{
1976
+ name: "doc";
1977
+ tableName: "comparison_reports";
1978
+ dataType: "json";
1979
+ columnType: "PgJsonb";
1980
+ data: Record<string, unknown>;
1981
+ driverParam: unknown;
1982
+ notNull: true;
1983
+ hasDefault: false;
1984
+ isPrimaryKey: false;
1985
+ isAutoincrement: false;
1986
+ hasRuntimeDefault: false;
1987
+ enumValues: undefined;
1988
+ baseColumn: never;
1989
+ identity: undefined;
1990
+ generated: undefined;
1991
+ }, {}, {
1992
+ $type: Record<string, unknown>;
1993
+ }>;
1994
+ reportedAt: import("drizzle-orm/pg-core").PgColumn<{
1995
+ name: string;
1996
+ tableName: "comparison_reports";
1997
+ dataType: "string";
1998
+ columnType: "PgText";
1999
+ data: string;
2000
+ driverParam: string;
2001
+ notNull: true;
2002
+ hasDefault: false;
2003
+ isPrimaryKey: false;
2004
+ isAutoincrement: false;
2005
+ hasRuntimeDefault: false;
2006
+ enumValues: [string, ...string[]];
2007
+ baseColumn: never;
2008
+ identity: undefined;
2009
+ generated: undefined;
2010
+ }, {}, {}>;
2011
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
2012
+ name: string;
2013
+ tableName: "comparison_reports";
2014
+ dataType: "string";
2015
+ columnType: "PgText";
2016
+ data: string;
2017
+ driverParam: string;
2018
+ notNull: true;
2019
+ hasDefault: false;
2020
+ isPrimaryKey: false;
2021
+ isAutoincrement: false;
2022
+ hasRuntimeDefault: false;
2023
+ enumValues: [string, ...string[]];
2024
+ baseColumn: never;
2025
+ identity: undefined;
2026
+ generated: undefined;
2027
+ }, {}, {}>;
2028
+ project: import("drizzle-orm/pg-core").PgColumn<{
2029
+ name: string;
2030
+ tableName: "comparison_reports";
2031
+ dataType: "string";
2032
+ columnType: "PgText";
2033
+ data: string;
2034
+ driverParam: string;
2035
+ notNull: true;
2036
+ hasDefault: false;
2037
+ isPrimaryKey: false;
2038
+ isAutoincrement: false;
2039
+ hasRuntimeDefault: false;
2040
+ enumValues: [string, ...string[]];
2041
+ baseColumn: never;
2042
+ identity: undefined;
2043
+ generated: undefined;
2044
+ }, {}, {}>;
2045
+ };
2046
+ dialect: "pg";
2047
+ }>;
2048
+ }> & {
2049
+ $client: import("pg").Pool;
2050
+ };
2051
+ pool: import("pg").Pool;
2052
+ store: PgStore;
2053
+ auth: DrizzleAuth;
2054
+ close: () => Promise<void>;
2055
+ }>;
2056
+ /** Embedded Postgres for offline tests and local development. */
2057
+ export declare function fromPglite(dataDir?: string, fallbackAuth?: KeyAuth, loadDriver?: () => Promise<typeof import("@electric-sql/pglite")>): Promise<{
2058
+ db: import("drizzle-orm/pglite").PgliteDatabase<{
2059
+ rubrics: import("drizzle-orm/pg-core").PgTableWithColumns<{
2060
+ name: "rubrics";
2061
+ schema: undefined;
2062
+ columns: {
2063
+ id: import("drizzle-orm/pg-core").PgColumn<{
2064
+ name: "id";
2065
+ tableName: "rubrics";
2066
+ dataType: "string";
2067
+ columnType: "PgText";
2068
+ data: string;
2069
+ driverParam: string;
2070
+ notNull: true;
2071
+ hasDefault: false;
2072
+ isPrimaryKey: true;
2073
+ isAutoincrement: false;
2074
+ hasRuntimeDefault: false;
2075
+ enumValues: [string, ...string[]];
2076
+ baseColumn: never;
2077
+ identity: undefined;
2078
+ generated: undefined;
2079
+ }, {}, {}>;
2080
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
2081
+ name: "tenant_id";
2082
+ tableName: "rubrics";
2083
+ dataType: "string";
2084
+ columnType: "PgText";
2085
+ data: string;
2086
+ driverParam: string;
2087
+ notNull: false;
2088
+ hasDefault: false;
2089
+ isPrimaryKey: false;
2090
+ isAutoincrement: false;
2091
+ hasRuntimeDefault: false;
2092
+ enumValues: [string, ...string[]];
2093
+ baseColumn: never;
2094
+ identity: undefined;
2095
+ generated: undefined;
2096
+ }, {}, {}>;
2097
+ name: import("drizzle-orm/pg-core").PgColumn<{
2098
+ name: "name";
2099
+ tableName: "rubrics";
2100
+ dataType: "string";
2101
+ columnType: "PgText";
2102
+ data: string;
2103
+ driverParam: string;
2104
+ notNull: true;
2105
+ hasDefault: false;
2106
+ isPrimaryKey: false;
2107
+ isAutoincrement: false;
2108
+ hasRuntimeDefault: false;
2109
+ enumValues: [string, ...string[]];
2110
+ baseColumn: never;
2111
+ identity: undefined;
2112
+ generated: undefined;
2113
+ }, {}, {}>;
2114
+ version: import("drizzle-orm/pg-core").PgColumn<{
2115
+ name: "version";
2116
+ tableName: "rubrics";
2117
+ dataType: "string";
2118
+ columnType: "PgText";
2119
+ data: string;
2120
+ driverParam: string;
2121
+ notNull: true;
2122
+ hasDefault: true;
2123
+ isPrimaryKey: false;
2124
+ isAutoincrement: false;
2125
+ hasRuntimeDefault: false;
2126
+ enumValues: [string, ...string[]];
2127
+ baseColumn: never;
2128
+ identity: undefined;
2129
+ generated: undefined;
2130
+ }, {}, {}>;
2131
+ doc: import("drizzle-orm/pg-core").PgColumn<{
2132
+ name: "doc";
2133
+ tableName: "rubrics";
2134
+ dataType: "json";
2135
+ columnType: "PgJsonb";
2136
+ data: Record<string, unknown>;
2137
+ driverParam: unknown;
2138
+ notNull: true;
2139
+ hasDefault: false;
2140
+ isPrimaryKey: false;
2141
+ isAutoincrement: false;
2142
+ hasRuntimeDefault: false;
2143
+ enumValues: undefined;
2144
+ baseColumn: never;
2145
+ identity: undefined;
2146
+ generated: undefined;
2147
+ }, {}, {
2148
+ $type: Record<string, unknown>;
2149
+ }>;
2150
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2151
+ name: "created_at";
2152
+ tableName: "rubrics";
2153
+ dataType: "string";
2154
+ columnType: "PgText";
2155
+ data: string;
2156
+ driverParam: string;
2157
+ notNull: true;
2158
+ hasDefault: false;
2159
+ isPrimaryKey: false;
2160
+ isAutoincrement: false;
2161
+ hasRuntimeDefault: false;
2162
+ enumValues: [string, ...string[]];
2163
+ baseColumn: never;
2164
+ identity: undefined;
2165
+ generated: undefined;
2166
+ }, {}, {}>;
2167
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2168
+ name: "updated_at";
2169
+ tableName: "rubrics";
2170
+ dataType: "string";
2171
+ columnType: "PgText";
2172
+ data: string;
2173
+ driverParam: string;
2174
+ notNull: true;
2175
+ hasDefault: false;
2176
+ isPrimaryKey: false;
2177
+ isAutoincrement: false;
2178
+ hasRuntimeDefault: false;
2179
+ enumValues: [string, ...string[]];
2180
+ baseColumn: never;
2181
+ identity: undefined;
2182
+ generated: undefined;
2183
+ }, {}, {}>;
2184
+ };
2185
+ dialect: "pg";
2186
+ }>;
2187
+ evaluations: import("drizzle-orm/pg-core").PgTableWithColumns<{
2188
+ name: "evaluations";
2189
+ schema: undefined;
2190
+ columns: {
2191
+ id: import("drizzle-orm/pg-core").PgColumn<{
2192
+ name: "id";
2193
+ tableName: "evaluations";
2194
+ dataType: "string";
2195
+ columnType: "PgText";
2196
+ data: string;
2197
+ driverParam: string;
2198
+ notNull: true;
2199
+ hasDefault: false;
2200
+ isPrimaryKey: true;
2201
+ isAutoincrement: false;
2202
+ hasRuntimeDefault: false;
2203
+ enumValues: [string, ...string[]];
2204
+ baseColumn: never;
2205
+ identity: undefined;
2206
+ generated: undefined;
2207
+ }, {}, {}>;
2208
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
2209
+ name: "tenant_id";
2210
+ tableName: "evaluations";
2211
+ dataType: "string";
2212
+ columnType: "PgText";
2213
+ data: string;
2214
+ driverParam: string;
2215
+ notNull: false;
2216
+ hasDefault: false;
2217
+ isPrimaryKey: false;
2218
+ isAutoincrement: false;
2219
+ hasRuntimeDefault: false;
2220
+ enumValues: [string, ...string[]];
2221
+ baseColumn: never;
2222
+ identity: undefined;
2223
+ generated: undefined;
2224
+ }, {}, {}>;
2225
+ rubricId: import("drizzle-orm/pg-core").PgColumn<{
2226
+ name: "rubric_id";
2227
+ tableName: "evaluations";
2228
+ dataType: "string";
2229
+ columnType: "PgText";
2230
+ data: string;
2231
+ driverParam: string;
2232
+ notNull: false;
2233
+ hasDefault: false;
2234
+ isPrimaryKey: false;
2235
+ isAutoincrement: false;
2236
+ hasRuntimeDefault: false;
2237
+ enumValues: [string, ...string[]];
2238
+ baseColumn: never;
2239
+ identity: undefined;
2240
+ generated: undefined;
2241
+ }, {}, {}>;
2242
+ rubricName: import("drizzle-orm/pg-core").PgColumn<{
2243
+ name: "rubric_name";
2244
+ tableName: "evaluations";
2245
+ dataType: "string";
2246
+ columnType: "PgText";
2247
+ data: string;
2248
+ driverParam: string;
2249
+ notNull: true;
2250
+ hasDefault: false;
2251
+ isPrimaryKey: false;
2252
+ isAutoincrement: false;
2253
+ hasRuntimeDefault: false;
2254
+ enumValues: [string, ...string[]];
2255
+ baseColumn: never;
2256
+ identity: undefined;
2257
+ generated: undefined;
2258
+ }, {}, {}>;
2259
+ subjectName: import("drizzle-orm/pg-core").PgColumn<{
2260
+ name: "subject_name";
2261
+ tableName: "evaluations";
2262
+ dataType: "string";
2263
+ columnType: "PgText";
2264
+ data: string;
2265
+ driverParam: string;
2266
+ notNull: false;
2267
+ hasDefault: false;
2268
+ isPrimaryKey: false;
2269
+ isAutoincrement: false;
2270
+ hasRuntimeDefault: false;
2271
+ enumValues: [string, ...string[]];
2272
+ baseColumn: never;
2273
+ identity: undefined;
2274
+ generated: undefined;
2275
+ }, {}, {}>;
2276
+ status: import("drizzle-orm/pg-core").PgColumn<{
2277
+ name: "status";
2278
+ tableName: "evaluations";
2279
+ dataType: "string";
2280
+ columnType: "PgText";
2281
+ data: string;
2282
+ driverParam: string;
2283
+ notNull: true;
2284
+ hasDefault: false;
2285
+ isPrimaryKey: false;
2286
+ isAutoincrement: false;
2287
+ hasRuntimeDefault: false;
2288
+ enumValues: [string, ...string[]];
2289
+ baseColumn: never;
2290
+ identity: undefined;
2291
+ generated: undefined;
2292
+ }, {}, {}>;
2293
+ score: import("drizzle-orm/pg-core").PgColumn<{
2294
+ name: "score";
2295
+ tableName: "evaluations";
2296
+ dataType: "number";
2297
+ columnType: "PgDoublePrecision";
2298
+ data: number;
2299
+ driverParam: string | number;
2300
+ notNull: false;
2301
+ hasDefault: false;
2302
+ isPrimaryKey: false;
2303
+ isAutoincrement: false;
2304
+ hasRuntimeDefault: false;
2305
+ enumValues: undefined;
2306
+ baseColumn: never;
2307
+ identity: undefined;
2308
+ generated: undefined;
2309
+ }, {}, {}>;
2310
+ grade: import("drizzle-orm/pg-core").PgColumn<{
2311
+ name: "grade";
2312
+ tableName: "evaluations";
2313
+ dataType: "string";
2314
+ columnType: "PgText";
2315
+ data: string;
2316
+ driverParam: string;
2317
+ notNull: false;
2318
+ hasDefault: false;
2319
+ isPrimaryKey: false;
2320
+ isAutoincrement: false;
2321
+ hasRuntimeDefault: false;
2322
+ enumValues: [string, ...string[]];
2323
+ baseColumn: never;
2324
+ identity: undefined;
2325
+ generated: undefined;
2326
+ }, {}, {}>;
2327
+ passed: import("drizzle-orm/pg-core").PgColumn<{
2328
+ name: "passed";
2329
+ tableName: "evaluations";
2330
+ dataType: "boolean";
2331
+ columnType: "PgBoolean";
2332
+ data: boolean;
2333
+ driverParam: boolean;
2334
+ notNull: false;
2335
+ hasDefault: false;
2336
+ isPrimaryKey: false;
2337
+ isAutoincrement: false;
2338
+ hasRuntimeDefault: false;
2339
+ enumValues: undefined;
2340
+ baseColumn: never;
2341
+ identity: undefined;
2342
+ generated: undefined;
2343
+ }, {}, {}>;
2344
+ pendingHuman: import("drizzle-orm/pg-core").PgColumn<{
2345
+ name: "pending_human";
2346
+ tableName: "evaluations";
2347
+ dataType: "number";
2348
+ columnType: "PgInteger";
2349
+ data: number;
2350
+ driverParam: string | number;
2351
+ notNull: true;
2352
+ hasDefault: true;
2353
+ isPrimaryKey: false;
2354
+ isAutoincrement: false;
2355
+ hasRuntimeDefault: false;
2356
+ enumValues: undefined;
2357
+ baseColumn: never;
2358
+ identity: undefined;
2359
+ generated: undefined;
2360
+ }, {}, {}>;
2361
+ decisionCalls: import("drizzle-orm/pg-core").PgColumn<{
2362
+ name: "decision_calls";
2363
+ tableName: "evaluations";
2364
+ dataType: "number";
2365
+ columnType: "PgInteger";
2366
+ data: number;
2367
+ driverParam: string | number;
2368
+ notNull: true;
2369
+ hasDefault: true;
2370
+ isPrimaryKey: false;
2371
+ isAutoincrement: false;
2372
+ hasRuntimeDefault: false;
2373
+ enumValues: undefined;
2374
+ baseColumn: never;
2375
+ identity: undefined;
2376
+ generated: undefined;
2377
+ }, {}, {}>;
2378
+ llmCalls: import("drizzle-orm/pg-core").PgColumn<{
2379
+ name: "llm_calls";
2380
+ tableName: "evaluations";
2381
+ dataType: "number";
2382
+ columnType: "PgInteger";
2383
+ data: number;
2384
+ driverParam: string | number;
2385
+ notNull: true;
2386
+ hasDefault: true;
2387
+ isPrimaryKey: false;
2388
+ isAutoincrement: false;
2389
+ hasRuntimeDefault: false;
2390
+ enumValues: undefined;
2391
+ baseColumn: never;
2392
+ identity: undefined;
2393
+ generated: undefined;
2394
+ }, {}, {}>;
2395
+ inputTokens: import("drizzle-orm/pg-core").PgColumn<{
2396
+ name: "input_tokens";
2397
+ tableName: "evaluations";
2398
+ dataType: "number";
2399
+ columnType: "PgInteger";
2400
+ data: number;
2401
+ driverParam: string | number;
2402
+ notNull: true;
2403
+ hasDefault: true;
2404
+ isPrimaryKey: false;
2405
+ isAutoincrement: false;
2406
+ hasRuntimeDefault: false;
2407
+ enumValues: undefined;
2408
+ baseColumn: never;
2409
+ identity: undefined;
2410
+ generated: undefined;
2411
+ }, {}, {}>;
2412
+ durationMs: import("drizzle-orm/pg-core").PgColumn<{
2413
+ name: "duration_ms";
2414
+ tableName: "evaluations";
2415
+ dataType: "number";
2416
+ columnType: "PgInteger";
2417
+ data: number;
2418
+ driverParam: string | number;
2419
+ notNull: true;
2420
+ hasDefault: true;
2421
+ isPrimaryKey: false;
2422
+ isAutoincrement: false;
2423
+ hasRuntimeDefault: false;
2424
+ enumValues: undefined;
2425
+ baseColumn: never;
2426
+ identity: undefined;
2427
+ generated: undefined;
2428
+ }, {}, {}>;
2429
+ doc: import("drizzle-orm/pg-core").PgColumn<{
2430
+ name: "doc";
2431
+ tableName: "evaluations";
2432
+ dataType: "json";
2433
+ columnType: "PgJsonb";
2434
+ data: Record<string, unknown>;
2435
+ driverParam: unknown;
2436
+ notNull: true;
2437
+ hasDefault: false;
2438
+ isPrimaryKey: false;
2439
+ isAutoincrement: false;
2440
+ hasRuntimeDefault: false;
2441
+ enumValues: undefined;
2442
+ baseColumn: never;
2443
+ identity: undefined;
2444
+ generated: undefined;
2445
+ }, {}, {
2446
+ $type: Record<string, unknown>;
2447
+ }>;
2448
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2449
+ name: "created_at";
2450
+ tableName: "evaluations";
2451
+ dataType: "string";
2452
+ columnType: "PgText";
2453
+ data: string;
2454
+ driverParam: string;
2455
+ notNull: true;
2456
+ hasDefault: false;
2457
+ isPrimaryKey: false;
2458
+ isAutoincrement: false;
2459
+ hasRuntimeDefault: false;
2460
+ enumValues: [string, ...string[]];
2461
+ baseColumn: never;
2462
+ identity: undefined;
2463
+ generated: undefined;
2464
+ }, {}, {}>;
2465
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
2466
+ name: "updated_at";
2467
+ tableName: "evaluations";
2468
+ dataType: "string";
2469
+ columnType: "PgText";
2470
+ data: string;
2471
+ driverParam: string;
2472
+ notNull: true;
2473
+ hasDefault: false;
2474
+ isPrimaryKey: false;
2475
+ isAutoincrement: false;
2476
+ hasRuntimeDefault: false;
2477
+ enumValues: [string, ...string[]];
2478
+ baseColumn: never;
2479
+ identity: undefined;
2480
+ generated: undefined;
2481
+ }, {}, {}>;
2482
+ };
2483
+ dialect: "pg";
2484
+ }>;
2485
+ ratings: import("drizzle-orm/pg-core").PgTableWithColumns<{
2486
+ name: "ratings";
2487
+ schema: undefined;
2488
+ columns: {
2489
+ id: import("drizzle-orm/pg-core").PgColumn<{
2490
+ name: "id";
2491
+ tableName: "ratings";
2492
+ dataType: "string";
2493
+ columnType: "PgText";
2494
+ data: string;
2495
+ driverParam: string;
2496
+ notNull: true;
2497
+ hasDefault: false;
2498
+ isPrimaryKey: true;
2499
+ isAutoincrement: false;
2500
+ hasRuntimeDefault: false;
2501
+ enumValues: [string, ...string[]];
2502
+ baseColumn: never;
2503
+ identity: undefined;
2504
+ generated: undefined;
2505
+ }, {}, {}>;
2506
+ evaluationId: import("drizzle-orm/pg-core").PgColumn<{
2507
+ name: "evaluation_id";
2508
+ tableName: "ratings";
2509
+ dataType: "string";
2510
+ columnType: "PgText";
2511
+ data: string;
2512
+ driverParam: string;
2513
+ notNull: true;
2514
+ hasDefault: false;
2515
+ isPrimaryKey: false;
2516
+ isAutoincrement: false;
2517
+ hasRuntimeDefault: false;
2518
+ enumValues: [string, ...string[]];
2519
+ baseColumn: never;
2520
+ identity: undefined;
2521
+ generated: undefined;
2522
+ }, {}, {}>;
2523
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
2524
+ name: "tenant_id";
2525
+ tableName: "ratings";
2526
+ dataType: "string";
2527
+ columnType: "PgText";
2528
+ data: string;
2529
+ driverParam: string;
2530
+ notNull: false;
2531
+ hasDefault: false;
2532
+ isPrimaryKey: false;
2533
+ isAutoincrement: false;
2534
+ hasRuntimeDefault: false;
2535
+ enumValues: [string, ...string[]];
2536
+ baseColumn: never;
2537
+ identity: undefined;
2538
+ generated: undefined;
2539
+ }, {}, {}>;
2540
+ rubricId: import("drizzle-orm/pg-core").PgColumn<{
2541
+ name: "rubric_id";
2542
+ tableName: "ratings";
2543
+ dataType: "string";
2544
+ columnType: "PgText";
2545
+ data: string;
2546
+ driverParam: string;
2547
+ notNull: false;
2548
+ hasDefault: false;
2549
+ isPrimaryKey: false;
2550
+ isAutoincrement: false;
2551
+ hasRuntimeDefault: false;
2552
+ enumValues: [string, ...string[]];
2553
+ baseColumn: never;
2554
+ identity: undefined;
2555
+ generated: undefined;
2556
+ }, {}, {}>;
2557
+ criterionId: import("drizzle-orm/pg-core").PgColumn<{
2558
+ name: "criterion_id";
2559
+ tableName: "ratings";
2560
+ dataType: "string";
2561
+ columnType: "PgText";
2562
+ data: string;
2563
+ driverParam: string;
2564
+ notNull: true;
2565
+ hasDefault: false;
2566
+ isPrimaryKey: false;
2567
+ isAutoincrement: false;
2568
+ hasRuntimeDefault: false;
2569
+ enumValues: [string, ...string[]];
2570
+ baseColumn: never;
2571
+ identity: undefined;
2572
+ generated: undefined;
2573
+ }, {}, {}>;
2574
+ raterId: import("drizzle-orm/pg-core").PgColumn<{
2575
+ name: "rater_id";
2576
+ tableName: "ratings";
2577
+ dataType: "string";
2578
+ columnType: "PgText";
2579
+ data: string;
2580
+ driverParam: string;
2581
+ notNull: true;
2582
+ hasDefault: false;
2583
+ isPrimaryKey: false;
2584
+ isAutoincrement: false;
2585
+ hasRuntimeDefault: false;
2586
+ enumValues: [string, ...string[]];
2587
+ baseColumn: never;
2588
+ identity: undefined;
2589
+ generated: undefined;
2590
+ }, {}, {}>;
2591
+ judgeType: import("drizzle-orm/pg-core").PgColumn<{
2592
+ name: "judge_type";
2593
+ tableName: "ratings";
2594
+ dataType: "string";
2595
+ columnType: "PgText";
2596
+ data: string;
2597
+ driverParam: string;
2598
+ notNull: true;
2599
+ hasDefault: false;
2600
+ isPrimaryKey: false;
2601
+ isAutoincrement: false;
2602
+ hasRuntimeDefault: false;
2603
+ enumValues: [string, ...string[]];
2604
+ baseColumn: never;
2605
+ identity: undefined;
2606
+ generated: undefined;
2607
+ }, {}, {}>;
2608
+ status: import("drizzle-orm/pg-core").PgColumn<{
2609
+ name: "status";
2610
+ tableName: "ratings";
2611
+ dataType: "string";
2612
+ columnType: "PgText";
2613
+ data: string;
2614
+ driverParam: string;
2615
+ notNull: true;
2616
+ hasDefault: false;
2617
+ isPrimaryKey: false;
2618
+ isAutoincrement: false;
2619
+ hasRuntimeDefault: false;
2620
+ enumValues: [string, ...string[]];
2621
+ baseColumn: never;
2622
+ identity: undefined;
2623
+ generated: undefined;
2624
+ }, {}, {}>;
2625
+ score: import("drizzle-orm/pg-core").PgColumn<{
2626
+ name: "score";
2627
+ tableName: "ratings";
2628
+ dataType: "number";
2629
+ columnType: "PgDoublePrecision";
2630
+ data: number;
2631
+ driverParam: string | number;
2632
+ notNull: false;
2633
+ hasDefault: false;
2634
+ isPrimaryKey: false;
2635
+ isAutoincrement: false;
2636
+ hasRuntimeDefault: false;
2637
+ enumValues: undefined;
2638
+ baseColumn: never;
2639
+ identity: undefined;
2640
+ generated: undefined;
2641
+ }, {}, {}>;
2642
+ normalized: import("drizzle-orm/pg-core").PgColumn<{
2643
+ name: "normalized";
2644
+ tableName: "ratings";
2645
+ dataType: "number";
2646
+ columnType: "PgDoublePrecision";
2647
+ data: number;
2648
+ driverParam: string | number;
2649
+ notNull: false;
2650
+ hasDefault: false;
2651
+ isPrimaryKey: false;
2652
+ isAutoincrement: false;
2653
+ hasRuntimeDefault: false;
2654
+ enumValues: undefined;
2655
+ baseColumn: never;
2656
+ identity: undefined;
2657
+ generated: undefined;
2658
+ }, {}, {}>;
2659
+ confidence: import("drizzle-orm/pg-core").PgColumn<{
2660
+ name: "confidence";
2661
+ tableName: "ratings";
2662
+ dataType: "number";
2663
+ columnType: "PgDoublePrecision";
2664
+ data: number;
2665
+ driverParam: string | number;
2666
+ notNull: false;
2667
+ hasDefault: false;
2668
+ isPrimaryKey: false;
2669
+ isAutoincrement: false;
2670
+ hasRuntimeDefault: false;
2671
+ enumValues: undefined;
2672
+ baseColumn: never;
2673
+ identity: undefined;
2674
+ generated: undefined;
2675
+ }, {}, {}>;
2676
+ model: import("drizzle-orm/pg-core").PgColumn<{
2677
+ name: "model";
2678
+ tableName: "ratings";
2679
+ dataType: "string";
2680
+ columnType: "PgText";
2681
+ data: string;
2682
+ driverParam: string;
2683
+ notNull: false;
2684
+ hasDefault: false;
2685
+ isPrimaryKey: false;
2686
+ isAutoincrement: false;
2687
+ hasRuntimeDefault: false;
2688
+ enumValues: [string, ...string[]];
2689
+ baseColumn: never;
2690
+ identity: undefined;
2691
+ generated: undefined;
2692
+ }, {}, {}>;
2693
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2694
+ name: "created_at";
2695
+ tableName: "ratings";
2696
+ dataType: "string";
2697
+ columnType: "PgText";
2698
+ data: string;
2699
+ driverParam: string;
2700
+ notNull: true;
2701
+ hasDefault: false;
2702
+ isPrimaryKey: false;
2703
+ isAutoincrement: false;
2704
+ hasRuntimeDefault: false;
2705
+ enumValues: [string, ...string[]];
2706
+ baseColumn: never;
2707
+ identity: undefined;
2708
+ generated: undefined;
2709
+ }, {}, {}>;
2710
+ };
2711
+ dialect: "pg";
2712
+ }>;
2713
+ apiKeys: import("drizzle-orm/pg-core").PgTableWithColumns<{
2714
+ name: "api_keys";
2715
+ schema: undefined;
2716
+ columns: {
2717
+ id: import("drizzle-orm/pg-core").PgColumn<{
2718
+ name: "id";
2719
+ tableName: "api_keys";
2720
+ dataType: "string";
2721
+ columnType: "PgText";
2722
+ data: string;
2723
+ driverParam: string;
2724
+ notNull: true;
2725
+ hasDefault: false;
2726
+ isPrimaryKey: true;
2727
+ isAutoincrement: false;
2728
+ hasRuntimeDefault: false;
2729
+ enumValues: [string, ...string[]];
2730
+ baseColumn: never;
2731
+ identity: undefined;
2732
+ generated: undefined;
2733
+ }, {}, {}>;
2734
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
2735
+ name: "tenant_id";
2736
+ tableName: "api_keys";
2737
+ dataType: "string";
2738
+ columnType: "PgText";
2739
+ data: string;
2740
+ driverParam: string;
2741
+ notNull: true;
2742
+ hasDefault: false;
2743
+ isPrimaryKey: false;
2744
+ isAutoincrement: false;
2745
+ hasRuntimeDefault: false;
2746
+ enumValues: [string, ...string[]];
2747
+ baseColumn: never;
2748
+ identity: undefined;
2749
+ generated: undefined;
2750
+ }, {}, {}>;
2751
+ name: import("drizzle-orm/pg-core").PgColumn<{
2752
+ name: "name";
2753
+ tableName: "api_keys";
2754
+ dataType: "string";
2755
+ columnType: "PgText";
2756
+ data: string;
2757
+ driverParam: string;
2758
+ notNull: true;
2759
+ hasDefault: false;
2760
+ isPrimaryKey: false;
2761
+ isAutoincrement: false;
2762
+ hasRuntimeDefault: false;
2763
+ enumValues: [string, ...string[]];
2764
+ baseColumn: never;
2765
+ identity: undefined;
2766
+ generated: undefined;
2767
+ }, {}, {}>;
2768
+ keyHash: import("drizzle-orm/pg-core").PgColumn<{
2769
+ name: "key_hash";
2770
+ tableName: "api_keys";
2771
+ dataType: "string";
2772
+ columnType: "PgText";
2773
+ data: string;
2774
+ driverParam: string;
2775
+ notNull: true;
2776
+ hasDefault: false;
2777
+ isPrimaryKey: false;
2778
+ isAutoincrement: false;
2779
+ hasRuntimeDefault: false;
2780
+ enumValues: [string, ...string[]];
2781
+ baseColumn: never;
2782
+ identity: undefined;
2783
+ generated: undefined;
2784
+ }, {}, {}>;
2785
+ prefix: import("drizzle-orm/pg-core").PgColumn<{
2786
+ name: "prefix";
2787
+ tableName: "api_keys";
2788
+ dataType: "string";
2789
+ columnType: "PgText";
2790
+ data: string;
2791
+ driverParam: string;
2792
+ notNull: true;
2793
+ hasDefault: false;
2794
+ isPrimaryKey: false;
2795
+ isAutoincrement: false;
2796
+ hasRuntimeDefault: false;
2797
+ enumValues: [string, ...string[]];
2798
+ baseColumn: never;
2799
+ identity: undefined;
2800
+ generated: undefined;
2801
+ }, {}, {}>;
2802
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2803
+ name: "created_at";
2804
+ tableName: "api_keys";
2805
+ dataType: "string";
2806
+ columnType: "PgText";
2807
+ data: string;
2808
+ driverParam: string;
2809
+ notNull: true;
2810
+ hasDefault: false;
2811
+ isPrimaryKey: false;
2812
+ isAutoincrement: false;
2813
+ hasRuntimeDefault: false;
2814
+ enumValues: [string, ...string[]];
2815
+ baseColumn: never;
2816
+ identity: undefined;
2817
+ generated: undefined;
2818
+ }, {}, {}>;
2819
+ lastUsedAt: import("drizzle-orm/pg-core").PgColumn<{
2820
+ name: "last_used_at";
2821
+ tableName: "api_keys";
2822
+ dataType: "string";
2823
+ columnType: "PgText";
2824
+ data: string;
2825
+ driverParam: string;
2826
+ notNull: false;
2827
+ hasDefault: false;
2828
+ isPrimaryKey: false;
2829
+ isAutoincrement: false;
2830
+ hasRuntimeDefault: false;
2831
+ enumValues: [string, ...string[]];
2832
+ baseColumn: never;
2833
+ identity: undefined;
2834
+ generated: undefined;
2835
+ }, {}, {}>;
2836
+ revokedAt: import("drizzle-orm/pg-core").PgColumn<{
2837
+ name: "revoked_at";
2838
+ tableName: "api_keys";
2839
+ dataType: "string";
2840
+ columnType: "PgText";
2841
+ data: string;
2842
+ driverParam: string;
2843
+ notNull: false;
2844
+ hasDefault: false;
2845
+ isPrimaryKey: false;
2846
+ isAutoincrement: false;
2847
+ hasRuntimeDefault: false;
2848
+ enumValues: [string, ...string[]];
2849
+ baseColumn: never;
2850
+ identity: undefined;
2851
+ generated: undefined;
2852
+ }, {}, {}>;
2853
+ };
2854
+ dialect: "pg";
2855
+ }>;
2856
+ idempotencyKeys: import("drizzle-orm/pg-core").PgTableWithColumns<{
2857
+ name: "idempotency_keys";
2858
+ schema: undefined;
2859
+ columns: {
2860
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
2861
+ name: "tenant_id";
2862
+ tableName: "idempotency_keys";
2863
+ dataType: "string";
2864
+ columnType: "PgText";
2865
+ data: string;
2866
+ driverParam: string;
2867
+ notNull: false;
2868
+ hasDefault: false;
2869
+ isPrimaryKey: false;
2870
+ isAutoincrement: false;
2871
+ hasRuntimeDefault: false;
2872
+ enumValues: [string, ...string[]];
2873
+ baseColumn: never;
2874
+ identity: undefined;
2875
+ generated: undefined;
2876
+ }, {}, {}>;
2877
+ key: import("drizzle-orm/pg-core").PgColumn<{
2878
+ name: "key";
2879
+ tableName: "idempotency_keys";
2880
+ dataType: "string";
2881
+ columnType: "PgText";
2882
+ data: string;
2883
+ driverParam: string;
2884
+ notNull: true;
2885
+ hasDefault: false;
2886
+ isPrimaryKey: false;
2887
+ isAutoincrement: false;
2888
+ hasRuntimeDefault: false;
2889
+ enumValues: [string, ...string[]];
2890
+ baseColumn: never;
2891
+ identity: undefined;
2892
+ generated: undefined;
2893
+ }, {}, {}>;
2894
+ fingerprint: import("drizzle-orm/pg-core").PgColumn<{
2895
+ name: "fingerprint";
2896
+ tableName: "idempotency_keys";
2897
+ dataType: "string";
2898
+ columnType: "PgText";
2899
+ data: string;
2900
+ driverParam: string;
2901
+ notNull: true;
2902
+ hasDefault: false;
2903
+ isPrimaryKey: false;
2904
+ isAutoincrement: false;
2905
+ hasRuntimeDefault: false;
2906
+ enumValues: [string, ...string[]];
2907
+ baseColumn: never;
2908
+ identity: undefined;
2909
+ generated: undefined;
2910
+ }, {}, {}>;
2911
+ targetType: import("drizzle-orm/pg-core").PgColumn<{
2912
+ name: "target_type";
2913
+ tableName: "idempotency_keys";
2914
+ dataType: "string";
2915
+ columnType: "PgText";
2916
+ data: "evaluation" | "batch";
2917
+ driverParam: string;
2918
+ notNull: true;
2919
+ hasDefault: false;
2920
+ isPrimaryKey: false;
2921
+ isAutoincrement: false;
2922
+ hasRuntimeDefault: false;
2923
+ enumValues: [string, ...string[]];
2924
+ baseColumn: never;
2925
+ identity: undefined;
2926
+ generated: undefined;
2927
+ }, {}, {
2928
+ $type: "evaluation" | "batch";
2929
+ }>;
2930
+ targetId: import("drizzle-orm/pg-core").PgColumn<{
2931
+ name: "target_id";
2932
+ tableName: "idempotency_keys";
2933
+ dataType: "string";
2934
+ columnType: "PgText";
2935
+ data: string;
2936
+ driverParam: string;
2937
+ notNull: false;
2938
+ hasDefault: false;
2939
+ isPrimaryKey: false;
2940
+ isAutoincrement: false;
2941
+ hasRuntimeDefault: false;
2942
+ enumValues: [string, ...string[]];
2943
+ baseColumn: never;
2944
+ identity: undefined;
2945
+ generated: undefined;
2946
+ }, {}, {}>;
2947
+ targetIds: import("drizzle-orm/pg-core").PgColumn<{
2948
+ name: "target_ids";
2949
+ tableName: "idempotency_keys";
2950
+ dataType: "json";
2951
+ columnType: "PgJsonb";
2952
+ data: string[];
2953
+ driverParam: unknown;
2954
+ notNull: false;
2955
+ hasDefault: false;
2956
+ isPrimaryKey: false;
2957
+ isAutoincrement: false;
2958
+ hasRuntimeDefault: false;
2959
+ enumValues: undefined;
2960
+ baseColumn: never;
2961
+ identity: undefined;
2962
+ generated: undefined;
2963
+ }, {}, {
2964
+ $type: string[];
2965
+ }>;
2966
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
2967
+ name: "created_at";
2968
+ tableName: "idempotency_keys";
2969
+ dataType: "string";
2970
+ columnType: "PgText";
2971
+ data: string;
2972
+ driverParam: string;
2973
+ notNull: true;
2974
+ hasDefault: false;
2975
+ isPrimaryKey: false;
2976
+ isAutoincrement: false;
2977
+ hasRuntimeDefault: false;
2978
+ enumValues: [string, ...string[]];
2979
+ baseColumn: never;
2980
+ identity: undefined;
2981
+ generated: undefined;
2982
+ }, {}, {}>;
2983
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
2984
+ name: "expires_at";
2985
+ tableName: "idempotency_keys";
2986
+ dataType: "string";
2987
+ columnType: "PgText";
2988
+ data: string;
2989
+ driverParam: string;
2990
+ notNull: true;
2991
+ hasDefault: false;
2992
+ isPrimaryKey: false;
2993
+ isAutoincrement: false;
2994
+ hasRuntimeDefault: false;
2995
+ enumValues: [string, ...string[]];
2996
+ baseColumn: never;
2997
+ identity: undefined;
2998
+ generated: undefined;
2999
+ }, {}, {}>;
3000
+ };
3001
+ dialect: "pg";
3002
+ }>;
3003
+ publications: import("drizzle-orm/pg-core").PgTableWithColumns<{
3004
+ name: "publications";
3005
+ schema: undefined;
3006
+ columns: {
3007
+ id: import("drizzle-orm/pg-core").PgColumn<{
3008
+ name: "id";
3009
+ tableName: "publications";
3010
+ dataType: "string";
3011
+ columnType: "PgText";
3012
+ data: string;
3013
+ driverParam: string;
3014
+ notNull: true;
3015
+ hasDefault: false;
3016
+ isPrimaryKey: true;
3017
+ isAutoincrement: false;
3018
+ hasRuntimeDefault: false;
3019
+ enumValues: [string, ...string[]];
3020
+ baseColumn: never;
3021
+ identity: undefined;
3022
+ generated: undefined;
3023
+ }, {}, {}>;
3024
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
3025
+ name: "tenant_id";
3026
+ tableName: "publications";
3027
+ dataType: "string";
3028
+ columnType: "PgText";
3029
+ data: string;
3030
+ driverParam: string;
3031
+ notNull: false;
3032
+ hasDefault: false;
3033
+ isPrimaryKey: false;
3034
+ isAutoincrement: false;
3035
+ hasRuntimeDefault: false;
3036
+ enumValues: [string, ...string[]];
3037
+ baseColumn: never;
3038
+ identity: undefined;
3039
+ generated: undefined;
3040
+ }, {}, {}>;
3041
+ owner: import("drizzle-orm/pg-core").PgColumn<{
3042
+ name: "owner";
3043
+ tableName: "publications";
3044
+ dataType: "string";
3045
+ columnType: "PgText";
3046
+ data: string;
3047
+ driverParam: string;
3048
+ notNull: true;
3049
+ hasDefault: false;
3050
+ isPrimaryKey: false;
3051
+ isAutoincrement: false;
3052
+ hasRuntimeDefault: false;
3053
+ enumValues: [string, ...string[]];
3054
+ baseColumn: never;
3055
+ identity: undefined;
3056
+ generated: undefined;
3057
+ }, {}, {}>;
3058
+ slug: import("drizzle-orm/pg-core").PgColumn<{
3059
+ name: "slug";
3060
+ tableName: "publications";
3061
+ dataType: "string";
3062
+ columnType: "PgText";
3063
+ data: string;
3064
+ driverParam: string;
3065
+ notNull: true;
3066
+ hasDefault: false;
3067
+ isPrimaryKey: false;
3068
+ isAutoincrement: false;
3069
+ hasRuntimeDefault: false;
3070
+ enumValues: [string, ...string[]];
3071
+ baseColumn: never;
3072
+ identity: undefined;
3073
+ generated: undefined;
3074
+ }, {}, {}>;
3075
+ versionId: import("drizzle-orm/pg-core").PgColumn<{
3076
+ name: "version_id";
3077
+ tableName: "publications";
3078
+ dataType: "string";
3079
+ columnType: "PgText";
3080
+ data: string;
3081
+ driverParam: string;
3082
+ notNull: true;
3083
+ hasDefault: false;
3084
+ isPrimaryKey: false;
3085
+ isAutoincrement: false;
3086
+ hasRuntimeDefault: false;
3087
+ enumValues: [string, ...string[]];
3088
+ baseColumn: never;
3089
+ identity: undefined;
3090
+ generated: undefined;
3091
+ }, {}, {}>;
3092
+ title: import("drizzle-orm/pg-core").PgColumn<{
3093
+ name: "title";
3094
+ tableName: "publications";
3095
+ dataType: "string";
3096
+ columnType: "PgText";
3097
+ data: string;
3098
+ driverParam: string;
3099
+ notNull: true;
3100
+ hasDefault: false;
3101
+ isPrimaryKey: false;
3102
+ isAutoincrement: false;
3103
+ hasRuntimeDefault: false;
3104
+ enumValues: [string, ...string[]];
3105
+ baseColumn: never;
3106
+ identity: undefined;
3107
+ generated: undefined;
3108
+ }, {}, {}>;
3109
+ domain: import("drizzle-orm/pg-core").PgColumn<{
3110
+ name: "domain";
3111
+ tableName: "publications";
3112
+ dataType: "string";
3113
+ columnType: "PgText";
3114
+ data: string;
3115
+ driverParam: string;
3116
+ notNull: false;
3117
+ hasDefault: false;
3118
+ isPrimaryKey: false;
3119
+ isAutoincrement: false;
3120
+ hasRuntimeDefault: false;
3121
+ enumValues: [string, ...string[]];
3122
+ baseColumn: never;
3123
+ identity: undefined;
3124
+ generated: undefined;
3125
+ }, {}, {}>;
3126
+ locale: import("drizzle-orm/pg-core").PgColumn<{
3127
+ name: "locale";
3128
+ tableName: "publications";
3129
+ dataType: "string";
3130
+ columnType: "PgText";
3131
+ data: string;
3132
+ driverParam: string;
3133
+ notNull: false;
3134
+ hasDefault: false;
3135
+ isPrimaryKey: false;
3136
+ isAutoincrement: false;
3137
+ hasRuntimeDefault: false;
3138
+ enumValues: [string, ...string[]];
3139
+ baseColumn: never;
3140
+ identity: undefined;
3141
+ generated: undefined;
3142
+ }, {}, {}>;
3143
+ judgmentType: import("drizzle-orm/pg-core").PgColumn<{
3144
+ name: "judgment_type";
3145
+ tableName: "publications";
3146
+ dataType: "string";
3147
+ columnType: "PgText";
3148
+ data: string;
3149
+ driverParam: string;
3150
+ notNull: true;
3151
+ hasDefault: false;
3152
+ isPrimaryKey: false;
3153
+ isAutoincrement: false;
3154
+ hasRuntimeDefault: false;
3155
+ enumValues: [string, ...string[]];
3156
+ baseColumn: never;
3157
+ identity: undefined;
3158
+ generated: undefined;
3159
+ }, {}, {}>;
3160
+ license: import("drizzle-orm/pg-core").PgColumn<{
3161
+ name: "license";
3162
+ tableName: "publications";
3163
+ dataType: "string";
3164
+ columnType: "PgText";
3165
+ data: string;
3166
+ driverParam: string;
3167
+ notNull: true;
3168
+ hasDefault: false;
3169
+ isPrimaryKey: false;
3170
+ isAutoincrement: false;
3171
+ hasRuntimeDefault: false;
3172
+ enumValues: [string, ...string[]];
3173
+ baseColumn: never;
3174
+ identity: undefined;
3175
+ generated: undefined;
3176
+ }, {}, {}>;
3177
+ doc: import("drizzle-orm/pg-core").PgColumn<{
3178
+ name: "doc";
3179
+ tableName: "publications";
3180
+ dataType: "json";
3181
+ columnType: "PgJsonb";
3182
+ data: Record<string, unknown>;
3183
+ driverParam: unknown;
3184
+ notNull: true;
3185
+ hasDefault: false;
3186
+ isPrimaryKey: false;
3187
+ isAutoincrement: false;
3188
+ hasRuntimeDefault: false;
3189
+ enumValues: undefined;
3190
+ baseColumn: never;
3191
+ identity: undefined;
3192
+ generated: undefined;
3193
+ }, {}, {
3194
+ $type: Record<string, unknown>;
3195
+ }>;
3196
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3197
+ name: "created_at";
3198
+ tableName: "publications";
3199
+ dataType: "string";
3200
+ columnType: "PgText";
3201
+ data: string;
3202
+ driverParam: string;
3203
+ notNull: true;
3204
+ hasDefault: false;
3205
+ isPrimaryKey: false;
3206
+ isAutoincrement: false;
3207
+ hasRuntimeDefault: false;
3208
+ enumValues: [string, ...string[]];
3209
+ baseColumn: never;
3210
+ identity: undefined;
3211
+ generated: undefined;
3212
+ }, {}, {}>;
3213
+ withdrawnAt: import("drizzle-orm/pg-core").PgColumn<{
3214
+ name: "withdrawn_at";
3215
+ tableName: "publications";
3216
+ dataType: "string";
3217
+ columnType: "PgText";
3218
+ data: string;
3219
+ driverParam: string;
3220
+ notNull: false;
3221
+ hasDefault: false;
3222
+ isPrimaryKey: false;
3223
+ isAutoincrement: false;
3224
+ hasRuntimeDefault: false;
3225
+ enumValues: [string, ...string[]];
3226
+ baseColumn: never;
3227
+ identity: undefined;
3228
+ generated: undefined;
3229
+ }, {}, {}>;
3230
+ };
3231
+ dialect: "pg";
3232
+ }>;
3233
+ publishers: import("drizzle-orm/pg-core").PgTableWithColumns<{
3234
+ name: "publishers";
3235
+ schema: undefined;
3236
+ columns: {
3237
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
3238
+ name: "tenant_id";
3239
+ tableName: "publishers";
3240
+ dataType: "string";
3241
+ columnType: "PgText";
3242
+ data: string;
3243
+ driverParam: string;
3244
+ notNull: true;
3245
+ hasDefault: false;
3246
+ isPrimaryKey: true;
3247
+ isAutoincrement: false;
3248
+ hasRuntimeDefault: false;
3249
+ enumValues: [string, ...string[]];
3250
+ baseColumn: never;
3251
+ identity: undefined;
3252
+ generated: undefined;
3253
+ }, {}, {}>;
3254
+ githubId: import("drizzle-orm/pg-core").PgColumn<{
3255
+ name: "github_id";
3256
+ tableName: "publishers";
3257
+ dataType: "number";
3258
+ columnType: "PgInteger";
3259
+ data: number;
3260
+ driverParam: string | number;
3261
+ notNull: true;
3262
+ hasDefault: false;
3263
+ isPrimaryKey: false;
3264
+ isAutoincrement: false;
3265
+ hasRuntimeDefault: false;
3266
+ enumValues: undefined;
3267
+ baseColumn: never;
3268
+ identity: undefined;
3269
+ generated: undefined;
3270
+ }, {}, {}>;
3271
+ login: import("drizzle-orm/pg-core").PgColumn<{
3272
+ name: "login";
3273
+ tableName: "publishers";
3274
+ dataType: "string";
3275
+ columnType: "PgText";
3276
+ data: string;
3277
+ driverParam: string;
3278
+ notNull: true;
3279
+ hasDefault: false;
3280
+ isPrimaryKey: false;
3281
+ isAutoincrement: false;
3282
+ hasRuntimeDefault: false;
3283
+ enumValues: [string, ...string[]];
3284
+ baseColumn: never;
3285
+ identity: undefined;
3286
+ generated: undefined;
3287
+ }, {}, {}>;
3288
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3289
+ name: "created_at";
3290
+ tableName: "publishers";
3291
+ dataType: "string";
3292
+ columnType: "PgText";
3293
+ data: string;
3294
+ driverParam: string;
3295
+ notNull: true;
3296
+ hasDefault: false;
3297
+ isPrimaryKey: false;
3298
+ isAutoincrement: false;
3299
+ hasRuntimeDefault: false;
3300
+ enumValues: [string, ...string[]];
3301
+ baseColumn: never;
3302
+ identity: undefined;
3303
+ generated: undefined;
3304
+ }, {}, {}>;
3305
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3306
+ name: "updated_at";
3307
+ tableName: "publishers";
3308
+ dataType: "string";
3309
+ columnType: "PgText";
3310
+ data: string;
3311
+ driverParam: string;
3312
+ notNull: true;
3313
+ hasDefault: false;
3314
+ isPrimaryKey: false;
3315
+ isAutoincrement: false;
3316
+ hasRuntimeDefault: false;
3317
+ enumValues: [string, ...string[]];
3318
+ baseColumn: never;
3319
+ identity: undefined;
3320
+ generated: undefined;
3321
+ }, {}, {}>;
3322
+ };
3323
+ dialect: "pg";
3324
+ }>;
3325
+ projects: import("drizzle-orm/pg-core").PgTableWithColumns<{
3326
+ name: "projects";
3327
+ schema: undefined;
3328
+ columns: {
3329
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
3330
+ name: string;
3331
+ tableName: "projects";
3332
+ dataType: "string";
3333
+ columnType: "PgText";
3334
+ data: string;
3335
+ driverParam: string;
3336
+ notNull: true;
3337
+ hasDefault: false;
3338
+ isPrimaryKey: false;
3339
+ isAutoincrement: false;
3340
+ hasRuntimeDefault: false;
3341
+ enumValues: [string, ...string[]];
3342
+ baseColumn: never;
3343
+ identity: undefined;
3344
+ generated: undefined;
3345
+ }, {}, {}>;
3346
+ name: import("drizzle-orm/pg-core").PgColumn<{
3347
+ name: string;
3348
+ tableName: "projects";
3349
+ dataType: "string";
3350
+ columnType: "PgText";
3351
+ data: string;
3352
+ driverParam: string;
3353
+ notNull: true;
3354
+ hasDefault: false;
3355
+ isPrimaryKey: false;
3356
+ isAutoincrement: false;
3357
+ hasRuntimeDefault: false;
3358
+ enumValues: [string, ...string[]];
3359
+ baseColumn: never;
3360
+ identity: undefined;
3361
+ generated: undefined;
3362
+ }, {}, {}>;
3363
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3364
+ name: string;
3365
+ tableName: "projects";
3366
+ dataType: "string";
3367
+ columnType: "PgText";
3368
+ data: string;
3369
+ driverParam: string;
3370
+ notNull: true;
3371
+ hasDefault: false;
3372
+ isPrimaryKey: false;
3373
+ isAutoincrement: false;
3374
+ hasRuntimeDefault: false;
3375
+ enumValues: [string, ...string[]];
3376
+ baseColumn: never;
3377
+ identity: undefined;
3378
+ generated: undefined;
3379
+ }, {}, {}>;
3380
+ };
3381
+ dialect: "pg";
3382
+ }>;
3383
+ environments: import("drizzle-orm/pg-core").PgTableWithColumns<{
3384
+ name: "environments";
3385
+ schema: undefined;
3386
+ columns: {
3387
+ name: import("drizzle-orm/pg-core").PgColumn<{
3388
+ name: string;
3389
+ tableName: "environments";
3390
+ dataType: "string";
3391
+ columnType: "PgText";
3392
+ data: string;
3393
+ driverParam: string;
3394
+ notNull: true;
3395
+ hasDefault: false;
3396
+ isPrimaryKey: false;
3397
+ isAutoincrement: false;
3398
+ hasRuntimeDefault: false;
3399
+ enumValues: [string, ...string[]];
3400
+ baseColumn: never;
3401
+ identity: undefined;
3402
+ generated: undefined;
3403
+ }, {}, {}>;
3404
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3405
+ name: string;
3406
+ tableName: "environments";
3407
+ dataType: "string";
3408
+ columnType: "PgText";
3409
+ data: string;
3410
+ driverParam: string;
3411
+ notNull: true;
3412
+ hasDefault: false;
3413
+ isPrimaryKey: false;
3414
+ isAutoincrement: false;
3415
+ hasRuntimeDefault: false;
3416
+ enumValues: [string, ...string[]];
3417
+ baseColumn: never;
3418
+ identity: undefined;
3419
+ generated: undefined;
3420
+ }, {}, {}>;
3421
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
3422
+ name: string;
3423
+ tableName: "environments";
3424
+ dataType: "string";
3425
+ columnType: "PgText";
3426
+ data: string;
3427
+ driverParam: string;
3428
+ notNull: true;
3429
+ hasDefault: false;
3430
+ isPrimaryKey: false;
3431
+ isAutoincrement: false;
3432
+ hasRuntimeDefault: false;
3433
+ enumValues: [string, ...string[]];
3434
+ baseColumn: never;
3435
+ identity: undefined;
3436
+ generated: undefined;
3437
+ }, {}, {}>;
3438
+ project: import("drizzle-orm/pg-core").PgColumn<{
3439
+ name: string;
3440
+ tableName: "environments";
3441
+ dataType: "string";
3442
+ columnType: "PgText";
3443
+ data: string;
3444
+ driverParam: string;
3445
+ notNull: true;
3446
+ hasDefault: false;
3447
+ isPrimaryKey: false;
3448
+ isAutoincrement: false;
3449
+ hasRuntimeDefault: false;
3450
+ enumValues: [string, ...string[]];
3451
+ baseColumn: never;
3452
+ identity: undefined;
3453
+ generated: undefined;
3454
+ }, {}, {}>;
3455
+ };
3456
+ dialect: "pg";
3457
+ }>;
3458
+ projectVersions: import("drizzle-orm/pg-core").PgTableWithColumns<{
3459
+ name: "project_versions";
3460
+ schema: undefined;
3461
+ columns: {
3462
+ name: import("drizzle-orm/pg-core").PgColumn<{
3463
+ name: string;
3464
+ tableName: "project_versions";
3465
+ dataType: "string";
3466
+ columnType: "PgText";
3467
+ data: string;
3468
+ driverParam: string;
3469
+ notNull: true;
3470
+ hasDefault: false;
3471
+ isPrimaryKey: false;
3472
+ isAutoincrement: false;
3473
+ hasRuntimeDefault: false;
3474
+ enumValues: [string, ...string[]];
3475
+ baseColumn: never;
3476
+ identity: undefined;
3477
+ generated: undefined;
3478
+ }, {}, {}>;
3479
+ id: import("drizzle-orm/pg-core").PgColumn<{
3480
+ name: string;
3481
+ tableName: "project_versions";
3482
+ dataType: "string";
3483
+ columnType: "PgText";
3484
+ data: string;
3485
+ driverParam: string;
3486
+ notNull: true;
3487
+ hasDefault: false;
3488
+ isPrimaryKey: false;
3489
+ isAutoincrement: false;
3490
+ hasRuntimeDefault: false;
3491
+ enumValues: [string, ...string[]];
3492
+ baseColumn: never;
3493
+ identity: undefined;
3494
+ generated: undefined;
3495
+ }, {}, {}>;
3496
+ doc: import("drizzle-orm/pg-core").PgColumn<{
3497
+ name: "doc";
3498
+ tableName: "project_versions";
3499
+ dataType: "json";
3500
+ columnType: "PgJsonb";
3501
+ data: Record<string, unknown>;
3502
+ driverParam: unknown;
3503
+ notNull: true;
3504
+ hasDefault: false;
3505
+ isPrimaryKey: false;
3506
+ isAutoincrement: false;
3507
+ hasRuntimeDefault: false;
3508
+ enumValues: undefined;
3509
+ baseColumn: never;
3510
+ identity: undefined;
3511
+ generated: undefined;
3512
+ }, {}, {
3513
+ $type: Record<string, unknown>;
3514
+ }>;
3515
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3516
+ name: string;
3517
+ tableName: "project_versions";
3518
+ dataType: "string";
3519
+ columnType: "PgText";
3520
+ data: string;
3521
+ driverParam: string;
3522
+ notNull: true;
3523
+ hasDefault: false;
3524
+ isPrimaryKey: false;
3525
+ isAutoincrement: false;
3526
+ hasRuntimeDefault: false;
3527
+ enumValues: [string, ...string[]];
3528
+ baseColumn: never;
3529
+ identity: undefined;
3530
+ generated: undefined;
3531
+ }, {}, {}>;
3532
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
3533
+ name: string;
3534
+ tableName: "project_versions";
3535
+ dataType: "string";
3536
+ columnType: "PgText";
3537
+ data: string;
3538
+ driverParam: string;
3539
+ notNull: true;
3540
+ hasDefault: false;
3541
+ isPrimaryKey: false;
3542
+ isAutoincrement: false;
3543
+ hasRuntimeDefault: false;
3544
+ enumValues: [string, ...string[]];
3545
+ baseColumn: never;
3546
+ identity: undefined;
3547
+ generated: undefined;
3548
+ }, {}, {}>;
3549
+ project: import("drizzle-orm/pg-core").PgColumn<{
3550
+ name: string;
3551
+ tableName: "project_versions";
3552
+ dataType: "string";
3553
+ columnType: "PgText";
3554
+ data: string;
3555
+ driverParam: string;
3556
+ notNull: true;
3557
+ hasDefault: false;
3558
+ isPrimaryKey: false;
3559
+ isAutoincrement: false;
3560
+ hasRuntimeDefault: false;
3561
+ enumValues: [string, ...string[]];
3562
+ baseColumn: never;
3563
+ identity: undefined;
3564
+ generated: undefined;
3565
+ }, {}, {}>;
3566
+ };
3567
+ dialect: "pg";
3568
+ }>;
3569
+ pointers: import("drizzle-orm/pg-core").PgTableWithColumns<{
3570
+ name: "pointers";
3571
+ schema: undefined;
3572
+ columns: {
3573
+ environment: import("drizzle-orm/pg-core").PgColumn<{
3574
+ name: string;
3575
+ tableName: "pointers";
3576
+ dataType: "string";
3577
+ columnType: "PgText";
3578
+ data: string;
3579
+ driverParam: string;
3580
+ notNull: true;
3581
+ hasDefault: false;
3582
+ isPrimaryKey: false;
3583
+ isAutoincrement: false;
3584
+ hasRuntimeDefault: false;
3585
+ enumValues: [string, ...string[]];
3586
+ baseColumn: never;
3587
+ identity: undefined;
3588
+ generated: undefined;
3589
+ }, {}, {}>;
3590
+ name: import("drizzle-orm/pg-core").PgColumn<{
3591
+ name: string;
3592
+ tableName: "pointers";
3593
+ dataType: "string";
3594
+ columnType: "PgText";
3595
+ data: string;
3596
+ driverParam: string;
3597
+ notNull: true;
3598
+ hasDefault: false;
3599
+ isPrimaryKey: false;
3600
+ isAutoincrement: false;
3601
+ hasRuntimeDefault: false;
3602
+ enumValues: [string, ...string[]];
3603
+ baseColumn: never;
3604
+ identity: undefined;
3605
+ generated: undefined;
3606
+ }, {}, {}>;
3607
+ versionId: import("drizzle-orm/pg-core").PgColumn<{
3608
+ name: string;
3609
+ tableName: "pointers";
3610
+ dataType: "string";
3611
+ columnType: "PgText";
3612
+ data: string;
3613
+ driverParam: string;
3614
+ notNull: true;
3615
+ hasDefault: false;
3616
+ isPrimaryKey: false;
3617
+ isAutoincrement: false;
3618
+ hasRuntimeDefault: false;
3619
+ enumValues: [string, ...string[]];
3620
+ baseColumn: never;
3621
+ identity: undefined;
3622
+ generated: undefined;
3623
+ }, {}, {}>;
3624
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
3625
+ name: string;
3626
+ tableName: "pointers";
3627
+ dataType: "string";
3628
+ columnType: "PgText";
3629
+ data: string;
3630
+ driverParam: string;
3631
+ notNull: true;
3632
+ hasDefault: false;
3633
+ isPrimaryKey: false;
3634
+ isAutoincrement: false;
3635
+ hasRuntimeDefault: false;
3636
+ enumValues: [string, ...string[]];
3637
+ baseColumn: never;
3638
+ identity: undefined;
3639
+ generated: undefined;
3640
+ }, {}, {}>;
3641
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
3642
+ name: string;
3643
+ tableName: "pointers";
3644
+ dataType: "string";
3645
+ columnType: "PgText";
3646
+ data: string;
3647
+ driverParam: string;
3648
+ notNull: true;
3649
+ hasDefault: false;
3650
+ isPrimaryKey: false;
3651
+ isAutoincrement: false;
3652
+ hasRuntimeDefault: false;
3653
+ enumValues: [string, ...string[]];
3654
+ baseColumn: never;
3655
+ identity: undefined;
3656
+ generated: undefined;
3657
+ }, {}, {}>;
3658
+ project: import("drizzle-orm/pg-core").PgColumn<{
3659
+ name: string;
3660
+ tableName: "pointers";
3661
+ dataType: "string";
3662
+ columnType: "PgText";
3663
+ data: string;
3664
+ driverParam: string;
3665
+ notNull: true;
3666
+ hasDefault: false;
3667
+ isPrimaryKey: false;
3668
+ isAutoincrement: false;
3669
+ hasRuntimeDefault: false;
3670
+ enumValues: [string, ...string[]];
3671
+ baseColumn: never;
3672
+ identity: undefined;
3673
+ generated: undefined;
3674
+ }, {}, {}>;
3675
+ };
3676
+ dialect: "pg";
3677
+ }>;
3678
+ promotions: import("drizzle-orm/pg-core").PgTableWithColumns<{
3679
+ name: "promotions";
3680
+ schema: undefined;
3681
+ columns: {
3682
+ id: import("drizzle-orm/pg-core").PgColumn<{
3683
+ name: string;
3684
+ tableName: "promotions";
3685
+ dataType: "string";
3686
+ columnType: "PgText";
3687
+ data: string;
3688
+ driverParam: string;
3689
+ notNull: true;
3690
+ hasDefault: false;
3691
+ isPrimaryKey: false;
3692
+ isAutoincrement: false;
3693
+ hasRuntimeDefault: false;
3694
+ enumValues: [string, ...string[]];
3695
+ baseColumn: never;
3696
+ identity: undefined;
3697
+ generated: undefined;
3698
+ }, {}, {}>;
3699
+ environment: import("drizzle-orm/pg-core").PgColumn<{
3700
+ name: string;
3701
+ tableName: "promotions";
3702
+ dataType: "string";
3703
+ columnType: "PgText";
3704
+ data: string;
3705
+ driverParam: string;
3706
+ notNull: true;
3707
+ hasDefault: false;
3708
+ isPrimaryKey: false;
3709
+ isAutoincrement: false;
3710
+ hasRuntimeDefault: false;
3711
+ enumValues: [string, ...string[]];
3712
+ baseColumn: never;
3713
+ identity: undefined;
3714
+ generated: undefined;
3715
+ }, {}, {}>;
3716
+ name: import("drizzle-orm/pg-core").PgColumn<{
3717
+ name: string;
3718
+ tableName: "promotions";
3719
+ dataType: "string";
3720
+ columnType: "PgText";
3721
+ data: string;
3722
+ driverParam: string;
3723
+ notNull: true;
3724
+ hasDefault: false;
3725
+ isPrimaryKey: false;
3726
+ isAutoincrement: false;
3727
+ hasRuntimeDefault: false;
3728
+ enumValues: [string, ...string[]];
3729
+ baseColumn: never;
3730
+ identity: undefined;
3731
+ generated: undefined;
3732
+ }, {}, {}>;
3733
+ doc: import("drizzle-orm/pg-core").PgColumn<{
3734
+ name: "doc";
3735
+ tableName: "promotions";
3736
+ dataType: "json";
3737
+ columnType: "PgJsonb";
3738
+ data: Record<string, unknown>;
3739
+ driverParam: unknown;
3740
+ notNull: true;
3741
+ hasDefault: false;
3742
+ isPrimaryKey: false;
3743
+ isAutoincrement: false;
3744
+ hasRuntimeDefault: false;
3745
+ enumValues: undefined;
3746
+ baseColumn: never;
3747
+ identity: undefined;
3748
+ generated: undefined;
3749
+ }, {}, {
3750
+ $type: Record<string, unknown>;
3751
+ }>;
3752
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
3753
+ name: string;
3754
+ tableName: "promotions";
3755
+ dataType: "string";
3756
+ columnType: "PgText";
3757
+ data: string;
3758
+ driverParam: string;
3759
+ notNull: true;
3760
+ hasDefault: false;
3761
+ isPrimaryKey: false;
3762
+ isAutoincrement: false;
3763
+ hasRuntimeDefault: false;
3764
+ enumValues: [string, ...string[]];
3765
+ baseColumn: never;
3766
+ identity: undefined;
3767
+ generated: undefined;
3768
+ }, {}, {}>;
3769
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
3770
+ name: string;
3771
+ tableName: "promotions";
3772
+ dataType: "string";
3773
+ columnType: "PgText";
3774
+ data: string;
3775
+ driverParam: string;
3776
+ notNull: true;
3777
+ hasDefault: false;
3778
+ isPrimaryKey: false;
3779
+ isAutoincrement: false;
3780
+ hasRuntimeDefault: false;
3781
+ enumValues: [string, ...string[]];
3782
+ baseColumn: never;
3783
+ identity: undefined;
3784
+ generated: undefined;
3785
+ }, {}, {}>;
3786
+ project: import("drizzle-orm/pg-core").PgColumn<{
3787
+ name: string;
3788
+ tableName: "promotions";
3789
+ dataType: "string";
3790
+ columnType: "PgText";
3791
+ data: string;
3792
+ driverParam: string;
3793
+ notNull: true;
3794
+ hasDefault: false;
3795
+ isPrimaryKey: false;
3796
+ isAutoincrement: false;
3797
+ hasRuntimeDefault: false;
3798
+ enumValues: [string, ...string[]];
3799
+ baseColumn: never;
3800
+ identity: undefined;
3801
+ generated: undefined;
3802
+ }, {}, {}>;
3803
+ };
3804
+ dialect: "pg";
3805
+ }>;
3806
+ runReports: import("drizzle-orm/pg-core").PgTableWithColumns<{
3807
+ name: "run_reports";
3808
+ schema: undefined;
3809
+ columns: {
3810
+ runId: import("drizzle-orm/pg-core").PgColumn<{
3811
+ name: string;
3812
+ tableName: "run_reports";
3813
+ dataType: "string";
3814
+ columnType: "PgText";
3815
+ data: string;
3816
+ driverParam: string;
3817
+ notNull: true;
3818
+ hasDefault: false;
3819
+ isPrimaryKey: false;
3820
+ isAutoincrement: false;
3821
+ hasRuntimeDefault: false;
3822
+ enumValues: [string, ...string[]];
3823
+ baseColumn: never;
3824
+ identity: undefined;
3825
+ generated: undefined;
3826
+ }, {}, {}>;
3827
+ name: import("drizzle-orm/pg-core").PgColumn<{
3828
+ name: string;
3829
+ tableName: "run_reports";
3830
+ dataType: "string";
3831
+ columnType: "PgText";
3832
+ data: string;
3833
+ driverParam: string;
3834
+ notNull: true;
3835
+ hasDefault: false;
3836
+ isPrimaryKey: false;
3837
+ isAutoincrement: false;
3838
+ hasRuntimeDefault: false;
3839
+ enumValues: [string, ...string[]];
3840
+ baseColumn: never;
3841
+ identity: undefined;
3842
+ generated: undefined;
3843
+ }, {}, {}>;
3844
+ versionId: import("drizzle-orm/pg-core").PgColumn<{
3845
+ name: string;
3846
+ tableName: "run_reports";
3847
+ dataType: "string";
3848
+ columnType: "PgText";
3849
+ data: string;
3850
+ driverParam: string;
3851
+ notNull: true;
3852
+ hasDefault: false;
3853
+ isPrimaryKey: false;
3854
+ isAutoincrement: false;
3855
+ hasRuntimeDefault: false;
3856
+ enumValues: [string, ...string[]];
3857
+ baseColumn: never;
3858
+ identity: undefined;
3859
+ generated: undefined;
3860
+ }, {}, {}>;
3861
+ datasetName: import("drizzle-orm/pg-core").PgColumn<{
3862
+ name: string;
3863
+ tableName: "run_reports";
3864
+ dataType: "string";
3865
+ columnType: "PgText";
3866
+ data: string;
3867
+ driverParam: string;
3868
+ notNull: false;
3869
+ hasDefault: false;
3870
+ isPrimaryKey: false;
3871
+ isAutoincrement: false;
3872
+ hasRuntimeDefault: false;
3873
+ enumValues: [string, ...string[]];
3874
+ baseColumn: never;
3875
+ identity: undefined;
3876
+ generated: undefined;
3877
+ }, {}, {}>;
3878
+ startedAt: import("drizzle-orm/pg-core").PgColumn<{
3879
+ name: string;
3880
+ tableName: "run_reports";
3881
+ dataType: "string";
3882
+ columnType: "PgText";
3883
+ data: string;
3884
+ driverParam: string;
3885
+ notNull: true;
3886
+ hasDefault: false;
3887
+ isPrimaryKey: false;
3888
+ isAutoincrement: false;
3889
+ hasRuntimeDefault: false;
3890
+ enumValues: [string, ...string[]];
3891
+ baseColumn: never;
3892
+ identity: undefined;
3893
+ generated: undefined;
3894
+ }, {}, {}>;
3895
+ doc: import("drizzle-orm/pg-core").PgColumn<{
3896
+ name: "doc";
3897
+ tableName: "run_reports";
3898
+ dataType: "json";
3899
+ columnType: "PgJsonb";
3900
+ data: Record<string, unknown>;
3901
+ driverParam: unknown;
3902
+ notNull: true;
3903
+ hasDefault: false;
3904
+ isPrimaryKey: false;
3905
+ isAutoincrement: false;
3906
+ hasRuntimeDefault: false;
3907
+ enumValues: undefined;
3908
+ baseColumn: never;
3909
+ identity: undefined;
3910
+ generated: undefined;
3911
+ }, {}, {
3912
+ $type: Record<string, unknown>;
3913
+ }>;
3914
+ reportedAt: import("drizzle-orm/pg-core").PgColumn<{
3915
+ name: string;
3916
+ tableName: "run_reports";
3917
+ dataType: "string";
3918
+ columnType: "PgText";
3919
+ data: string;
3920
+ driverParam: string;
3921
+ notNull: true;
3922
+ hasDefault: false;
3923
+ isPrimaryKey: false;
3924
+ isAutoincrement: false;
3925
+ hasRuntimeDefault: false;
3926
+ enumValues: [string, ...string[]];
3927
+ baseColumn: never;
3928
+ identity: undefined;
3929
+ generated: undefined;
3930
+ }, {}, {}>;
3931
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
3932
+ name: string;
3933
+ tableName: "run_reports";
3934
+ dataType: "string";
3935
+ columnType: "PgText";
3936
+ data: string;
3937
+ driverParam: string;
3938
+ notNull: true;
3939
+ hasDefault: false;
3940
+ isPrimaryKey: false;
3941
+ isAutoincrement: false;
3942
+ hasRuntimeDefault: false;
3943
+ enumValues: [string, ...string[]];
3944
+ baseColumn: never;
3945
+ identity: undefined;
3946
+ generated: undefined;
3947
+ }, {}, {}>;
3948
+ project: import("drizzle-orm/pg-core").PgColumn<{
3949
+ name: string;
3950
+ tableName: "run_reports";
3951
+ dataType: "string";
3952
+ columnType: "PgText";
3953
+ data: string;
3954
+ driverParam: string;
3955
+ notNull: true;
3956
+ hasDefault: false;
3957
+ isPrimaryKey: false;
3958
+ isAutoincrement: false;
3959
+ hasRuntimeDefault: false;
3960
+ enumValues: [string, ...string[]];
3961
+ baseColumn: never;
3962
+ identity: undefined;
3963
+ generated: undefined;
3964
+ }, {}, {}>;
3965
+ };
3966
+ dialect: "pg";
3967
+ }>;
3968
+ comparisonReports: import("drizzle-orm/pg-core").PgTableWithColumns<{
3969
+ name: "comparison_reports";
3970
+ schema: undefined;
3971
+ columns: {
3972
+ id: import("drizzle-orm/pg-core").PgColumn<{
3973
+ name: string;
3974
+ tableName: "comparison_reports";
3975
+ dataType: "string";
3976
+ columnType: "PgText";
3977
+ data: string;
3978
+ driverParam: string;
3979
+ notNull: true;
3980
+ hasDefault: false;
3981
+ isPrimaryKey: false;
3982
+ isAutoincrement: false;
3983
+ hasRuntimeDefault: false;
3984
+ enumValues: [string, ...string[]];
3985
+ baseColumn: never;
3986
+ identity: undefined;
3987
+ generated: undefined;
3988
+ }, {}, {}>;
3989
+ name: import("drizzle-orm/pg-core").PgColumn<{
3990
+ name: string;
3991
+ tableName: "comparison_reports";
3992
+ dataType: "string";
3993
+ columnType: "PgText";
3994
+ data: string;
3995
+ driverParam: string;
3996
+ notNull: true;
3997
+ hasDefault: false;
3998
+ isPrimaryKey: false;
3999
+ isAutoincrement: false;
4000
+ hasRuntimeDefault: false;
4001
+ enumValues: [string, ...string[]];
4002
+ baseColumn: never;
4003
+ identity: undefined;
4004
+ generated: undefined;
4005
+ }, {}, {}>;
4006
+ headVersionId: import("drizzle-orm/pg-core").PgColumn<{
4007
+ name: string;
4008
+ tableName: "comparison_reports";
4009
+ dataType: "string";
4010
+ columnType: "PgText";
4011
+ data: string;
4012
+ driverParam: string;
4013
+ notNull: true;
4014
+ hasDefault: false;
4015
+ isPrimaryKey: false;
4016
+ isAutoincrement: false;
4017
+ hasRuntimeDefault: false;
4018
+ enumValues: [string, ...string[]];
4019
+ baseColumn: never;
4020
+ identity: undefined;
4021
+ generated: undefined;
4022
+ }, {}, {}>;
4023
+ doc: import("drizzle-orm/pg-core").PgColumn<{
4024
+ name: "doc";
4025
+ tableName: "comparison_reports";
4026
+ dataType: "json";
4027
+ columnType: "PgJsonb";
4028
+ data: Record<string, unknown>;
4029
+ driverParam: unknown;
4030
+ notNull: true;
4031
+ hasDefault: false;
4032
+ isPrimaryKey: false;
4033
+ isAutoincrement: false;
4034
+ hasRuntimeDefault: false;
4035
+ enumValues: undefined;
4036
+ baseColumn: never;
4037
+ identity: undefined;
4038
+ generated: undefined;
4039
+ }, {}, {
4040
+ $type: Record<string, unknown>;
4041
+ }>;
4042
+ reportedAt: import("drizzle-orm/pg-core").PgColumn<{
4043
+ name: string;
4044
+ tableName: "comparison_reports";
4045
+ dataType: "string";
4046
+ columnType: "PgText";
4047
+ data: string;
4048
+ driverParam: string;
4049
+ notNull: true;
4050
+ hasDefault: false;
4051
+ isPrimaryKey: false;
4052
+ isAutoincrement: false;
4053
+ hasRuntimeDefault: false;
4054
+ enumValues: [string, ...string[]];
4055
+ baseColumn: never;
4056
+ identity: undefined;
4057
+ generated: undefined;
4058
+ }, {}, {}>;
4059
+ tenantId: import("drizzle-orm/pg-core").PgColumn<{
4060
+ name: string;
4061
+ tableName: "comparison_reports";
4062
+ dataType: "string";
4063
+ columnType: "PgText";
4064
+ data: string;
4065
+ driverParam: string;
4066
+ notNull: true;
4067
+ hasDefault: false;
4068
+ isPrimaryKey: false;
4069
+ isAutoincrement: false;
4070
+ hasRuntimeDefault: false;
4071
+ enumValues: [string, ...string[]];
4072
+ baseColumn: never;
4073
+ identity: undefined;
4074
+ generated: undefined;
4075
+ }, {}, {}>;
4076
+ project: import("drizzle-orm/pg-core").PgColumn<{
4077
+ name: string;
4078
+ tableName: "comparison_reports";
4079
+ dataType: "string";
4080
+ columnType: "PgText";
4081
+ data: string;
4082
+ driverParam: string;
4083
+ notNull: true;
4084
+ hasDefault: false;
4085
+ isPrimaryKey: false;
4086
+ isAutoincrement: false;
4087
+ hasRuntimeDefault: false;
4088
+ enumValues: [string, ...string[]];
4089
+ baseColumn: never;
4090
+ identity: undefined;
4091
+ generated: undefined;
4092
+ }, {}, {}>;
4093
+ };
4094
+ dialect: "pg";
4095
+ }>;
4096
+ }> & {
4097
+ $client: import("@electric-sql/pglite").PGlite;
4098
+ };
4099
+ client: import("@electric-sql/pglite").PGlite;
4100
+ store: PgStore;
4101
+ auth: DrizzleAuth;
4102
+ close: () => Promise<void>;
4103
+ }>;
4104
+ interface PgMigratableDb {
4105
+ execute(query: SQL): PromiseLike<{
4106
+ rows: unknown[];
4107
+ }>;
4108
+ }
4109
+ /** Apply generated migrations in order, tracking completed files. */
4110
+ export declare function applyPgMigrations(db: PgMigratableDb, dir?: string): Promise<void>;
4111
+ export {};