bopodev-db 0.1.1

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